What does "monitoring inside the SDK" actually mean?

Your users install a client with an error reporter that ships switched off. Once the developer using it enables reporting, an error in production 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?

GitHub sync defaults to a draft with a diff for you to review. When you publish a release, SDKs publish to linked registries after the build finishes if registry auto-publish is on. You can turn that switch off and publish packages manually.

Octri is hosted today. Self-hosted generation and docs rendering are not available yet.

How hard is it to migrate from another docs or SDK tool?

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.

Octri builds 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.

Score your OpenAPI spec

SDKs generated from public OpenAPI specs by Octri View samples

OpenAI
Anthropic
GitHub
Twilio
Resend
Clerk
Vercel
DigitalOcean
Neon
Intercom

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

API documentation your readers actually finish. Guides you write beside a reference generated from your spec, published to your own domain.

Explore API Studio

SDK Studio

Ten languages, zero forks

Idiomatic SDKs in 10 languages, generated from your OpenAPI spec and shaped to your conventions. Each release publishes to your registries.

Explore SDK Studio

Monitoring

Errors traced to a commit

What breaks, and why. Error tracking for your SDKs and monitoring for your API, with every error grouped and traced to a commit.

Explore Monitoring

MCP

Your API as agent tools

An MCP server built from your spec. Your API becomes context and callable tools for AI agents in Claude, Cursor and any MCP client.

Explore MCP

API StudioAPI documentation platform

API docs worth reading, from the first guide to the last endpoint

Write guides, tutorials and quickstarts in the editor or in MDX, beside an interactive API reference generated from your OpenAPI spec. AI drafts every endpoint, you edit all of it like a document, and the whole developer portal publishes to your own domain.

Guides with real components: callouts, steps, tabs and code groups, synced from GitHub
Generated documentation for every endpoint, written wherever your spec leaves a description empty
API reference pages with schema trees that open a level at a time
Live “try it” playground that calls your real API with the reader's own key
AI search and llms.txt, so developers and coding agents find the answer
Your own domain on every tier, Free included

See API Studio

SDK StudioOpenAPI SDK generator

SDKs in ten languages, built to your conventions

Idiomatic, type-safe client libraries for TypeScript, Python, Go, Java and six more, generated from your OpenAPI spec. Rename methods, exclude endpoints, pick your HTTP engine and folder structure. Then let each release publish itself.

Retries, pagination and typed errors built into every client
Custom hooks you write, compiled into the client
Auto-publish to npm, PyPI, Maven, crates.io, RubyGems and more
Regenerated on every spec change, with a build history of exactly what shipped and when

See SDK Studio

MonitoringAPI monitoring and SDK error tracking

Find out what breaks before your customers tell you

Error tracking inside every SDK you ship, plus logs, traces, uptime checks and a status page for the API behind it. Switch it on for a project and each SDK user can opt in from their app, or add the standalone package to your backend. Neither needs a separate agent.

Logs

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

Error tracking

Errors from your SDKs and backend, grouped by fingerprint, each with the function and file that threw it.

Distributed 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 and status page

Uptime checks built from your spec, with incidents published to a status page on your own domain.

Alerts

Fire on burn rate and regressions to Slack or any webhook, 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 AI agents

Stop agents from hallucinating your API

MCP is how an AI agent reaches something it was never trained on. Octri turns your OpenAPI spec into an MCP server, so Claude, Cursor, VS Code and any other MCP client can search your docs, 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
Tool lists for any agent framework, exported in MCP, OpenAI and Anthropic formats

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 stops at “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 and build. Monitoring needs each SDK user to opt in; linked registries can publish the release automatically.

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. Want a hand with the move? A call with us and our onboarding help are both free of charge.

Book a call Let Octri onboard me

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.

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

$79/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$79/mo	Business$249/mo	EnterpriseCustom
SDK languages included	1	2	4	All 10	Unlimited
Additional SDK languages	No	+$50/mo each	+$50/mo each	Included	Included
API endpoints	50	100	300	600	Unlimited
AI credits	100 one-time	1,000 / mo	2,500 / mo	5,000 / mo	Custom
Monitoring ingest	100 MB	1 GB	5 GB	20 GB	Custom
Ask-the-docs AI chat on every page	Yes	Yes	Yes	Yes	Yes
GitHub sync	Yes	Yes	Yes	Yes	Yes
Custom domain	Yes	Yes	Yes	Yes	Yes
Publish to package registries	Yes	Yes	Yes	Yes	Yes
Docs versioning	No	No	Yes	Yes	Yes
Custom components	No	No	Yes	Yes	Yes
White-label	No	No	No	Yes	Yes
SDK artifacts served from a CDN	No	No	No	Yes	Yes
SAML single sign-on	No	No	No	No	Yes
Support	Community	Email	Priority	Priority	Dedicated

Compare all 79 features, Studio by Studio

Notes from building it

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

All articles

Engineering15 Oct 20263 min read

Can an AI agent actually integrate your API? Build an eval to find out

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.