Mock API Studio
Mock API Studio is ForgePlug's flagship developer platform — a production-quality mock backend that runs entirely in your browser. Pick from 21 realistic datasets (users, posts, products, orders, invoices, companies and more), spin up a full CRUD REST API with filtering, sorting, pagination, search, mock JWT/API-key/basic authentication, error and latency simulation — then test it in a beautiful request playground, browse GraphQL schemas, generate OpenAPI specs, export to SQL/MongoDB/Postman/CSV, and copy ready-to-run code in 15 languages. Build custom collections from your own fields or import JSON/CSV. No login, no watermark, privacy-first — your data never leaves your device.
Mock API Studio
100% browser-based mock backend
Response customization
Custom response headers
No response headers yet — add one below.
Cookies (Set-Cookie)
No cookies yet — add one below.
Mock APIs are generated for development and testing purposes only. No personal information is collected or stored.
Ready for your first request
Pick a resource, tweak query params, then hit Send. Responses appear here with status, headers and timing.
GET /api/mock/users?limit=5
Tip: switch Playground to Live endpoint to hit the real /api/mock server (CORS enabled), keep Simulate for instant, offline request testing — or open the Realtime tab for mock WebSocket/SSE event streams.
Frequently Asked Questions
Everything you need to know about generating and consuming mock APIs
How does Mock API Studio work?
Is the mock data deterministic?
Can I call the API from my own app?
Do my collections or data leave my device?
What endpoints does the studio generate?
Can I import my own data?
Can I test realtime endpoints like WebSockets or SSE?
Is this really free?
Why the mock data is deterministic instead of random
And the difference between the Simulate and Live SSE modes that trips people up first.
I built the first version of this because I was tired of frontend work getting blocked on a backend endpoint that didn't exist yet — you either stub it with a hand-written JSON file that goes stale, or you wait. Mock API Studio generates realistic fake datasets with a real CRUD surface on top, entirely in your browser, so you can build against something that behaves like a REST API before the real one is ready.
How it works
The core design decision is that everything is seeded, not random. When you pick a dataset (say, "users") and a seed value, the generator produces the exact same rows every time for that seed — same names, same emails, same IDs. This matters more than it sounds: if your test suite asserts against specific field values, or your frontend snapshot tests compare rendered output, random mock data breaks them on every run for no reason. Change the seed and you get a different but equally consistent dataset. Underneath, requests to the generated endpoints go through an in-memory router that actually implements filtering, sorting, pagination, and nested relations — hitting /api/mock/users?country=Germany&sort=-createdAt really filters and sorts the generated rows rather than returning a canned response.
A real example
Say you're building a product listing page and the real backend won't have pagination and price filtering ready for two more weeks. Pick the "products" dataset, set a seed, and you immediately have a working endpoint at /api/mock/products?page=2&limit=20&price_gt=50 that returns real pagination metadata and actually respects the price filter — not a static JSON file you'd have to hand-edit every time you need a different scenario. Build the whole UI against it, and when the real backend ships, you're swapping a base URL, not rewriting logic that only worked against fake static data.
Common mistakes
- Confusing Simulate mode with Live endpoint mode. Simulate runs entirely client-side with zero network calls — good for offline work, but only visible in your own browser tab. Live endpoint mode hits a real hosted URL at forgeplug.com/api/mock/... with CORS enabled, which is what you actually need if you're calling it from a separate app or a teammate needs to hit the same data. Using Simulate mode when you actually needed a real network-reachable URL is the most common confusion I see.
- Expecting imported CSV/JSON data to behave exactly like the built-in datasets. Field-type detection on imported data is automatic but not perfect — a column of numeric-looking strings can get inferred as numbers when you needed strings (or vice versa). Check the inferred schema before building filters against it.
- Assuming realtime (WebSocket/SSE) events fire on a fixed schedule matching your production system. The Realtime tab streams synthetic create/update/delete events at an interval you control — it's for testing that your client-side event handling works, not for simulating your actual backend's real event cadence.
Tool Overview
A closer look at Mock API Studio — how it works, who it's for, and where it fits in your workflow.
Frontend and mobile developers shouldn't have to wait for a backend to start building. Mock API Studio lets you design realistic API responses — endpoints, datasets, REST collections, and GraphQL queries — and test your client against them instantly. Define resources like /users or /orders, attach sample datasets, and the studio serves them through configurable endpoints with full CRUD semantics, all without standing up a single server.
The realtime simulator takes mocking a step further: spin up WebSocket and SSE streams that push events on your schedule, so you can prototype chat, live dashboards, notifications, or IoT telemetry flows before any infrastructure exists. OpenAPI import lets you generate a complete mock from an existing specification, and the code generator emits typed clients and SDK snippets from your mock, turning a prototype into a head start on real integration code.
Because the whole studio runs in your browser, mock data — which frequently mirrors production schemas — never leaves your machine. There's nothing to deploy, no account to create, and no cost. Design, test, iterate, and ship the UI first; wire the real API when it's ready.
Key Features
Everything you get with this tool, at a glance.
REST & CRUD Endpoints
Define endpoints with status codes, headers, and response bodies in seconds.
Rich Datasets
Model collections of records that power list, detail, and filter responses.
GraphQL Mocking
Serve realistic query responses from your schema without a GraphQL server.
Realtime WS/SSE Simulator
Push scheduled WebSocket and SSE events to prototype live features.
OpenAPI Import
Generate a full mock from an existing OpenAPI specification.
Client Code Generation
Emit typed clients and SDK snippets from your mock definitions.
How to Use Mock API Studio
Get from zero to done in four quick steps — no account, no learning curve.
Create a resource
Add an endpoint such as GET /users and attach a sample dataset.
Shape the responses
Configure status codes, headers, and response bodies — or enable CRUD behavior.
Test from your client
Point your frontend at the generated mock URL and exercise success and error paths.
Share or codegen
Export the mock config or generate typed client code to speed up the real integration.
Practical Examples
Real input and output pairs so you know exactly what to expect.
Mock a list endpoint
Input
GET /users → dataset: [{id:1,name:"Ada"},{id:2,name:"Grace"}]Output
{"users":[{"id":1,"name":"Ada"},{"id":2,"name":"Grace"}],"total":2}Realtime event stream
Input
SSE channel "notifications" → every 3s push {type:"ping",ts:...}Output
5 events streamed: ping, ping, ping, ping, ping
Not-found response
Error caseInput
GET /users/999
Output
The tool flags this input as invalid — no output is produced until the issue is fixed.
Guides & Articles
Learn how to get the most out of this tool with our in-depth guides.
How to Test a REST API Without Building a Backend
You don't need a server to design, test, and document an API. Here's how mock APIs work and how to prototype requests, errors, and auth.
What Is JSON Schema and When Should Developers Use It?
JSON Schema describes the shape of JSON data — required fields, types, ranges — in a machine-checkable form. Here's when it's worth using.
How to Format JSON When Debugging API Responses
Raw API responses arrive as one long unreadable line. Here's how to format them, what the common errors mean, and when formatting alone won't save you.
Was this tool helpful?
Your feedback helps us improve Mock API Studio for everyone.
Share this tool
