Chrome Extension · MV3 · Free

Intercept & mock
any HTTP request
in the browser

A developer tool for capturing, inspecting, and mocking network traffic - REST and GraphQL - without a proxy or backend changes.

No proxy setup. No backend changes. All data stays on your device.

syncmock · dashboard
Dashboard ● Live
Requests
379total
Mocked
4712%
Recent activity
  • GET /api/v2/products?page=1 Mocked 200
  • POST /api/auth/token 201
  • PUT /api/v2/cart/items/9821 Mocked 200
Product tour

Real screens, not marketing mockups

Every screenshot below is the actual extension UI.

The Syncmock dashboard showing live interception status, request and mock counters, a traffic sparkline, status-code breakdown, top hosts, and recent activity.
Built for real workflows

Not just API mocking.
It unblocks daily frontend work.

Syncmock is most useful when your backend is incomplete, unstable, slow, or simply out of your control.

Frontend teams shipping against unfinished APIs

Keep moving when the backend contract exists on paper but not in production. Model happy paths, failures, slow states, and partial payloads without waiting for another team.

  • Prototype a new UI before the API exists
  • Test loading, empty, 401, 403, 404, 422, and 500 states
  • Share the same rule pack with the whole team

QA and product teams reproducing hard-to-hit scenarios

Many bugs only show up under specific response shapes or headers. Syncmock makes those scenarios repeatable so testers and PMs can validate edge cases without needing custom backend flags.

  • Reproduce production incidents locally with one rule
  • Validate UX for degraded responses and partial data
  • Switch between multiple variants without editing code

Developers integrating with third-party services

When you depend on Stripe, Auth0, Shopify, internal gateways, or any external partner API, you rarely control availability or shape changes. Syncmock gives you a safe simulation layer inside the browser.

  • Redirect vendor traffic to staging or localhost
  • Inject missing auth or debugging headers
  • Develop against realistic partner payloads offline

Debugging production-like behaviour without changing app code

Sometimes you need to answer one question fast: “what happens if this request returns different data?” Syncmock is a safer, faster loop than adding temporary code paths or branching your backend.

  • Patch requests at runtime without rebuilding
  • Inspect what changed in the Network panel immediately
  • Remove the rule and return to the real flow instantly
Works with
REST APIs
GraphQL
fetch & XHR
Any website
MV3 · Chrome 116+
Everything you need

Built for the way
developers actually work

Six tools in one extension. No proxy server, no certificates to install, no backend code to touch.

Live network capture

Every request and response streams into a panel in real time. Filter by method, status, URL, or mocked-only. Inspect headers and body with zero latency.

fetch · XHR · webRequest

Mock REST & GraphQL

Return any JSON body, status code, and headers - before the real request ever leaves the browser. Perfect for frontend development without a live backend.

mock-rest · mock-graphql

Override response bodies

Let the real request fly, then swap the response body before the page sees it. Test edge cases and error states against your actual backend.

override-response-body

Redirect & replace URLs

Point API calls to a different host, path, or port without touching source code. Great for routing staging traffic to local servers or vice versa.

redirect · replace-url

Modify headers

Inject, override, or remove any request or response header. Add auth tokens, CORS headers, feature flags - without rebuilding the app.

modify-request-headers

AI-assisted rule authoring

Paste a request, describe what you want, and get a ready-to-use rule. Uses your own AI endpoint - your data never goes anywhere unexpected.

local · BYO key · optional
Why choose Syncmock

Built differently from most request-mocking tools.

Most competitors are either proxy-first, cloud-first, or limited to simple redirects and canned mocks. Syncmock is designed around a different idea: keep everything in the browser, expose full request/response visibility, and let developers mix declarative speed with body-level control.

Where Syncmock is different

Use a proxy when you need full machine-wide traffic control. Use a mock server when you need shared backend simulation. Use Syncmock when you need instant browser-side interception with no proxy, no certificate ceremony, and no loss of request/response context.

