Remix is React Router v7+ framework mode now — and your loaders still need an API that exists. We pointed them at a hosted mock with realistic seeded data: thrown-Response 404s render your ErrorBoundary with a real 404 status, and ?mock_status=500 shows the crash page on demand:

Mock a REST API for Remix / React Router in 60 seconds — Mockbird Guides

Loaders against a hosted mock, ErrorBoundary with real 404s, pending UI proven with ?mock_delay, Vitest on snapshot-pinned data.

mockbird.mockbird.workers.dev

Solid's createResource + Suspense + ErrorBoundary want an API that can actually fail. We drove a fresh Vite+Solid app against a hosted mock and hit 3 gotchas for real: a Retry button that never retries, the keystroke flash .latest fixes, and a falsy source that silently never fetches:

Mock API for SolidJS — createResource, Suspense & ErrorBoundary against a real URL

Every snippet driven in a real browser: the Retry button that never retries, the keystroke flash .latest fixes, the falsy source that silently never fetches. Free hosted mock API.

mockbird.mockbird.workers.dev

Astro's static-by-default means your 'mock API' has to be a URL that's up when CI builds. We built an Astro 7 site against a hosted mock: getStaticPaths page-per-record, paginate() that's real, and 2 gotchas we hit for real — numeric route params fail the build, and the missing charset mojibake:

Mock a REST API for your Astro site in 60 seconds — Mockbird Guides

Build-time fetch, getStaticPaths page-per-record, real paginate(), client-island search, on-demand node adapter — every snippet built and browser-checked in a fresh Astro 7 project.

mockbird.mockbird.workers.dev

htmx swaps HTML — but every mock API tool speaks JSON. Mockbird custom routes return templated HTML fragments: hx-post a form and get {{body.email}} rendered back, spinners vs real latency, error states on demand. Plus the htmx 2.0 selfRequestsOnly gotcha that bites first:

Mock backend for htmx — endpoints that speak HTML fragments, not JSON

Free hosted endpoints that return templated HTML fragments: hx-post forms rendered server-side, spinners with ?mock_delay, error states with ?mock_status, HX-Trigger events.

mockbird.mockbird.workers.dev

Nuxt folks: useLazyFetch does NOT give you a visible skeleton on hard loads — SSR still awaits the fetch. We measured it: 2,320ms shell with plain useLazyFetch, 225ms after adding server:false. That gotcha + real pagination + an error.vue you can trigger on demand, all in one guide:

Mock a REST API for your Nuxt app in 60 seconds — Mockbird Guides

useAsyncData with real X-Total-Count pagination, error.vue on demand with ?mock_status, visible skeletons via ?mock_delay, a one-line routeRules proxy. Every snippet run in a real Nuxt 4 app.

mockbird.mockbird.workers.dev

Retry tests with mock_chaos=0.5 are probabilistic — fine for soak, flaky for assertions. New: ?mock_seq=503,503,200. First request fails, second fails, third+ serves real data. Exactly. WireMock calls this a scenario state machine; here it's a query param on any endpoint:

Testing loading and error states — Mockbird Guides

mock_delay, mock_status, mock_chaos and deterministic mock_seq sequences: drill every sad path of your UI against a hosted mock API. Free, no signup.

mockbird.mockbird.workers.dev

Spring Boot devs: your external-API base URL already lives in a property. So the whole test mocking story is ONE line of application-test.properties — RestClient, @GetExchange interfaces, everything follows it. Real @Retryable retries vs injected 5xx chaos, verified on Boot 3.3:

Mock API for Spring Boot tests — RestClient, @Retryable, snapshots | Mockbird

One line of application-test.properties points RestClient at a hosted mock: pagination, typed errors, real timeouts, chaos-vs-@Retryable, snapshot pinning. Free, no signup.

mockbird.mockbird.workers.dev

Your test suite calls the OpenAI API: every CI run costs tokens, returns something different each time, and sometimes eats an unrelated 429. We made a hosted OpenAI-compatible mock — deterministic replies, real SSE streaming, injected failures. Verified with the official SDK:

Mock the OpenAI API — test AI clients and agents without burning tokens

