Install Jentic One Beta
Jentic One is a self-hosted execution layer for AI agents. It lets your agent call the Core, or any other public or private API you need. You set the rules, the agent never sees your credentials, and every call is logged.
Two steps, two machines. Install the instance in a safe environment, then register your agent from wherever it runs.
Step 1: Jentic One Host machine
# On the machine that will host your Jentic One instance:
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fscalar.com%2Fscalar" | shStep 2: Agent machine
# On the machine where your agent runs (keep this separate from the instance):
curl -fsSL "https://jentic.com/install.sh?src=apis&api=%2Fapis%2Fscalar.com%2Fscalar" | sh
jentic register # connects your agent to your Jentic One instanceJentic One is in public beta. The setup above keeps your agent separate from the instance, which is what you want before using real credentials: an agent running as the same OS user as Jentic One can read its stored keys directly. Just evaluating? A single local install is fine to start. See the secure deployment guide for the tiers.
What an agent can do with Core API.
Create and version OpenAPI or AsyncAPI documents in a team namespace, and roll a version tag back to an earlier content instance
Lint an unsaved OpenAPI or AsyncAPI document with Vacuum before saving it
Create an SDK with language targets such as typescript, python, go, or rust and trigger a manual multi-language build
Roll out docs changes by publishing, redeploying, or cancelling an in-flight publish, and stream its build log
GET STARTED
Link a GitHub repository as the source of truth for a registry resource, propose edits as pull requests, and publish from a commit
Read docs project analytics: KPI totals, top pages, top referrers, reader feedback, and a consumer breakdown such as human, bot, or llm
Subscribe webhooks to platform events, rotate their signing secret, and list recent delivery attempts
Patterns agents use Core API for, with concrete tasks.
★ AI agent maintaining an API registry
An agent asked to ship a spec change searches Jentic for 'create a Scalar API document version', lints the new document with postManagedDocLint, and, if it is clean, creates the version under the team namespace and slug. If the release goes wrong it lists the registry versions and rolls the version tag back to an earlier content instance, with the Scalar token injected at call time.
POST /managed-doc/lint with the document, then POST /managed-doc/{namespace}/{slug}/version for namespace acme and slug payments with the new content
Generating SDKs from an API document
Teams that publish client libraries create an SDK from an API document with one or more language targets, link each target to a GitHub repository, and trigger builds. The API can resolve a complete SDK config, check whether a package name is free on a language registry, toggle publish-on-merge, and fetch the release PR open on a target's repository.
POST /v1/sdks with apiUid api_123 and languages ['typescript','python'], then POST /v1/sdks/build to start the build
Reading who uses your docs
Docs owners want to know which pages matter and who reads them, including AI agents. The analytics operations return KPI totals and a timeseries, top pages by views, top referrers, reader feedback per page, and a consumer breakdown that separates human, bot, and llm traffic for a docs project.
Call GET /analytics/projects/{projectUid}/consumers and GET /analytics/projects/{projectUid}/pages for project prj_123 and report the share of llm readers on the top pages
Shipping docs from a git repository
Hosted docs projects are backed by a Forgejo, GitHub, or Bitbucket repository. The API reads and commits the scalar config directly on the provider without cloning, switches a project to a different repository, and handles publishing: redeploy a previous publish, cancel one in flight, stream its build log, or check that a custom domain points at Scalar.
Call GET /docs-projects/{projectUid}/config for project prj_123, then PUT /docs-projects/{projectUid}/config with the updated config and GET /publish/logs/{publishUid} to follow the resulting publish
244 endpoints — the scalar core api runs the scalar platform for api documentation, registries, and sdks: it stores and versions openapi and asyncapi documents, json schemas, and lint rulesets in team namespaces, and publishes hosted docs projects.
METHOD
PATH
DESCRIPTION
/managed-doc
List all API documents for a team
/managed-doc/lint
Lint an OpenAPI or AsyncAPI document
/managed-doc/{namespace}/{slug}/version
Create an API document version
/registry/{asset}/{namespace}/{slug}/versions/{version}/active
Roll a version tag back
/v1/sdks
Create an SDK with language targets
/v1/sdks/build
Trigger a multi-language SDK build
/docs-projects/{projectUid}/config
Read a docs project's scalar config
/analytics/projects/{projectUid}/overview
Get docs project KPIs
/managed-doc
List all API documents for a team
/managed-doc/lint
Lint an OpenAPI or AsyncAPI document
/managed-doc/{namespace}/{slug}/version
Create an API document version
/registry/{asset}/{namespace}/{slug}/versions/{version}/active
Roll a version tag back
/v1/sdks
Create an SDK with language targets
/v1/sdks/build
Trigger a multi-language SDK build
/docs-projects/{projectUid}/config
Read a docs project's scalar config
/analytics/projects/{projectUid}/overview
What agents get from Jentic-routed access to this vendor.
Setup
Wiring the Scalar Core API by hand means obtaining a bearer JWT or personal token, finding the right operation among hundreds of team, registry, SDK, and docs routes, and getting namespace and slug paths right. Through Jentic you install once, import Scalar from the API Directory, store the token once, and your agent calls it.
Permission scoping
Scalar puts the namespace and document slug in the URL path (/managed-doc/{namespace}/{slug}/...), so a rule can pin your agent to one API document in one namespace. You choose the operations it may call, so destructive ones like deleteTeam or deleteManagedDocNamespaceSlug are not included unless you add them.
Credential isolation
Your Scalar token is stored once, encrypted, by your own Jentic One instance and injected at execution time. It never enters the agent's prompt, logs, or context.
Intent-based discovery
Agents search Jentic by intent such as 'lint an OpenAPI document' or 'build an SDK', and Jentic returns the matching Scalar operation, such as postManagedDocLint or postV1SdksBuild, with its input schema.
Alternatives and complements available in the Jentic catalogue.
Specific to using Core API through Jentic.
What authentication does the Scalar Core API use?
Per its OpenAPI spec, the Scalar Core API uses a bearer JWT in the Authorization header for most operations, and the generate-personal-token operation issues a named personal token. A handful of operations need no credential, including email signup, email OTP request and verification, the team slug availability check, and the GitHub and Bitbucket OAuth callbacks. Through Jentic the token is stored by your own instance and attached at call time.
Can the Scalar Core API lint OpenAPI documents?
Yes. The postManagedDocLint operation lints an unsaved OpenAPI or AsyncAPI document with Vacuum, taking the document as a string. Managed rulesets can be created per namespace for the rules you want to apply.
Which SDK languages does Scalar support?
The SDK create operation accepts language targets including typescript, python, cli, csharp, java, ruby, php, go, rust, kotlin, swift, cpp, and dart.
What are the rate limits for the Scalar Core API?
The OpenAPI spec does not specify rate limits. Check the Scalar documentation at https://scalar.com for current limits.
Is there a Scalar MCP server?
You don't need an MCP server to give your agent the Scalar Core API. Jentic connects it directly from the API Directory: import it, store your Scalar token once, and your agent calls the registry, SDK, and docs operations it needs without loading a separate server's tool definitions.
How do I publish a new API document version through Jentic?
Search Jentic for 'create a Scalar API document version', load the postManagedDocNamespaceSlugVersion operation, and execute POST /managed-doc/{namespace}/{slug}/version with your namespace, slug, and document content. To run it on your own infrastructure, install Jentic One from its GitHub repo.
Can I limit what my agent is allowed to do with the Scalar Core API?
Yes. Allow only GET and POST under /managed-doc/acme/payments plus POST /managed-doc/lint, and the agent can lint and version the payments document in the acme namespace while team settings, billing, secrets, and deletes stay off its list. Every call it makes is logged.
For Agents
Version API documents in the Scalar registry, lint them, publish docs, build multi-language SDKs, and read docs analytics for a Scalar team.
Use for: Lint this OpenAPI document before I upload it, Create a new version 2.1.0 of our payments API document in the acme namespace, Build TypeScript and Python SDKs for our API, Which referrers send the most traffic to our docs?
Not supported: Does not call or proxy the APIs it documents, host your application code, or replace a CI system. Use for managing Scalar API documents, SDKs, docs projects, and team settings only.
The Scalar Core API runs the Scalar platform for API documentation, registries, and SDKs: it stores and versions OpenAPI and AsyncAPI documents, JSON schemas, and lint rulesets in team namespaces, and publishes hosted docs projects. It lints documents with Vacuum, builds multi-language SDKs in languages such as typescript, python, go, and rust, and turns linked API documents into hosted agent tool servers. Registry resources can be synced with GitHub or Bitbucket repositories, docs projects report page views, referrers, and consumer types such as human, bot, and LLM readers, and the team side covers members, roles, SSO identity providers, access groups, secrets, and webhooks.
This API is usable in Jentic One now. Its AI-readiness score against Jentic's framework shows where it stands today and where improvements would make it even easier for agents to use.
Get docs project KPIs
Base layer of spec validity and structural soundness.
Aggregated quality score from linter diagnostics, weighted by severity.
Percentage of `$ref` references that resolve successfully.
Checks whether the API description parses successfully and conforms to its declared specification (e.g., OpenAPI).
Structural correctness score based on schema issues using logarithmic dampening.
Clarity, completeness, and ingestion readiness for developers and tooling.
How richly the API is illustrated with examples.
Percentage of examples that conform to their schemas.
Percentage of operations with complete response definitions (success, client error, server error).
Health of API ingestion, bundling, and resolution within Jentic pipelines.
Semantic breadth, depth, and agent comprehension for AI systems.
Coverage of descriptions across API elements.
Coverage of RFC 9457 Problem Details for error responses.
Coverage, uniqueness, and casing consistency of operationIds for AI inference.
Coverage of summaries across operations/tags/info.
Functional utility, complexity comfort, and AI orchestration readiness.
Agent comfort level based on API operational and structural complexity.
Trust, risk posture, and security compliance.
Average quality of security schemes based on authentication method strength (weakest link for OAuth2).
Findability, semantic richness, and reasoning readiness.
Clarity and depth of descriptions across API elements.
Score it yourself
Every API in the directory is allowlisted, so you can re-score it with no key required.
npx @jentic/api-scorecard-cli score <openapi-url>