AI Platforms for Designing APIs in 2026: Spec Editors, SDK Generators, MCP Builders and AI Gateways Reviewed
Ask two developers in 2026 what platform they use to design an API, and you will get two answers that have almost nothing in common. One of them means the tool where they write the OpenAPI document, lint it, mock it and publish the reference docs. The other means the layer that sits between their application and a dozen model providers, routing requests to whichever LLM is cheapest or still up. Both groups call it “API design.” Both groups are right, because the two stacks have quietly grown into each other.
This is a review of the whole thing: the spec editors, the clients, the documentation platforms, the SDK generators, the MCP tooling that turns a REST API into something an agent can call, and the AI gateways that do the reverse. Where prices are public, they’re here. Where a vendor is grading its own homework, that’s flagged.
What changed in the last eighteen months
Three things, and they explain most of the current tooling churn.
OpenAPI 3.2 landed in September 2025 with first-class streaming support (server-sent events and JSON Lines) and structured tag navigation for large catalogs. Streaming stopped being a thing you documented in prose.
The Model Context Protocol, which Anthropic introduced in November 2024, reached its final specification in July 2026. That release deprecated protocol-level custom logging in favour of OpenTelemetry, which means MCP servers are now expected to emit the same telemetry as everything else in your stack rather than inventing a log format. Around the same time, Article 12 of the EU AI Act reached full enforcement on 2 August 2026, requiring high-risk systems to keep logs detailed enough to reconstruct an individual AI-assisted decision. Between those two dates, “can you prove which agent called which endpoint on whose behalf” went from a nice-to-have to a compliance line item.
And Postman ended free team collaboration on 1 March 2026. The free plan is now single-user. That one commercial decision did more to reshape the API client market than any feature release in the category’s history.
Spec editors and design platforms
SwaggerHub, now folded into SmartBear’s API Hub, is the commercial descendant of the Swagger project that made OpenAPI a standard in the first place. You get a code editor and a form-based editor side by side, with real-time validation, autocomplete and a live docs preview, plus a draft mode so a team can rework a spec without publishing it. Its real differentiator is governance: Spectral-based style guides and AI-assisted resolution of standardisation errors, which matters when you have six teams and six opinions about whether a field is called userId or user_id. It supports OpenAPI 2.0, 3.0 and 3.1 plus AsyncAPI 3.0. Individual plans start around $23 a month; team plans around $34 per user. It is a design tool and nothing more, so you still need a gateway, a portal and key management elsewhere.
Stoplight built Spectral, the linter that most of the industry now runs, including inside competing products. Its visual designer lets a product manager or a technical writer shape an API without touching YAML, which sounds like a small thing until you watch a non-engineer actually contribute a schema. Mock servers come from your examples, so frontend work can start before the backend exists. Free tier for individuals, paid team plans above that. SmartBear owns Stoplight too, and has been absorbing pieces of it into API Hub, so the standalone roadmap deserves a sceptical eye before you commit.
Postman is still the biggest installed base in the category, and its Spec Hub handles OpenAPI 2.0, 3.0 and 3.1 with repo sync and collection generation. The interesting move was buying Fern in January 2026, which pulled high-quality docs rendering and nine-language SDK generation in-house. The March 2026 relaunch also added native Git support and offline file storage, addressing the two complaints people had been making for years. Pricing is $9 a month solo, $19 per user for a team, free for exactly one person.
Apidog bundles design, mocking, testing and documentation into one desktop app and has been openly recruiting Postman refugees. For a solo developer or a small shop, replacing three subscriptions with one is a stronger argument than any individual feature.
Zuplo takes the most opinionated position: your OpenAPI file is the gateway config. A single routes.oas.json defines routing, request validation, policies and docs, and it deploys to 300-plus edge locations along with the reference portal (rendered by Zudoku, which is open source and usable on its own). Request validation happens at the edge on every call, not as a separate lint step, and API key provisioning is built in. Free tier, usage-based paid plans. Worth saying plainly: Zuplo’s own comparison guide recommends Zuplo, so weigh the architecture argument on its merits rather than on the write-up.
The client layer
This is where the market broke open after the Postman pricing change, and it is now genuinely competitive.
Bruno stores collections as plain text files on your filesystem, commits them to Git like source code, and refuses to have a cloud. It passed 42,000 GitHub stars in March 2026 and 44,000 by May, growing faster than any API client before it, and it ships two or three releases a month. As of v3.x it covers REST, GraphQL, gRPC and WebSockets. No MQTT, no built-in MCP client, no real-time collaboration. For code-adjacent work where the collection should live in the repo next to the code, it’s the obvious pick.
Insomnia, maintained by Kong, has the most flexible storage model of anything here. It is the only client that lets one team keep some projects fully local, some in a plain Git repo, and some in end-to-end encrypted cloud sync, chosen per project. Apache 2.0 on the desktop side, with a design-first OpenAPI editor, native mocking, a CLI for pipelines, and MCP client support for agentic work. If your GraphQL workflow leans on schema introspection and query autocompletion, this is the one people keep coming back to.
Hoppscotch runs in the browser with nothing to install, sits at roughly 79,000 stars, and supports six protocols including MQTT and Socket.IO. Self-hosted team workspaces run $6 per user per month, which makes it the credible option for a regulated team that wants to leave Postman’s cloud but keep hosted collaboration. The trade-off is the browser sandbox: filesystem access and a few protocols are off the table.
Thunder Client lives inside VS Code, free with a $5 lifetime Pro upgrade. Narrow by design, and fine if you never leave the editor.
Documentation and developer portals
Mintlify generates interactive references from OpenAPI and AsyncAPI, with a playground that handles bearer, basic and API key auth, and a scraper CLI that turns a spec into editable MDX so you keep styling control. It is used by Anthropic, Cursor and Perplexity. The number worth stealing from their pitch: close to half of documentation traffic now comes from AI agents rather than humans, which is why llms.txt support, Markdown served to agents, and AI traffic analytics have become selection criteria rather than curiosities.
Redocly still produces the best-looking reference docs in the market, and the open-source Redoc renderer (25,000-plus stars, near a million weekly npm downloads) is free if you self-host. The three-panel layout handles discriminators, polymorphism and deeply nested allOf/oneOf compositions without falling apart, which is not true of every renderer. It supports OpenAPI up to 3.2 plus AsyncAPI and Arazzo. The commercial Realm platform starts around $69 a month billed annually and adds Git-native workflows, PR previews, versioning and custom domains.
ReadMe is less about rendering and more about measurement. Its “Try It” console is the best of the bunch, and it tracks which endpoints developers view versus actually call, where they drop off, and how long it takes from first doc visit to first successful request. If you sell an API, those numbers are your funnel. The pricing steps are steep: $79 a month to start, $349 for the Business tier where AI search and SSO live, $3,000-plus for enterprise.
Scalar and Bump.sh are the lighter, cheaper options when all you need is clean hosted reference docs and a changelog. Document360 fits when the API reference is one section of a larger knowledge base. RapiDoc is a single web component you can drop into an existing page.
Treblle runs the pipeline backwards. Point it at live traffic and it produces the OpenAPI spec in JSON and YAML from what it observes, which is the only sane starting point for an API that already exists and was never documented.
SDK generators
This is the most consolidated corner of the stack, and the comparisons are almost entirely vendor-authored, so read the following knowing that each of these companies publishes a chart where it wins.
Stainless generates the official SDKs for OpenAI, Anthropic, Cloudflare and Google, with output downloaded well over a hundred million times a week. Seven languages currently (TypeScript, Python, Go, Java, Kotlin, Ruby, PHP, C#), with Terraform, Rust and Swift in progress, and it goes beyond client libraries into Terraform providers, CLI tools and MCP servers. It layers a custom configuration DSL over OpenAPI, which gives fine control and also creates a second artifact that can drift from the spec. Generation requires connectivity to Stainless cloud. Entry pricing is $250 per month per SDK.
Speakeasy covers ten languages, treats the OpenAPI document as the only source of truth, adds runtime type safety with Zod, and ships TypeScript SDKs with a single runtime dependency. It is also one of only two options here that generates fully air-gapped, as a standalone binary with no cloud call. That matters more than it sounds if you have ever tried to get a codegen vendor through a security review. It does not generate documentation, so budget for a docs platform alongside it.
Fern, now Postman’s, supports seven languages and generates both SDKs and reference docs from one definition. Built on a proprietary DSL with OpenAPI as an import format. TypeScript output is Node-only, and OAuth 2.0 sits behind paid plans. Entry pricing also $250 per month per SDK.
APIMatic is the long-standing enterprise option, OpenAPI-native, though its TypeScript output carries a heavy dependency tree.
OpenAPI Generator remains free, self-hosted, and by far the widest in raw language coverage. It produces client libraries, server stubs, docs and config from a v2 or v3 spec. The output is less idiomatic than the commercial generators and you will spend time on templates, but the price is zero and nothing phones home.
Dependency footprint is the underrated criterion here. Speakeasy’s TypeScript SDKs ship with one runtime dependency; Stainless-generated ones can carry more than twenty-five, and APIMatic more than forty. Every one of those is supply chain surface area that someone in security will eventually ask you about.
The agent layer: turning an API into MCP tools
This is the fastest-moving part of the stack and the least settled.
The basic problem is that an OpenAPI document tells a human developer what your API can do, and agents need more than that. Vague descriptions, undocumented auth and ambiguous parameters are what cause agents to fail, and they fail silently rather than throwing a 400. Most APIs were designed for people reading docs, not for a model deciding which of forty tools to call.
The generation options fall into rough tiers. FastMCP is the Python path. openapi-mcp-generator is the open-source CLI path. Zuplo exposes a spec as MCP tools through a server handler with no custom code and hosting included. Speakeasy ships an x-speakeasy-mcp OpenAPI extension giving per-operation control over how each endpoint is presented to an agent, which is the right shape for this problem: the design lives in the spec, not in a separate config. Stainless generates MCP servers as one of its codegen targets. Redpanda has a managed OpenAPI MCP server in beta that generates one tool per operation from any 3.x spec. Gram covers the platform end.
Toolsmith, from API Commons, is the most interesting thing in this category and the least commercial. It is a browser-based workbench for designing the agent layer of an API explicitly: load an OpenAPI document, then for every operation design an MCP tool with an honest input schema and behaviour annotations, plus the resources and prompts that give it context, sampling guidance, and Agent Skills that teach an agent to use the tool competently. The designs are stored inside the document as x-mcp and x-agent-skills extensions, so the enriched OpenAPI stays the artifact of record. A lint pass validates tool-name uniqueness, read-only versus destructive annotations, resource URIs and registry shape, and it exports a registry-ready server.json plus a zipped Agent Skills bundle.
For the observability side, MintMCP and TrueFoundry do gateway-level logging of agent calls, groundcover handles traces, and MCP Inspector is the debugger. Elva bundles generation, hosting with OAuth2 and per-tool scopes, and per-agent call logging, and also publishes the roundup where it appears first, which tells you what it is.
One framing worth keeping: MCP and OpenAPI function calling are not competitors so much as different bets on volatility. Function calling against a documented REST API is the pragmatic choice when one agent uses a small, stable tool set and you are the only consumer. MCP pays off when several clients need the same tools, the tool set keeps growing, or tools change at runtime. In practice an MCP server usually wraps exactly the REST endpoints your OpenAPI document already describes.
AI gateways: the other meaning of the question
If your API design problem is “which model API do I build against,” the answer for most teams in 2026 is: don’t pick one, put a gateway in front.
OpenRouter gives managed access to 400-plus models behind one endpoint and one bill, with quality-aware routing and automatic fallback. LiteLLM is the dominant open-source option, with the broadest provider compatibility of anything self-hostable (100-plus providers across native and OpenAI-compatible APIs) and a straightforward deployment. It is also the default for anyone in a regulated or air-gapped environment, provided you budget for the surrounding infrastructure rather than a licence. Portkey is the managed equivalent with guardrails, semantic caching, prompt management and observability out of the box; free tier at 10,000 requests a month, production pricing from $49. Cloudflare AI Gateway is a one-line addition if you already run Cloudflare, and worth configuring Dynamic Routing explicitly rather than trusting automatic retries for cross-provider failover. Helicone is the low-overhead prototype option. Vercel AI Gateway slots in behind the AI SDK model string. Kong AI Gateway makes sense when Kong is already your edge and you want LLM traffic on the same operational story; for a greenfield AI-only deployment it is more machinery than you need. Eden AI goes wider than LLMs, with 500-plus models across text, OCR, document parsing, speech, translation and image analysis, and it is French-headquartered with EU data residency by default, which is an actual differentiator rather than a marketing line.
Here is the part most comparison tables miss. Every major gateway in this list has dropped its per-token markup to zero. The price race is finished, so choosing on cents per million tokens is choosing on a dimension where the options are identical. What is left to evaluate is deployment model and failover behaviour, and almost nobody tests failover before production. The case for doing so: in a single month, December 2025, OpenAI logged 22 incidents totalling 182.7 hours of impact and Anthropic logged 20 incidents totalling 184.5 hours. A gateway that does not fail over correctly is a gateway that inherits both outage schedules.
Testing and governance
Spectral is the linting baseline and runs inside half the products above. Schemathesis generates property-based tests from a spec and drops into any CI as a CLI command. Dredd validates that the implementation matches the documentation. Newman runs Postman collections in a pipeline, at the cost of maintaining those collections by hand. Spec-aware tools get meaningfully higher baseline coverage than general clients, because they already know the endpoints, schemas and constraints; the general clients make you write every case yourself whether a spec exists or not.
What to actually use
Solo developer or small shop: write the OpenAPI document with an LLM in your editor, lint it with Spectral, keep collections in Bruno so they live in the repo, generate stubs with OpenAPI Generator, render docs with Scalar or self-hosted Redoc. Total cost, nothing. Everything stays in Git where the rest of your project already is.
Small team shipping a public API: Insomnia for the client layer, Redocly or Mintlify for docs, Speakeasy for SDKs if you need them in more than two languages. Add Zuplo if you would rather have one spec drive the gateway, the portal and the keys than keep four systems in sync.
API-first company: Stainless or Speakeasy for SDKs, ReadMe if developer adoption metrics drive the roadmap, SwaggerHub or Stoplight for governance once more than three teams are producing endpoints, and a deliberate agent layer designed in the spec rather than bolted on afterwards.
Building on models rather than shipping an API: LiteLLM if you self-host, Portkey or OpenRouter if you don’t, and test the failover path on a Tuesday afternoon rather than discovering it during someone else’s incident.
The one thing that has genuinely changed about API design is the audience. For twenty years the reader of your documentation was a developer with a browser tab open. Now a large share of that traffic is a model deciding whether your endpoint does what its name suggests. An API designed only for the human reader will keep working and will keep quietly failing the other half of its users.