Mockingbird — Help & Guide

Hold, edit, and mock HTTP traffic for one tab — from a side panel, with no backend.

New here? Read Quick start, then jump to Mocking or Breakpoints. Everything runs locally — nothing leaves your machine (see the Privacy Policy).

Quick start

Mockingbird works on one tab at a time — the tab you “arm.”

Open the page you want to debug.
Click the Mockingbird toolbar icon. The side panel opens and Chrome shows a yellow “Mockingbird is debugging this browser” banner — that’s normal and expected.
Interact with the page. Requests stream into the Traffic tab.
To stop, click Disarm (bottom of the panel) or close the panel.

The debug banner is unavoidable — pausing and rewriting live traffic requires Chrome’s debugger. It appears only while a tab is armed.

Capturing & inspecting

Every request the armed tab makes appears newest-first: method, path, host, status, and duration. Click a row to open its detail — request line, query params, headers, response/request bodies (pretty-printed JSON), and a timing breakdown.

Filter with the search box (matches URL, status, content-type), the method/type dropdowns, and the 4xx+ errors chip.
Right-click any row for quick actions: Mock this · Breakpoint on request · Breakpoint on response · Inspect · Copy URL.
Response bodies are captured when Intercept responses is on (Settings) or a response breakpoint is set — see Settings.
Clear empties the log; capture keeps running until you disarm.

Mocking an endpoint

A mock returns a synthetic response without touching the network. Fastest path:

Right-click a request → Mock this. The rule form opens pre-filled. (If the real body wasn’t captured and it’s a GET, Mockingbird fetches it in the background to seed the editor.)
Edit status, headers, and body. Hit Format JSON to tidy/validate the body.
Save. The row now shows a MOCKED tag and returns your response.

Mocks are an ordered list, first match wins — reorder with the ▲▼ buttons, toggle each on/off, and set optional latency (seconds) to simulate a slow endpoint.

Cross-origin just works. Mockingbird auto-adds CORS headers (and answers OPTIONS preflights) so a mock for a third-party API isn’t blocked by the browser. Set your own Access-Control-Allow-Origin to override.

Passthrough + rewrite

Sometimes you want the real response, lightly modified. Choose Passthrough + rewrite as the rule type. Mockingbird lets the request hit the network, then on the way back:

Override status (leave blank to keep the real one).
Merge headers into the real response.
Rewrite JSON fields with JSONPath — one per line:

$.user.plan = "free"
$.items[0].price = 0
$.flags.beta = true

The right-hand side is parsed as JSON (so true, 0, "text", arrays all work). Rows rewritten this way show an edited tag.

Breakpoints — pause & edit live

A breakpoint holds a real request on the wire so you can edit it before it continues.

Arm one

Right-click a row → Breakpoint on request or on response (or create one in the Rules tab with a URL pattern + method + stage). Armed rows show a BP·→ marker. The Break on all toggle (Rules) pauses everything for quick exploration.

When it hits

Request stage: edit method, URL, headers, body → Continue or Abort. Tick “Also pause at response” to catch it again on the way back.
Response stage: the real body is loaded for you. Edit status, headers, body, add a delay (seconds), then Continue (sends your edited response) or Abort.
Several at once? A queue strip lets you switch between held requests; nothing auto-continues without you.

Tip: from a held response you can Save as mock to capture it as a reusable rule.

Replay & composer

Re-send a request, or build one from scratch.

In a request’s detail, click the paper-plane (Replay) icon. The composer opens pre-filled; GET/HEAD auto-send so you see the response immediately.
Edit method, URL, headers, body, then Send. The response (status, headers, body) renders below; Save response as mock turns it into a rule.
The toolbar compose chip opens a blank request.

Replays run in the armed page’s own context (real cookies & origin). They also pass through Mockingbird’s interception — if a matching mock or breakpoint is active, disable it first to see the genuine response.

Diffing

In a request’s detail, use Compare to another request to pick a second capture. You’ll get a line-by-line body diff (green added / red removed) plus highlighted header and status differences — handy for spotting what changed between two calls.

URL pattern syntax

Type	Example	Matches
Substring	`/api/users`	any URL containing that text (case-insensitive)
Glob	`/api/v2/`	`*` matches any characters, including `/`
Regex	`/\/orders\/\d+/i`	wrap in slashes; flags optional

The rule form shows the detected type and how many captured requests currently match — so you can confirm a pattern before saving.

Rules, export & import

The Rules tab lists mocks (first-match-wins, reorderable) and breakpoints. Toggle, edit, delete, or Clear all breakpoints.
Export rules downloads a JSON file; Import loads one back — the no-backend way to share rule sets with teammates.
Export HAR saves the captured session as a standard .har file for other tools.

Settings

Setting	What it does
Break on all requests	Pause every request at the request stage — exploratory.
Intercept responses	Capture response bodies for every request (needed to inspect bodies & “Save as mock”). Slightly higher overhead.
Persist capture log	Keep a metadata-only history across restarts (no bodies stored).
Max retained body size	Cap on stored body size; larger bodies are truncated with a marker.

How it stays safe

A paused request could otherwise hang a page forever. Mockingbird guarantees it won’t:

While anything is held, a keepalive timer plus the panel connection keep the background worker alive.
Held requests are mirrored to durable storage; if the worker is ever evicted, on restart the tab is cleanly released — never left frozen.
Closing the panel, navigating, or closing the tab releases any held requests automatically.

Troubleshooting

“Can’t attach” when arming

DevTools is open on that tab — Chrome allows only one debugger per tab. Close DevTools, then re-arm.
Another debugger extension is attached — disable it for this tab.
Managed device — your organization may disable developer tools (DeveloperToolsAvailability policy). Mockingbird can’t attach in that case.
Try an Incognito window for a clean debugger slot (enable Mockingbird in incognito at chrome://extensions → Details → “Allow in Incognito”).

A mocked request shows “Failed to fetch”

Usually a cross-origin response without CORS headers — Mockingbird adds them automatically, but if you set custom headers, make sure they don’t remove Access-Control-Allow-Origin.

Response body says “not captured”

Turn on Intercept responses in Settings, or add a response breakpoint — bodies are only readable at the response stage.

Why only one tab?

By design — it keeps one banner, one clear “armed here” model, and a much simpler (and safer) held-request state machine. You’re debugging a page, not the whole browser.