Develop against
real production streams.

Replicata taps real streaming responses in your own browser — ChatGPT, Claude, any SSE app — and replays them into your local renderer with original chunk timing. Your code calls fetch() and gets real bytes back. No mocks, no API keys, no cost.

View on GitHub open source · MIT license

The problem

You're building a streaming UI. Maybe a chat interface, maybe a real-time dashboard. You need to handle SSE, chunked responses, partial JSON, reconnection, error states.

So you try the usual approaches:

Mock the API. Write a fake SSE endpoint that sends clean, uniform chunks every 50ms. Ship it. Prod streams are bursty, split across packet boundaries, occasionally malformed. Your UI jitters.
Use the real API with a key. Pay per request. Hit rate limits. Wait for responses. Burn through credits debugging a CSS issue.
Take a course. Follow a tutorial that was written for last year's API format. The payload shape changed three months ago.
Copy-paste responses into fixtures. Open DevTools, copy a response, save it as JSON. No timing info. One snapshot that goes stale immediately.
Ask an LLM to generate test data. It doesn't know the real SSE framing, the real chunk boundaries, the real error shapes. You learn nothing about production behavior.

Every approach is either expensive, stale, or fake. None of them give you what you actually need: the real bytes, with real timing, flowing into your code while you develop.

How does replicata compare?

	Mocks	Record & replay	Real API + key	Courses	Replicata
Fidelity	Low	Medium	High	Low	Real prod bytes
Chunk timing	Fake	Snapshot	Real	N/A	Real
Edge cases	Only imagined	Only captured	Uncontrolled	Curated	Real + injectable
Stays current	No	No	Yes	6-12mo behind	Always
Cost per use	Free	Free	$$$ + rate limits	Course fee	Free
Failure testing	Manual	If recorded	Can't control	Scripted	Built-in scenarios

How it works

Start replicata + Chrome

npm run chrome opens a dedicated Chrome with remote debugging. npm run dev starts replicata. Navigate to any streaming app and log in.

Connect your renderer

Open your localhost app in the same Chrome. In the replicata UI, pick the real app tab and your renderer tab. Streams flow into your normal fetch("/api/chat") call.

Develop against real data

Send a message in the real app. Your renderer gets the same bytes with original timing. Tag elements, forward events, inject failures. Export captured chunks for your test suite.

Real bytes, not mocks

Mocks give you clean, uniform chunks on a predictable cadence. Real SSE streams are bursty, occasionally malformed, sometimes disconnect mid-message. Replicata makes the real ones your dev loop.

Failure injection

Latency multipliers, mid-stream disconnects, dropped chunks, rate-limit responses, malformed JSON. Deterministic scenarios applied to real captured data. Your error UI finally gets tested.

Export chunks for tests

Capture a streaming response, export the chunks with original timing. Paste into MSW, Playwright route mocks, or any test framework. Real production data in your test suite — not hand-written fixtures.

Passive by design

Replicata never automates the real app, never fires events into it, never scrapes or redistributes data. It's a DevTools-grade passive tap on your own browser session — you drive, it observes.

Get started

# clone + install
git clone https://github.com/codalife/replicata.git
cd replicata && npm install

# terminal 1: launch Chrome
npm run chrome

# terminal 2: start replicata
npm run dev

# terminal 3: start your app (or the example)
npm run example

Open the replicata UI tab in Chrome, pick your tabs, send a message in the real app.

FAQ

Is this a scraper? Does it violate ToS?

No. Replicata is a passive tap — it observes bytes in a browser you drive, like the DevTools Network panel. No automation, no requests on your behalf, no data leaves your machine.

Do I need API keys?

No. Your regular logged-in browser session is the source. Zero cost, zero keys.

I see a Cloudflare challenge page.

Click through it in the Chrome window. It's the same challenge you'd see in any fresh browser. Once solved, the session persists across restarts.

What frameworks does it work with?

Any. Your app calls fetch() and gets a normal Response back. React, Svelte, Vue, vanilla — all the same.

What apps can I observe?

Any web app that streams data — LLM chat apps, real-time dashboards, collaborative editors. Tested against ChatGPT and Claude.

Mac / Windows / Linux?

Anywhere Node.js and Chrome run. Tested on macOS and Linux.

Develop against real production streams.