Searching your reference for creating a customer.Calling it with an email and a name.Loading llms-full.txt, then the auth guide.Checking the docs for a TypeScript client.Installing @profoundai/client. Writing the first call.

Reading orders.md for the pagination rules.Pages by next_cursor. Following it to the last page.Searching the Docs MCP for webhooks.Checking @profoundai/client against openapi.json.Matches the client. Writing the reports.visibility call.

Fetching llms.txt to pick an API.Starting with Payments. Reading authentication.md.

Running the SDK’s smoke tests against the mock server.All green. Trying the 404 case by hand.

Connected to your MCP server. Calling GET /v1/invoices.Seven unpaid. Calling GET /v1/invoices/{id} for each.Got a 429. Reading errors.md for retries.Updated @profoundai/client. Reading the changelog.No renames. All 14 call sites resolve. Running the tests.

Reading quickstart.md for the install step.Installed 2.3.0, pinned. Trying one call on the mock.

Infrastructure for APIs in the age of agents.

From an agent's first read of your docs to its millionth production call, Scalar is the layer in between: hosted, observed, and kept in sync from one OpenAPI document.

Get Started

Docs

First, an agent has to understand your product.

Agents read docs the way developers do, except they want Markdown, not a rendered page. Scalar serves both from one source, so agents get your API right the first time.

Every page in Markdown, plus llms.txt and a Docs MCP endpoint.
Your domain, your theme, and access groups for partner portals.
An open source core with 15.7k GitHub stars and eight framework integrations.

SDKs

Then a developer's agent builds on it.

Your customers' coding agents write the integration now. Scalar generates typed SDKs from your OpenAPI document, one pull request per release, so an agent's code compiles the first time.

TypeScript, Python, Go, Java, Kotlin, and Ruby, plus a CLI.
Published to npm, PyPI, Go modules, Maven Central, and RubyGems, with changelogs.
Upload your stainless.yml as is and existing call sites keep working.

import Profound from '@profoundai/client' const client = new Profound({ apiKey: process.env.PROFOUND_API_KEY, }) const report = await client.reports.visibility({ category_id: 'cat_1234', start_date: '2026-09-01', end_date: '2026-10-01', metrics: ['visibility_score'], })

import os from profound import Profound client = Profound(api_key=os.environ["PROFOUND_API_KEY"]) report = client.reports.visibility( category_id="cat_1234", start_date="2026-09-01", end_date="2026-10-01", metrics=["visibility_score"], ) print(report.data[0].metrics)

package main import "github.com/profoundai/profound-go" client := profound.NewClient(os.Getenv("PROFOUND_API_KEY")) report, err := client.Reports.Visibility(ctx, profound.VisibilityParams{ CategoryID: "cat_1234", StartDate: "2026-09-01", EndDate: "2026-10-01", Metrics: []string{"visibility_score"}, })

$ export PROFOUND_API_KEY=pk_live_… $ profound categories list cat_1234 Search platforms $ profound reports visibility \ --category cat_1234 \ --from 2026-09-01 --to 2026-10-01 \ --metrics visibility_score asset_name visibility_score Profound 0.42

MCPs

Then users' agents act on it directly — no code at all.

Someone asks Claude or ChatGPT for something, and the agent calls your API itself. Scalar turns your OpenAPI document into that MCP server, which is not yours to run.

One line connects any remote MCP client to the operations you choose.
Any API fits in a fixed tool set, about 0.2% of context.
Hosted on your own subdomain with OAuth, rate limits, and nothing to deploy.
Call counts, errors, and latency per tool and client, with arguments never stored.

Retry this month’s failed renewals with each customer’s backup card and tell me what’s still unpaid.

I’ll list this month’s failed renewals, check each customer for a backup card, retry the charge where there is one, and report what’s still unpaid.

GET /v1/invoices?status=failed

200 OK. 23 invoices, 17 with a backup card.

POST /v1/invoices/{id}/pay for those 17.

17 calls: 16 paid, 1 declined.

16 of the 23 are paid. Seven are still unpaid: six have no backup card on file, and one was declined again.

Write a message…

Fable 5.1 Ultracode

We run the infrastructure. You run your API.

An MCP server is a production service. It must stay up, authenticate callers, absorb agent traffic, and track a protocol that changes every few months. Scalar runs yours at mcp.yourcompany.com and goes where MCP goes. You keep shipping your API.

Your API

openapi.yaml

Developer

API consumer

Claude Code

Coding agent

Developer

SDK user

Copilot

Coding agent

Claude

MCP client

ChatGPT

MCP client

Gemini

MCP client

Without Scalar

Vibe code APIs, Docs, MCP, & SDKs

With Scalar

or just use one prompt with Scalar

Set up Scalar for this repo with the Scalar MCP server (https://mcp.scalar.com/) and the Scalar CLI (npx -y @scalar/cli@latest).

Find my OpenAPI file and the brand site for , check what my team already has so nothing is duplicated, and confirm with me once. Then:

Publish the API to the Scalar Registry.
Create one SDK with create_an_sdk (it builds itself, never call build_an_sdk).
Host an MCP server for the API with create_an_mcp_server, pointed at the Registry entry.
Scaffold scalar-docs/ with intro, quickstart and authentication guides from the spec, a custom --scalar-* CSS theme from my brand (siteConfig.theme), and a config (schema https://registry.scalar.com/@scalar/schemas/config) whose API reference route points at the Registry entry by namespace and slug, not a local file, so the SDK samples show.
Create the docs project and project publish it.