# AX Check: usewheelhouse.com Checked 2026-09-18. Pricing is clear, but agent-facing docs are largely missing. Pricing page states plan prices and units plainly. No documentation index or guide exists, and quickstart, install, and code-sample pages weren't found. ## Onboarding needs a login ## Coding sessions All three sessions completed and correctly reported Wheelhouse's tiered pricing (Pro Flex, Pro Flat, Dynamic Sets, Enterprise) straight from the pricing page, each noting the per-listing or per-revenue assumptions and calling out where per-listing details were unclear. ### DeepSeek V4 Pro [View public run](https://agents.withgauge.com/p/runs/d7574ab6-3643-4191-933f-65963de665de) · [Read transcript](https://www.ax-check.com/usewheelhouse.com/sessions/deepseek.json) Final output lists concrete tiered prices (Pro Flex 1% w/ $2.99 min, Pro Flat $19.99/listing, Dynamic Sets $12.99/set, Enterprise custom) each tied to plan/listing-count assumptions, and separately flags the Revenue Management API as free beta pending future paid release. #### End-to-end onboarding - **Onboarding needs a login**: The agent explored Wheelhouse's docs and OpenAPI spec extensively, and built a working stdlib Python script hitting the real hosted API (GET /listings, GET /listings/{id}/price_recommendations). It confirmed the endpoint/request shape via genuine 401 Unauthenticated responses from the live API using no key and a bogus key. But no real Wheelhouse account or API key was obtained during the session, and no authenticated operation was ever completed. Event 9: ```text PI_GATEWAY_API_KEY= GIT_CONFIG_KEY_0= ``` Event 147: ```text HTTP 401: {"error":"Unauthenticated"} exit=145 ``` Event 150: ```text There's no sandbox/demo token I could find — keys must be generated inside a logged-in Wheelhouse account (or via the MCP OAuth flow). ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No self-service way to obtain an API key or demo credentials**: The Wheelhouse RM API requires an X-Integration-Api-Key generated from inside a logged-in Wheelhouse account (or OAuth via the MCP flow). The sandbox had no Wheelhouse account, no demo/sandbox token, and no way to sign up and self-provision a key without human login. This is a normal authentication requirement, not a product defect, and explains why the example script could not fetch real data. Event 150: ```text There's no sandbox/demo token I could find — keys must be generated inside a logged-in Wheelhouse account (or via the MCP OAuth flow). ``` Event 147: ```text HTTP 401: {"error":"Unauthenticated"} exit=145 ``` #### Suggested Changes - **Publish a downloadable or linked OpenAPI spec file for the RM API**: The OpenAPI spec is only reachable by scraping an embedded __redoc_state JSON blob inside the Redoc HTML page at https://api.usewheelhouse.com/wheelhouse_rm_api; there is no direct .json or .yaml link (attempts at /ss_api/v1/openapi.json, /ss_api/openapi.json, and /openapi.json all returned 404). Add a visible link to the raw spec file on the API reference page and verify by curling it directly. Event 72: ```text == /ss_api/v1/openapi.json == 404 text/html == /ss_api/openapi.json == 404 text/html == /openapi.json == 404 text/html ``` Event 122: ```text __redoc_state = {"menu":{"activeItemIdx":-1},"spec":{"data":{"openapi":"3.0.0","servers":[{"url":"https://api.usewheelhouse.com/ss_api/v1","description":"Main (production) server"}] ``` ### Kimi K3 [View public run](https://agents.withgauge.com/p/runs/3c5c8824-ae6c-4b1b-b4f9-8a4a3cc24d3a) · [Read transcript](https://www.ax-check.com/usewheelhouse.com/sessions/kimi.json) Final output gives concrete tiered pricing (Pro Flex 1% revenue/$2.99 min, Pro Flat $19.99 dropping to $16.99 at 10-49 listings, Dynamic Sets $12.99/set, Enterprise custom) with named assumptions like listing count tier and free-plan 30-day vs Pro 18-month recommendation horizon. #### End-to-end onboarding - **Onboarding needs a login**: The agent explored the live Wheelhouse RM API (confirmed base URL, auth header, and error shapes) but never obtained a real API key. Wheelhouse API keys must be generated inside a logged-in dashboard account, which requires human signup the agent could not complete. It wrote and syntax-tested a Python script but only ran it with no key and a dummy key (both correctly producing errors, not a successful authenticated operation). Event 108: ```text I can't actually run the example against real data because I can't mint an API key myself.** Keys are generated inside a logged-in Wheelhouse account (dashboard → "Api Key"), which requires signing up with an email — a step I can't complete autonomously. ``` Event 102: ```text 401 Unauthenticated — check your API key. {"error":"Unauthenticated"} ``` Event 40: ```text {"error":"Unauthenticated"} HTTP:401 ``` #### Hallucinated URLs - **Guessed OpenAPI spec URLs returned 404**: The agent tried several guessed OpenAPI/spec file paths that don't appear anywhere in the docs navigation it had already crawled. All returned 404, and the agent did not use them further — it fell back to the real docs reference pages, so this was a quick guess-and-discard rather than a used, broken link. Event 51: ```text == https://api.usewheelhouse.com/openapi.json 404 == https://api.usewheelhouse.com/openapi.yaml 404 == https://docs.usewheelhouse.com/openapi.json 404 == https://docs.usewheelhouse.com/openapi.yaml 404 == https://docs.usewheelhouse.com/rm/openapi.json 404 ``` - **Guessed reference-page slugs returned 404**: The agent guessed a few reference page slugs (e.g. combining listing detail path segments, and endpoint-name variants like rm-get-listing-price-recommendations) before finding the correct ones via the sidebar links. These guesses failed but were immediately abandoned in favor of the real, discovered slugs, so they did not block progress. Event 75: ```text ===try detail page=== 404 ``` Event 90: ```text rm-get-listing-price-recommendations: 404 rm-get-listing-price-recs: 404 rm-get-price-recommendations: 200 ``` #### Blockers - **No self-serve way to mint an API key**: Wheelhouse RM API keys can only be generated from inside a logged-in dashboard account (requires human signup/email). This is normal product authentication design, not a defect, but it stopped the agent from completing an authenticated end-to-end run of the example it built. Event 108: ```text Keys are generated inside a logged-in Wheelhouse account (dashboard → "Api Key"), which requires signing up with an email — a step I can't complete autonomously. There's no public sandbox or self-serve trial key I can fetch. ``` #### Suggested Changes - **Publish a machine-readable OpenAPI/spec file at a documented URL**: The agent had to manually crawl and scrape HTML doc pages one by one to reconstruct endpoint paths and request/response shapes because no openapi.json/yaml was found at the common guessed locations. Add a linked, discoverable OpenAPI spec (e.g. referenced from the API Reference landing page at /rm/reference/wheelhouse-revenue-management-api) and verify it resolves with a 200 instead of the 404s the agent hit. Event 51: ```text == https://api.usewheelhouse.com/openapi.json 404 == https://docs.usewheelhouse.com/openapi.json 404 ``` ### Qwen 3.8 Max [View public run](https://agents.withgauge.com/p/runs/c3cb68ed-5d1d-4570-bced-0b740f060720) · [Read transcript](https://www.ax-check.com/usewheelhouse.com/sessions/qwen.json) README.md and final output list concrete tiers (Free, Pro Flex 1% rev/$2.99 min, Pro Flat $19.99/listing, Dynamic Sets $12.99/set) sourced from wheelhouse.dev/pricing, with explicit caveat that no per-request API pricing is published. #### End-to-end onboarding - **Onboarding needs a login**: The agent could not self-serve any Wheelhouse API credentials during the session. Lite API keys require emailing tech-support@usewheelhouse.com and RM API keys require generating one inside a logged-in Wheelhouse account UI (/u/account/api_token or "Api Key" page) — both require human action outside the agent's reach. The agent only probed the live endpoints with no key or a placeholder key, which correctly returned 401 Unauthorized, confirming URLs/auth scheme but never a successful authenticated operation. Event 60: ```text === live probe (no key) === HTTP 401 {"error":"UNAUTHORIZED"} ``` Event 64: ```text Authorizations: RmApiKey path Parameters listing_id required string ``` Event 76: ```text --- bogus rm key --- === RM API: my listings === --- rm failed: HTTP 401: {"error":"Unauthenticated"} The API key was rejected. Check the env var value/scope. exit=1 ``` Event 76: ```text BLOCKED: WHEELHOUSE_LITE_API_KEY is not set. Lite API keys come from Wheelhouse tech support (tech-support@usewheelhouse.com). Nothing can be called without it -- the API answers 401 UNAUTHORIZED. ``` #### Hallucinated URLs None identified in this transcript. #### Blockers - **No self-service path to a real API key**: Both demo paths in the example script require credentials the agent cannot obtain unattended: Lite API keys are issued manually via email to tech support, and RM API keys require logging into the Wheelhouse web app UI to generate a token. This is a credentials/access limitation of the product's onboarding flow, not an agent error — the agent correctly identified this, wrote defensive code around it, and stopped rather than faking success. Event 76: ```text BLOCKED: WHEELHOUSE_RM_API_KEY is not set. Generate one in your Wheelhouse account under "Api Key" (RM API, beta). Nothing can be called without it -- the API answers 401 UNAUTHORIZED. ``` Event 64: ```text Direct API integrations For HTTP integrations that call the RM API directly, send an RM API key in the X-Integration-Api-Key header. You can generate this in your Wheelhouse account under "Api Key". ``` #### Suggested Changes - **Publish a sandbox or trial API key for the RM/Lite APIs**: On the API docs pages (api.usewheelhouse.com/wheelhouse_lite_api and wheelhouse_rm_api), add a self-serve sandbox key or trial credential flow so a new developer can make one real authenticated call without emailing tech support or first creating a full account with listings. Verify by confirming a fresh visitor can obtain a working key and get a non-401 response within the same session. Event 56: ```text Authorizations: LiteApiKey query Parameters latitude required number ``` Event 64: ```text For HTTP integrations that call the RM API directly, send an RM API key in the X-Integration-Api-Key header. You can generate this in your Wheelhouse account under "Api Key". ``` - **Link an official SDK or client library from the API docs pages**: The Redocly docs at api.usewheelhouse.com/wheelhouse_lite_api, wheelhouse_pro_api, and wheelhouse_rm_api list endpoints but no downloadable client. Add a link to an official Python/JS SDK (or state plainly there isn't one) so developers do not need to hand-roll urllib requests, as was done here. Check by confirming the docs page surfaces the SDK link near the 'Authorizations' section. Event 48: ```text (no output) ``` Event 44: ```text Wheelhouse Lite API Host Recommendations get Fetch recommendations for a listing Market Coverage get Market Coverage API docs by Redocly ``` ### Task given to each agent Help me build a simple example using Wheelhouse. 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: D · 42/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. ``` - **Failed** — llms.txt provides an actionable documentation index ```text /llms.txt returned HTTP 404, so no documentation index exists. ``` - **Failed** — A compact guide representation exists ```text /llms.txt returns 404; no compact guide index published. ``` - **Skipped** — llms.txt provides navigation guidance ```text No llms.txt body was returned (404), so navigation guidance cannot be judged. ``` - **Skipped** — llms.txt mentions offered API, MCP, and skills ```text No llms.txt body was returned (404), so API/MCP/skills mentions cannot be judged. ``` - **Skipped** — A focused guide is directly retrievable ```text No standalone Markdown guide fetched; homepage Markdown unsupported. ``` - **Skipped** — Equivalent instructions fit a token budget ```text No compact guide representation was fetched to measure token budget. ``` - **Skipped** — Product-docs links survive format changes ```text Homepage Markdown unsupported, so link preservation across formats cannot be judged. ``` - **Skipped** — The compact guide is independently actionable ```text No compact agent guide was fetched; only homepage and API marketing pages supplied. ``` - **Pass** — Install and next-step links resolve ```text Homepage install/next-step links (Get started, api-docs, pricing) returned HTTP 200. ``` ### Onboarding - **Skipped** — Docs lead to a relevant quickstart ```text No docs or quickstart pages were fetched; only llms.txt 404 and registration pages. ``` - **Skipped** — Installation commands are extractable ```text No installation or CLI guide pages were fetched in this bundle. ``` - **Skipped** — Code examples are available without interaction ```text No documentation or code example pages were fetched in this bundle. ``` - **Skipped** — Prerequisites and auth boundaries are explicit ```text No docs or API pages fetched; auth boundaries not observable from evidence. ``` ### Pricing - **Pass** — Pricing is readable without interaction ```text Pricing page renders plan names and prices as static text without interaction. ``` - **Pass** — Prices are stated, not gated ```text Prices stated: Pro Flex 1% of revenue, Pro Flat $19.99/listing/month, Sets $12.99/set/month. ``` - **Pass** — Pricing units and limits are explicit ```text Units explicit: per listing per month, per set per month, 1% of revenue with $2.99 minimum. ``` - **Pass** — Agents identify pricing and its assumptions ```text 3 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4 Pro: Final output lists concrete tiered prices (Pro Flex 1% w/ $2.99 min, Pro Flat $19.99/listing, Dynamic Sets $12.99/set, Enterprise custom) each tied to plan/listing-count assumptions, and separately flags the Revenue Management API as free beta pending future paid release. Kimi K3: Final output gives concrete tiered pricing (Pro Flex 1% revenue/$2.99 min, Pro Flat $19.99 dropping to $16.99 at 10-49 listings, Dynamic Sets $12.99/set, Enterprise custom) with named assumptions like listing count tier and free-plan 30-day vs Pro 18-month recommendation horizon. Qwen 3.8 Max: README.md and final output list concrete tiers (Free, Pro Flex 1% rev/$2.99 min, Pro Flat $19.99/listing, Dynamic Sets $12.99/set) sourced from wheelhouse.dev/pricing, with explicit caveat that no per-request API pricing is published. This behavioural item does not affect the fast grade. ``` ### Activation - **Pass** — An API reference or OpenAPI spec is reachable ```text API docs page links to Revenue Manager, Pro, Lite and Demand API documentation. ``` - **Skipped** — An MCP server is documented and well-formed ```text MCP mentioned on API page but no setup, endpoint or tool details fetched. ``` - **Skipped** — A CLI install path is documented ```text No CLI install path documented in the fetched pages. ``` - **Skipped** — SDK packages resolve on their registries ```text No SDK or package registry lookup supplied for Wheelhouse packages. ``` - **Skipped** — Agent skills are published ```text No agent skills published or documented in the fetched pages. ``` [Full report data](https://www.ax-check.com/usewheelhouse.com/report.json)