The Best Apiary Alternative

Apiary is shutting down. Oracle has posted an announcement of the termination of Apiary support, and reporting across the API tooling space puts the final shutdown of the hosted service around September 2026. The site still loads today, but the trajectory has been visible for years: Oracle acquired Apiary in January 2017, deprecated the paid plans in 2018, and let the surrounding open-source tools (Dredd, Gavel) drift into archive status. If your API documentation lives on apiary.io, you are not evaluating alternatives anymore. You are migrating, and the deadline is not yours to move.

Here’s the direct answer: Apidog is the best Apiary alternative, because it replaces everything Apiary did (design-first spec editing, hosted interactive docs, a mock server) and adds the parts Apiary never finished: automated API testing, spec-driven validation to replace the now-archived Dredd, and CI integration. It’s free for up to 4 users, with paid plans from $9 per user per month. The one honest catch is that Apidog does not import API Blueprint files directly, so Blueprint-based projects need a one-time conversion to OpenAPI on the way out. This article covers what’s happening to Apiary, the exact migration path including that conversion step, and which alternative fits if Apidog doesn’t.

What’s actually happening to Apiary

Apiary, founded in 2011, effectively invented the design-first API workflow as a product. It gave the world API Blueprint, a Markdown-based API description format from the era before OpenAPI won, plus the three-column documentation layout that Stripe made famous and everyone else copied. It bundled a hosted mock server, GitHub sync, and a pair of well-liked open-source contract-testing tools, Dredd and Gavel.

Then Oracle bought it in January 2017, and the product entered the long quiet. Paid tiers were deprecated in 2018, leaving Apiary as a free legacy service while Oracle pointed enterprise customers at its API Platform Cloud. New feature development stopped. Dredd and Gavel were archived. And now the formal end: Oracle’s support-termination announcement, with the hosted service expected to go dark around September 2026. Bump.sh, one of the vendors publishing migration guides, put it plainly in its farewell post: export your API descriptions before the shutdown, because after it there is nothing to export from.

Two practical consequences follow. First, anything that exists only inside Apiary (API descriptions, documentation prose, team configuration) needs to leave now, while the export buttons still work. Second, because API Blueprint has no maintained successor tool, the migration is also a format migration: the sane destination format is OpenAPI, whatever platform you land on.

What you’re replacing

It helps to be precise about what Apiary actually did for your team, because the replacement has to cover each piece:

• A design-first spec editor. You wrote API Blueprint (or, in later projects, OpenAPI 3.0) in the browser, and the docs updated live.
• Hosted interactive documentation. The three-column reference with example requests, on an apiary.io URL.
• A mock server. Every Apiary project got a hosted mock endpoint that served the examples from your spec, so consumers could integrate before the backend existed.
• GitHub sync. The spec file lived in your repo and synced both ways.
• Contract testing via Dredd. The open-source runner that replayed your spec against a real implementation and reported drift. It’s archived now; we covered the replacement problem in how to validate your API against its spec without Dredd.

That bundle (design, docs, mock, validate) is exactly the shape of a modern API development platform. Which is why the best migration target is not a documentation renderer but a platform with the same shape and active development behind it.

The answer: Apidog

Apidog is an API development platform used by over 500,000 developers. It covers the full lifecycle that Apiary sketched out in 2011 and then stopped building: design, documentation, mocking, debugging, and automated testing, all driven by one spec.

For someone migrating off Apiary specifically:

1. Design-first is the default workflow. Apidog has both a visual spec editor and a code editor for OpenAPI 3.x. You define endpoints, schemas, and examples once; docs, mocks, and tests are generated views of that definition, the same philosophy Apiary pioneered, with a maintained product behind it.
2. The docs are hosted, interactive, and yours. Published documentation gets the modern reference layout with a working “try it” console, on a custom domain, with versioning. No apiary.io URL to lose in a shutdown.
3. The mock server is smarter than the one you’re leaving. Apiary’s mock replayed your written examples. Apidog’s smart mock generates realistic responses from your schemas the moment the spec exists, no examples required, and you can add custom mock rules where determinism matters.
4. Contract validation replaces Dredd. Apidog’s automated test scenarios run real requests against your implementation and validate responses against the spec’s schemas, which is the job Dredd did, plus assertions, data-driven cases, and CI runs via the Apidog CLI. Docs also publish alongside an MCP server, so AI agents can read your spec directly; details in what is Apidog MCP Server.

Migrating from Apiary, step by step

The migration has one extra step compared to a normal tool switch, and it’s better to say so upfront: Apidog imports OpenAPI (Swagger 2.0, OpenAPI 3.0 and 3.1), Postman collections, HAR, RAML, JMeter, apiDoc, I/O Docs, WADL, and Google Discovery, per the Apidog import documentation. API Blueprint is not on that list, so Blueprint projects convert to OpenAPI first. In practice this is a one-time command, and it’s the same step every other serious destination requires, because nobody maintains Blueprint tooling anymore.

1. Export everything from Apiary now

For each project, download the API description from the Apiary editor. If the project syncs with GitHub, your source of truth is already in the repo; confirm it’s current. Later Apiary projects authored in OpenAPI 3.0 are already in the right format and can skip step 2. Do this first and completely, before touching anything else: exports are the step with a deadline.

