# AX Check: mintlify.com Checked 2026-10-05. Mintlify's docs, CLI, and pricing are all immediately usable by agents. All 23 checked items passed: quickstart, CLI install, API/MCP docs, and pricing (Starter $0, Pro $450-540/mo, Enterprise contact sales) are stated plainly, no login walls. ## End-to-end onboarding not demonstrated ## Coding sessions Three independent sessions (DeepSeek V4.1 Flash, Kimi K3, Qwen 3.8 Max) all completed the task and read pricing successfully, reporting Starter/Free, Pro, and Enterprise tiers with consistent dollar figures and named billing assumptions; none hit a login wall or unreadable pricing page. ### DeepSeek V4.1 Flash [View public run](https://agents.withgauge.com/p/runs/60867d93-da00-4dbd-959b-db3836ad8353) · [Read transcript](https://www.ax-check.com/mintlify.com/sessions/deepseek.json) Final output gives a pricing table (Starter $0, Pro $450/mo annual or $540/mo monthly, Enterprise contact sales) plus credit-cost assumptions (25/50/250 credits per action, $0.01/credit overage, 14-day trial with 5,000 credits, add-on tiers), sourced from fetched docs at seq 37-38/45. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: Agent never attempted account creation or API key generation. It explicitly declined to run mint signup/mint login (interactive, browser-based) and never obtained a real Mintlify API key or called an authenticated endpoint. It only read public docs and ran local JSON/frontmatter validation on files it wrote itself. Event 88: ```text node -e 'const fs=require("fs");const j=JSON.parse(fs.readFileSync("docs.json","utf8"));console.log("docs.json: valid JSON"); ``` Event 91: ```text The alternative, the **hosted REST API**, isn't usable anonymously: it needs an account, a dashboard-issued API key, and the platform API is gated behind Pro/Enterprise. There's no public, credential-free SDK endpoint to call. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **Hosted API requires paid plan and dashboard-issued key**: Product behavior: the Mintlify REST/Developer API is gated behind Pro/Enterprise plans and requires a server-side API key created in the dashboard. No free or anonymous path exists to call the hosted API, so the agent could not exercise it under the session's light-SDK/API-only constraint. Event 44: ```text The platform REST API requires a [Pro or Enterprise plan](https://mintlify.com/pricing?ref=api). ``` Event 91: ```text it needs an account, a dashboard-issued API key, and the platform API is gated behind Pro/Enterprise. There's no public, credential-free SDK endpoint to call. ``` - **Quickstart workflow requires local dev server and interactive signup**: Test environment / session restriction: Mintlify's documented quickstart workflow for 'managing' a docs site requires either mint dev (a local background service) or mint signup/mint login (an interactive browser + email verification flow). The seed prompt explicitly forbade starting local service stacks or waiting on long-running commands, so the agent correctly stopped rather than treating this as a product defect. Event 91: ```text **`mint dev`** — starts a local preview server on `localhost:3000` (a local service stack). ``` Event 91: ```text **`mint signup` / `mint login`** — interactive, opens a browser, and `mint signup` waits for email verification (a long-running/auth flow). ``` #### Suggested Changes - **Add a free or trial-tier path to generate a usable API key**: On the pricing page and API introduction docs, clarify whether any credential-only (non-interactive) way exists to obtain a Developer API key without starting the full CLI signup/login flow or upgrading to Pro. Verify by having a fresh agent session attempt to acquire and use an API key without browser interaction; success means a key is generated and an authenticated endpoint returns real data. Event 44: ```text Generate API keys on the [API keys page](https://app.mintlify.com/settings/organization/api-keys) in your dashboard. ``` Event 91: ```text needs an account, a dashboard-issued API key, and the platform API is gated behind Pro/Enterprise ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/7c1262b8-5297-49c9-bd1e-495565d4e444) · [Read transcript](https://www.ax-check.com/mintlify.com/sessions/kimi.json) Final output gives Free/Pro/Enterprise tier breakdown with explicit caveat that exact dollar figures are client-side rendered/approximate and names assumptions (annual vs monthly billing, seat counts, AI message credits) (seq 54). #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent never attempted Mintlify signup/login or any authenticated API call. It read the mint CLI quickstart instructions (mint signup, mint login, mint dev) but explicitly declined to run them, citing the prompt's constraint against long-running local servers and the need for real email/browser verification it could not supply. It scaffolded local MDX/JSON files only and never created or queried any hosted resource. Event 54: ```text Mintlify has no hosted API/SDK workflow I can act on without an account, so I'm stopping at the file scaffold, plainly stated. ``` Event 54: ```text I authored the content but can't preview or deploy it here. If you create an account and install the GitHub App, pushing this repo as-is would deploy. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No hosted SDK/API path without human signup**: The documented Mintlify workflow (mint signup, mint login, mint dev, GitHub App install) requires real email verification and browser-based account approval, which the agent correctly refused to fabricate. This is a normal authentication/session limitation, not a product defect — the product does gate dashboard/deploy actions behind account creation. Event 10: ```text `mint signup` waits for email verification, so keep it running as a background process when your environment supports background commands. Tell the user to click the verification link and approve the CLI in the browser. Never invent signup details. ``` Event 54: ```text `mint signup` / `mint login` — needs a real email, browser-based verification, and connecting a GitHub repo during onboarding (I won't invent signup details) ``` - **Pricing page is client-rendered, blocking scrape of exact figures**: Multiple curl/grep attempts against mintlify.com/pricing failed to extract dollar amounts because the page renders pricing client-side via JavaScript; the raw HTML only contained CSS/theme variables and UI labels, not the numeric plan prices. This is a test-environment limitation (no JS execution in the shell-based fetch) rather than a product defect, though it meant the agent could only give approximate, unverified price figures. Event 30: ```text 425815 /tmp/mint_pricing.html ``` Event 32: ```text The pricing page is fully client-rendered, so I can't scrape exact dollar figures reliably. ``` #### Suggested Changes - **Add a static/server-rendered fallback for pricing figures**: On mintlify.com/pricing, dollar amounts for Pro/Enterprise tiers are injected client-side and absent from the raw HTML response. Add server-side rendering or a static data fallback so automated tools and simple scrapers can retrieve accurate numbers; verify by curling the page without a JS engine and confirming price strings appear in the response body. Event 32: ```text The pricing page is fully client-rendered, so I can't scrape exact dollar figures reliably. ``` ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/8bdefcae-419b-46e4-8639-a92d72806f41) · [Read transcript](https://www.ax-check.com/mintlify.com/sessions/qwen.json) States Free/Hobby, Pro (~$150/mo), and Growth/Enterprise tiers with assumptions named (per-organization/month billing, seat-oriented, no usage metering) and flags the figures as public info to verify. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent made two quick network checks (hit api.mintlify.com and mintlify.com) and then immediately concluded, without attempting any SDK/API calls, account creation, or token acquisition, that there was no actionable developer workflow. No credentials were ever obtained or used, and no authenticated operation was attempted against the product. Event 4: ```text curl -s -m 8 -o /dev/null -w "%{http_code}" https://api.mintlify.com 2>&1; echo; curl -s -m 8 -o /dev/null -w "%{http_code}" https://mintlify.com 2>&1 ``` Event 10: ```text api.mintlify.com exists but requires an authenticated account connection, and its purpose is account/dashboard operations, not self-serve content publishing. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No self-serve API/SDK path found for Mintlify docs**: The agent determined Mintlify's workflow is docs-as-code (MDX files plus a Git repo) rather than something operable via a hosted SDK/API. Publishing requires either a long-running local preview server or connecting a GitHub repo through the Mintlify dashboard with human credentials/OAuth, both of which were explicitly excluded by the task constraints. This is product behavior (Mintlify's architecture) intersecting with the session's own restriction against local long-running services and human-provided login, rather than an agent error. Event 10: ```text The quickstart requires both things you ruled out: 1. Local preview via `mintlify dev` — a long-running local server (prohibited, and the CLI isn't even installed here). 2. Publishing via Git sync — connecting a GitHub repo to your Mintlify account through their dashboard, which requires your credentials/OAuth, not something an API token from me can do headlessly. ``` #### Suggested Changes - **Document a headless/API path for publishing content**: The agent found no public REST API or SDK for creating or publishing documentation content programmatically, only Git-sync via dashboard OAuth and a local dev server. If a headless publishing path exists, surface it clearly on the Mintlify quickstart or API reference page; verify by having a fresh agent session attempt to publish a page without dashboard login and without starting `mintlify dev`. Event 10: ```text There is no public SDK or REST API for creating/publishing documentation pages programmatically — `api.mintlify.com` exists but requires an authenticated account connection, and its purpose is account/dashboard operations, not self-serve content publishing. ``` ### Task given to each agent Help me build a simple example using Mintlify. Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage. Let me know if you get blocked. If this product has no developer workflow you can act on, say so plainly and stop. Stay light: use the hosted product through its SDK or API. Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop. No product credentials were supplied and no purchases were authorized. ## Score: A · 100/100 (provisional) Grades come from completed site checks. Coding sessions and skipped checks do not affect the score. ### Clarity - **Pass** — Homepage answers Markdown requests ```text Homepage returned text/markdown with 200 when requested with Accept: text/markdown. ``` - **Pass** — llms.txt provides an actionable documentation index ```text llms.txt indexes docs, quickstart, API, MCP, skill, blog, library and legal pages. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt groups links under Docs, Pages, Blog, Library, Customers, Legal, Security headings. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt links API reference, MCP docs, and the agent skill page. ``` - **Pass** — A compact guide representation exists ```text skill.md is a standalone Markdown agent guide covering setup, CLI, and MCP. ``` - **Pass** — A focused guide is directly retrievable ```text skill.md and quickstart.md are directly retrievable Markdown guides with concrete steps. ``` - **Pass** — Equivalent instructions fit a token budget ```text skill.md is 367 tokens, well under the 8000-token budget. ``` - **Pass** — Product-docs links survive format changes ```text skill.md links to llms.txt, quickstart.md, and MCP docs, preserving doc routes. ``` - **Pass** — The compact guide is independently actionable ```text Quickstart gives concrete CLI steps: install mint, signup/login, mint dev, validate, deploy. ``` - **Pass** — Install and next-step links resolve ```text Fetched install and next-step links (quickstart, CLI install, MCP, custom domain) resolve successfully. ``` ### Onboarding - **Pass** — Docs lead to a relevant quickstart ```text llms.txt and docs index link a Quickstart with concrete deploy steps. ``` - **Pass** — Installation commands are extractable ```text Quickstart and CLI install give npm i -g mint and pnpm add -g mint. ``` - **Pass** — Code examples are available without interaction ```text Quickstart shows inline bash, mdx and yaml code blocks without interaction. ``` - **Pass** — Prerequisites and auth boundaries are explicit ```text Node.js v20.17.0+ prerequisite and mint login/signup auth flow are explicit. ``` ### Pricing - **Pass** — Pricing is readable without interaction ```text Pricing page renders full plan tiers and comparison tables as static Markdown, no interaction needed. ``` - **Pass** — Prices are stated, not gated ```text Starter $0/mo, Pro $450/mo annual or $540/mo monthly, Enterprise contact sales all stated. ``` - **Pass** — Pricing units and limits are explicit ```text Seats, 10,000 monthly credits, $0.01 overage, 25/250 credit action prices all explicit. ``` - **Pass** — Agents identify pricing and its assumptions ```text 3 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4.1 Flash: Final output gives a pricing table (Starter $0, Pro $450/mo annual or $540/mo monthly, Enterprise contact sales) plus credit-cost assumptions (25/50/250 credits per action, $0.01/credit overage, 14-day trial with 5,000 credits, add-on tiers), sourced from fetched docs at seq 37-38/45. Kimi K3: Final output gives Free/Pro/Enterprise tier breakdown with explicit caveat that exact dollar figures are client-side rendered/approximate and names assumptions (annual vs monthly billing, seat counts, AI message credits) (seq 54). Qwen 3.8 Max: States Free/Hobby, Pro (~$150/mo), and Growth/Enterprise tiers with assumptions named (per-organization/month billing, seat-oriented, no usage metering) and flags the figures as public info to verify. This behavioural item does not affect the fast grade. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text Mintlify REST API introduction lists endpoints; webhook page embeds an OpenAPI spec. ``` - **Pass** — An MCP server is documented and well-formed ```text Search MCP server documented with tools, endpoints, discovery, and client setup. ``` - **Pass** — A CLI install path is documented ```text CLI install documented: npm i -g mint, pnpm add -g mint, mint new/dev. ``` - **Pass** — SDK packages resolve on their registries ```text npm registry lookup for the mint CLI package returned HTTP 200. ``` - **Pass** — Agent skills are published ```text skill.md published with name, description, and agent workflow guidance. ``` [Full report data](https://www.ax-check.com/mintlify.com/report.json)