# AX Check: cal.com Checked 2026-10-29. Cal.com docs and pricing are readable instantly, no login needed Pricing is fully stated on a static page (Free, Teams $12, Orgs $28 per user/month). A quickstart walkthrough and install commands weren't found by agents. ## Onboarding needs a login ## Coding sessions One of three independent sessions stopped before finishing, as the task called for a local setup step outside its scope. The other two completed and described pricing by recalling plan names and rough per-user rates from memory rather than quoting the live pricing page, both adding caveats that figures should be verified. ### DeepSeek V4.1 Flash [View public run](https://agents.withgauge.com/p/runs/80bf46fb-5de7-4f7c-a6ce-eefa07a8cf2b) · [Read transcript](https://www.ax-check.com/cal.com/sessions/deepseek.json) #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The transcript only shows the agent fetching public pricing and docs pages via curl (cal.com/pricing, cal.com/docs/api-reference). No attempt to create a Platform OAuth client, obtain a managed-user access token, or call an authenticated Cal.com API endpoint is shown in the supplied events. No credential acquisition or authenticated operation evidence exists in this transcript excerpt. Event 13: ```text curl -sS -m 20 -o /tmp/cal_home.html -w "HTTP %{http_code}\n" https://cal.com/pricing ``` Event 20: ```text curl -sSL -m 20 -o /tmp/cal_docs.html -w "FINAL %{url_effective} HTTP %{http_code}\n" https://api.cal.com/v2/docs ``` #### Hallucinated URLs - **Guessed OpenAPI spec paths that 404'd**: The agent tried several guessed URLs for the Cal.com API spec/docs (openapi.json, openapi.yaml, /docs) without prior confirmation they existed. These returned 404/410, consistent with guessed paths rather than documented links, though this is not fully certain since one later redirected successfully. Event 11: ```text curl -sS -m 20 -o /tmp/cal_openapi.json -w "HTTP %{http_code}\n" https://api.cal.com/v2/openapi.json ``` Event 22: ```text https://api.cal.com/v2/openapi.yaml https://api.cal.com/docs ``` Event 24: ```text == https://api.cal.com/v2/openapi.yaml HTTP 404 size 249 final https://api.cal.com/v2/openapi.yaml == https://api.cal.com/docs HTTP 410 size 109 final https://api.cal.com/docs ``` #### Blockers None identified in this transcript. #### Suggested Changes - **Publish a direct, stable link to the OpenAPI spec**: Multiple guessed paths for the API v2 spec (/v2/openapi.json, /v2/openapi.yaml, /docs) returned 404/410 before the agent found the working docs page at cal.com/docs/api-reference/v2/introduction. Add a visible link to the machine-readable OpenAPI spec directly from the API v2 introduction page so tooling and agents do not need to guess common spec file paths. Verify by checking that a fresh curl to the linked URL returns HTTP 200 with the spec content. Event 15: ```text HTTP 404 ---size--- 249 /tmp/cal_openapi.json ``` Event 24: ```text == https://api.cal.com/docs HTTP 410 size 109 final https://api.cal.com/docs ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/b23db390-bca7-4de7-8154-ecab833ea97a) · [Read transcript](https://www.ax-check.com/cal.com/sessions/kimi.json) Gave per-plan prices (Free, Teams ~$15–20/user/mo, Orgs ~$37/user/mo, Platform ~$299/mo) with seat basis and an 'approximate, check the site' caveat. Figures came from memory, not a fetched page. (seq 16, seq 10) #### End-to-end onboarding - **Onboarding needs a login**: The agent checked for existing credentials in the environment, found none, and confirmed the hosted v2 API requires authentication (received a 401/UnauthorizedException on an unauthenticated call). It never obtained a real API key during the session; API key issuance requires a manual step in the Cal.com web UI. No authenticated call was ever made, so no product operation was demonstrated. Event 4: ```text env | grep -iE 'cal|CALCOM' ; echo "---" ; node --version 2>/dev/null; python3 --version 2>/dev/null; echo "---"; ls /sandbox/repo ``` Event 9: ```text "error":{"code":"UnauthorizedException","message":"ApiAuthStrategy - No authentication method provided. Either pass an API key as 'Bearer' header or OAuth client credentials as 'x-cal-secret-key' and 'x-cal-client-id' headers" ``` Event 16: ```text account creation and API-key issuance only happen through the web UI** (app.cal.com → Settings → Developer → API keys). There are no credentials in this environment, so I could not run authenticated calls end-to-end. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No self-service way to obtain a Cal.com API key**: The sandbox had no Cal.com credentials, and the only path to get an API key is the app.cal.com web UI under Settings > Developer > API keys — a manual human step. This is a normal login/credential requirement, not a product defect, but it stopped the agent from running any authenticated call end-to-end. Event 4: ```text env | grep -iE 'cal|CALCOM' ``` Event 16: ```text account creation and API-key issuance only happen through the web UI** (app.cal.com → Settings → Developer → API keys). There are no credentials in this environment, so I could not run authenticated calls end-to-end. ``` #### Suggested Changes - **Clarify the version-header requirement for v2 endpoints in onboarding docs**: The agent had to infer that v2 calls need a dated 'cal-api-version' header, embedding this as a comment in the generated script rather than finding it from a first unauthenticated test. Check the current v2 quickstart/docs page to confirm this requirement is called out prominently near the authentication section, since the raw 401 response from /v2/me did not mention it. Event 9: ```text "message":"ApiAuthStrategy - No authentication method provided. Either pass an API key as 'Bearer' header or OAuth client credentials as 'x-cal-secret-key' and 'x-cal-client-id' headers" ``` Event 13: ```text "cal-api-version": "2024-08-13", // v2 requires a dated API version header ``` ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/f1468e09-4827-4c31-99a5-ada74bc9af33) · [Read transcript](https://www.ax-check.com/cal.com/sessions/qwen.json) Tied figures to plans (free tier, ~$12–15/user/mo Teams, ~$0.004–0.005/booking Platform) and noted paid-plan API gating. Numbers came from memory and weren't fetched. (seq 25) #### End-to-end onboarding - **Onboarding needs a login**: The agent never obtained a Cal.com API key on its own. It checked the environment for credentials, found none, probed a guessed endpoint, then wrote example code and stopped, explicitly stating it needed a human to supply CAL_API_KEY or log into a hosted account. No authenticated request to the real Cal.com API was ever made. Event 4: ```text NODE_EXTRA_CA_CERTS=*** CARGO_HOME=*** RUSTUP_HOME=*** PI_GATEWAY_API_KEY=*** PATH=*** GIT_CONFIG_KEY_0=*** ``` Event 25: ```text I cannot run the example live**: there is no Cal.com API key in this environment, and creating one requires logging into a hosted Cal.com account (paid plan for API access). ``` Event 9: ```text 404 ``` #### Hallucinated URLs - **Guessed wrong Cal.com API base path (app.cal.com/v2/me)**: The agent probed https://app.cal.com/v2/me as a guess for the API, got a 404, and then silently switched to a different base URL (api.cal.com/v2) in the actual script without reconciling or explaining the discrepancy. This looks like a guessed/invented endpoint that failed, though a single 404 alone is not conclusive proof since app.cal.com could plausibly host docs or redirects rather than the API. Event 7: ```text curl -s -o /dev/null -w '%{http_code}\n' --max-time 10 https://app.cal.com/v2/me ``` Event 9: ```text 404 ``` #### Blockers - **No self-service way to obtain a Cal.com API key**: The sandbox environment had no Cal.com credentials, and the agent determined that creating an API key requires a human to log into a hosted Cal.com account (and per the agent's own research, a paid plan). This is a normal authentication/session limitation rather than a product defect, since API keys are expected to require account login. Event 25: ```text there is no Cal.com API key in this environment, and creating one requires logging into a hosted Cal.com account (paid plan for API access) ``` - **Example script never executed or validated against the live API**: Because no credentials were available, the agent never ran calcom-example.mjs against the real Cal.com API, so the correctness of the script (booking flow, slot-finding logic, response shapes) is unverified. This is a consequence of the credential blocker, not a separate product issue. Event 25: ```text If you paste a `CAL_API_KEY` into the environment, I can run `calcom-example.mjs` end-to-end immediately. ``` #### Suggested Changes - **Clarify that the public v2 API requires a paid plan before the quickstart step**: The agent's research found that free hosted accounts have limited or no API access, which blocked end-to-end testing. Stating this plan requirement explicitly at the top of the API quickstart/key-creation page (https://app.cal.com/settings/developer/api-keys per the agent's own doc comment) would let developers know upfront whether they need to upgrade before writing any code. Event 25: ```text The public API is gated to paid plans — free accounts have limited/no API access, which matters for this example. ``` ### Task given to each agent Help me build a simple example using Cal.com. 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 (200) when requested with Accept: text/markdown. ``` - **Pass** — llms.txt provides an actionable documentation index ```text llms.txt links docs, API v2, Cal Atoms, MCP server, and a full docs index. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt organizes sections with guidance and points agents to docs and pricing. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt mentions v2 REST API, Cal Atoms, and hosted MCP server at mcp.cal.com. ``` - **Pass** — A compact guide representation exists ```text Homepage returns text/markdown via content negotiation, a compact guide representation. ``` - **Pass** — A focused guide is directly retrievable ```text llms.txt and API v2 introduction.md are directly retrievable focused guides. ``` - **Pass** — Equivalent instructions fit a token budget ```text Homepage Markdown is 3523 tokens, well under the 8000-token budget. ``` - **Pass** — Product-docs links survive format changes ```text Docs, API, MCP and pricing links persist in the Markdown homepage representation. ``` - **Pass** — The compact guide is independently actionable ```text llms.txt gives agent instructions, plans, API/MCP details, and developer links; independently actionable. ``` - **Pass** — Install and next-step links resolve ```text Fetched install/next-step links (signup, docs, API, MCP, Docker) all returned 200. ``` ### Onboarding - **Skipped** — Docs lead to a relevant quickstart ```text llms.txt links developer docs and API reference, but no fetched quickstart page for Cal.com. ``` - **Skipped** — Installation commands are extractable ```text Only Cal.diy self-hosting install commands fetched; no Cal.com product install commands observed. ``` - **Skipped** — Code examples are available without interaction ```text llms.txt mentions v2 REST API and Cal Atoms but no fetched page shows code examples. ``` - **Skipped** — Prerequisites and auth boundaries are explicit ```text llms.txt notes API key or OAuth auth, but no fetched developer quickstart states prerequisites. ``` ### Pricing - **Pass** — Pricing is readable without interaction ```text Pricing page renders as static Markdown with all plan tiers and prices visible, no interaction needed. ``` - **Pass** — Prices are stated, not gated ```text Free, Teams $12, Organizations $28 per user/month stated; Enterprise custom pricing. ``` - **Pass** — Pricing units and limits are explicit ```text Units explicit: per user/month, 1 user free, 14-day trial, yearly save 25%. ``` - **Pass** — Agents identify pricing and its assumptions ```text 2 of 3 sessions were judged on pricing; 0 fell short. Kimi K3: Gave per-plan prices (Free, Teams ~$15–20/user/mo, Orgs ~$37/user/mo, Platform ~$299/mo) with seat basis and an 'approximate, check the site' caveat. Figures came from memory, not a fetched page. (seq 16, seq 10) Qwen 3.8 Max: Tied figures to plans (free tier, ~$12–15/user/mo Teams, ~$0.004–0.005/booking Platform) and noted paid-plan API gating. Numbers came from memory and weren't fetched. (seq 25) This behavioural item does not affect the fast grade. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text API v2 introduction and per-endpoint OpenAPI specs are fetched from cal.com docs. ``` - **Pass** — An MCP server is documented and well-formed ```text MCP server documented: hosted mcp.cal.com, OAuth 2.1, client configs, 72 tools. ``` - **Skipped** — A CLI install path is documented ```text No Cal.com CLI install path documented; only self-hosting Docker and npx MCP server. ``` - **Pass** — SDK packages resolve on their registries ```text npm registry lookup for @calcom/atoms returned HTTP 200. ``` - **Skipped** — Agent skills are published ```text No agent skills published or documented in the fetched Cal.com pages. ``` [Full report data](https://www.ax-check.com/cal.com/report.json)