# AX Check: allium.so
Checked 2026-10-15.

Docs and quickstart are solid, but plan pricing stays sales-only
16 of 23 checks passed, including a clear Beam quickstart and documented MCP/API/CLI paths. Standard plan prices aren't published on the site.

## Onboarding needs a login

## Coding sessions
All three independent sessions completed and converged on the same picture: per-call USDC machine-payment pricing runs about $0.01 to $0.03 with no subscription or minimum, while standard subscription plan pricing is sales-gated and not published.

### DeepSeek V4.1 Flash
[View public run](https://agents.withgauge.com/p/runs/105490be-1f4f-44e7-9c86-dd200cf4b14d) · [Read transcript](https://www.ax-check.com/allium.so/sessions/deepseek.json)
Quoted $0.02–$0.03 per call for the USDC pay-per-call route with no subscription, confirmed $0.02 from a live 402 amount, and noted plan pricing is sales-only. (seq 41, seq 24, seq 68, seq 84)
#### End-to-end onboarding
- **Onboarding needs a login**: Agent never obtained real Allium credentials. It found two paid-access paths (API key and USDC machine-payments) but had neither: no human supplied an API key, and no funded wallet/private key existed in the sandbox. It confirmed both paths are gated (403 Not Authenticated on the API-key endpoint, 402 Payment Required on the machine-payments endpoint) and then wrote a local example script that only runs the free, unauthenticated discovery endpoint. No authenticated product operation (price query, SQL run, etc.) was ever completed.
  Event 68:

  ```text
  === paid endpoint without key (api.allium.so) ===
  HTTP 403
  {"detail":"Not authenticated"}
  ```
  Event 68:

  ```text
  === paid endpoint without payment (agents.allium.so) ===
  HTTP 402
  {"x402Version":2,"error":"Payment Required!"
  ```
  Event 74:

  ```text
  Paid call skipped: ALLIUM_API_KEY is not set. Create one at https://app.allium.so/settings/api-keys
  Alternative: machine payments (no key). See README.md.
  ```

#### Hallucinated URLs
None identified in this transcript.

#### Blockers
- **No API key or funded wallet available in sandbox**: Allium requires either a human-created API key (app.allium.so signup) or a funded crypto wallet for USDC machine payments to call any paid endpoint. Neither was available to the agent, so every real data call (prices, wallets, SQL) was out of reach. This is a credential/environment limitation, not a product defect — the agent correctly identified it and verified the gating behavior rather than faking success.
  Event 47:

  ```text
  Create your account at [https://app.allium.so/join](https://app.allium.so/join)
  ```
  Event 68:

  ```text
  {"detail":"Not authenticated"}
  ```
  Event 68:

  ```text
  {"x402Version":2,"error":"Payment Required!"
  ```
- **Explorer and Datastream APIs restricted to enterprise customers**: The programmatic Explorer API (run saved queries) and Stream Transformation API are documented as enterprise-only, requiring sales contact rather than self-serve signup. This is a product packaging decision that blocks a first-time developer from testing those specific workflows, though the Realtime API remained usable.
  Event 47:

  ```text
  The Stream Transformation APIs are currently only available to enterprise
    customers. Please reach out to [support@allium.so](mailto:support@allium.so) to learn more about
    enterprise access.
  ```
  Event 47:

  ```text
  The Explorer APIs are currently only available to enterprise customers. Please
    reach out to [support@allium.so](mailto:support@allium.so) to learn more about enterprise access.
  ```

#### Suggested Changes
- **Publish a self-serve price list instead of redirecting pricing page to contact sales**: Both allium.so/pricing and www.allium.so/pricing 302-redirect to a contact form instead of showing numbers, forcing developers to infer pricing from scattered docs (API call pricing table, product-comparison billing basis). Add a pricing page under allium.so/pricing that at least lists the machine-payments per-call rates and Explorer Unit basis already documented at docs.allium.so/ai/machine-payments/endpoints-pricing, and verify it by curling allium.so/pricing and confirming it returns a 200 with rate content rather than a redirect to /contact.
  Event 24:

  ```text
  === https://allium.so/pricing ===
  200 -> https://www.allium.so/contact
  ```
  Event 24:

  ```text
  === https://www.allium.so/pricing ===
  200 -> https://www.allium.so/contact
  ```

### Kimi K3
[View public run](https://agents.withgauge.com/p/runs/57349105-ff5a-4f85-a3fe-98461966641c) · [Read transcript](https://www.ax-check.com/allium.so/sessions/kimi.json)
Quoted $0.01–$0.03 per call, scoped to USDC machine payments with no subscription or minimum and a 3 req/s limit. Said subscription prices aren't published and plans are sales-led. (seq 38, seq 47, seq 71)
#### End-to-end onboarding
- **Onboarding needs a login**: The agent found a self-service signup path (app.allium.so/join) and a no-signup pay-per-call path (machine payments via USDC), but could not complete either without human involvement. The API key path requires email/account signup the agent cannot do; the machine-payments path requires a USDC-funded wallet the agent does not hold. The one authenticated call it attempted against the real hosted API returned a live 402 Payment Required, confirming real product behavior but no successful authenticated operation was ever completed.
  Event 65:

  ```text
  [402] Payment required — here are the live payment terms Allium returned:
    - $0.0200 USDC on eip155:8453 -> 0x3dcb406c03c0d39869be1dbe59aa6df4bdf7d63c
  ```
  Event 71:

  ```text
  Completing it needs either an Allium account API key (signup at `app.allium.so/join` requires email verification — I can't do that) or a USDC-funded crypto wallet to pay per call (I don't hold funds and won't transact).
  ```
  Event 37:

  ```text
  Create your account at [https://app.allium.so/join](https://app.allium.so/join)
  ```

#### Hallucinated URLs
None identified in this transcript.

#### Blockers
- **Paid endpoints require account signup or a funded crypto wallet**: Every revenue-generating API call (e.g. latest token prices) returns HTTP 402 Payment Required unless the caller supplies either an API key from a signed-up Allium account or USDC in a wallet to pay per call. The agent has neither, since account signup needs human email verification and it won't hold/spend crypto funds. This is a credentials/environment limitation, not a product defect — the product behaved exactly as documented.
  Event 48:

  ```text
  {"x402Version":2,"error":"Payment Required!","accepts":[{"scheme":"exact","network":"eip155:8453","amount":"20000"
  ```
  Event 71:

  ```text
  Completing it needs either an Allium account API key (signup at `app.allium.so/join` requires email verification — I can't do that) or a USDC-funded crypto wallet to pay per call (I don't hold funds and won't transact).
  ```
- **Default Python user-agent blocked by Cloudflare**: The first call to agents.allium.so with Python's default urllib user-agent was rejected by Cloudflare as a banned browser signature. This was an agent-side configuration issue (no custom User-Agent header), quickly fixed in-session and not an unresolved blocker.
  Event 56:

  ```text
  'error_name': 'browser_signature_banned', 'error_category': 'access_denied'
  ```
  Event 58:

  ```text
  Cloudflare blocks urllib's default user-agent — easy fix:
  ```

#### Suggested Changes
- **Publish subscription plan pricing or clarify it is sales-led only**: The public pricing page at allium.so/pricing redirects to a 'Get a Demo' contact form with no dollar figures for subscription plans, while the machine-payments docs do publish exact per-call prices. Add at least indicative subscription pricing or tiers to the pricing page so developers evaluating the product do not have to book a demo just to learn plan cost ranges; verify by checking that a visit to the pricing page shows numeric pricing without requiring contact.
  Event 14:

  ```text
  Contact Allium | Enterprise Blockchain Data
  ```
  Event 71:

  ```text
  Dollar prices aren't published — the website's pricing page is a "Get a Demo" contact form, so it's sales-led for plans.
  ```
- **Document the Cloudflare user-agent requirement in API docs**: Calls to agents.allium.so from a plain script (default urllib/curl user-agent) get a 403 'browser_signature_banned' error from Cloudflare before any product logic runs. Add a note in the Getting Started or Realtime API docs (docs.allium.so/api/getting-started) stating a custom User-Agent header is required, so first-time integrators do not have to discover this through trial and error; verify by making a stdlib HTTP request with a default user-agent and confirming the docs preempt the resulting 403.
  Event 56:

  ```text
  'detail': "The site owner has blocked access based on your browser's signature."
  ```
  Event 58:

  ```text
  Cloudflare blocks urllib's default user-agent — easy fix:
  ```

### Qwen 3.8 Max
[View public run](https://agents.withgauge.com/p/runs/d813084a-f754-4b39-9637-08c4b939c076) · [Read transcript](https://www.ax-check.com/allium.so/sessions/qwen.json)
Gave per-call USDC prices by endpoint ($0.01–$0.03, discovery free) under the Machine Payments model. Named settlement networks, rate limits and no minimum, and noted enterprise plans are sales-gated with no public price. (seq 38, seq 55, seq 106, seq 127)
#### End-to-end onboarding
- **End-to-end onboarding not demonstrated**: The agent explored Allium's hosted Machine Payments API (agents.allium.so) and confirmed it needs no API key for pay-per-call endpoints, but deliberately stopped short of completing an authenticated/paid operation. It never obtained a wallet, private key, or Privy credential, and never submitted a signed payment, so no real authenticated product operation was demonstrated. The free endpoint call (HTTP 200) requires no credentials at all, and the 402 response is just a pricing quote, not a completed transaction.
  Event 106:

  ```text
  HTTP 402  -> Payment Required!
    x402Version: 2
  ```
  Event 127:

  ```text
  I did **not** execute a real paid call: that would spend your USDC and require a private key I shouldn't hold or use autonomously.
  ```

#### Hallucinated URLs
None identified in this transcript.

#### Blockers
- **No self-serve path for the paid API without funded wallet/key**: To go beyond pricing discovery and actually complete a paid call, the agent needed a funded crypto wallet and a private key (or Privy server wallet credential), which it correctly declined to generate or use autonomously since it would spend real USDC. This is a product-by-design requirement (machine payments need real funds), not a bug, and the agent treated it as an intentional stopping point rather than an unresolved blocker.
  Event 127:

  ```text
  I did **not** execute a real paid call: that would spend your USDC and require a private key I shouldn't hold or use autonomously.
  ```
- **Default Python User-Agent rejected by Cloudflare (403)**: Calling agents.allium.so with Python's default urllib User-Agent returned HTTP 403 with Cloudflare error code 1010 (bot-protection on the UA header), even though the identical request via curl succeeded. This is test-environment/tooling friction rather than a product defect, and the agent diagnosed and fixed it by setting a normal User-Agent string, after which calls returned HTTP 200/402 as expected.
  Event 96:

  ```text
  HTTP 403
  error code: 1010
  ```
  Event 96:

  ```text
  HTTP 200
  {"/api/v1/developer/wallet/balances/history":...
  ```

#### Suggested Changes
- **Clarify the Cloudflare User-Agent requirement in machine-payments docs**: On docs.allium.so/api/developer/machine-payments.md (or endpoints-pricing.md), add a note that requests to agents.allium.so must send a standard User-Agent header, since Cloudflare returns HTTP 403 (error 1010) for default scripting-library user agents like Python's urllib. Verify by making a raw request with no custom User-Agent header and confirming the doc now flags the requirement.
  Event 96:

  ```text
  HTTP 403
  error code: 1010
  ```
- **Link directly to self-serve pricing from the main /pricing page**: www.allium.so/pricing currently redirects to /contact (sales-gated), hiding the fact that the Machine Payments product has fully public, self-serve, pay-per-call pricing documented at docs.allium.so/ai/machine-payments/endpoints-pricing. Add a visible link or section on /pricing pointing to the machine-payments pricing table so developers don't assume all of Allium is sales-gated. Check by visiting /pricing and confirming a path to per-call USDC pricing is discoverable without contacting sales.
  Event 38:

  ```text
  === https://www.allium.so/pricing ===
  HTTP 200 -> https://www.allium.so/contact
  ```

### Task given to each agent
Help me build a simple example using Allium. 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 · 81/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, products, API, MCP and agent surfaces with links and starting guidance.
  ```

- **Pass** — llms.txt provides navigation guidance

  ```text
  llms.txt organizes key pages, products, use cases and comparisons for navigation.
  ```

- **Pass** — llms.txt mentions offered API, MCP, and skills

  ```text
  llms.txt mentions Developer REST APIs, Allium AI MCP server and agent-native workflows.
  ```

- **Pass** — A compact guide representation exists

  ```text
  docs.allium.so/beam/quickstart.md returns standalone Markdown quickstart for Beam pipelines.
  ```

- **Pass** — A focused guide is directly retrievable

  ```text
  Beam quickstart fetched directly as Markdown with concrete create/deploy/consume steps.
  ```

- **Pass** — Equivalent instructions fit a token budget

  ```text
  Markdown quickstart is 1536 tokens, well under 8000 and below HTML extraction.
  ```

- **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
  Beam quickstart gives concrete steps: open builder, configure source, filter, Kafka sink, deploy, consume with code.
  ```

- **Pass** — Install and next-step links resolve

  ```text
  Fetched Beam quickstart and its next-step config/examples routes resolve; docs.allium.so pages returned 200.
  ```


### Onboarding
- **Pass** — Docs lead to a relevant quickstart

  ```text
  Docs homepage links Quickstart; Beam quickstart gives concrete create/deploy/consume steps.
  ```

- **Skipped** — Installation commands are extractable

  ```text
  Beam quickstart is UI-driven; no install commands for a package or CLI are shown.
  ```

- **Pass** — Code examples are available without interaction

  ```text
  Quickstart shows Python and TypeScript Kafka consumer code inline, no interaction required.
  ```

- **Pass** — Prerequisites and auth boundaries are explicit

  ```text
  Quickstart states beta access required and to contact support before beginning.
  ```


### Pricing
- **Skipped** — Pricing is readable without interaction

  ```text
  No pricing page was fetched; homepage shows only demo and sales contact, no prices.
  ```

- **Skipped** — Prices are stated, not gated

  ```text
  No pricing page was fetched; homepage shows only demo and sales contact, no prices.
  ```

- **Skipped** — Pricing units and limits are explicit

  ```text
  No pricing page was fetched; homepage shows only demo and sales contact, no prices.
  ```

- **Pass** — Agents identify pricing and its assumptions

  ```text
  3 of 3 sessions were judged on pricing; 0 fell short. DeepSeek V4.1 Flash: Quoted $0.02–$0.03 per call for the USDC pay-per-call route with no subscription, confirmed $0.02 from a live 402 amount, and noted plan pricing is sales-only. (seq 41, seq 24, seq 68, seq 84) Kimi K3: Quoted $0.01–$0.03 per call, scoped to USDC machine payments with no subscription or minimum and a 3 req/s limit. Said subscription prices aren't published and plans are sales-led. (seq 38, seq 47, seq 71) Qwen 3.8 Max: Gave per-call USDC prices by endpoint ($0.01–$0.03, discovery free) under the Machine Payments model. Named settlement networks, rate limits and no minimum, and noted enterprise plans are sales-gated with no public price. (seq 38, seq 55, seq 106, seq 127) This behavioural item does not affect the fast grade.
  ```


### Activation
- **Pass** — An API reference or OpenAPI spec is reachable

  ```text
  API overview and Realtime API reference pages fetched successfully from docs.allium.so.
  ```

- **Pass** — An MCP server is documented and well-formed

  ```text
  MCP server URL, OAuth/API-key auth, client setup, toolsets and tools documented.
  ```

- **Pass** — A CLI install path is documented

  ```text
  npx @allium-labs/mcp install CLI documented with client slugs and API-key flag.
  ```

- **Skipped** — SDK packages resolve on their registries

  ```text
  No registry lookup result for @allium-labs/mcp or any Allium SDK package supplied.
  ```

- **Pass** — Agent skills are published

  ```text
  Skills offered: npx skills add allium-labs/skills and get_skill/list_skills MCP tools.
  ```



[Full report data](https://www.ax-check.com/allium.so/report.json)