AI-native API registry & MCP layer

Your AI agents, finally fluent in your internal APIs

spec0 is the live, governed registry of your internal APIs — so every agent queries the current spec, never a stale doc or a 150k-token dump.

Get started free

app.spec0.io — acme

live

Org

Dashboard

APIs

Mocks

Teams

All APIs 2

payments-api

v3.2.0 · Billing MCP

catalog-api

v1.8.4 · Growth MCP

orders-api

v1.4.2 · Checkout MCP

orders-api

v1.4.2 Active

Spec

✓ indexed

Mock

live

Team

Checkout

MCP

available

Operations

GET /orders

POST /orders/{id}/refunds

GET /orders/{id}

$ ▍ ✓ pushed · indexed · v1.4.2

One push — live in the registry, mocked, owned by a team, and answering your agents.

Works natively with

Cursor Claude Code Any MCP client

tokens per query: ~300
stale specs: 0s
data residency: EU
LLM keys stored: 0

The platform

Push once. Query forever.

Every spec your team pushes — from CI, the web UI, or CLI — is indexed, governed, and live over the API Registry MCP. Your agents query exactly what they need, always current, never pasted.

Explore the MCP Layer

Three paths in, one live registry out

Push via CI, the web UI, or CLI directly — spec0 indexes every spec as operations, components & metadata, governed by your team structure, and exposes them over the API Registry MCP.

spec0 — registry 3 live

Main

Dashboard

APIs

Teams

Mocks

Settings

Environments

All APIs (4)

orders-api

v2.1 · Payments MCP

payments-api

v1.4 · Payments MCP

auth-service

v3.0 · Platform MCP

notifications

v1.0 · Growth —

Team ownership

APIs know their team. Governance, change alerts, and subscriber routing go to the right owners automatically.

push → ✓ lint → diff → API Reg MCP

spectral lint diff check mcp auto

Git-native lifecycle

Spectral lint and breaking-change detection on every push. Block bad specs before agents ever see them.

Strategy A

Pasting the spec

~150k tokens / session

paths: /orders/{id}/refunds: post:
…and 4,800 more lines of unrelated endpoints

Pasted at 9am. Spec changed by lunch. The agent doesn't know.

Strategy B · spec0

Querying via API Registry MCP

~400 tokens / query

// get_api_spec("orders-api", "POST /orders/{id}/refunds")
body: amount_minor_units · reason · Idempotency-Key

Retrieved the moment the agent asked. Always current. Nothing it didn't need.

Schema-correct mocks

push spec

lint

diff

API Reg
MCP

mock ready

Schema-correct mocks

From push to live mock in one step. Open source (MIT) — self-hostable in your VPC or CI.

GitHub → mock-server

From zero to agent-ready

In your agent in 5 minutes. No hand-editing JSON.

Explore the API Registry

Create your account

✓ Org provisioned · Private registry ready · MCP endpoint live

acme provisioned

✓ Private registry ready

✓ MCP endpoint live

▸ app.spec0.io

Push your spec from CI

Install the CLI, authenticate once, and push your private OpenAPI spec. Add to CI to keep it always current on every merge.

✓ Spec indexed · Org-scoped · Auto-linted · Stays current on every push

bash

# Install the CLI
$ npm install -g @spec0/cli

# Authenticate (opens browser)
$ spec0 auth login

# Push your spec privately
$ spec0 push openapi.yaml

orders · v1.4.2 indexed

linted ✓ 12 operations org-scoped

Wire your agent's MCP client

One CLI command configures any client — Cursor, Claude Code, Windsurf. Your org bearer token is written automatically.

✓ Config written · Token included · Restart your client

bash

# Write your org-scoped MCP config
$ spec0 mcp install --client cursor

# → writes ~/.cursor/mcp.json
# → includes your org bearer token
# → restart Cursor

▸ ~/.cursor/mcp.json

+ spec0 server · org bearer token · restart Cursor

Your agents know every API

Ask about any API in your catalog — cross-API search, governance-aware, always current. Every agent, every teammate, forever.

Always current Token-efficient Cross-API Org-scoped

▍ Using our Orders API, write a refund handler.

↓

POST /orders/{id}/refunds ~310 tok

retrieved the one operation it needed — always current, never a full spec dump.

What makes it stick

⊞

Intelligent API registry