OpenAI-compatible chat completions (streaming + JSON), models and embeddings, deterministic replies, injected 429/500s, latency simulation. Point OPENAI_BASE_URL at it — no code change, no signup. Verified with the official SDK.

mockbird.mockbird.workers.dev

FastAPI devs: TestClient mocks nothing external, and respx only patches httpx — we watched `requests` + urllib fetch REAL data mid-test past an active mock. dependency_overrides? In-process only: uvicorn/Playwright/workers never see it. Every claim verified on FastAPI 0.141:

Mock a REST API for FastAPI — where respx, TestClient and dependency_overrides stop

respx patches httpx only; TestClient mocks nothing external; dependency_overrides is in-process. When the mock needs to be a URL: hosted, free, verified with 12 tests.

mockbird.mockbird.workers.dev

Django devs: the `responses` library only patches `requests` — we watched httpx and urllib fetch REAL data mid-test past an active mock. mock.patch("requests.get") misses `from requests import get`. And runserver/celery/Playwright never see any of it. Every claim verified on Django 6:

Mock APIs in Django — responses/mock.patch and when the mock needs to be a real URL

Verified on Django 6: the responses library only patches requests (httpx and urllib hit the real network mid-test), mock.patch has the classic where-to-patch trap, and no in-process mock reaches runserver, Playwright or celery.

mockbird.mockbird.workers.dev

Laravel devs: Http::fake() has a sharp default — unmatched requests silently hit the REAL network. And it only fakes the Http facade: direct Guzzle, raw curl, and anything in another process (Dusk! queue workers!) sail past it. We verified every claim on Laravel 13, tests included:

Mock API for Laravel — Http::fake()'s verified limits and a hosted alternative | Mockbird

Http::fake()'s verified gotchas: unmatched requests silently hit the real network, direct Guzzle/curl bypass the fake, Dusk and queue workers never see it. When the mock needs to be a real URL: hosted stateful CRUD, one curl.

mockbird.mockbird.workers.dev

axios users: axios-mock-adapter only mocks the axios instance you wrap. Native fetch, an SDK's internal instance, curl, teammates — all sail past it to the real network. And an unmatched request gets a synthesized 404 by default. We verified every claim (v2.1.0, Node 22):

axios-mock-adapter alternative — a real mock API URL, no adapter code | Mockbird

Only the wrapped axios instance is mocked — fetch and other instances pass through; unmatched requests get a synthesized 404. When the mock needs to be a real URL: hosted stateful CRUD, one curl.

mockbird.mockbird.workers.dev

Cypress folks: cy.intercept never sees cy.request() — the very tool Cypress recommends for API tests, seeding, and login-by-request. We wrote a test that proves it: the intercept would return [], yet cy.request got 3 real products and the handler fired 0 times. All snippets run verbatim:

Mock API for Cypress tests — beyond cy.intercept | Mockbird

cy.intercept never sees cy.request(). Point Cypress at a hosted, stateful mock API: real CRUD, error/latency simulation, snapshot-pinned scenarios.

mockbird.mockbird.workers.dev

