Skip to content
ForgePlug — Logo
developer100% Browser-BasedNo Signup

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

Quick resources:
/api/mock
Endpoint mode
Response customization
Envelope pagination ({ data, meta })

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?
Everything runs in your browser. We generate realistic fake data deterministically from a seed, then simulate a REST server in memory — routing, CRUD, filtering, sorting, pagination, authentication and error/latency scenarios. No backend, no account, no uploads.
Is the mock data deterministic?
Yes. The same dataset, seed and record count always produce the same rows, so your tests and frontend code see stable responses. Change the seed to regenerate different data.
Can I call the API from my own app?
Yes — switch the playground to 'Live endpoint' mode, or use the generated code snippets. ForgePlug hosts a real endpoint at https://forgeplug.com/api/mock/<resource> (e.g. /api/mock/users?limit=5) that serves the same deterministic data with CORS enabled for local development.
Do my collections or data leave my device?
No. Custom collections, imported JSON/CSV and your request history are stored only in your browser's local storage. The statement 'Mock APIs are generated for development and testing purposes only. No personal information is collected or stored.' applies — we never collect personal information.
What endpoints does the studio generate?
Every dataset gets a full CRUD surface: GET /:resource, GET /:resource/:id, POST, PUT, PATCH and DELETE, plus nested relations such as /users/:id/posts and query operators like ?page=, ?limit=, ?sort=, ?q=, ?country=, ?price_gt=, ?cursor= and ?fields=.
Can I import my own data?
Yes. Use the Schema Builder tab to define fields and generate rows, or paste/upload a JSON array or CSV file — the studio auto-detects field types and exposes the data as a new mock resource immediately.
Can I test realtime endpoints like WebSockets or SSE?
Yes — the Realtime tab streams mock create/update/delete events from any dataset. In Simulate mode everything runs in your browser with zero network calls (perfect for offline WebSocket prototyping). Switch to Live SSE to consume a real stream at /api/mock/realtime?resource=users&interval=1000 with CORS enabled — it works with EventSource, fetch streams and curl, and uses the same deterministic data as the REST API.
Is this really free?
Yes. No login, no watermark, no rate limits, unlimited requests. ForgePlug's mission is fast, private, browser-first developer tools.

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.

  1. Create a resource

    Add an endpoint such as GET /users and attach a sample dataset.

  2. Shape the responses

    Configure status codes, headers, and response bodies — or enable CRUD behavior.

  3. Test from your client

    Point your frontend at the generated mock URL and exercise success and error paths.

  4. 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 case

Input

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.

Was this tool helpful?

Your feedback helps us improve Mock API Studio for everyone.

Share this tool

Share
Runs in your browser100% privateNo data uploaded