2. Convert API Blueprint to OpenAPI

Use one of the maintained converters:

• api-spec-converter (LucyBot), which handles API Blueprint to OpenAPI directly
• apib2swagger, a focused Blueprint-to-Swagger/OpenAPI converter
• openapi-format afterwards, if you want to normalize the output and upgrade it to OpenAPI 3.1

Then lint the result (a validator like vacuum, or any OpenAPI linter in your toolchain) and hand-check two known weak spots: authentication schemes, which API Blueprint never modeled formally and converters therefore can’t fully recover, and any prose that lived in Blueprint’s Markdown sections rather than in endpoint descriptions. Budget an hour per API, not a week; the format is Markdown, not magic.

3. Import into Apidog

Project Settings, Manual Import, select your OpenAPI file (or import from a URL). Endpoints, schemas, and examples arrive structured and grouped. Reference docs exist immediately, and the smart mock server is live for every imported endpoint without further setup, which restores the “mock URL for consumers” capability Apiary gave you.

4. Rebuild the parts Apiary couldn’t do anyway

Point a custom domain at your published docs, so the next platform shutdown (anyone’s) never takes your docs URL with it. Recreate your Dredd checks as Apidog test scenarios: real requests, schema validation against the spec, run locally or in CI via the CLI. If your team had consumers relying on the Apiary mock URL, send them the new mock base URL in the same email that announces the docs move.

A single-API project moves in an afternoon, including conversion. A portfolio of a dozen Blueprint APIs is a sprint, most of it the auth-scheme hand-check.

Apiary vs Apidog at a glance

What replacing a free tool costs

Apiary’s price was its best remaining feature, so the fair comparison for a migrating team is the annual bill at the destination. Using list prices: Apidog free for 4 users then $9 per user per month, SwaggerHub Team at $34.44 per user per month, ReadMe Pro at $250 per month billed annually:

The honest note: if all you need is a place to render one spec for free, several docs-only tools have free tiers too, and the table above only matters once you want the mock server, testing, and collaboration that made Apiary useful in the first place. Apidog’s free plan covers all of that for up to 4 users, which for many Apiary refugees means the migration costs exactly the conversion afternoon.

If Apidog isn’t the right fit

An honest section, since “keep using Apiary” is not on the menu:

• You only want documentation rendering, nothing else. If your spec is produced and tested elsewhere and you purely need beautiful hosted docs with changelog tooling, a docs-first product like Bump.sh (whose migration guide for Apiary users is genuinely good) is a reasonable landing spot. You’ll still convert Blueprint to OpenAPI to get there.
• You’re standardizing on the SmartBear stack. SwaggerHub is the closest philosophical descendant of Apiary’s hosted-spec-registry idea. Be aware of the per-seat cost and metered test executions; we’ve broken that down in the best SwaggerHub alternative.
• Your center of gravity is design governance for a large platform team. Stoplight built deep style-guide and governance tooling; see the best Stoplight alternative for how it compares before you commit.
• You’re emotionally attached to API Blueprint. Sympathized, but don’t. The format’s tooling is unmaintained, the company that created it is being switched off, and OpenAPI won. Convert once and never think about it again. Our older guide to API Blueprint can stay a historical read.

Frequently asked questions

When exactly does Apiary shut down?

Oracle has announced the termination of Apiary support on its forums, and current reporting from API tooling vendors puts the hosted service’s shutdown around September 2026. The safe assumption is simpler: export now, because every part of the product is already unmaintained.

Can Apidog import API Blueprint files directly?

No. Apidog imports OpenAPI/Swagger, Postman, HAR, RAML, JMeter, apiDoc, I/O Docs, WADL, and Google Discovery formats. Convert API Blueprint to OpenAPI first with a tool like api-spec-converter or apib2swagger, then import the result. It’s a one-time step, and check authentication schemes by hand afterwards.

What replaces the Apiary mock server?

Apidog’s built-in smart mock server. Where Apiary replayed the examples you wrote, Apidog generates realistic responses from your schemas automatically, and you can define custom mock rules for specific cases. Every imported endpoint gets a mock endpoint with zero configuration.

What replaces Dredd for contract testing?

Apidog’s automated test scenarios: they send real requests to your implementation and validate responses against your spec’s schemas, with assertions and CI execution through the Apidog CLI. That covers Dredd’s job plus the test-suite features Dredd never had.

Is Apidog actually free for a small team?

Yes. The free plan covers up to 4 users with the spec editors, published interactive docs, the smart mock server, and API testing included. Beyond 4 users it’s $9 per user per month, which is the lowest per-seat price among the serious Apiary migration destinations.

Export today, redesign nothing

The order of operations matters: export from Apiary first, convert Blueprint to OpenAPI second, and only then evaluate destinations at leisure, because the first two steps have a deadline and the third doesn’t. When you’re ready, import the OpenAPI file into Apidog and you’ll have docs, mocks, and a test harness before the afternoon is out. Download Apidog or start in the browser; a team of 4 pays nothing, and the design-first workflow Apiary invented finally gets the maintained platform it deserved.