Free for teams up to 5 — no install, no card.

Version control for your API, not just your code.

Push code. APIOS reads every endpoint, flags breaking changes in caller terms, and holds them for human review. The reference, OpenAPI spec, and mock regenerate from the same approval — nothing drifts.

Nothing publishes without review Every approval kept, permanently Keyboard-first Self-hostable

Every other tool

Docs are a second copy of the truth

The spec is written by hand. The code moves on. Six weeks later the mock returns fields that no longer exist.

src/routes/orders.tsPOST /orders · requires authopenapi.yamlPOST /orders · public  ← stale
APIOS

Docs are a projection of the truth

No second copy to maintain. The reference, spec, and mock are all derived from your code — and only update after a human approves.

src/routes/orders.tsPOST /orders · requires authreference · openapi · mockPOST /orders · requires auth  ← derived
How it works

Four steps, and you own the one that matters

Fully automatic until the step that needs judgment — that one stays yours.

  1. 1Push

    Connect the repo

    Express, Fastify, Hono, NestJS, Next.js, FastAPI, Flask, Django, Gin, Echo, Fiber, Spring, Rails, Laravel, ASP.NET — route handlers detected automatically, in whichever language they are written. Zero annotations.

  2. 2Extract

    Read what changed

    Endpoints, params, body fields, status codes, and auth — pulled straight from source.

  3. 3Review

    In caller terms

    Auth added to a public route is breaking, even if it's one line. Changes are judged by consumer impact.

  4. 4Publish

    Everything at once

    One approval regenerates the reference, OpenAPI 3.1 doc, and mock server in a single pass.

your-workspace / review queue
a4f21c9 · feat: require auth on order refunds
src/routes/orders.ts
−router.post("/orders/:id/refund", handler)
+router.post("/orders/:id/refund", requireAuth, handler)

A route changes. APIOS reads the push, not a spec you'd have to update by hand.

One approval

Four artifacts that cannot disagree

Generated from the same approved endpoints in one pass. “Mock out of sync with docs” stops being a thing.

API reference

Grouped, searchable, with runnable cURL per endpoint. Generated from reviewer-approved code.

OpenAPI 3.1

JSON or YAML with real operation IDs. Feed it to any generator you already use.

A running mock

Simulates auth and pagination. Force failures so the frontend can build error states before the backend ships.

A collection you can send

Organized by resource, documented to the source file and line, with auth and environment pre-wired.

The gate

Catch it in the pull request, not in the incident

A dashboard gets checked after the outage. A required CI check blocks the merge until someone reviews the consumer impact.

  • Read-only — never publishes, safe on every push.
  • Always returns 200 with the verdict in the body. An outage never looks like a breaking change.
  • Authenticates with a role-scoped API key, not a session cookie.
  • Returns findings, counts, and a link to the review queue.
Required check · pull request
# fails the build when the API changed and nobody said so
curl -X POST $APIOS_URL/api/check \
  -H "Authorization: Bearer $APIOS_API_KEY" \
  -d '{"repository":"acme/orders","ref":"$GITHUB_SHA"}'

# → { "ok": false, "counts": { "breaking": 1 },
    "findings": [{ "kind": "field.removed",
      "method": "GET", "path": "/orders/:id" }],
    "reviewUrl": "…/builder?rail=review" }
And the client it ships with

Free forever, and genuinely good

Try it here — real requests, no account needed. Sign in once for the full workspace. Your data stays in the browser.

apios, live playground
GET

This is a real request.

Press Send and it goes out through the same proxy the product uses, real latency, real headers, no CORS.

Built around what actually costs you time

Composing the request was never the hard part.

Error detective

Every failure gets a root cause, a fix, and the checks to run — grounded in the actual request.

Requests from a sentence

Describe the endpoint in plain English. Get method, URL, headers, payload, and docs.

Tests from real responses

Assertions derived from the response you received. Every path is guaranteed to exist.

Timing that names the culprit

DNS, TCP, TLS, TTFB, and download — measured at the socket, explained in a sentence.

Chaining without scripts

Bind a token from a login response and every subsequent request uses it. No scripts.

Paste any cURL

Drop a cURL from docs, a bug report, or DevTools. The entire request populates instantly.

And everything else

Everything you’d otherwise stitch together

Runner, mock server, monitors, four protocols, and import — one workspace instead of four tools.

Run a whole collection

Run a folder top to bottom, carrying values forward. Assertions per step, stop on failure, save the report.

Not only HTTP

WebSocket, SSE, and gRPC-Web — same tabs, environments, and history as HTTP.

Environments that hold secrets

Mark a variable secret and it stays masked. Share the environment — keys travel, values don't.

Import anything

OpenAPI 3.x, Postman v2.1, and cURL in. Postman out. Nothing is trapped.

The request, as code

Turn any request into a code snippet with variables resolved. What you paste is what you sent.

Diff against last time

The response viewer remembers the last run and highlights what changed. No more guessing.

Uptime monitors

Schedule any request, assert on the response. Hear it from us, not your customers.

History and a cookie jar

Full request history, searchable, plus a cookie jar that behaves like a browser's.

Keyboard-first

Your hands never leave the keyboard

Every action, two keystrokes away. One palette for requests, environments, tabs, and commands.

⌘KCommand palette⌘↵Send request⌘5Review queue?Every shortcut
Search requests, or run a command…

Requests

GETList products
POSTCreate user
DELETERemove order

Actions

Publish approved proposal⌘5
Compare

Everyone else diffs your spec

They all diff a hand-maintained spec. That’s the artifact that drifts.

For an organisation

Built for 30 repos and five roles

Every guarantee is enforced server-side, not behind a greyed-out button.

Five roles, one matrix

Reviewers approve. A separate permission publishes. Enforced server-side, not behind a greyed-out button.

An audit log that answers questions

Every publish, role change, and connection logged with who did it. Post-incident, you'll have the answer.

Credentials for machines

Role-scoped API keys for CI — no more session cookies pasted into secrets.

Share without an account

Publish publicly or share a single link. Partners read the real docs without an account.

Who breaks if this ships

Consumers tracked per endpoint. Breaking changes measured by who calls it, not diff size.

Live across the team

Real-time presence and updates. Two people in the review queue see the same queue.

Pricing

Priced per workspace. Never per reviewer.

Scale is metered — seats, repos, audit retention. Review and breaking-change detection are always free.

Free

A real team, and the whole pipeline.

$0forever

Start free
  • 5 members, not one, and no card
  • 3 repositories, read on every push
  • Breaking-change detection, review queue, audit log
  • Generated reference, OpenAPI 3.1 and mock server
  • The full client: chaining, runner, response diff, AI
  • Self-hostable, on this tier too

Enterprise

For teams with a security review.

Customannual

Talk to us
  • Everything in Team
  • Unlimited members, repositories and keys
  • SSO / SAML and SCIM provisioning
  • Unlimited audit retention, exportable to your SIEM
  • SLA and dedicated support

Team pricing is per workspace, not per seat. Add reviewers freely. Self-hosting available on every tier, including free.

Stop maintaining a second copy

Connect a repo and see your first proposal. Or send a request in ten seconds. Free, forever.