# AX Check: back4app.com Checked 2026-10-06. Quickstart, SDKs and pricing are all readable without logging in. 20 of 23 checklist items passed: install steps, code samples, CLI, MCP docs and API reference all resolve, and all four pricing tiers are stated plainly. ## Onboarding needs a login ## Coding sessions All three independent sessions completed and reviewed pricing. Two cited the actual published tiers (Free, MVP $15, Pay-as-you-go $80, Dedicated $400) while one estimated figures after noting the live pricing page relies on client-side rendering, flagging its numbers as approximate. ### DeepSeek V4.1 Flash [View public run](https://agents.withgauge.com/p/runs/71d11fbe-4610-4a04-8109-2baeeccfa94a) · [Read transcript](https://www.ax-check.com/back4app.com/sessions/deepseek.json) README.md pricing table cites a source URL and lists plan/price/requests/storage/transfer with explicit notes on per-app billing, annual vs monthly, and free-tier limits as assumptions. #### End-to-end onboarding - **Onboarding needs a login**: Agent never obtained real Back4app credentials. It explored the quickstart docs, scaffolded a Parse SDK script and a REST curl script, and ran them only with no credentials (exit 1) and with placeholder/fake values (BACK4APP_APP_ID=test-app-id), which reached the hosted endpoint but returned 'unauthorized'. No account was created and no authenticated operation (create/read/update/delete against a real Back4app app) was ever demonstrated. The agent explicitly stated signing up requires email/ToS and stopped, calling this a blocker rather than resolving it. Event 64: ```text === fake creds (proves hosted endpoint reachable) === Connected to https://parseapi.back4app.com/ Request failed: unauthorized exit=1 ``` Event 87: ```text I can't run it end-to-end because it needs an **Application ID** and keys from a Back4app account (`App Settings → Security & Keys`). Signing up requires your email/ToS, so I stopped there. ``` Event 64: ```text === no creds === Missing credentials. Create a free app at https://www.back4app.com, then copy the keys from App Settings -> Security & Keys into: BACK4APP_APP_ID and BACK4APP_JS_KEY exit=1 ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No Back4app account credentials available in session**: Product requires account signup (email/ToS) to obtain an Application ID and API keys before any real CRUD can run. This is a normal authentication requirement, not a product defect, and the agent correctly identified it as a stopping point rather than fabricating success. Event 87: ```text I can't run it end-to-end because it needs an **Application ID** and keys from a Back4app account (`App Settings → Security & Keys`). Signing up requires your email/ToS, so I stopped there. ``` #### Suggested Changes - **Clarify pricing page monthly-vs-annual default pricing before purchase**: On https://www.back4app.com/pricing/backend-as-a-service, the plan cards show the discounted annual per-month price ($15, $80, $400) as the headline number, with the true monthly rate only recoverable by computing the 'Save 20%/40%' discount. Displaying both monthly and annual prices side-by-side on the main plan card (not just in the Annually/Monthly toggle) would reduce the risk of a developer misreading the sticker price, as happened when the agent had to caveat its own README with estimated monthly equivalents. Event 35: ```text $ 15 Per App / Month Save 40% Billed Annually 500 K Requests ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/9845a6f6-a844-463b-9e3d-25058762f82b) · [Read transcript](https://www.ax-check.com/back4app.com/sessions/kimi.json) Final output gives free-tier limits (~tens of thousands requests/month, 1GB storage) and paid tier (~$25/mo MVP), explicitly framed as usage-based on request volume and flagged as approximate ('check back4app.com/pricing for current numbers'). #### End-to-end onboarding - **Onboarding needs a login**: Agent determined Back4app requires browser-based signup (email verification, dashboard app creation) to obtain App ID and keys, and had no path to do this itself. It wrote an untested example script but never obtained or used real credentials, so no authenticated operation against the hosted product occurred. Event 14: ```text Back4app has no unauthenticated workflow. To get the `App ID` and `Client Key` / `REST API Key` the SDK and REST API require, you must register at back4app.com via browser (email signup + verification, then create an app in their dashboard). I can't do that step, so I can't execute a live example. ``` Event 19: ```text If you give me an App ID and key, I can run and verify the example in under a minute. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No self-service account creation for Back4app**: Product requires browser-based email signup, verification, and dashboard app creation to get App ID/keys. This is a normal authentication requirement (not a product defect) but it fully blocked the agent from running or verifying any live example in this session. Event 14: ```text Back4app has no unauthenticated workflow. To get the `App ID` and `Client Key` / `REST API Key` the SDK and REST API require, you must register at back4app.com via browser (email signup + verification, then create an app in their dashboard). I can't do that step, so I can't execute a live example. ``` #### Suggested Changes - **Offer a programmatic or CLI-based account/app creation path**: Add a documented API or CLI method to create a Back4app account and app (with App ID/keys) without browser email verification, so automated agents and scripts can self-provision. Verify by checking whether a non-interactive signup/app-creation endpoint exists and is documented alongside the REST API docs at parseapi.back4app.com. Event 14: ```text you must register at back4app.com via browser (email signup + verification, then create an app in their dashboard) ``` ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/c205c04c-b377-4e7d-a327-053eb0aa517d) · [Read transcript](https://www.ax-check.com/back4app.com/sessions/qwen.json) Final output gives tiered pricing (Free ~25K req/mo, Basic ~$25/mo, Professional $100-250/mo, Enterprise custom) and flags it as approximate since the live pricing page loads client-side and couldn't be scraped (seq 4-30 curl attempts). #### End-to-end onboarding - **Onboarding needs a login**: The agent never obtained real Back4App credentials. It wrote two demo scripts (REST and SDK versions) but could not execute them against a live app because creating an app requires signing up via the Back4App web dashboard (email/Google/GitHub), which the agent cannot do autonomously. It only verified that the hosted endpoint is reachable by sending a deliberately fake App ID and confirming a 401, which is not an authenticated operation. Event 46: ```text it requires **account signup + creating an app in their web dashboard** to get an Application ID / REST key / JS key. I can't sign up (email/Google/GitHub registration), so I can't execute the demo against a live app. ``` Event 44: ```text {"error":"unauthorized"} HTTP 401 ``` Event 43: ```text Missing credentials. Set BACK4APP_APP_ID, BACK4APP_JS_KEY, BACK4APP_REST_KEY. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No self-service account creation for Back4App**: Back4App requires signing up through its web dashboard (email, Google, or GitHub) and manually creating an app to obtain the Application ID, JS Key, and REST API Key. This is a normal authentication requirement, not a product defect, and the agent correctly identified it as a session limitation rather than attempting to fake around it. Event 46: ```text it requires **account signup + creating an app in their web dashboard** to get an Application ID / REST key / JS key. I can't sign up (email/Google/GitHub registration), so I can't execute the demo against a live app. ``` - **Pricing tiers not scrapable from static HTML**: The pricing page content loads client-side via Next.js chunks, so curl-based scraping only returned marketing copy and no concrete tier numbers. This is a test-environment limitation (no JS execution) rather than a product defect, and the agent flagged the figures it reported as estimates needing verification. Event 46: ```text Plans are request-quota based, roughly (verify on back4app.com/pricing — the tiers load client-side so I couldn't scrape live numbers): ``` #### Suggested Changes - **Publish static pricing tier numbers on the plans page**: The pricing page at back4app.com/pricing-back4app-plans renders tier details (Free/Basic/Professional/Enterprise limits and prices) via client-side JS chunks, so a plain HTTP fetch of the page returns only marketing copy with no numbers. Adding the plan details as server-rendered HTML or a simple JSON/docs endpoint would let automated tools and simple scripts confirm pricing without executing JavaScript. Verify by curling the page and checking that dollar amounts and quota numbers appear in the raw response. Event 17: ```text Scale with confidence Keep costs under control as you scale your apps with simple, predictable pricing. ``` ### Task given to each agent Help me build a simple example using Back4app. 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 Markdown Accept header; no Markdown representation offered. ``` - **Pass** — llms.txt provides an actionable documentation index ```text llms.txt lists docs, SDKs, API, MCP and tutorials with descriptive links. ``` - **Pass** — llms.txt provides navigation guidance ```text llms.txt organizes pages into Main, Products, Docs, SDK and Tutorial sections. ``` - **Pass** — llms.txt mentions offered API, MCP, and skills ```text llms.txt mentions REST/GraphQL APIs, MCP integration, and AI Agent skills. ``` - **Pass** — A compact guide representation exists ```text Standalone Markdown quickstart served at /docs/get-started/welcome.md with full setup steps. ``` - **Pass** — A focused guide is directly retrievable ```text Quickstart page gives concrete steps: get keys, install SDK, save data. ``` - **Pass** — Equivalent instructions fit a token budget ```text Markdown quickstart is 2596 tokens, well under the 8000-token budget. ``` - **Skipped** — Product-docs links survive format changes ```text Homepage Markdown unsupported, so link preservation across formats cannot be measured. ``` - **Pass** — The compact guide is independently actionable ```text Quickstart gives concrete steps: get App Keys, install Parse SDK, initialize, save data, with per-platform code. ``` - **Pass** — Install and next-step links resolve ```text Fetched quickstart, new-app, MCP and API-reference pages all returned HTTP 200. ``` ### Onboarding - **Pass** — Docs lead to a relevant quickstart ```text Docs quickstart page gives concrete setup steps: create account, get keys, install SDK, save data. ``` - **Pass** — Installation commands are extractable ```text Quickstart lists install commands: npm install parse, pubspec.yaml, build.gradle, CocoaPods, Composer. ``` - **Pass** — Code examples are available without interaction ```text Quickstart shows inline code for JS, Flutter, Android, iOS, PHP, .NET, REST without interaction. ``` - **Pass** — Prerequisites and auth boundaries are explicit ```text Quickstart states need Application ID and key from App Settings -> Security & Keys. ``` ### Pricing - **Pass** — Pricing is readable without interaction ```text Pricing pages render plan names, prices and feature tables directly in fetched HTML without interaction. ``` - **Pass** — Prices are stated, not gated ```text Prices stated openly: Free, MVP $15, Pay-as-you-go $80, Dedicated $400 per app/month. ``` - **Pass** — Pricing units and limits are explicit ```text Units and limits explicit: requests/month, GB storage, transfer, file storage, per-app billing. ``` - **Pass** — Agents identify pricing and its assumptions ```text 3 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4.1 Flash: README.md pricing table cites a source URL and lists plan/price/requests/storage/transfer with explicit notes on per-app billing, annual vs monthly, and free-tier limits as assumptions. Kimi K3: Final output gives free-tier limits (~tens of thousands requests/month, 1GB storage) and paid tier (~$25/mo MVP), explicitly framed as usage-based on request volume and flagged as approximate ('check back4app.com/pricing for current numbers'). Qwen 3.8 Max: Final output gives tiered pricing (Free ~25K req/mo, Basic ~$25/mo, Professional $100-250/mo, Enterprise custom) and flags it as approximate since the live pricing page loads client-side and couldn't be scraped (seq 4-30 curl attempts). This behavioural item does not affect the fast grade. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text API Reference page documents the auto-generated REST/GraphQL API and SDK usage. ``` - **Pass** — An MCP server is documented and well-formed ```text MCP docs give npx installer, per-IDE JSON configs, account-key auth, and tool list. ``` - **Pass** — A CLI install path is documented ```text CLI guide documents install script, b4a binary, account-key config, and commands. ``` - **Pass** — SDK packages resolve on their registries ```text npm registry lookup for the parse SDK package returned HTTP 200. ``` - **Skipped** — Agent skills are published ```text No agent skills surface is offered or documented in the fetched evidence. ``` [Full report data](https://www.ax-check.com/back4app.com/report.json)