Octri.dev

Octri.dev is a platform that takes an OpenAPI specification as its single input and generates four connected products: a documentation site, client SDKs in ten programming languages, an MCP server that exposes your API as tools for AI agents, and production monitoring that reports errors from wherever those SDKs run. It is built for developers and teams who publish APIs and want documentation, client libraries, agent integrations, and observability to stay in sync without manual effort. The problem Octri addresses is what happens after an SDK leaves your control. As the site puts it, "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, an API team may spend three days with something still broken in production, receiving angry support tickets. With Octri, the same team can ship a fix in nine minutes with zero support tickets because the SDKs themselves report errors back. This visibility gap is the core motivation behind the monitoring that is built into every generated SDK. The first product is API Studio, a documentation generator. Octri reads your OpenAPI spec and AI writes a first draft for every endpoint. You then edit the documentation like a document, so nobody on the team has to open the YAML. The generated docs include three-column endpoint pages with schema trees that open a level at a time, a live "try it" playground on every endpoint, MDX guides alongside the generated reference, and your own domain on every tier including the free plan. You can rename methods, exclude endpoints, and publish when it reads right. Docs changes are stored per page, so a new spec revision only disturbs the endpoints that actually changed. The second product is SDK Studio, which generates idiomatic client libraries in ten languages: TypeScript, Python, Go, Java, Dart, Ruby, PHP, Rust, Swift, and Kotlin. Each SDK is generated from the same OpenAPI document and published to the registry its users already install from: npm for TypeScript, PyPI for Python, Maven Central for Java and Kotlin, crates.io for Rust, RubyGems for Ruby, Packagist for PHP, pub.dev for Dart, and git tags for Go and Swift. SDK Studio provides per-language configuration for namespaces, pagination, idempotency, and code style. You can rename methods, exclude endpoints, pick your HTTP engine (fetch or axios for TypeScript, OkHttp or Ktor for Kotlin, standard library HTTP for Go), and choose folder structure. Custom hooks you write are compiled into the client. Auto-publish handles releases, and build history shows exactly what shipped and when. The SDKs are "configured, not forked," meaning you tune them to your house style without maintaining separate versions. The third product is Monitoring, which offers two ways to get visibility. You can flip it on and the telemetry compiles into your generated SDKs, so every client reports its own production errors back to you. Alternatively, you can drop the standalone package straight into your backend. Either way, there is no agent to deploy and nothing to instrument. Monitoring includes several capabilities: Logs, which let you query structured events directly by level, route, status code, or release; Issues, which group errors by fingerprint, each with the function and file that threw it; Traces, which show one request end to end across client, server, cache, database, and queue, with the slow span called out; a Service map that shows every service, the calls between them, and the error rate on each edge; N+1 query detection that finds the same query fired in a loop and counts it across traces; Uptime synthetic probes on a schedule with run history; and Alerts that fire on burn rate and regressions, so a single stray 500 never wakes anyone. Security is built in: credentials and identifiers are redacted client side before an event leaves your process, then again at ingest, and personal context waits on your app's consent under a pre-signed GDPR Article 28 DPA. Monitoring is off by default and switches on from the dashboard. The fourth product is the MCP server. MCP is described as "how an agent reaches something it was never trained on." Without it, Claude or Cursor might integrate your API from memory, hallucinating endpoints and parameters. With Octri's MCP server, one command turns your project into a server that these agents connect to. The agent can then list your real endpoints and call them. The MCP server includes seven documentation tools to search, read, and navigate your docs, and one callable tool per endpoint so the agent can hit your API for real. It is curated by SDK Studio, so your exclusion list becomes the agent's permission list. Installation is one line: npx @octri/mcp, with nothing to host. Octri also offers an OpenAPI audit tool. You paste your OpenAPI URL or upload a spec file in JSON or YAML, and you get a score out of ten on the same rules the SDK Studio runs. The audit checks fourteen rules, showing every missing schema, undeclared path parameter, and awkward method name before anyone generates a client from it. Example check results include operationIds being unique, every path placeholder having a parameter, a server URL being declared, authentication being described, shared models living in components and being referenced, request bodies being documented, and successful responses declaring a schema. The audit runs across operations and returns a readiness score, helping teams prepare their spec for code generation. How does Octri work overall? The platform is built on one source underneath all four products. According to the site, "Change one. All four follow." If you deprecate an endpoint in API Studio, 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, or push a new spec: the same synchronization happens. There is never a second place to go and update. The workflow from spec to shipped can be done in an afternoon: connect your spec by uploading a file or linking a GitHub repo (Postman and AsyncAPI are translated), review the AI-written draft for every endpoint and edit anything, pick your languages and configure the SDKs while flipping on monitoring, then push to repository. Every spec change reruns the whole pipeline, keeping docs, SDKs, agent tools, and monitoring in sync. GitHub sync regenerates everything on every merge. Benefits for users center on speed and visibility. The site contrasts a three-day cycle where something is still broken in production and support tickets pile up with a nine-minute cycle where a fix is shipped and nobody notices. Because every SDK reports its own production errors, integration failures reach the API team before users file tickets. The monitoring traces errors to a commit, so teams can see what broke and why. The MCP server stops agents from hallucinating your API and lets them call real endpoints. The docs site gives readers a polished reference they actually finish. SDKs ship in ten languages and publish themselves to registries, reducing maintenance burden. The migration importer reads existing config and brings it across, including navigation, custom pages, SDK settings, endpoint overrides, and theme, so teams do not start from a blank project. The platform aims to keep everything in sync from one spec, eliminating the need to update multiple places when the API changes. Use cases for Octri include: API-first teams who want to generate and maintain client SDKs across multiple languages from a single OpenAPI spec; developer documentation teams who need polished reference docs with editing, guides, and a playground; platform teams who want to give AI agents like Claude and Cursor reliable access to their API via MCP; backend teams who need production observability for SDKs and APIs, including error grouping, tracing, and alerts; teams preparing their OpenAPI spec for code generation who use the audit to find missing schemas and other issues; and teams migrating from another docs or SDK tool who want to bring their configuration with them. Target users range from indie developers shipping real APIs on the Starter plan, to growing teams shipping fast on Growth, to scaling products that need more on Business, and enterprises needing unlimited scale with SLA guarantees. Pricing is combined for docs, SDKs, and monitoring, with extra SDK languages as a flat add-on. The Free plan costs $0/mo and includes 1 SDK language, 50 API endpoints, 100 one-time AI credits, 100 MB monitoring ingress per month, GitHub sync, custom domain, and registry auto-publish. Starter is $49/mo plus tax with 2 SDK languages, 100 endpoints, 1,000 AI credits per month, and 1 GB monitoring ingress. Growth is $99/mo plus tax with 4 SDK languages, 300 endpoints, 2,500 AI credits, 5 GB ingress, versioning, and custom code and components. Business is $249/mo plus tax with all 10 SDK languages, 600 endpoints, 5,000 AI credits, 20 GB ingress, white-label, and SDK CDN hosting. Enterprise offers custom pricing with unlimited scale, SLA guarantees, SSO/SAML, dedicated support, and the option to run the generator and docs renderer in your own infrastructure. Additional SDK languages are $50/mo each on plans where they are not included, and annual billing saves 15%. In summary, Octri.dev turns one OpenAPI spec into a complete ecosystem: documentation, SDKs in ten languages, an MCP server for AI agents, and production monitoring that reports errors from the SDKs themselves. It is designed for any team that ships an API and wants to keep docs, clients, agent tools, and observability synchronized from a single source of truth, reducing the time from spec change to shipped update to an afternoon.