For every team blocked by an unfinished backend

The mock server your whole team shares.

Capture real API responses, serve stateful scenarios, and push MQTT messages. One deployment, one URL, every tester in sync.

Open Dashboard Read the docs

request

GET /api/mock/v1/orders/8123
X-Api-Key: <project-api-key>
X-Mock-Scenario: success

response 200 no delay

{
  "orderId": "8123",
  "status": "CONFIRMED",
  "etaMinutes": 25
}

Swap the scenario header, get a different failure. No rebuild, no backend.

From real traffic to reliable mocks

Three moves. After that the backend can be late, broken, or not started yet. Your team keeps building.

Capture

Point staging traffic at the Collect API. Real responses become snapshots with extracted schemas, sensitive fields masked before anything is stored.

Configure

Turn snapshots into scenarios. Add match rules, latency, error variants, and multi-step sequences from the dashboard, no code required.

Serve

Ship one URL to the team. Scenarios resolve per header, per session, per rule, and MQTT topics fire automatically on every hit.

Everything your team needs from a fake backend

Scenario engine with match rules

Return different responses based on query, body, header, or path values. Priorities decide the order, a default scenario catches the rest.

{ "field": "body.amount", "operator": "eq",
  "value": "0", "scenario": "invalid-amount" }

Per-tester session pins

A tester pins the timeout scenario for their session with the X-Mock-Session header. Everyone else keeps the happy path.

Stateful scenario chains

Each hit advances to the next step. Simulate pagination, polling status flows, or an order that moves from pending to shipped.

Schema drift detection

Every captured response is diffed against the approved snapshot. Breaking changes surface in the dashboard before they break the app.

- "price": number
+ "price": { amount, currency }
status: pending review

Embedded MQTT broker

TCP and WebSocket broker built into the server. Publish manually from the dashboard or auto-publish templated payloads when an endpoint is hit. Topics are namespaced per project.

Serve analytics

Every mock hit is logged with its resolved scenario. See which endpoints the team actually exercises and which error paths were never tested.

Why Mock Alpha

Most mock tools mock a laptop. This one mocks your backend.

Local mock tools are great for one developer. They fall apart the moment a whole team, its testers, and its CI need the same fake backend at the same time.

The usual mock setup

Each developer runs their own mock server, and everyone's state drifts apart
Responses are hand-written JSON, pasted together and easily outdated
Everything is stateless. A POST changes nothing, flows can't be tested end to end
Config is shared by passing files around in Git and hoping everyone imports them
Backend schema changes are discovered when the app crashes in QA
HTTP only. Push messaging has to be faked somewhere else

Mock Alpha

One deployment, one URL. The whole team hits the same mock state
Real responses captured from staging, masked, and turned into scenarios
Scenario steps advance on every hit, so flows behave like a real backend
Multi-user projects with roles and email invitations, built into the dashboard
Every capture is diffed against the approved schema, breaking changes get flagged
Embedded MQTT broker publishes templated payloads alongside HTTP mocks