Scalar renders OpenAPI documents as a live reference, and its starter snippet pins no version
Scalar is an open-source API platform: a modern REST API client, beautiful API references, and first-class OpenAPI/Swagger support.
At a glance
- What is it?
- Scalar is an MIT licensed TypeScript project that turns an OpenAPI or Swagger document into an interactive API reference with a built-in request tester, and separately ships an offline-first API client for Windows, MacOS and Linux. The integration list is long and the fallback is one HTML file, but that fallback loads an unversioned module from a CDN and points both the document and the proxy at Scalar hosted infrastructure.
- Who is it for?
- Scalar fits teams that already have an OpenAPI document and want readable reference pages plus a request tester without standing up a docs stack. It does not fit an air-gapped or compliance-bound deployment unless you self-host and point away from the hosted proxy, and the CDN import carries no version, so pin it before this reaches a production page.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 1 day ago.
- What is it written in?
- Mainly TypeScript, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- scalar/scalar16,410 ★ · +250
| Repository | 2026-09-21 | 2026-11-15 |
|---|---|---|
| scalar/scalar | 16.2k | 16.4k |
250 Stars in the last 55 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The CDN import in the quickstart carries no version at all
The documented starting point needs no build step and no package manager. You create a single HTML file, drop in a div with the id app, and import one ESM module straight from jsdelivr:
<!doctype html>
<html>
<head>
<title>Scalar API Reference</title>
<meta charset="utf-8" />
<meta
name="viewport"
content="width=device-width, initial-scale=1" />
</head>
<body>
<div id="app"></div>
<script type="module">
import { createApiReference } from 'https://cdn.jsdelivr.net/npm/@scalar/api-reference/esm.js'
createApiReference('#app', {
// The URL of the OpenAPI document
url: 'https://registry.scalar.com/@scalar/apis/galaxy?format=json',
// Avoid CORS issues
proxyUrl: 'https://proxy.scalar.com',What that snippet cannot do is hold still. The import path carries no version segment, so the browser resolves whatever the registry currently considers latest every time the page loads, with no lockfile, no integrity hash and no fallback if the published module changes shape. Harmless on a scratch page. On the reference your own users read, pin a specific @scalar/api-reference version and review it on each bump, or install the package through your own bundler.
Both the document URL and the proxy default to Scalar hosted hosts
Two defaults in that snippet decide where traffic goes before you configure anything. The document is fetched from 'https://registry.scalar.com/@scalar/apis/galaxy?format=json', which is a hosted registry rather than a file in your repository, and the proxy is set to 'https://proxy.scalar.com' directly beneath the comment Avoid CORS issues.
So out of the box the page reads neither your local OpenAPI document nor your own server. It asks a third party for the schema, and the proxy exists specifically to keep browser cross-origin checks from blocking the requests a tester fires at your API.
That is a sensible way to evaluate the tool and a poor default for production. An internal reference on an isolated network reaches neither host, so the page simply will not load its document. And keeping the hosted proxy means requests your testers send to your own API travel through infrastructure you do not operate. Point url at your document and either drop proxyUrl or front it with your own before this goes anywhere near users.
Release tags are dates and commit hashes rather than version numbers
Three releases appear in a three day window and none of them carries a version number: release-2026-10-30-66ba1d7, release-2026-10-30-4b04099 and release-2026-10-28-0d01943, each named for its date with the short commit hash appended. The repository is not archived and last took a push on 2026-11-01, so the cadence is clearly high.
What the naming withholds is comparability. With no semver tag in that list you cannot write a manifest entry meaning the build that shipped in March, and a date alone does not tell you whether a change is breaking. The docs script makes the same choice, since dev:docs runs npx @scalar/cli@latest project preview.
The versioning machinery exists even so. A .changeset directory, CHANGELOG.md, release-notes.config.ts and RELEASE.md at the top level are the changesets workflow that normally produces semver output. If you consume the packages rather than the CDN, read the changelog to work out which release changed what, instead of assuming tag order tells you.
pnpm is mandatory and the integration packages build on their own schedule
The monorepo declares its package manager twice over. package.json sets engines.pnpm to ^12.0.0 and packageManager to [email protected], the root scripts are pnpm commands, and both pnpm-lock.yaml and pnpm-workspace.yaml sit at the top level. npm and yarn are not supported paths into this tree, and a contributor reaching for npm will not reproduce the dependency graph.
The build is split because the integration surface is wide. The root build script is turbo build, with build:packages filtering on the packages directory and build:integrations filtering on the integrations directory. The README's integration list covers HTML/JS plus .NET ASP.NET Core, Aspire, AdonisJS, Astro, Django, Django Ninja, Docker, Docusaurus, Elixir, Express, FastAPI, Fastify, Flask, Go, Hapi, Hono, Java, Laravel, Laravel Scribe, Micronaut, NestJS, Next.js, Nuxt, Python, React, Ruby on Rails, Rust, Spring Boot, SvelteKit, Symfony, Ts.ED and more.
One operational detail before you build anything. The clean script recursively deletes every dist, .turbo, .nuxt, .next, target and node_modules directory in the tree, so a clean is a full reinstall. Scope your builds to the single integration you touched rather than the whole workspace.
One repository holds two products, and one release tag moves both
The project presents two distinct things. The first is an interactive API reference rendered from an OpenAPI or Swagger document, which ships with an API testing tool and generates code examples for many languages and frameworks. The second is an offline-first API client built for OpenAPI, which syncs with a server framework in Watch Mode, carries environment variables and dynamic parameters, and is distributed for Windows, MacOS and Linux alongside a browser version.
Keeping both under scalar/scalar is tidy for branding and large for the tree, with packages/, integrations/, projects/, tooling/, documentation/ and examples/ all sitting at the top level beside each other.
It also means a single dated tag can move either half. A release named release-2026-10-30-66ba1d7 does not say whether it changed the rendered reference, the desktop binary, or both. If you only consume the reference, integrate through the framework package rather than assuming a desktop client upgrade altered what your readers see, and read the release notes instead of trusting tag order.
Setup is handed to a coding agent that is also invited to open a discussion
The quickstart opens by telling you to install a scalar-api-reference skill for your coding agent, then to copy a prompt into it:
Set up Scalar API Reference in this project.
Inspect the project's framework, package manager, routing, and existing
OpenAPI setup. Choose the appropriate framework integration from
https://scalar.com/products/api-references and install it using this
project's conventions.
If no framework integration exists, render a route using the HTML/JS guide:
https://scalar.com/products/api-references/integrations/html-js
Also ask whether I want to request a framework integration here:
https://github.com/scalar/scalar/discussions/new?category=ideas
Serve the API reference at /scalar, or use anRead what that hands over. The model is told to inspect your routing and select the integration, and it is told to ask whether you want a framework integration requested at a GitHub discussions URL. The integration that lands in your repository is a model's reading of your codebase, and the prompt invites an outbound action in your name.
The repository leans this way throughout. The top level carries .agents/, .claude/, AGENTS.md, CLAUDE.md, .mcp.json, .zed/, .devcontainer/, .vscode/, .nvmrc and .npmrc. Convenient for bootstrapping a new project, but read the diff before committing and make the decision about that discussion yourself.
Dead link linting protects the monorepo, not the reference you deploy
Part of the tooling betrays what kind of company this is. The dev dependencies include knip at 6.41.0 with a knip.jsonc config at the root, remark-lint-no-dead-urls and remark-validate-links, alongside biome, eslint, prettier with an import-sorting plugin and a Tailwind plugin, vitest and Playwright, with git hooks wired through lefthook.yml. The compiler entry is @typescript/native-preview pinned to a 7.0.0 dev build, and wrangler is present for edge deployment.
A linter that fails on dead URLs is a strong signal about link rot, and it applies only to Scalar's own content. Once a reference page is deployed inside your documentation site, nothing in this toolchain follows your links or notices that an endpoint your OpenAPI document still advertises no longer exists in your service.
So the checks keeping the project tidy will never keep your published reference accurate. That makes schema drift your problem to solve. Regenerate the document from code on every build instead of maintaining it by hand, because nothing here is watching it once it leaves the repository.
Editorial conclusion
Scalar fits teams that already have an OpenAPI document and want readable reference pages plus a request tester without standing up a docs stack. It does not fit an air-gapped or compliance-bound deployment unless you self-host and point away from the hosted proxy, and the CDN import carries no version, so pin it before this reaches a production page. The desktop client is a separate product and should be judged separately from the reference.
Frequently asked questions
how to use scalar
Pick a framework integration, of which there are more than thirty, or serve one HTML file that calls createApiReference against your OpenAPI document. The same project also ships a separate offline-first API client for OpenAPI on Windows, MacOS and Linux that syncs with a server framework in Watch Mode.
What does scalar do?
Two things under one repository. It turns an OpenAPI document into a browsable interactive reference with a request tester, and it provides an offline-first API client that syncs with a server framework in Watch Mode and supports environment variables and dynamic parameters.
how to use scalar api
Either pick one of the framework integrations, which cover FastAPI, Express, Django, NestJS, Next.js, Spring Boot, Ruby on Rails and about twenty more, or create a single HTML file that imports createApiReference from the jsdelivr ESM build and calls it against a div. A separate guide covers the HTML/JS route.
how to install scalar
The HTML/JS route needs no installation at all: add one HTML file with a div and a module import from cdn.jsdelivr.net, served by any static host. Framework users install the integration package through their own package manager. The desktop client is a separate download for Windows, MacOS and Linux from scalar.com/download.
What does scalar Company do?
This repository documents Scalar as an open-source API platform under the MIT licence: a REST API client, API references and OpenAPI/Swagger support. Its homepage is scalar.com.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/scalar-scalar)Star history chart for your README
[](https://hysenlabs.com/projects/scalar-scalar)Was this useful?