Your entire org's API catalog, semantically indexed. Agents find the right operation across hundreds of APIs in a single query — not just one spec at a time.

search_my_apis across org

⎇

Git-native lifecycle

Push specs from CI on every merge. Auto-lint with Spectral, auto-generate changelogs, diff breaking changes — spec management that lives where your code lives.

spec0 push + spec0 ci

⬡

Governance at org scale

Enforce custom Spectral rulesets on every publish. Org-scoped RBAC, audit log for every MCP query, SSO — compliance that doesn't slow your teams down.

spectral · rbac · audit log

↻

Always in sync

Real-time MCP server — 300 tokens per query instead of 150k. Specs update the moment code merges. No stale docs, no manual refreshes, no re-pasting.

~300 tokens vs 150,000

Works with the MCP clients you already use

Cursor
Claude Code
Claude Desktop
Continue.dev
Cline
+ any MCP client

If your client speaks MCP, spec0 works.

Mock server

A live mock the moment you publish.

Hand-rolling a mock server — fake data to write, a service to host, drift from the real API the second it changes — is a tax every team quietly pays. Spec0 just hands you one. Push a spec, get a schema-accurate mock URL. Zero infrastructure.

Explore Mock Servers

Generated from your spec. Always current.

Every API you push gets a mock automatically, serving realistic responses straight from your schema. Change the spec and the mock changes with it — it never lies to whoever's building against it.

bash

$ spec0 mock create --api orders
→ live at https://mock.spec0.io/acme/orders

GET /orders/o_92f1 200 OK

{
  "id": "o_92f1",
  "status": "fulfilled",
  "total": 4299
}

Real behaviour, no backend.

Auto-generated examples get you moving in seconds; then shape the edges with expression rules — a 404 for a missing order, a 402 when the balance is zero, a different payload per query param. The hard cases your frontend has to handle, without waiting on the API.

Response rules

when order.id == "0" → 404

when balance <= 0 → 402

default → 200

Let your agents call it.

Point Claude, Cursor, or any MCP client at the mock and let them build and test integrations against a live endpoint before the real API exists. Spec0's MCP server hands the agent the spec; the mock answers its calls.

▍ Test the refund flow against our mock.

↓

POST /orders/o_1/refunds 200

agent verified the happy path + the 402 on a zero balance — no backend yet.

Share one URL. Gate your CI.

The part teams fall for: one link your whole org and your consumers can hit, always current — no "spin it up locally" ritual. Then wire it into CI and run contract tests on every push, so a backward-incompatible change is caught in the PR that introduces it — not in a customer's incident channel.

Shareable URL Contract tests in CI Catch BWC breaks

mock.spec0.io/acme/orders

✓ contract-tests · consumer: web-app

✓ contract-tests · consumer: partner-sdk

✗ breaking change · removed field orders.total

Blocked in the PR — before it reached a consumer.

spec0 mock create --api orders CLI + MCP, built in

Hosted in the EU
·
Specs encrypted at rest
·
Status page
·
Security
·
Open-source CLI and mock server

FAQ

Reasonable questions before you push.

Where does my OpenAPI spec live?

Encrypted at rest in EU-hosted Postgres. You can delete any spec via CLI or API at any time. We don't share, train on, or expose your specs.

Does spec0 see my LLM prompts?

No. Your agent runs on your OpenAI or Anthropic account. spec0 only serves spec content over the API Registry MCP — we never see your prompts, your model output, or your model key.

What if the API Registry MCP goes down?

Live status at spec0.io/status . If the MCP is unreachable, your agent falls back to whatever context it already has — your code doesn't break.

Can I self-host?

The mock server (MIT) and the CLI (Apache-2.0) are open source and self-hostable. The registry and the API Registry MCP layer are a managed, EU-hosted service — self-hosting them isn't on the roadmap.

Early access for design partners

If you're at a 50–500 person engineering org, use Cursor or Claude Code daily, and have internal OpenAPI specs you'd like your agents to query — we want to talk.

Six months of Team tier free, in exchange for two 30-minute conversations as we ship.

Email us

Give your agents live access. Today.

No account needed to try it. Five commands to make it yours.

5 commands

$ # paste demo config → restart Cursor

$ npm install -g @spec0/cli

$ spec0 auth login

$ spec0 push openapi.yaml

$ spec0 mcp install --client cursor

Get started free Apply as design partner →

Or book a 20-minute demo and we'll do it together.