What does "monitoring inside the SDK" actually mean?

Your users install a client that already knows how to report itself. When it throws in production, the error reaches you tagged with the SDK version, the language and the method that failed. Ingress is metered, so a very chatty SDK counts against your plan’s monthly allowance.

Can I edit the generated docs and SDKs?

Yes, and regeneration works around your edits. Docs changes are stored per page, so a new spec revision only disturbs the endpoints that actually changed. Custom SDK code is available on Growth and above.

What happens when my spec changes?

Nothing republishes behind your back. The rebuild produces a draft and a diff of what moved, you approve it, and that is when new SDK versions reach the registries.

Enterprise plans can run the generator and the docs renderer in your own infrastructure.

How hard is it to migrate from Mintlify or Speakeasy?

Most of a day for a normal docs site. The importer rebuilds your structure from the config you already have. What takes real work is anything hand-built on top of it, like custom components or bespoke pages.

Your OpenAPI spec, all the way to production.

A docs site, SDKs in ten languages, an MCP server for agents, and monitoring that tells you when those SDKs break in production. One spec generates all four and keeps them current.

Start for free Generate your SDK

AACME APIAPI ReferenceChangelog

Search…⌘K

PAYMENTSGETReturns a list of payments./paymentsPOSTCreate a payment against a customer…/paymentsGETRetrieves a payment./payments/{payment_id}POSTCaptures an authorized payment./payments/{payment_id}/captureDELETECancel a payment./payments/{payment_id}REFUNDSPOSTRefunds a captured payment./refundsGETReturns a list of refunds./refundsGETRetrieves a refund./refunds/{refund_id}POSTUpdates a refund's metadata./refunds/{refund_id}GETReturns a refund's ledger entrie…/refunds/{refund_id}/ledgerPOSTCancel a pending refund./refunds/{refund_id}/cancelGETRetrieves a ledger entry./ledger/{entry_id}CUSTOMERSGETList your organization's customers./customersPOSTCreates a customer from a billing pr…/customersGETRetrieves a customer./customers/{customer_id}

llms.txtPowered by Octri

GET/payments

Returns a list of payments.

Every list endpoint is paginated.Ask for up to 100 objects per page.Cursors stay valid for 24 hours.

Request4 parameters

QUERY PARAMETERS4

limitintegeroptional

A limit on the number of objects to be returned. Limit can range between 1 and 100, and the default is 20.

Default: 20orderstringoptional

Sort order by the created_at timestamp of the objects. asc for ascending order and desc for descending order.

Allowed:ascdescDefault:descafterstringoptional

A cursor for use in pagination. after is an object ID that defines your place in the list. For instance, if you make a list request and receive 100 objects, ending with obj_foo, your subsequent call can include after=obj_foo.

beforestringoptional

A cursor for use in pagination. before is an object ID that defines your place in the list.

Response1 status code

200OK

objectstringREQUIREDdataarray<Payment>REQUIREDShow 13 properties per itemfirst_idstringREQUIREDlast_idstringREQUIREDhas_morebooleanREQUIRED

Copy for LLMView raw

REQUESTTypeScript SDKCopy

import { configureClient, listPayments } from "acme-sdk";

configureClient({
  baseUrl: "https://api.acme.com",
  auth: { bearer: process.env.API_TOKEN },
});

const result = await listPayments({ limit: 20, order: "desc" });

RESPONSECopy

{
  "object": "list",
  "data": [
    {
      "id": "pay_3Nx8kL2eZvKYlo2C",
      "object": "payment",
      "created_at": 1,
      "amount": 4200,
      "currency": "usd",
      "status": "succeeded",
      "customer": "cus_9fK2Lp",
      "payment_method": {
        "type": "card",
        "card": {
          "brand": "visa",
          "last4": "4242"
        }
      },
      "captured": true,
      "refunded": false,
      "receipt_url": "https://acme.com/r/3Nx8"
    }
  ],
  "first_id": "pay_abc123",
  "last_id": "pay_abc456",
  "has_more": false
}

One input

Upload a spec once. Ship four products