Capability
Syncmock
Traditional setup
Start mocking a request in under a minute
Yes
Usually slower
No proxy server or local certificates
Yes
Often required
Visible request/response debugging in the same UI
Built in
Split across tools
Safe to toggle per browser session
Yes
Depends on setup
Body-level mocking without leaving the browser
Native workflow
Often proxy or backend-driven
One place for capture, rules, variants, and settings
Single UI
Often split across tools

Two-lane interception model

Syncmock does something many tools do not: it combines Chrome's declarative network layer with a MAIN-world page bridge. That means fast rule execution for redirects and headers, plus real body-touching control for fetch and XHR when you need to override or fully mock responses.

  • Declarative rules stay lightweight and fast
  • Body overrides still work because the page bridge can patch fetch and XHR
  • You don't have to choose between speed and depth

Privacy-first by default

All rules, settings, and captured traffic live on your device. There is no Syncmock cloud, no hidden telemetry, and no account wall before you can use the product.

0 accounts required to start
0 telemetry events sent by default

Response variants instead of duplicate rules

Most tools push you toward duplicating rules for every scenario. Syncmock supports named variants on a rule, so you can keep one matcher and switch between success, empty, slow, and error states without creating rule sprawl.

  • One matcher, many scenarios
  • Cleaner rule lists as projects grow
  • Faster QA handoff for edge-case validation

Local-first by design

Rules and captured traffic are stored in your browser's local storage. There is no account, no cloud sync, and no telemetry - your requests never leave your machine.

0 bytes of your traffic sent to us
MV3 built on modern Chrome extension architecture
Three steps

From install to
first mock in 60 seconds

No configuration file, no proxy certificate, no server to run.

01

Install the extension

Add Syncmock from the Chrome Web Store. Click the toolbar icon to open the popup and enable interception. That's the only setup required.

02

Create a rule

Define a matcher (URL, domain, method, header, GraphQL operation) and pick an action - mock, override, redirect, or modify headers. Name it, save it, done.

03

Watch it work

Reload the page. The Network panel shows matched requests highlighted. The dashboard counts what was mocked and how fast. Toggle rules on and off in real time.

Products API - mock 404 ● Active
url-contains  /api/v2/products
GET
mock-rest  · status 404
{
  "error": "not_found",
  "message": "Product does not exist",
  "code": 404
}
Rule engine

6 matchers × 8 actions - wire them any way you need

Each rule pairs a matcher (how to detect a request) with an action (what to do with it). Rules run in priority order. Variants let you switch between multiple response scenarios without editing the rule.

  • Matchers: URL regex, URL contains, domain, HTTP method, header, GraphQL operation name
  • Actions: mock REST, mock GraphQL, redirect, replace URL, modify headers, override request or response body
  • Response variants - multiple named scenarios on one rule, switchable in one click
  • Import / export rules as JSON - share with your team or version-control them
8+
Action types
6+
Matcher kinds
0
Proxy servers required
0
Data sent to us
FAQ

Questions people ask before they install

The site now says it clearly, not just in structured data.

Is this just another mock server?

No. Syncmock runs in the browser as a Chrome extension, so it can intercept and reshape requests exactly where your frontend experiences them. That makes it much faster for UI debugging than standing up a separate mock backend.

Does it work only for REST?

No. It works with REST and GraphQL, and it observes both fetch and XMLHttpRequest. You can match on GraphQL operation names, modify headers, replace URLs, or fully mock responses.

Can I use it on production websites?

You can use it on any site you control or are authorized to test. It is a developer tool, not a license to intercept unauthorized traffic. Use it responsibly and in line with the target application's terms and your own policies.

What happens to my data?

By default, nothing leaves your machine. Rules and settings are stored locally in Chrome. The only time traffic can be sent elsewhere is when you explicitly trigger the optional AI feature using an endpoint you configured yourself.

Free to use

Start intercepting
in 60 seconds

Add Syncmock to Chrome. Create your first rule. Ship faster.