# AX Check: posthog.com Checked 2026-10-06. PostHog docs and pricing are clear and ready for agent use 21 of 23 checks passed: install commands, API/MCP docs, and SDKs all resolved. Pricing is stated openly with exact per-unit rates and free-tier limits. ## End-to-end onboarding not demonstrated ## Coding sessions All three independent sessions (DeepSeek V4.1 Flash, Kimi K3, Qwen 3.8 Max) completed and produced clear pricing breakdowns, citing posthog.com/pricing with explicit free-tier thresholds, usage-based rates, and stated assumptions like plan type and region. ### DeepSeek V4.1 Flash [View public run](https://agents.withgauge.com/p/runs/025a8188-12e0-487c-a47a-92a45132b6e5) · [Read transcript](https://www.ax-check.com/posthog.com/sessions/deepseek.json) README/final output gives a per-product pricing table with explicit assumptions (usage-based, per-product free tiers, no per-seat, prices subject to change) sourced from posthog.com/pricing fetches (seq 13-34). #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent never obtained a real PostHog project token/API key. It wrote a script that defaults to --dry-run when no key is present, confirmed only that the endpoint accepts a payload shape (HTTP 200 with a deliberately invalid/fake token), and explicitly told the user it could not validate against a real project. No account signup or credential retrieval was attempted or demonstrated. Event 48: ```text curl -s -m 15 -X POST "https://us.i.posthog.com/capture/" -H "Content-Type: application/json" -d '{"api_key":"phc_smoke_test_invalid_token","event":"smoke_test","properties":{"distinct_id":"test_user"},"timestamp":"2026-01-01T00:00:00Z"}' -w '\nHTTP %{http_code}\n' ``` Event 61: ```text One caveat on the environment: there's no API key here, so I couldn't validate against a real project — only the payload shape and endpoint. If you provide a `POSTHOG_API_KEY`, I can run it live and confirm events land. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No real PostHog project token available in sandbox**: The sandbox had no PostHog credentials (env scan for 'posthog' returned none), and the agent had no self-service way to sign up for a project or mint a token during the session. This is a test-environment/credential limitation, not a product defect: PostHog's signup is a normal login/account-creation flow that requires a human. The agent worked around it correctly by defaulting the script to --dry-run and using a fake token only to test that the capture endpoint accepts well-formed payloads (HTTP 200), which does not constitute a validated authenticated operation on a real project. Event 5: ```text echo "---env vars (posthog)---"; env | grep -i posthog || echo "none" ``` Event 8: ```text none ``` Event 61: ```text there's no API key here, so I couldn't validate against a real project — only the payload shape and endpoint ``` #### Suggested Changes - **Fix the broken feature-flags pricing doc link**: Requesting https://posthog.com/docs/feature-flags/pricing returned a stylized 404 page instead of pricing content, forcing the agent to skip that product's pricing details in its summary (Feature Flags pricing was listed as generic 'usage-based' with no real numbers). Add or restore a working feature-flags pricing page and verify by curling the URL and confirming real pricing tiers render instead of the 404 hedgehog page. Event 35: ```text you requested does not exist. --> PostHog A fatal exception 404 has occurred ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/0428f2c3-e459-427b-b067-fe82ced2cc02) · [Read transcript](https://www.ax-check.com/posthog.com/sessions/kimi.json) Final output gives per-product free-tier thresholds (1M events, 5K recordings, 1M flag requests) and notes the demo stays within the free tier — concrete assumptions behind the 'free' cost claim. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent never obtained real PostHog credentials and never made an authenticated call to the hosted product. It wrote a demo script, ran it without an API key, and explicitly ran in 'dry-run mode' with a null client, so identify/capture/feature-flag calls were no-ops. No account signup, no API key retrieval, and no network call to app.posthog.com or us.i.posthog.com occurred during the session. Event 16: ```text Set POSTHOG_API_KEY=phc_... to send real events. Running in dry-run mode. → identify user "demo-user-123" with traits → capture event "demo_button_clicked" → feature flag "new-onboarding": false ``` Event 18: ```text The one thing I can't do myself: **create a PostHog Cloud account**, so I couldn't send real events — you'd need to sign up, grab a project API key, and run `POSTHOG_API_KEY=phc_... node demo.js` to see data in the live dashboard. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No self-service way to create a PostHog account or API key**: PostHog Cloud requires a human to sign up and generate a project API key via the web dashboard; the agent had no credentials and no path to obtain them autonomously, so it could not exercise the real hosted API. This is a normal authentication requirement (session limitation), not a product defect — the agent correctly flagged it rather than treating it as broken. Event 18: ```text The one thing I can't do myself: **create a PostHog Cloud account**, so I couldn't send real events — you'd need to sign up, grab a project API key, and run `POSTHOG_API_KEY=phc_... node demo.js` to see data in the live dashboard. ``` #### Suggested Changes - **Offer a self-service or ephemeral API key for sandboxed/demo evaluation**: Because creating a PostHog Cloud project currently requires dashboard signup, automated agents and CI-style demos can only run in dry-run mode without ever hitting the real ingestion endpoint. Consider a lightweight signup API or demo-key issuance flow; verify the fix by having an unauthenticated script obtain a working phc_ key and successfully call client.capture() against us.i.posthog.com without any manual dashboard step. Event 18: ```text The one thing I can't do myself: **create a PostHog Cloud account**, so I couldn't send real events — you'd need to sign up, grab a project API key, and run `POSTHOG_API_KEY=phc_... node demo.js` to see data in the live dashboard. ``` ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/1464f9aa-99d4-4b0c-9b14-abb99da2369a) · [Read transcript](https://www.ax-check.com/posthog.com/sessions/qwen.json) Final output states usage-based per-product pricing with explicit assumptions: free tier limits (1M events, 5K replays etc.), plan type (free vs pay-as-you-go), region (us/eu), sourced from posthog.com/pricing fetched at seq 13-17. #### End-to-end onboarding - **End-to-end onboarding not demonstrated**: The agent never obtained real PostHog credentials. It checked the environment for existing keys (none found), wrote a Python script that falls back to dry-run without an API key, and tested connectivity using a clearly fake placeholder key ('phc_placeholder_invalid_key'). PostHog's capture endpoint returned HTTP 200 regardless because it accepts and silently drops invalid-key events, so this only proves the endpoint is reachable, not that any authenticated operation succeeded. No sign-up flow was attempted and no real project key was ever created or used. Event 26: ```text curl -s --max-time 10 -w "\nHTTP %{http_code}\n" -X POST https://us.posthog.com/capture/ -H "Content-Type: application/json" -d '{"api_key":"phc_placeholder_invalid_key","event":"connectivity_test","distinct_id":"probe","properties":{}}' ``` Event 29: ```text {"status":"Ok"} HTTP 200 ``` Event 4: ```text env | grep -iE "posthog|ph_|api_key|token" ``` Event 31: ```text The one thing I can't do myself is create an account — sending real events and querying insights requires keys you'd provide ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No self-service account creation for real API key**: The agent correctly identified that creating a PostHog account and obtaining a real project API key (phc_ prefix) requires human sign-up, which it could not perform itself. This is a normal login/account-creation requirement, not a product defect — the agent treated it appropriately by shipping a dry-run mode instead of claiming false success. Event 31: ```text The one thing I can't do myself is create an account — sending real events and querying insights requires keys you'd provide (`phc_` project key for capture; a personal API key for the query API). ``` #### Suggested Changes - **Make the capture endpoint reject invalid API keys with a distinguishable error**: Testing POST https://us.posthog.com/capture/ with a fake key ('phc_placeholder_invalid_key') still returned HTTP 200 and status Ok. A first-time developer validating their integration has no way to tell from the response whether their key is real or events are being silently dropped. Consider returning a distinct status or warning field when the api_key is not recognized, and verify by resending the same placeholder-key request and checking for a non-generic-success response. Event 29: ```text {"status":"Ok"} HTTP 200 ``` Event 26: ```text "api_key":"phc_placeholder_invalid_key" ``` ### Task given to each agent Help me build a simple example using PostHog. 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: B · 84/100 (provisional) Grades come from completed site checks. Coding sessions and skipped checks do not affect the score. ### Clarity - **Failed** — Homepage answers Markdown requests ```text Homepage returned text/html for a text/markdown request; no Markdown representation served. ``` - **Pass** — llms.txt provides an actionable documentation index ```text llms.txt links to docs, API, MCP, skills, and product pages with organized sections. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt gives starting guidance, install wizard, and organized product/tool navigation. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt mentions API base URLs, MCP server install, and agent skills. ``` - **Pass** — A compact guide representation exists ```text Docs pages are published as raw Markdown by appending .md, e.g. /docs/api.md and /docs/ai-observability/start-here.md. ``` - **Pass** — A focused guide is directly retrievable ```text Focused guides fetched directly: /docs/ai-observability/start-here.md and /docs/api.md return Markdown with concrete steps. ``` - **Pass** — Equivalent instructions fit a token budget ```text Compact guides fit budget: start-here.md ~3003 tokens, api.md ~2410 tokens, well under 8000. ``` - **Skipped** — Product-docs links survive format changes ```text Homepage Markdown unsupported, so link preservation across format changes cannot be measured. ``` - **Pass** — The compact guide is independently actionable ```text llms.txt gives install command `npx @posthog/wizard@latest` plus per-product guidance and API/MCP notes. ``` - **Pass** — Install and next-step links resolve ```text Fetched docs pages (api, mcp, skills, start-here) all returned HTTP 200 with usable content. ``` ### Onboarding - **Pass** — Docs lead to a relevant quickstart ```text llms.txt and start-here pages link to concrete quickstarts like OpenAI observability installation. ``` - **Pass** — Installation commands are extractable ```text Install commands extractable: 'npx @posthog/wizard', 'pip install posthog openai', 'npm install @posthog/ai'. ``` - **Pass** — Code examples are available without interaction ```text Code examples shown inline in Python, Node, C# without interaction. ``` - **Pass** — Prerequisites and auth boundaries are explicit ```text Auth boundaries explicit: project token, personal API key with scopes, where to obtain. ``` ### Pricing - **Pass** — Pricing is readable without interaction ```text Homepage and per-product pricing docs state free tiers and per-unit rates in plain text. ``` - **Pass** — Prices are stated, not gated ```text Prices are stated openly: $0.00005/event, $0.005/recording, $0.0001/request, $0.000015/row. ``` - **Pass** — Pricing units and limits are explicit ```text Units and tiers explicit: 1M events/mo free, then $0.00005/event; 5,000 recordings/mo free. ``` - **Pass** — Agents identify pricing and its assumptions ```text 3 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4.1 Flash: README/final output gives a per-product pricing table with explicit assumptions (usage-based, per-product free tiers, no per-seat, prices subject to change) sourced from posthog.com/pricing fetches (seq 13-34). Kimi K3: Final output gives per-product free-tier thresholds (1M events, 5K recordings, 1M flag requests) and notes the demo stays within the free tier — concrete assumptions behind the 'free' cost claim. Qwen 3.8 Max: Final output states usage-based per-product pricing with explicit assumptions: free tier limits (1M events, 5K replays etc.), plan type (free vs pay-as-you-go), region (us/eu), sourced from posthog.com/pricing fetched at seq 13-17. This behavioural item does not affect the fast grade. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text API overview documents endpoints and links downloadable OpenAPI spec and Swagger UI. ``` - **Pass** — An MCP server is documented and well-formed ```text MCP server documented with install command, tool catalog, and per-product usage pages. ``` - **Pass** — A CLI install path is documented ```text CLI install documented via wizard, npm, curl, Homebrew, and Cargo. ``` - **Pass** — SDK packages resolve on their registries ```text Registry lookups for @posthog/cli, @posthog/ai, and pypi posthog all returned HTTP 200. ``` - **Pass** — Agent skills are published ```text Agent skills published: AI Observability skills, Desktop skills, and community skills catalog. ``` [Full report data](https://www.ax-check.com/posthog.com/report.json)