Docs, SDKs, monitoring and agent tools. Each one stands on its own. They just happen to be better together.

input
Your spec
Any format: OpenAPI, Swagger, Postman or AsyncAPI, JSON or YAML. Normalised to OpenAPI 3.1.
Docs site
Written, edited, published
SDKs · 10 languages
Tuned to your house style
Observability
What breaks, and why
MCP server
Your API as agent tools

Four products, one platform

API Studio

Docs from your spec

Documentation your readers actually finish. Generated from the spec, edited by you, published to your own domain.

Explore API Studio

SDK Studio

Ten languages, zero forks

Idiomatic client libraries in 10 languages. Configure them, don't fork them. Auto-publish to every registry.

Explore SDK Studio

Monitoring

Errors traced to a commit

What breaks, and why. Errors grouped and traced to a commit, from your SDKs or your own backend.

Explore Monitoring

MCP

Your API as agent tools

Your API becomes context and callable tools for Claude, Cursor, and any MCP client.

Explore MCP

API StudioAPI documentation

Docs worth reading, from the spec you already have

AI writes the first draft for every endpoint. You edit it like a document. Nobody has to open the YAML.

Three-column endpoint pages with schema trees that open a level at a time
Live “try it” playground on every endpoint
MDX guides alongside the generated reference
Custom domains and white-label on every tier, so it stays your brand

See API Studio

SDK StudioSDK generator

Ten languages, built to your conventions

Rename methods, exclude endpoints, pick your HTTP engine and folder structure. Then let it publish itself.

Per-language config for namespaces, pagination, idempotency and code style
Custom hooks you write, compiled into the client
Auto-publish to npm, PyPI, Maven, crates.io, RubyGems and more
Build history so you can see exactly what shipped and when

See SDK Studio

MonitoringSDK and API monitoring

Find out what breaks before your customers tell you

Two ways in: flip it on and the telemetry compiles into your generated SDKs, or drop the standalone package straight into your backend. Either way, there's no agent to deploy and nothing to instrument.

Logs

Query structured events directly by level, route, status code or release.

Issues

Errors grouped by fingerprint, each with the function and file that threw it.

Traces

One request end to end across client, server, cache, database and queue, with the slow span called out.

Service map

Every service, the calls between them, and the error rate on each edge.

N+1 queries

The same query fired in a loop, found for you and counted across traces.

Uptime

Synthetic probes on a schedule, with the run history behind every endpoint.

Alerts

Fire on burn rate and regressions, so a single stray 500 never wakes anyone.

Security

Credentials and identifiers are redacted client side before an event leaves your process, then again at ingest.

Monitoring is off by default and switches on from the dashboard. Credentials and direct identifiers, from tokens to email, phone and IP, are redacted on the client side, before an event leaves your process, then again at ingest. Personal context waits on your app's consent, under a pre-signed GDPR Article 28 DPA.

See Monitoring

MCPMCP server for agents

Stop agents from hallucinating your API

MCP is how an agent reaches something it was never trained on. Without it, Claude or Cursor integrates your API from memory. With it, one command turns your project into a server they connect to. Then they list your real endpoints and call them.

Seven documentation tools to search, read and navigate your docs
One callable tool per endpoint, so the agent can hit your API for real
Curated by SDK Studio, so your exclusion list becomes the agent's permission list
One line to install: npx @octri/mcp, with nothing to host

See MCP

Is your spec ready for code generation?

Paste your OpenAPI URL and get a score out of 10, on the same rules the SDK Studio runs. You see every missing schema, undeclared path parameter and awkward method name, before anyone generates a client from it.

10.010.08.47.56.8/ 10

Queue clear across 24 operationsQueue clear across 24 operations1 open across 24 operations2 open across 24 operations3 open across 24 operations

POST /assistantsSuccessful responses declare a schema

24 of 24 operationsoperationIds are unique

GET /threads/{id}Every path placeholder has a parameter

1 of 1 serverA server URL is declared

15 operationIdsoperationIds read as method names

1 of 1 schemeAuthentication is described

31 of 31 modelsShared models live in components and are $ref'd