ReferenceError: fetch is not defined — the classic Jest jsdom surprise (Node has had fetch since v18; jsdom still doesn't). One-line fix, then the better question: why stub fetch at all? Point Jest at a hosted mock URL — error states, real timeouts, parallel files pinned to frozen snapshots:

Mock APIs in Jest — fix "fetch is not defined" and test against a real URL

The jsdom fetch fix, error-state tests with ?mock_status, real timeouts, parallel files pinned to frozen snapshots, retry vs injected 5xx chaos, Zod contract tests — every snippet run verbatim.

mockbird.mockbird.workers.dev

Vitest runs test files in parallel by default. If your files share one mutable mock dataset, they race — every 'reset the DB in beforeEach' strategy included. Fix: pin each file to a frozen server-side snapshot with one header. Read-only, no interference, verified with a real parallel run:

Mock APIs for Vitest — parallel-safe, no fetch stubs

Snapshot-pinned parallel test files, real timeouts, chaos retries, Zod contract tests — every snippet run verbatim against a live hosted mock.

mockbird.mockbird.workers.dev

Playwright folks: your page.route mocks have a blind spot — SSR/loader fetches never hit them. We wrote a test that proves it: the page renders API data and the route handler never fires. That, plus a route.fallback gotcha that makes error-state tests pass for the wrong reason. All run verbatim:

Mock APIs for Playwright: what page.route can't reach

SSR blind spot proved with a real test, route.fallback gotcha dissected, hosted-mock fix — every snippet run verbatim.

mockbird.mockbird.workers.dev

Node folks: if nock is silently ignoring your fetch() calls — nock v13 doesn't see native fetch at all, and half of nock's ~7M weekly installs are still v13. Upgrading to v14+ genuinely fixes it. And when the mock needs to be a URL curl, browsers, teammates and CI can hit — every claim tested first:

Nock alternative: when the mock needs to be a URL — Mockbird

nock v13 doesn't intercept native fetch. Every claim tested: v13 vs v15 behavior, consumed-once gotcha, and a hosted stateful mock API as the URL-shaped fix.

mockbird.mockbird.workers.dev

Kotlin folks: Ktor's MockEngine is genuinely great — official, multiplatform, one-line DI swap. But the mock lives inside your Kotlin process: curl, the iOS half of your KMP app, teammates and CI get nothing, and every handler is code you maintain. Hosted-URL guide, every snippet compiled+run first.

Mock APIs for Ktor & Kotlin — beyond MockEngine | Mockbird

When the mock needs to be a URL: hosted CRUD, chaos, timeouts, snapshot pinning. Every snippet compiled and run against prod.

mockbird.mockbird.workers.dev

Swift folks: URLProtocol stubbing is elegant — Mocker and OHHTTPStubs wrap it well. But the stub lives in one process: it can't feed the simulator, SwiftUI previews, teammates and CI, and it answers in microseconds so timeout/retry code never runs. Zero-dep guide, every snippet compiled+run.

Mock a REST API for Swift — URLSession, async/await and Swift Testing against a real URL

Hosted mock API for Swift, zero dependencies: real URLSession timeouts, retry vs injected 5xx chaos, parallel Swift Testing pinned to frozen snapshots, typed client via swift-openapi-generator.

mockbird.mockbird.workers.dev

Bun folks: your in-process mocks are fine — bun:test spyOn can stub fetch, and MSW runs in Bun (verified both). But a stub can't feed the same dataset to your service, frontend and CI, and it answers instantly — retry/timeout code never really runs. Point it at a hosted mock that really 503s.

Mock APIs for Bun — hosted, stateful, every snippet verified

bun:test stubs and MSW work in Bun — this guide is for when the mock needs to be a URL: chaos-tested retries, real timeouts, frozen snapshots, native-TS typed clients. Free, no signup.

mockbird.mockbird.workers.dev

Deno folks: your mock API can be your type checker too. Deno imports by URL — import type { Product } from the mock's own /types.ts and deno check enforces the live schema. No codegen, no npm, nothing to commit. Schema changed? deno check --reload. Every snippet run before publishing.

Mock a REST API for Deno — typed fetch and Deno.test against a real URL

Import your API's TypeScript types straight from the mock's URL; deno check enforces the live schema. Retry vs injected chaos, real timeouts, frozen snapshots.

mockbird.mockbird.workers.dev

Elixir folks: Bypass, Mox and ExVCR are great — but an in-node fake can't hit a real receive_timeout over the network, and Req's retry: :transient almost never fires outside an incident. A hosted mock really 503s, really holds a response 3s, really rate-limits. Every snippet run before publishing.

Free hosted mock API for Elixir — Req, ExUnit, retries, snapshots

Point Req at a hosted mock that really 503s, delays, and rate-limits. Every snippet run against prod before publishing.

mockbird.mockbird.workers.dev

Rust folks: wiremock, httpmock, mockito are great — but a loopback mock can't feed one dataset to frontend, teammates and CI, and stubs never exercise reqwest-retry backoff. A hosted mock really holds a response 3s (err.is_timeout()), really 503s, really rate-limits. Every snippet compiled + run.

Mock a REST API for Rust — reqwest, retries and cargo test against a real URL

A real hosted URL for reqwest, serde and cargo test. Exercise actual reqwest-retry backoff against injected 5xx chaos, pin parallel tokio tests to frozen snapshots. Every snippet compiled and run before publishing.

mockbird.mockbird.workers.dev

Android devs: mocking against your laptop means 10.0.2.2 aliases, LAN-IP juggling on real devices, and a cleartext-traffic XML to strip before release. A hosted https mock kills all three: emulator, device, teammate & CI hit one URL, zero network config. Every snippet was run before publishing.

Mock API for Android — Retrofit against a real URL (no 10.0.2.2, no cleartext config)

Tutorial: mock a REST API for Android in 60 seconds — a hosted https URL for Retrofit/OkHttp, so you can skip the 10.0.2.2 emulator alias, LAN IPs and cleartext-traffic config entirely.

mockbird.mockbird.workers.dev

.NET folks: WireMock.Net and MockHttpMessageHandler are great — but an in-process fake can't hit a real HttpClient.Timeout over the network, and instant stubs never truly exercise your Polly backoff. Point them at a hosted mock that really holds a response 3s, really 503s, really rate-limits.

Mock a REST API for C# / .NET — HttpClient, Polly retries and xUnit against a real URL — Mockbird Guides

Tutorial: mock a REST API for C# / .NET in 60 seconds — a real hosted URL for HttpClient, Polly and xUnit. Every snippet was run, verbatim, before publishing.

mockbird.mockbird.workers.dev

Java folks: WireMock and MockWebServer are great — but an in-JVM fake can't hit a real HttpTimeoutException, and instant stubs never truly exercise Resilience4j backoff. Point them at a hosted mock that really holds a response 3s, really 503s, really rate-limits. Every snippet run before publishing.

Mock API for Java: real timeouts, chaos & snapshot pinning

Hosted mock REST+GraphQL API for Java: java.net.http, Jackson, Resilience4j retries vs chaos, concurrent JUnit 5 snapshot pinning, openapi-generator client. Free.

mockbird.mockbird.workers.dev

Ruby folks: WebMock and VCR are great — but a patched client can't hit a real Net::ReadTimeout, and instant stubs never truly exercise your faraday-retry backoff. Point them at a hosted mock that really holds a response 3s, really 503s, really rate-limits. Every snippet run before publishing.

Mock API for Ruby — retries, timeouts & parallel tests for real

Faraday + faraday-retry against a hosted mock that really 503s, really delays, really rate-limits. Minitest & RSpec parallel-safe via snapshots. Free, no signup.

mockbird.mockbird.workers.dev

Go folks: httptest means hand-writing every handler, and gock answers instantly in-process — your http.Client{Timeout} branches and retryablehttp config never truly run. Point them at a hosted mock that really holds a response 3s, really 503s, really rate-limits. Every snippet was run pre-publish.

Mock API for Go — httptest & gock alternative that really times out | Mockbird

Hosted mock REST API for Go: real timeouts, real 503s, chaos for go-retryablehttp, snapshot pinning for parallel go test, oapi-codegen ready. Free.

mockbird.mockbird.workers.dev

Node folks: nock / axios-mock-adapter / undici MockAgent answer instantly in-process — your AbortSignal.timeout() and axios-retry config never truly run. Point them at a hosted mock that really holds a response 3s, really 503s, really rate-limits. Every snippet here was run before publishing.

Mock APIs for Node.js — fetch, axios, node:test (every snippet actually run)

Hosted mock REST API with real delays, real 503s, real rate limits — test retry/timeout code for real. Free, no signup.

mockbird.mockbird.workers.dev

Python folks: responses/requests-mock stubs return instantly in-process, so your timeout= handling and urllib3 Retry config are never truly exercised. Point them at a hosted mock that really holds a response 3s, really 503s, really rate-limits. Every snippet here was run before publishing.

Mock APIs for Python — requests, httpx, pytest (every snippet actually run)

Hosted mock REST API with real delays, real 503s, real rate limits — test retry/timeout code for real. Free, no signup.

mockbird.mockbird.workers.dev