Scalar API documentation is the open-source renderer developers reach for when Swagger UI feels dated and Redoc feels too rigid. It takes an OpenAPI document, turns it into a fast, modern reference page with a built-in API client, and lets you ship it from a CDN script tag, a React component, or a hosted docs site. Adoption is surging: the project just crossed 12,000 GitHub stars, the npm package is downloaded over 480,000 times a week, and Microsoft replaced Swagger UI with Scalar as the default API reference in ASP.NET Core 9 (Microsoft Learn, 2025). This review covers what Scalar actually is, what it ships with, how it compares to the other OpenAPI renderers, its real pricing, and when a different tool is the better pick. If you arrived from a broader OpenAPI documentation search, the short answer is in the first section.
Key takeaways
- Scalar is open-source (MIT) and renders OpenAPI 3.x and Swagger 2.0 into an interactive API reference with a built-in HTTP client
- The renderer is free forever; paid plans start at $12 per editor per month and add hosting, GitHub sync, custom domains, SDK generation, and a managed API registry
- Compared to Swagger UI, Scalar is faster and prettier. Compared to Redoc, it adds a real API client and theming controls
- For pure dev-led API docs, Scalar is a strong default. For non-technical SaaS teams who do not want to maintain an OpenAPI workflow, an AI documentation generator is usually a better fit
What is Scalar API documentation?
Scalar API documentation is a developer-facing reference page generated from an OpenAPI document by Scalar's open-source rendering library. It produces a three-panel layout: navigation on the left, endpoint and schema documentation in the middle, and code samples plus a live request runner on the right. The same library powers both the free self-hosted version and the paid hosted product at scalar.com.
The project started in 2023, is licensed MIT, and is maintained by a small Berlin-based team that calls itself "The OpenAPI Company." The core renderer lives at github.com/scalar/scalar and has 12.4k stars and 624 forks at time of writing. The hosted platform layers documentation editing, an API registry, SDK generation, and team collaboration on top of the open-source renderer.
Three product lines share the same Scalar brand:
- API References (the free open-source renderer most people mean when they say "Scalar")
- Docs (a hosted WYSIWYG and Git-synced docs platform built around the renderer)
- API Client (a fully open-source Postman alternative that ships standalone and embedded in every Scalar reference page)
Most of this review is about the first one because that is what shows up when you search "scalar api documentation." The hosted product is covered separately in the pricing section.
How Scalar API documentation renders an OpenAPI document
You hand Scalar a YAML or JSON OpenAPI file, and it does three things: it parses the spec, it renders the documentation, and it wires up an interactive request runner against your live API. Nothing else is required. No build step. No Markdown conversion. No theme compilation.
Three delivery formats are supported, and the rendered output looks identical across all three:
- CDN script tag: drop a single
<script>into an HTML page and point it at your OpenAPI URL - NPM package: install
@scalar/api-referenceand embed it in any React, Vue, or vanilla app - Framework integrations: first-party adapters for Next.js, NestJS, Hono, Fastify, FastAPI, Laravel, Express, ASP.NET Core, and a dozen more
The CDN path is the one most teams use for a single-page reference. The NPM package is the path for teams who want to wrap the reference in their own shell. The framework integrations matter because they read the OpenAPI document directly from your running server, so the docs are always in sync with the code that generated them.
Here is the minimum HTML to get a working Scalar reference page:
<!doctype html>
<html>
<body>
<script
id="api-reference"
data-url="https://example.com/openapi.yaml"
></script>
<script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
</body>
</html>
That is the whole integration. The same approach generates docs for any size API, from a five-endpoint internal service to a 400-endpoint platform.
What Scalar gives you out of the box
A new Scalar reference page ships with a feature set that took Swagger UI and Redoc years to assemble piece by piece:
- Interactive API client built into the reference (send real requests without leaving the page)
- Automatic code samples in cURL, JavaScript, Python, Go, PHP, Ruby, C#, Java, Kotlin, and Swift
- Light and dark mode with one-line theme switching
- Full-text search across endpoints, schemas, and descriptions
- OAuth 2.0, API key, bearer, and basic auth flows handled in the client
- Webhook documentation
- Server selector for multi-environment APIs
- Mobile-responsive layout
- Direct support for OpenAPI 3.1 (Redoc still lags here for some features)
- A
Try itbutton that prefills your auth and lets you send live requests from the docs page
The default theme is clean enough that most teams ship without changing it. If you do want to customize, Scalar exposes a CSS variable system that covers colors, fonts, spacing, and code block styling. Heavy customization beyond that requires forking the React component, which most teams skip.
Scalar vs Swagger UI vs Redoc vs Stoplight Elements
The four most-deployed OpenAPI renderers are Swagger UI, Redoc, Scalar, and Stoplight Elements. They all do the same job. They are not equally good at it.
| Renderer | License | Best for | Built-in API client | OpenAPI 3.1 | GitHub stars |
|---|---|---|---|---|---|
| Scalar | MIT | Modern dev docs with built-in testing | Yes | Yes | 12.4k |
| Redoc | MIT | Static three-panel reference pages | No | Partial | 25.7k |
| Swagger UI | Apache 2.0 | Legacy compatibility, internal docs | Yes (basic) | Yes | 27.2k |
| Stoplight Elements | Apache 2.0 | Embedded reference inside other docs sites | Yes | Yes | 1.6k |
Scalar wins on perceived design quality. Redoc wins on raw popularity and on being the safer "boring" choice. Swagger UI wins on backwards compatibility (some teams still cannot move off it). Stoplight Elements wins when you need a renderer that drops into an existing docs site as a component rather than as a standalone page.
A few specific notes from running all four in real projects:
- Scalar vs Swagger UI: Scalar is roughly 3 to 4 times smaller in bundle size and renders noticeably faster on cold load. Authentication flows feel native rather than bolted on. Swagger UI still wins if your team has decades of OpenAPI tooling assumptions tied to it.
- Scalar vs Redoc: Redoc does not include an API client. Reading the docs and testing the API happen in two different places. Scalar collapses both into one page. If you want the docs and the test client unified, Scalar. If you want only docs and you serve a Postman collection separately, Redoc.
- Scalar vs Stoplight Elements: Stoplight Elements is built to live inside another docs site. Scalar is built to be the docs site. Use Stoplight Elements when you have a marketing or product docs platform and want to embed a reference inside it. Use Scalar when the API reference is the docs site.
Scalar pricing in 2026
The open-source renderer is free forever and always will be. That is the load-bearing fact. Almost every team that uses Scalar uses only this part.
The hosted product on scalar.com layers a docs editor, GitHub sync, custom domains, SDK generation, and an API registry on top. Pricing (verified May 2026):
| Plan | Price | Editors | Best for |
|---|---|---|---|
| Hobby | Free | 1 | Personal projects, public API docs, evaluation |
| Pro | $12 / editor / month | Unlimited | Small teams that want hosting + custom domains |
| Team | $40 / editor / month | Unlimited | Teams that need SDK generation + registry features |
| Enterprise | Custom | Unlimited | SSO, on-prem, dedicated support |
The Pro plan is the one to compare against ReadMe ($349/mo Business), GitBook ($300/mo for comparable features), and Mintlify ($300/mo Pro). For a 3-editor team, Pro Scalar costs $36 a month. The same setup on ReadMe is $349. The savings are real but the comparison is not exactly apples to apples: ReadMe and Mintlify include richer content authoring features that Scalar's hosted product is still building toward.
When to pick Scalar (and when not to)
Scalar is the right pick when:
- You already maintain an OpenAPI document and you want it rendered well
- You want one tool for both docs and live API testing
- You want the docs to look modern without designing them yourself
- Your audience is developers who read API references end to end
- You want open-source under the hood so you are never locked in
Scalar is the wrong pick when:
- You do not have an OpenAPI document and writing one is out of scope
- Your docs need long-form guides, tutorials, and concept pages more than they need API reference (Scalar's docs platform is still maturing here)
- Your audience is non-technical and the reference page itself is intimidating
- You need authoring features that match GitBook or Mintlify's editor
The last case is the gap. If you are a SaaS founder shipping a product to non-developers and "API documentation" is just one section of a larger docs site you do not want to maintain, Scalar solves the wrong half of the problem. For that audience, AI-generated platforms like Docsio handle the whole site from a single URL, including guides, concept pages, branding, and hosting, with no OpenAPI workflow required. Scalar is still the right tool if your docs are first and foremost an API reference for developers.
How to add Scalar to an existing project
The fastest integration path for most teams is the CDN script. It assumes your OpenAPI document is reachable at a public URL.
<!doctype html>
<html>
<head>
<title>Acme API Reference</title>
</head>
<body>
<script
id="api-reference"
data-url="https://api.acme.com/openapi.json"
></script>
<script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
</body>
</html>
If you are running a Node, Python, or .NET server with an OpenAPI generator already in place, the framework adapter is even faster. In Express:
import { apiReference } from '@scalar/express-api-reference';
app.use('/reference', apiReference({
spec: { url: '/openapi.json' },
}));
That mounts a Scalar reference page at /reference that reads your live OpenAPI document on every request. In ASP.NET Core 9, Scalar is the default reference page when you call app.MapScalarApiReference(), replacing the older app.UseSwaggerUI() line that used to be the default (Microsoft Learn, 2025).
Once it is running, the practical work is mostly in cleaning up your OpenAPI document. Scalar renders exactly what is in the spec. If your spec has missing descriptions, no examples, and vague schemas, the page will look thin. Most of the work of shipping good Scalar docs is upstream of Scalar itself, in the OpenAPI file. The same is true for every renderer in this category, see our notes on API documentation best practices for what to fix first.
Where Scalar still has gaps
No tool is perfect. The honest list of Scalar's current weaknesses:
- The hosted product's content editor is younger than GitBook's or Mintlify's, with fewer block types and fewer integrations
- Search inside large specs (1,000+ endpoints) can feel slow on initial load
- The CDN bundle, while small relative to Swagger UI, still adds 200KB+ to a page
- Customization beyond CSS variables requires forking the React component
- The API registry product is newer than Stoplight's and has fewer integrations with API gateways
These are mostly maturity issues that will resolve as the team ships. The core renderer is already among the best in its category.
FAQ
Is Scalar API documentation free?
Yes. The Scalar renderer is open-source under the MIT license and free to use commercially with no limits. You can self-host it on a CDN, embed it in a React app, or use one of the framework integrations without paying. Paid plans only kick in if you want the hosted scalar.com platform with custom domains, GitHub sync, and team editing.
Is Scalar better than Swagger UI?
For most new projects, yes. Scalar renders faster, looks more modern, supports OpenAPI 3.1 fully, and ships with a built-in API client. Swagger UI still has wider tooling compatibility and decades of community resources, so legacy projects often stay on it. New projects in 2026 generally start with Scalar or Redoc.
Does Scalar support OpenAPI 3.1?
Yes. Scalar has supported OpenAPI 3.1 since 2024 and handles the JSON Schema 2020-12 draft, webhooks, and the updated nullable handling correctly. This is one area where Scalar is ahead of Redoc, which still has partial 3.1 support for some edge cases.
Can Scalar work without an OpenAPI document?
Not really. The renderer reads OpenAPI. If you do not have a spec, Scalar will not generate one for you. For teams without an OpenAPI workflow who still want polished documentation, a no-code documentation tool or AI-generated platform is the practical alternative.
How does Scalar compare to Mintlify?
Mintlify is a full content platform optimized for developer docs as a whole, including guides, concept pages, and reference. Scalar is primarily an OpenAPI renderer with a docs platform layered on top. For pure API reference, Scalar wins on price and openness. For end-to-end dev docs with long-form content, Mintlify is still ahead. See our full Mintlify comparison for details.
Bottom line
Scalar is the cleanest OpenAPI renderer on the market in 2026 and the one most new projects should start with. The fact that Microsoft picked it over Swagger UI for ASP.NET Core 9 says most of what you need to know. For developer-led API docs where the OpenAPI document is already in good shape, Scalar gets you a polished reference page faster than any of its competitors and costs nothing for the open-source path.
If your docs are more than an API reference, if you need branded guides, concept pages, and hosted infrastructure that you do not want to build, the calculus changes. Docsio generates a full branded documentation site from a URL in under five minutes, with an AI agent that handles content, layout, and publishing without an OpenAPI workflow. That is a different shape of product from Scalar and a better fit for SaaS founders and small teams who want docs that look professional without becoming a side project.