24 of 24 operationsRequest bodies are documented

POST /assistantsSuccessful responses declare a schema

24 of 24 operationsoperationIds are unique

GET /threads/{id}Every path placeholder has a parameter

1 of 1 serverA server URL is declared

15 operationIdsoperationIds read as method names

1 of 1 schemeAuthentication is described

31 of 31 modelsShared models live in components and are $ref'd

24 of 24 operationsRequest bodies are documented

What the fourteen rules check, and what each one costs a generated SDK.

Change one. All four follow

Deprecate an endpoint in API Studio and the SDKs mark the method, the agent tools stop offering it, and monitoring shows you who still calls it. Add a language, cut a release, push a new spec: the same thing happens. There is one source underneath all four, so there is never a second place to go and update.

Everyone else stopsat “here's your SDK.”

That's the moment your code leaves your visibility. It runs on someone else's machine, fails on someone else's machine, and you hear about it in a support ticket three days later.

Without Octri

Error thrownon their machine

Nothing reportedno alert

3days

Still broken in prodyou have no idea

Angry support tickets#4412-4414

and again

With Octri

Error thrownon their machine

Alert firedinstantly

9min

Fix shippedv2.3.2

0 support ticketsnobody noticed

From spec to shipped in an afternoon

The whole pipeline from one OpenAPI spec: API documentation, client libraries in ten languages, an MCP server and production monitoring.

Connect your spec

Upload a file or link a GitHub repo. Coming from Postman or AsyncAPI? We translate it.

Review the draft

AI writes docs for every endpoint. Edit anything, publish when it reads right.

Pick your languages

Configure the SDKs, flip on monitoring, build. They publish themselves.

Push to repository

Every spec change reruns the whole pipeline. Docs, SDKs, agent tools, all in sync.

One spec, ten client libraries

Every client is generated from the same OpenAPI document and published to the registry its own users already install from.

Read the SDK guides

Already on something else?

We read your existing config and bring it across: navigation, custom pages, SDK settings and all. You don't start from a blank project.

See how Octri compares

Simple, combined pricing

Docs, SDKs and monitoring in one plan. Extra SDK languages are a flat add-on.

Extra languages are a flat $50/mo. Save 15% annually.

Free

$0/mo

For side projects and first APIs.

Start for free

Starter

$49/mo+ tax

For indie devs shipping real APIs.

Choose Starter

Recommended

Growth

$99/mo+ tax

For growing teams shipping fast.

Choose Growth

Business

$249/mo+ tax

For scaling products that need more.

Choose Business

Enterprise

Custom

Unlimited scale with SLA guarantees.

Contact sales

Feature	Free$0/mo	Starter$49/mo	Growth$99/mo	Business$249/mo	EnterpriseCustom
SDK languages included	1	2	4	All 10	Unlimited
Additional languages	No	+$50/mo each	+$50/mo each	Included	Custom
API endpoints	50	100	300	600	Unlimited
AI credits / mo	100 one-time	1,000	2,500	5,000	Custom
Monitoring ingress / mo	100 MB	1 GB	5 GB	20 GB	Custom
AI-enhanced docs + chat	Yes	Yes	Yes	Yes	Yes
GitHub sync	Yes	Yes	Yes	Yes	Yes
Custom domain	Yes	Yes	Yes	Yes	Yes
Versioning	No	No	Yes	Yes	Yes
Custom code & components	No	No	Yes	Yes	Yes
White-label	No	No	No	Yes	Yes
SDK CDN hosting + auto-publish	No	No	No	Yes	Yes
SSO / SAML	No	No	No	No	Yes
Support	Community	Email	Priority	Priority	Dedicated

Notes from building it

What we learn shipping specs, SDKs and telemetry, written up properly.

All articles

Engineering11 Sept 20265 min read

What counts as a breaking change when your SDK is generated

Questions

Plans, spec changes, editing the generated docs and SDKs, training data and self-hosting.

No. Plans are not per-product, so you can leave one switched off and turn it on months later without redoing anything you have already set up.

Your spec is already written

Everything else takes an afternoon.