# AX Check: apify.com Checked 2026-10-13. Apify's docs and pricing are fully readable without login or guesswork. All 23 checked items passed: install commands, API/MCP/SDK docs, and pricing tables are all stated openly with no gating or interaction required. ## Onboarding needs a login ## Coding sessions All three independent sessions completed the task. DeepSeek V4.1 Flash and Qwen 3.8 Max both quoted plan fees, compute-unit and proxy rates from the pricing docs and built cost estimates for a sample run, with Qwen flagging its figures as approximate; Kimi K3 also completed its session. ### DeepSeek V4.1 Flash [View public run](https://agents.withgauge.com/p/runs/ae5e4d23-2c6b-4a3b-a5d7-f20be76a6c39) · [Read transcript](https://www.ax-check.com/apify.com/sessions/deepseek.json) Quoted plan fees, the CU rate (1 GB RAM × 1 hour), and proxy rates from pricing.md. Estimated the hello-world cost using 256 MB memory and a run of a few seconds on pay-per-usage. (seq 28, seq 65, seq 75) #### End-to-end onboarding - **Onboarding needs a login**: No real Apify token was obtained. Agent confirmed no APIFY_TOKEN in sandbox, built a working example, ran it with no token (public store search succeeded; authenticated run skipped by design) and with a bogus token (clean 401). No authenticated operation against the live product was demonstrated. Docs confirmed a real token requires human browser sign-in or a crypto-wallet prepaid flow unavailable here; agent stopped rather than fabricate success. Event 9: ```text no apify env vars ``` Event 56: ```text [error] ApifyApiError: User was not found or authentication token is not valid ``` Event 37: ```text Authorizing happens in a browser, where the user signs in to Apify and approves the connection. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No Apify API token available in sandbox**: The sandbox had no APIFY_TOKEN, and obtaining one requires a human to sign in via browser to create a free Apify account or complete MCP OAuth. This is a normal credential/login requirement of the product, not a product defect. The agent identified this, tested the auth boundary with a bogus token to confirm behavior (clean 401 error), and stopped rather than guessing further. Event 9: ```text no apify env vars ``` Event 56: ```text [error] ApifyApiError: User was not found or authentication token is not valid ``` Event 37: ```text Authorizing happens in a browser, where the user signs in to Apify and approves the connection. ``` #### Suggested Changes - **Offer a short-lived no-signup demo token for agent testing**: The agent found that the only documented zero-human-signin path is the crypto-wallet x402/MPP flow at agi.apify.com, which is irrelevant to most developers testing the SDK. A short-lived, rate-limited demo token would let a coding agent execute one authenticated Actor run end-to-end before creating an account. Check by having a fresh session with no stored credentials successfully call client.actor(...).call() without any human browser step. Event 37: ```text Agents find the complete, current instructions, including supported chains, terms, and balance checks, at [agi.apify.com/AGENTS.md](https://agi.apify.com/AGENTS.md). ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/7bd49a11-5a63-498c-86c9-77203ead2972) · [Read transcript](https://www.ax-check.com/apify.com/sessions/kimi.json) #### End-to-end onboarding - **Onboarding needs a login**: The agent never obtained an Apify API token on its own. It checked the environment for APIFY_TOKEN (none found), confirmed anonymous access works only for read-only metadata (actor lookup, store browsing), and confirmed that executing an actual actor run is rejected by the hosted API without a token or payment signature. The example script was written but never successfully executed against the live API — it exits with an error instructing a human to supply APIFY_TOKEN from the Apify console. Event 5: ```text --- v22.23.2 Python 3.12.3 ``` Event 14: ```text { "error": { "type": "x402-payment-required", "message": "Request not authenticated. Add your Apify API token, or a PAYMENT-SIGNATURE header for x402 payment. See https://docs.apify.com/api/v2#/introduction/authentication" } } ``` Event 26: ```text Set APIFY_TOKEN first (https://console.apify.com/account/integrations) exit=1 ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **Actor execution requires a human-supplied API token**: The hosted Apify API rejects anonymous run requests with an x402-payment-required error, demanding either an API token or a crypto payment signature. This is expected product authentication behavior, not a defect, but it is a session limitation: no credentials were available, so the example script could never be run against the live API, only read-only metadata calls succeeded. Event 14: ```text "message": "Request not authenticated. Add your Apify API token, or a PAYMENT-SIGNATURE header for x402 payment. See https://docs.apify.com/api/v2#/introduction/authentication" ``` Event 26: ```text Set APIFY_TOKEN first (https://console.apify.com/account/integrations) exit=1 ``` #### Suggested Changes - **Add a free-tier self-serve token option for anonymous SDK trials**: Testing from a clean environment with apify-client showed that every write/run action (client.actor(id).call()) fails without a human-generated token from console.apify.com, even for the smallest public actor like apify/hello-world. Consider documenting a scoped, rate-limited trial token flow directly in the apify-client quickstart so first-time developers can execute at least one real run without leaving the terminal. Verify by running the same apify-example.js script and confirming a successful run status without manually visiting the console first. Event 26: ```text Set APIFY_TOKEN first (https://console.apify.com/account/integrations) exit=1 ``` ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/e3a823e1-383b-41c4-b111-912b2785ea8c) · [Read transcript](https://www.ax-check.com/apify.com/sessions/qwen.json) Gave plan tiers, a compute-unit definition, storage and proxy terms, and a cost estimate for a single-page httpx crawl. It flagged all figures as approximate and unverified. (seq 34) #### End-to-end onboarding - **Onboarding needs a login**: The agent wrote a working Python script using the apify-client SDK and attempted a live call to run a hosted Actor, but no APIFY_TOKEN was available in the environment. The call failed with an authentication error, and the agent never obtained credentials itself or completed any authenticated operation. It explicitly asked for a token to proceed, meaning the blocker was unresolved at session end. Event 17: ```text export APIFY_TOKEN=apify_api_xxx ``` Event 32: ```text apify_client.errors.ApifyApiError: Request not authenticated. Add your Apify API token, or a PAYMENT-SIGNATURE header for x402 payment. ``` Event 34: ```text **No `APIFY_TOKEN` in the environment.** The script runs correctly up to the API call, which returns *"Request not authenticated"* (confirmed the API is reachable, just unauthenticated). Give me a token and I can do a live end-to-end run in seconds. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **Missing Apify API token blocked live execution**: No APIFY_TOKEN was present in the sandbox environment, and the agent had no self-service way to generate one. This is a credentials/test-environment limitation rather than a product defect — Apify requires a normal account token for authenticated calls, which the agent correctly identified and surfaced instead of inventing a workaround. Event 5: ```text 401 Command exited with code 1 ``` Event 32: ```text apify_client.errors.ApifyApiError: Request not authenticated. Add your Apify API token, or a PAYMENT-SIGNATURE header for x402 payment. See https://docs.apify.com/api/v2#/introduction/authentication ``` - **Wrong PyPI package name caused an import error**: Agent initially installed the 'apify' package instead of 'apify-client', causing an ImportError on ApifyClient. This was an agent error (guessing the package name) rather than a product issue, and it self-corrected within two tool calls by installing apify-client and fixing the import. Event 19: ```text ImportError: cannot import name 'ApifyClient' from 'apify' (/opt/freestyle/python/lib/python3.12/site-packages/apify/__init__.py) ``` Event 27: ```text from apify_client import ApifyClient ``` #### Suggested Changes - **Show the correct pip package name earlier in SDK docs**: The agent's first instinct was to run 'pip install apify', which installs an unrelated/different package lacking ApifyClient, causing an avoidable failure. Clarify in the quickstart/README (wherever Python SDK installation is documented) that the client library is 'apify-client' distinctly from the 'apify' package, so first-time integrators don't hit this ImportError. Event 10: ```text 4.1.0 ``` Event 19: ```text ImportError: cannot import name 'ApifyClient' from 'apify' (/opt/freestyle/python/lib/python3.12/site-packages/apify/__init__.py) ``` ### Task given to each agent Help me build a simple example using Apify. 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 (3815 tokens) when requested with Accept: text/markdown. ``` - **Pass** — llms.txt provides an actionable documentation index ```text apify.com/llms.txt lists docs, API, SDK, CLI, MCP, skills and quickstart with descriptions. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt groups links under Main pages, documentation, Academy, API, Actors, SDK headings. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt mentions MCP server, Agent Skills registry, and API catalog/OpenAPI. ``` - **Pass** — A compact guide representation exists ```text agents.md is a standalone Markdown quickstart covering MCP, API, skills and CLI paths. ``` - **Pass** — A focused guide is directly retrievable ```text agents.md and CLI quick-start.md are directly retrievable focused guides with concrete steps. ``` - **Pass** — Equivalent instructions fit a token budget ```text agents.md is 4584 tokens, well under the 8000-token budget for the essential workflow. ``` - **Pass** — Product-docs links survive format changes ```text Homepage Markdown links to docs.apify.com pages that resolve as .md representations. ``` - **Pass** — The compact guide is independently actionable ```text agents.md gives concrete MCP setup, run steps, API token, and SDK install for agents. ``` - **Pass** — Install and next-step links resolve ```text CLI quick-start and SDK/API client pages fetched successfully with install and next steps. ``` ### Onboarding - **Pass** — Docs lead to a relevant quickstart ```text agents.md quickstart and CLI quick-start give concrete create/run/deploy steps. ``` - **Pass** — Installation commands are extractable ```text CLI install page lists curl, brew, and npm install -g apify-cli commands. ``` - **Pass** — Code examples are available without interaction ```text agents.md shows JS and Python apify-client code examples inline. ``` - **Pass** — Prerequisites and auth boundaries are explicit ```text agents.md states sign-up, token location, and Bearer auth header explicitly. ``` ### Pricing - **Pass** — Pricing is readable without interaction ```text Pricing page renders full plan and usage tables as static text, no interaction needed. ``` - **Pass** — Prices are stated, not gated ```text All plan prices ($0/$19/$199/$999) and usage rates stated openly, no gating. ``` - **Pass** — Pricing units and limits are explicit ```text Units explicit: CU = 1 GB RAM/hour, per-GB proxy, per-1,000 SERPs, RAM/concurrency limits. ``` - **Pass** — Agents identify pricing and its assumptions ```text 2 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4.1 Flash: Quoted plan fees, the CU rate (1 GB RAM × 1 hour), and proxy rates from pricing.md. Estimated the hello-world cost using 256 MB memory and a run of a few seconds on pay-per-usage. (seq 28, seq 65, seq 75) Qwen 3.8 Max: Gave plan tiers, a compute-unit definition, storage and proxy terms, and a cost estimate for a single-page httpx crawl. It flagged all figures as approximate and unverified. (seq 34) This behavioural item does not affect the fast grade. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text Apify API v2 reference and OpenAPI spec (JSON/YAML) are linked and reachable. ``` - **Pass** — An MCP server is documented and well-formed ```text Hosted MCP server documented with endpoint, transports, OAuth, tools, and server card. ``` - **Pass** — A CLI install path is documented ```text CLI install documented via npm, Homebrew, and install scripts, plus quickstart. ``` - **Pass** — SDK packages resolve on their registries ```text apify-client resolves on npm and PyPI; apify-cli resolves on npm. ``` - **Pass** — Agent skills are published ```text Agent Skills registry index lists five skills with URLs and digests. ``` [Full report data](https://www.ax-check.com/apify.com/report.json)