Skip to content
Gauge

ax-check.com

by Gauge

Allium

allium.so

ax-check.com

Checked 15 October 2026

B

81/100

Agents need your login

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.

2 fixes to start with

Concrete changes, backed by what we found.

Onboarding

Give agents a clear login handoff and a way to resume setup.

Agents cannot progress through onboarding without human help. Provide an agent-accessible path through authentication and setup.

Docs

Return Markdown when clients request text/markdown.

Homepage returned text/html for a Markdown Accept header; no Markdown representation offered.

Recorded coding sessions

Same task, 3 models, no allium.so account. Recorded 15 October 2026 on Pi.

3 recorded · 3m 19s

3m 19s · recorded

Session findings

Select a finding to see it in context.

piv0.84.2
modelQwen 3.8 Maxcwd/sandbox/repo
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.
Thinking…

Let me understand the request. The user wants help building a simple example using "Allium". They want me to explain how pricing works, and whether this product is easy for me (the AI agent) to manage. I should let them know if I get blocked.

Key instructions:

  • If this product has no developer workflow I 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.

First, I need to figure out what "Allium" is. Let me explore the current directory to see if there's any context about Allium.

Let me look around the sandbox/repo directory first.

I'll start by exploring the current directory to understand what Allium is and what context is available.

cd /sandbox/repo && ls -la && echo "---" && pwd
total 16
total 16
drwxr-xr-x 3 root root 4096 Sep 18 08:00 .
drwxr-xr-x 7 root root 4096 Oct 15 16:56 ..
drwxr-xr-x 8 root root 4096 Sep 24 20:05 .git
-rw-r--r-- 1 root root  408 Sep 18 08:00 .gitignore
---
/sandbox/repo

cd /sandbox/repo && find . -maxdepth 2 -type f 2>/dev/null | head -100
./.gitignore
./.gitignore
./.git/COMMIT_EDITMSG
./.git/config
./.git/index
./.git/HEAD
./.git/description
Thinking…

The repo is essentially empty except for a .gitignore and git metadata. Let me look at the git history and the .gitignore to understand what this repo is about.

The repo is nearly empty. Let me check the git history and config for context about what Allium is.

read /sandbox/repo/.gitignore{"content":[{"text":"# Keep generated and vendored files out of source diffs.\n\n# Logs / OS cruft\n*.log\n.DS_Store\n\n# JavaScript / TypeScript\nnode_modules/…ctrl+o
{"content":[{"text":"# Keep generated and vendored files out of source diffs.\n\n# Logs / OS cruft\n*.log\n.DS_Store\n\n# JavaScript / TypeScript\nnode_modules/\n.next/\ndist/\nbuild/\ncoverage/\n\n# Python\n.venv/\nvenv/\n__pycache__/\n*.py[cod]\n.pytest_cache/\n*.egg-info/\n\n# Rust\ntarget/\n\n# Go / PHP / Ruby vendored deps\nvendor/\n.bundle/\n\n# Java / Kotlin / Scala\n.gradle/\n\n# .NET\nbin/\nobj/\n\n# Elixir\n_build/\ndeps/\n\n# Dart / Flutter\n.dart_tool/\n","type":"text"}]}
cd /sandbox/repo && git log --oneline -20 2>/dev/null; echo "--- config ---"; cat .git/config 2>/dev/null; echo "--- description ---"; cat .git/description 2>/dev/null
9ebf5fb Initial workspace
9ebf5fb Initial workspace
--- config ---
[core]
	repositoryformatversion = 0
	filemode = true
	bare = false
	logallrefupdates = true
--- description ---
Unnamed repository; edit this file 'description' to name the repository.
Thinking…

The repo has no context about Allium. There's no remote configured, and just a single "Initial workspace" commit. So I need to figure out what "Allium" is on my own.

Allium could refer to several things:

  1. Allium (allium.so) - a blockchain data platform / data infrastructure company that provides curated blockchain data through APIs and data pipelines. They have a "Allium Explorer" and data APIs.
  2. Allium - the flower (genus of onions).
  3. Some other product.

Given the context (a coding agent, SDK/API, hosted product, pricing), Allium is most likely the blockchain data company allium.so. They provide blockchain data infrastructure.

Let me check if there's internet access to look up Allium. Let me try to search or check network access.

Actually, let me first check whether I have network access and whether there's any package manager access (npm, pip) to find Allium SDKs.

Let me think about the instructions carefully:

  • "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."
  • "If this product has no developer workflow you can act on, say so plainly and stop."

So I need to determine:

  1. What is Allium?
  2. Does it have an SDK or API I can use?
  3. How does pricing work?
  4. Is it easy for me (an AI agent) to manage?

Let me check network access first.

The repo has no Allium context. Let me research what Allium is and check my network/tooling access.

cd /sandbox/repo && echo "=== Network test ===" && (curl -sS -m 10 -I https://allium.so 2>&1 | head -20 || echo "curl failed"); echo "=== DNS ==="; (nslookup allium.so 2>&1 | head -10 || echo "no nslookup")
=== Network test ===
=== Network test ===
HTTP/2 301 
date: Thu, 15 Oct 2026 16:56:24 GMT
location: https://www.allium.so/
strict-transport-security: max-age=31536000; includeSubDomains
x-content-type-options: nosniff
server: cloudflare
cf-ray: a4b05b5efe1f2c74-IAD

=== DNS ===
Server:		2606:4700:4700::1111
Address:	2606:4700:4700::1111#53

Non-authoritative answer:
Name:	allium.so
Address: 104.18.12.30
Name:	allium.so
Address: 104.18.13.30
Name:	allium.so
Address: 2606:4700::6812:c1e

which node npm python3 pip pip3 go 2>&1; echo "--- versions ---"; node --version 2>&1; npm --version 2>&1; python3 --version 2>&1
/usr/local/bin/node
/usr/local/bin/node
/usr/local/bin/npm
/usr/local/bin/python3
/usr/local/bin/pip
/usr/local/bin/pip3
/usr/local/go/bin/go
--- versions ---
v22.23.2
10.9.8
Python 3.12.3
Thinking…

I have network access. Allium.so is a real product. Let me research what Allium is. It redirects to www.allium.so. Let me fetch the homepage and docs.

I have node, npm, python3, pip, go available. Let me look up Allium's documentation to understand:

  1. What it does
  2. Its SDK/API
  3. Pricing
  4. Quickstart

Let me fetch the website and docs.

Good — I have network access and Allium.so is a real hosted product. Let me research its docs, SDK/API, and pricing.

cd /sandbox/repo && echo "=== homepage ===" && curl -sSL -m 20 https://www.allium.so/ 2>&1 | sed -e 's/<[^>]*>//g' | tr -s ' \n' ' \n' | grep -iE "allium|blockchain|data|api|enterprise|price|schema|query|sql|explorer" | head -40
=== homepage ===
=== homepage ===
Allium: onchain data platform for institutions!function(o,c){var n=c.documentElement,t=" w-mod-";n.className+=t+"js",("ontouchstart"in o||o.DocumentTouch&&c instanceof DocumentTouch)&&(n.className+=t+"touch")}(window,document);
 window.dataLayer = window.dataLayer || [];
 function gtag(){dataLayer.push(arguments);}
 container, so the Allium side has to be swiped to and is easily missed.
 Stack to a single column under 768px: Others block, then Allium block. -->
 var h = document.querySelector('.section_report_header .report_header_content-top h2');
 document.querySelectorAll('.report_meta .report_tag').forEach(function (t) {
 :root { --aw-warn: url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24' fill='none' stroke='%23B5503F' stroke-width='1.5' stroke-linecap='round' stroke-linejoin='round'%3E%3Cpath d='M20.0429 21H3.95705C2.41902 21 1.45658 19.3364 2.22324 18.0031L10.2662 4.01533C11.0352 2.67792 12.9648 2.67791 13.7338 4.01532L21.7768 18.0031C22.5434 19.3364 21.581 21 20.0429 21Z'/%3E%3Cpath d='M12 9V13'/%3E%3Cpath d='M12 17.01L12.01 16.9989'/%3E%3C/svg%3E"); }
 .popup-toast.allium-show { opacity: 1; transform: translateY(0); }
 .advantage_table-item-body:has(> .advantage_table-item-outcome)::before { content: "Allium"; display: block; order: -1; font-size: 11px; line-height: 14px; font-weight: 600; letter-spacing: .08em; text-transform: uppercase; color: #c586c0; }
 .advantage_table > .advantage_table-col:first-child .advantage_table-item-body:has(> .advantage_table-item-outcome)::before { content: "Without Allium"; color: #B5503F; }
=768px): click tabs; pins only when it fits (>=992px, no reduced motion, heading + card fit below the navbar), heading + card centred vertically below the navbar: top = max(nav, nav + (vh - nav - block) / 2). While pinned every tab pane is held at the tallest tab's height. Tall screens (>=992px wide and >=850px tall): image panel, screenshot, card padding and card title (.ut_title, 32px up to 35.84px) scale with viewport height (clamp, capped). Unpins with the standard 80px section padding below. Phones: accordion. data-ut-images="off" = text-only card; data-ut-bullets="off" hides the bullet list. -->
 .ut_section .ut_icon{width:9px;height:14px;flex:0 0 9px;background-color:currentColor;-webkit-mask:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 9 14'%3E%3Cpath d='M0 2.8V0H2.8V2.8H5.6V5.6H8.4V8.4H5.6V11.2H2.8V14H0V2.8Z'/%3E%3C/svg%3E") center/contain no-repeat;mask:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 9 14'%3E%3Cpath d='M0 2.8V0H2.8V2.8H5.6V5.6H8.4V8.4H5.6V11.2H2.8V14H0V2.8Z'/%3E%3C/svg%3E") center/contain no-repeat}
 .ut_section .ut_arrow::before{content:"";display:block;width:100%;height:100%;min-width:14px;min-height:14px;background-color:currentColor;-webkit-mask:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 14 14' fill='none'%3E%3Cpath d='M3.5 11.08L11.08 3.5M3.8 3.5H11.08V10.78' stroke='%23000' stroke-linejoin='round'/%3E%3C/svg%3E") center/contain no-repeat;mask:url("data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 14 14' fill='none'%3E%3Cpath d='M3.5 11.08L11.08 3.5M3.8 3.5H11.08V10.78' stroke='%23000' stroke-linejoin='round'/%3E%3C/svg%3E") center/contain no-repeat}
 .ut_section[data-ut-bullets="off"] .ut_list{display:none}
 .ut_section[data-ut-images="off"] .solution_image-wrapper{display:none}
 .ut_section[data-ut-images="off"] .solution_card{grid-template-columns:1fr}
 .ut_section[data-ut-images="off"] .solution_image-container{background:transparent}
html:not([data-wf-page="6a19672a3e86bd5aff36e302"]) :is(.section_advantage,.section_impact,.section_value,.section_difference,.section_pipeline,.section_technique,.section_comparison,.section_integration,.section_application,.section_delivery,.section_team,.section_mcp,.section_layout175,.section_layout359,.ut_section) h2,html:not([data-wf-page="6a19672a3e86bd5aff36e302"]) :is(.section_advantage,.section_impact,.section_value,.section_difference,.section_pipeline,.section_technique,.section_comparison,.section_integration,.section_application,.section_delivery,.section_team,.section_mcp,.section_layout175,.section_layout359,.ut_section) :is(.align-center,.text-align-center,[class*="max-width-"],.tin-head,.dwh-head,.header26_rich-text,.impact_title-row,.margin-bottom,.margin-bottom-2,[class*="_title"],[class*="-head"]):has(h2) p,html:not([data-wf-page="6a19672a3e86bd5aff36e302"]) :is(.section_advantage,.section_impact,.section_value,.section_difference,.section_pipeline,.section_technique,.section_comparison,.section_integration,.section_application,.section_delivery,.section_team,.section_mcp,.section_layout175,.section_layout359,.ut_section) :is(.align-center,.text-align-center,[class*="max-width-"],.tin-head,.dwh-head,.header26_rich-text,.impact_title-row,.margin-bottom,.margin-bottom-2,[class*="_title"],[class*="-head"]):has(h2)+p,html:not([data-wf-page="6a19672a3e86bd5aff36e302"]) :is(.section_advantage,.section_impact,.section_value,.section_difference,.section_pipeline,.section_technique,.section_comparison,.section_integration,.section_application,.section_delivery,.section_team,.section_mcp,.section_layout175,.section_layout359,.ut_section) :is(.align-center,.text-align-center,[class*="max-width-"],.tin-head,.dwh-head,.header26_rich-text,.impact_title-row,.margin-bottom,.margin-bottom-2,[class*="_title"],[class*="-head"]):has(h2)+[class*="text-size"],html:not([data-wf-page="6a19672a3e86bd5aff36e302"]) :is(.section_advantage,.section_impact,.section_value,.section_difference,.section_pipeline,.section_technique,.section_comparison,.section_integration,.section_application,.section_delivery,.section_team,.section_mcp,.section_layout175,.section_layout359,.ut_section) :is(.align-center,.text-align-center,[class*="max-width-"],.tin-head,.dwh-head,.header26_rich-text,.impact_title-row,.margin-bottom,.margin-bottom-2,[class*="_title"],[class*="-head"]):has(h2)+[class*="margin-"]>p{text-align:left;margin-left:0}
html:not([data-wf-page="6a19672a3e86bd5aff36e302"]) :is(.section_advantage,.section_impact,.section_value,.section_difference,.section_pipeline,.section_technique,.section_comparison,.section_integration,.section_application,.section_delivery,.section_team,.section_mcp,.section_layout175,.section_layout359,.ut_section) :is(.align-center,.text-align-center,[class*="max-width-"],.tin-head,.dwh-head,.header26_rich-text,.impact_title-row,.margin-bottom,.margin-bottom-2,[class*="_title"],[class*="-head"]):has(h2){text-align:left;margin-left:0;justify-content:flex-start;align-items:flex-start;align-self:flex-start;justify-self:start}
.section_logo .logo_list[data-reveal-group] > *{opacity:1!important;transform:none!important;visibility:visible!important}
html[data-wf-page="6a32be220bb24ca05b48a7b7"] .hs-button.primary{background-color:#93408d!important;border-color:#93408d!important;color:#fff!important}
html .allium-research-label{font-size:14px}
html[data-allium-hero="ready"] .hero_image { display: none; }
 background: url('data:image/svg+xml,%3Csvg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="black" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"%3E%3Cpath d="M6 9l6 6 6-6"%3E%3C/path%3E%3C/svg%3E') no-repeat right 16px center;
Our data powers Visa&#x27;s public stablecoin dashboard.Read our latest report →
 var data = JSON.parse(stored);
 if (data.closed && Date.now() - data.timestamp < ONE_DAY_MS) {
 var banner = document.querySelector('.banner_component');
 var banner = document.querySelector('.banner_component');
 var closeBtn = document.querySelector('.banner_close-button');
Use CasesBy Use CaseAcademiaFinance &amp; OperationsInvestment ResearchIssuanceMarket OversightPaymentsProduct &amp; EngineeringTrading &amp; InvestmentExploreChain DirectoryCompare SolutionsClientsAccounting &amp; Audit FirmsAsset ManagersBanksExchangesHedge FundsPayment NetworksStablecoin IssuersProductsAnalyticsAllium AIAllium TerminalHistorical DataExplorerDatasharesReal-Time DataDevelopersDatastreamsResearchResourcesInsightsBlogDigital Asset Identifiers (DASID)Trust CenterCompanyAboutCareersPartnersPartner ProgramsSnowflakeDatabricksDocsLog InGet a DemoSign UpSign UpLog InGet a Demo
 [data-nav-menu-open]{
The onchain data platform the world&#x27;s largest institutions run onSee which stablecoin and tokenized asset activity is real, and build on onchain data you can trace to the block. SOC 1 and SOC 2 Type I and II.Explore the TerminalGet a demoVisa, KPMG, Coinbase and more than 30 of the Fortune Crypto 100 run on Allium data$176T in reported stablecoin volume. $17T is real.About 90% of onchain stablecoin volume is not economic activity. Allium removes it so you see what is real.-$100TIntra-entity money movement-$43TPass through routing (DEX, bridges)-$9TBOT / HFT activity-$4TSmart contract internals-$3TWash trading and spam$176TUnadjusted onchain volume$17TAllium adjusted volume$159Tof non-economic activity$300Bof stablecoin supply is actually in circulation. Allium separates live supply from what sits idle in foundation treasuries, protocol reserves and locked addresses.Explore Stablecoins on Allium83%of classified stablecoin volume comes from consumer wallets, not businesses or institutions. Allium classifies sender and receiver type, not just the transfer.Explore Stablecoins on Allium$8Bof stablecoin payments stayed inside APAC last year. Allium resolves sender and receiver geography across every corridor.Explore Payments on AlliumWhat institutions publish on Allium dataSources the ecosystem metrics in its State of Crypto report and live dashboard from Allium, refreshed monthly.ViewPublishes a public stablecoin dashboard on Allium data, separating organic flows from total transfer volume.ViewApplied its behavior-based methodology to Allium data to narrow $62T of 2025 stablecoin transfers to between $350B and $550B in real payments.ViewServes real-time onchain data across chains from Allium APIs, straight into what wallet users see.View
What Visa, BCG, Privy and Ondo say about Allium&quot;At Visa, we seek to both better inform how people and businesses are using stablecoins for transactions. We look forward to continuing with partners like Allium to explore use cases and opportunities for stablecoins in the payment ecosystem.&quot;Cuy SheffieldHead of Crypto"It's generated a lot of client traction, both in our active engagements and in client discussions and industry engagement. It's now a foundational piece of our digital assets practice infrastructure."Max ZevinManaging Director and Partner"The marriage of Privy, Allium, and a payment protocol like x402 or MPP is the legs of the stool for enabling autonomous systems that can act on the web in a contextual way."Henri SternCEO &amp; Co-Founder"Allium did a super good job aggregating all tokenized assets and also having a good schema that we use for comparisons, such as competitor volume vs. Ondo volume, so we can generate business insights based on that."Alex ChenData ScientistPick your use case: research, finance or productUnderstandResearch, Strategy &amp; Market IntelligenceResearch teams sizing real stablecoin volume by corridor.Hedge funds and asset managers tracking issuance, holders and flows across chains.Regulators and oversight teams monitoring market activity.See Investment ResearchStart in Allium Terminal: verified onchain data, ready to analyzeOperationalizeFinance &amp; OperationsFinance teams reconciling onchain holdings to the books.Tax and accounting teams producing audit-ready reports from onchain data.Auditors and issuers verifying balances and supply with a reproducible trail.See Finance &amp; OperationsReconcile onchain activity with verified dataBuildProduct &amp; Data InfrastructurePayments and tokenization platforms embedding onchain data in their products.Exchanges and wallets serving real-time balances across every chain.Engineering teams getting decoded data without running indexers.See Product &amp; EngineeringShip production-grade onchain data in your productPick the product that fits how you workAllium TerminalAggregated dashboards tell you how much activity happened. Allium Terminal tells you who, where, and what.Allium AIAsk a question in plain English and get an answer, chart included, no SQL required.ExplorerWrite custom SQL across 10,000+ protocols to answer the one question a dashboard can&#x27;t.DatasharesQuery production-ready onchain data in your own Snowflake, BigQuery, Databricks, S3 or GCS.DevelopersReal-time APIs at 50 to 100ms across 20+ chains, scaling to 100K+ requests per second.DatastreamsStream blockchain events to your systems in real time. Full chain data or filtered streams, without building infrastructure.
Latest Allium research
 Get new Allium research in your inbox
 .swiper-navigation.is-research-head #allium-research-cta {
 .swiper-navigation.is-research-head #allium-research-cta {
 #allium-research-cta .allium-research-label {

echo "=== npm search allium ==="; npm view allium 2>&1 | head -30; echo "=== npm search @allium ==="; npm search allium 2>&1 | head -20
=== npm search allium ===
=== npm search allium ===

allium@0.2.2 | Proprietary | deps: 3 | versions: 4
Simpler Gherkin parsing
http://github.com/unnali/allium

dist
.tarball: https://registry.npmjs.org/allium/-/allium-0.2.2.tgz
.shasum: 59d15b74b202dacf694239fd90588f1550ed1836
.integrity: sha512-OIjezTAcO6Mvvgdnorplafn62dOPzIYu+QCsPsEfD6kpKuYI7eJLhvjcuwpfQc20Yh8KO/HFkWNU82TIBvb0aQ==

dependencies:
mocha: ~1.0.2
underscore.string: ~2.2.0rc
underscore: ~1.3.3

maintainers:
- unnali <ashe+unnali@kivikakk.ee>
- kivikakk <ashe@kivikakk.ee>

dist-tags:
latest: 0.2.2

published over a year ago by unnali <a@unnali.com>
=== npm search @allium ===
@telus-uds/palette-allium
Telus(Allium) palette
Version 6.3.0 published 2026-10-13 by GitHub Actions
Maintainers: pdufault telusdigitaldelivery stv-telus shahzaibkhalid
Keywords: allium
https://npm.im/@telus-uds/palette-allium

@telus-uds/theme-allium
Allium theme
Version 8.3.0 published 2026-10-13 by GitHub Actions
Maintainers: pdufault telusdigitaldelivery stv-telus shahzaibkhalid
https://npm.im/@telus-uds/theme-allium

allium
Simpler Gherkin parsing
Version 0.2.2 published 2012-05-16 by unnali
Maintainers: unnali kivikakk
Keywords: gherkin cucumber bdd parsing
https://npm.im/allium
Thinking…

Now I understand Allium. It's a blockchain/onchain data platform for institutions. Key products:

  • Allium Terminal (dashboards)
  • Allium AI (natural language questions)
  • Explorer (custom SQL)
  • Datashares (Snowflake, BigQuery, Databricks, S3, GCS)
  • Developers (Real-time APIs at 50-100ms across 20+ chains)
  • Datastreams (stream blockchain events)

The npm "allium" package is unrelated (Gherkin parsing). The @telus ones are unrelated too.

So the "Developers" product with "Real-time APIs" is the developer workflow. Let me look at their docs. There's a "Docs" link. Let me find the docs site.

Let me check the docs and pricing pages. Let me look for the developer docs and API.

Allium is an onchain/blockchain data platform for institutions. It has a "Developers" product (real-time APIs across 20+ chains) and a Docs site. Let me find the developer docs and pricing pages.

cd /sandbox/repo && for u in "https://www.allium.so/pricing" "https://docs.allium.so" "https://developers.allium.so" "https://www.allium.so/developers"; do echo "=== $u ==="; curl -sSL -m 15 -o /dev/null -w "HTTP %{http_code} -> %{url_effective}\n" "$u" 2>&1; done
=== https://www.allium.so/pricing ===
=== https://www.allium.so/pricing ===
HTTP 200 -> https://www.allium.so/contact
=== https://docs.allium.so ===
HTTP 200 -> https://docs.allium.so/
=== https://developers.allium.so ===
curl: (6) Could not resolve host: developers.allium.so
HTTP 000 -> https://developers.allium.so/
=== https://www.allium.so/developers ===
HTTP 404 -> https://www.allium.so/developers

cd /sandbox/repo && echo "=== find docs links on homepage ==="; curl -sSL -m 20 https://www.allium.so/ 2>&1 | grep -oiE 'href="[^"]*"' | grep -iE 'docs|pricing|developer|api|api-reference|signup|login|terminal|explorer' | sort -u | head -40
=== find docs links on homepage ===
=== find docs links on homepage ===
href="/product/allium-developer"
href="/product/allium-explorer"
href="/product/allium-terminal"
href="https://app.allium.so/login"
href="https://app.allium.so/terminal/payments/key-metrics?tab=b2bb2cc2bc2c"
href="https://app.allium.so/terminal/stablecoins/key-metrics?tab=overview"
href="https://docs.allium.so/"
Thinking…

Interesting findings:

  • /pricing redirects to /contact — so pricing is not public; you have to contact them. This is a strong signal that this is an enterprise, sales-gated product.
  • docs.allium.so exists (HTTP 200).
  • app.allium.so/login exists.
  • There's /product/allium-developer.

Let me look at the docs site and the developer product page. Let me understand the API and quickstart.

Notable: /pricing redirects to /contact (sales-gated, not public). There's a docs site and an app login. Let me examine the docs and the developer product page.

cd /sandbox/repo && echo "=== docs.allium.so landing ==="; curl -sSL -m 20 https://docs.allium.so/ 2>&1 | sed -e 's/<[^>]*>//g' | tr -s ' \n' ' \n' | grep -vE '^\s*$' | head -80
=== docs.allium.so landing ===
=== docs.allium.so landing ===
 (function(){
 var RE = /^https?:\/\/leaves\.mintlify\.com/i;
 var to = location.origin + "/_leaves";
 var of = window.fetch;
 window.fetch = function(input, init){
 try {
 if (typeof input === 'string' && RE.test(input)) input = input.replace(RE, to);
 else if (input && input.url && RE.test(input.url)) input = new Request(input.url.replace(RE, to), input);
 } catch(e){}
 return of.call(this, input, init);
 };
 var oo = XMLHttpRequest.prototype.open;
 XMLHttpRequest.prototype.open = function(m, u){
 try { if (typeof u === 'string' && RE.test(u)) u = u.replace(RE, to); } catch(e){}
 return oo.apply(this, [m, u].concat([].slice.call(arguments, 2)));
 };
 })();
.base-ui-disable-scrollbar{scrollbar-width:none}.base-ui-disable-scrollbar::-webkit-scrollbar{display:none}Introduction - Allium Documentation Hub!function(){var b="";
function a(p){if(p==null)return"/";p=""+p;if(""===p)return"/";return"/"===p.charAt(0)?p:"/"+p}
function u(p){if(p==null)return p;p=""+p;if(!p||p.charAt(p.length-1)==="/")return p.slice(0,-1);return p}
function i(p){if(p==null)return p;p=""+p;if(6<=p.length&&p.substring(p.length-6)==="/index")return p.substring(0,p.length-6);if("index"===p)return"";return p}
var p=(location.pathname||"").split("?")[0].split("#")[0]||"";
if(b)if(p===b)p="";else if(0===p.indexOf(b+"/"))p=p.substring(b.length);
p=a(p);p=u(p);p=i(p);p=""===p||"index"===p?"/":a(p);
document.documentElement.setAttribute("data-current-path",p);
}();if((' '+document.cookie).indexOf(' mintlify_end_user_session_hint=1')!==-1)document.documentElement.setAttribute('data-auth-pending','nav user');(() => {
 const isIOS =
 /iP(hone|ad|od)/.test(navigator.userAgent) ||
 (/Macintosh/.test(navigator.userAgent) && navigator.maxTouchPoints > 1);
 if (!isIOS) return;
 const apply = () => {
 for (const meta of document.querySelectorAll('meta[name="viewport"]')) {
 const content = meta.getAttribute('content') || '';
 if (!content.includes('maximum-scale')) {
 meta.setAttribute('content', content + ', maximum-scale=1');
 }
 }
 };
 apply();
 new MutationObserver(apply).observe(document.head, {
 childList: true,
 subtree: true,
 attributes: true,
 attributeFilter: ['content'],
 });
})();!function(){
function read(){try{
var e=performance.getEntriesByType?performance.getEntriesByType("navigation"):[];
var st=(e[0]&&e[0].serverTiming)||[];
var g={};
for(var i=0;i<st.length;i++){var n=st[i].name,d=st[i].description;if(!d)continue;try{d=decodeURIComponent(d)}catch(x){}
if(n==="country")g.country=d;else if(n==="region")g.region=d;else if(n==="continent")g.continent=d;}
var w=window;w.mintlify=w.mintlify||{};w.mintlify.geo=g;
}catch(x){}}
read();document.addEventListener("DOMContentLoaded",read);
}();!function(){try{
var w=window;w.mintlify=w.mintlify||{};
var q=w.mintlify.__apiPlaygroundInputsQueue;
if(!Array.isArray(q)){q=[];w.mintlify.__apiPlaygroundInputsQueue=q;}
w.mintlify.api=w.mintlify.api||{};
w.mintlify.api.playground=w.mintlify.api.playground||{};
if(typeof w.mintlify.api.playground.setServerVariables!=="function"){
w.mintlify.api.playground.setServerVariables=function(v){q.push({type:"set",variables:v});};
}
if(typeof w.mintlify.api.playground.clearServerVariables!=="function"){
w.mintlify.api.playground.clearServerVariables=function(){q.push({type:"clear"});};
}
}catch(e){}}();(function(){
if(typeof CSS==="undefined"||!("registerProperty" in CSS))return;
if(CSS.supports&&CSS.supports("-webkit-backdrop-filter:none"))return;
var n=["--scroll-area-overflow-x-start","--scroll-area-overflow-x-end","--scroll-area-overflow-y-start","--scroll-area-overflow-y-end"];
var d={"syntax":"","inherits":false,"initialValue":"0px"};
for(var i=0;i<n.length;i++){try{CSS.registerProperty({name:n[i],syntax:d.syntax,inherits:d.inherits,initialValue:d.initialValue})}catch(e){}}
})();(function(a,b){try{let c=document.querySelector("div#banner")?.innerText;if(c){for(let d=0;d<localStorage.length;d++){let e=localStorage.key(d);if(e?.endsWith(a)&&localStorage.getItem(e)===c)return void document.documentElement.setAttribute(b,"hidden")}document.documentElement.setAttribute(b,"visible");return}for(let c=0;c<localStorage.length;c++){let d=localStorage.key(c);if(d?.endsWith(a)&&localStorage.getItem(d))return void document.documentElement.setAttribute(b,"hidden")}document.documentElement.setAttribute(b,"visible")}catch(a){document.documentElement.setAttribute(b,"hidden")}})(
 "bannerDismissed",
 "data-banner-state",
)((a,b,c,d,e,f,g,h)=>{let i=document.documentElement,j=["light","dark"];function k(b){var c;(Array.isArray(a)?a:[a]).forEach(a=>{let c="class"===a,d=c&&f?e.map(a=>f[a]||a):e;c?(i.classList.remove(...d),i.classList.add(f&&f[b]?f[b]:b)):i.setAttribute(a,b)}),c=b,h&&j.includes(c)&&(i.style.colorScheme=c)}if(d)k(d);else try{let a=localStorage.getItem(b)||c,d=g&&"system"===a?window.matchMedia("(prefers-color-scheme: dark)").matches?"dark":"light":a;k(d)}catch(a){}})("class","isDarkMode","system",null,["dark","light","true","false","system"],{"true":"dark","false":"light","dark":"dark","light":"light"},true,false)(function(){try{var f=null;var v=f||localStorage.getItem("isDarkMode");if(v==='true')v='dark';else if(v==='false')v='light';if(v!=='light'&&v!=='dark'&&v!=='system')v="system";document.documentElement.setAttribute("data-theme-preference",v)}catch(e){}})();Documentation IndexFetch the complete documentation index at: /llms.txtUse this file to discover all available pages before exploring further.:root{--banner-height:0px!important}(function i(a,b,c,d,e){try{let f,g,h=[];try{h=window.location.pathname.split("/").filter(a=>""!==a&&"global"!==a).slice(0,2)}catch{h=[]}let i=h.map(a=>c.find(b=>b.toLowerCase()===a.toLowerCase())).find(a=>void 0!==a),j=[];for(let c of(i?j.push(i):j.push(b),j.push("global"),j)){if(!c)continue;let b=a[c];if(b?.content){f=b.content,g=c;break}}if(!f)return void document.documentElement.setAttribute(d,"hidden");let k=!0,l=0;for(;l<localStorage.length;){let a=localStorage.key(l);if(l++,!a?.endsWith(e))continue;let b=localStorage.getItem(a);if(b&&b===f){k=!1;break}g&&(a.startsWith(`lang:${g}_`)||!a.startsWith("lang:"))&&(localStorage.removeItem(a),l--)}document.documentElement.setAttribute(d,k?"visible":"hidden")}catch(a){console.error(a),document.documentElement.setAttribute(d,"hidden")}})(
 {},
 "en",
 [],
Thinking…

The docs are hosted on Mintlify. There's an /llms.txt index. This is great — Mintlify docs have an llms.txt that lists all available pages. Let me fetch that to discover all the docs pages, including the developer/API docs.

The docs are on Mintlify with an /llms.txt index. Let me fetch that to discover all doc pages including the API/developer docs.

cd /sandbox/repo && curl -sSL -m 20 https://docs.allium.so/llms.txt 2>&1 | head -120
# Allium Documentation Hub
# Allium Documentation Hub

> Allium provides production-grade blockchain data infrastructure including historical data, realtime APIs, datashares, datastreams, and AI tools across 85+ blockchains.

## Welcome

- [Introduction](https://docs.allium.so/index.md): Allium is the enterprise blockchain data platform powering analytics, engineering, and accounting with unmatched breadth, depth, and accuracy.
- [Product Comparison](https://docs.allium.so/product-comparison.md): Allium delivers data via five core products: Explorer, Datashares, Realtime APIs, Datastreams, and Beam.
- [Allium Realtime APIs](https://docs.allium.so/realtime-apis.md)
- [Machine Payments](https://docs.allium.so/api/developer/machine-payments.md): Pay-per-call blockchain data access with USDC — no API key, no registration, no subscription.

### Use Cases

- [Analytics](https://docs.allium.so/use-cases/analytics.md): Query, visualize, and analyze blockchain data with Explorer and Datashares.
- [Applications](https://docs.allium.so/use-cases/applications.md): Build and scale blockchain applications with Allium Realtime and Datastreams.
- [Audit and Accounting](https://docs.allium.so/use-cases/accounting.md): Power transaction monitoring, data reconciliation, and financial reporting with Explorer and Datashares.

### Allium App

- [Overview](https://docs.allium.so/app/overview.md): A one-stop destination for all your blockchain analytics needs.
- [Visualize results](https://docs.allium.so/app/visualisations.md): Chart and present your data through our visualization tools.
- [Upload your own data](https://docs.allium.so/app/data-upload.md): Join your data with ours.

#### Run Queries

- [Run a basic query](https://docs.allium.so/app/run-queries/basic-query.md): Learn how to write and execute SQL queries across all blockchains in the Allium App.
- [Create a parameterized query](https://docs.allium.so/app/run-queries/parameterized-query.md): Build reusable queries with configurable parameters for flexible data analysis.
- [Query on a previous result](https://docs.allium.so/app/run-queries/query-on-previous-result.md): Build complex analyses by querying the results of completed query runs.

#### Manage your account

- [Multi-Factor Authentication (MFA)](https://docs.allium.so/app/account-management/mfa.md): Protect your account with an extra verification step.

#### Manage your team

- [IP Whitelisting](https://docs.allium.so/app/organization-management/ip-whitelisting.md): Restrict login to specific IPs.
- [Secrets](https://docs.allium.so/app/organization-management/secrets.md): Manage organization secrets for Beam pipelines and integrations.
- [Login Session Timeout](https://docs.allium.so/app/organization-management/session-timeout.md): Limit the duration of an idle login session.
- [SSO / SAML Setup](https://docs.allium.so/app/organization-management/sso.md): Set up Single Sign-On (SSO) for Allium using your identity provider (IdP) via SAML.
- [Usage & Billing](https://docs.allium.so/app/organization-management/usage-and-billing.md): Monitor usage, view invoices, and configure overage behavior.
- [User Management](https://docs.allium.so/app/organization-management/users.md): Manage users and roles in your organization.

#### Manage your query runs

- [Compute Profiles](https://docs.allium.so/app/query-management/compute-profiles.md): Choose the amount of compute resources used to run your queries.
- [Purge Query Queue](https://docs.allium.so/app/query-management/purge-query-queue.md): Remove pending queries to clear blocked execution.

### Allium Datashares

- [Overview](https://docs.allium.so/datashares/overview.md): Data delivery straight to your data lake for privacy and control.
- [Databricks](https://docs.allium.so/datashares/databricks.md): Access our blockchain data through secure Databricks Delta Sharing.
- [Snowflake](https://docs.allium.so/datashares/snowflake.md): Access our blockchain data through secure Snowflake Shares.
- [BigQuery](https://docs.allium.so/datashares/bigquery.md): Access Allium data in your own native GCP/BigQuery environment.
- [BI Visualization Tools](https://docs.allium.so/datashares/bi-visualization-tools.md): Connect your preferred BI tool to visualize Allium's blockchain data.
- [Walrus](https://docs.allium.so/datashares/walrus.md): Fetch Allium blockchain data from Walrus as encrypted quilt patches.

### Allium Datastreams

- [Overview](https://docs.allium.so/datastreams/overview.md): Realtime, low-latency data streaming to your data lake of choice.
- [Apache Kafka](https://docs.allium.so/datastreams/kafka.md): Integrate Allium's realtime data streams via Apache Kafka.
- [Google Pub/Sub](https://docs.allium.so/datastreams/pubsub.md): Integrate Allium's realtime data streams via Google Cloud Pub/Sub.
- [Amazon SNS](https://docs.allium.so/datastreams/sns.md): Integrate Allium's realtime data streams via Amazon Simple Notification Service.
- [Websockets](https://docs.allium.so/datastreams/websockets.md): Access Allium's APIs and data streams through websockets for real-time data delivery.
- [Transformations](https://docs.allium.so/datastreams/transformations.md): Turn raw blockchain streams into actionable signals by applying transformations on Allium streams.

### Allium Beam

- [Overview](https://docs.allium.so/beam/overview.md): Build filtered, realtime blockchain data pipelines and deploy them in seconds, with no infrastructure to manage.
- [Quickstart](https://docs.allium.so/beam/quickstart.md): Create, deploy, and consume your first Beam pipeline in minutes.
- [Configuration reference](https://docs.allium.so/beam/configuration.md): Configure Beam pipeline sources, transforms, and sinks in the Allium App.
- [Webhook authentication](https://docs.allium.so/beam/webhook-authentication.md): Verify that incoming webhook requests came from Beam, with replay protection.
- [Permissions](https://docs.allium.so/beam/permissions.md): Roles and access levels that control who can view, edit, and manage a Beam pipeline.
- [Examples](https://docs.allium.so/beam/examples.md): Pipeline configuration examples for common Beam use cases.

### Allium Nodes

- [Overview](https://docs.allium.so/nodes/overview.md): Direct peer access to blockchain nodes Allium already runs — no node operations on your side.
- [Hyperliquid Sentry Peer](https://docs.allium.so/nodes/hyperliquid-sentry-peer.md): Connect your Hyperliquid node to Allium's sentry peer for a stable, low-latency upstream.

## Allium AI

### Updates

- [What's new](https://docs.allium.so/ai/whats-new.md): Releases and improvements to the Allium AI Assistant and Allium MCP, by month.

### Assistant

- [Overview](https://docs.allium.so/ai/assistant/overview.md): An AI data analyst built into the Allium App. Ask a question in plain English and get the answer, the SQL, a chart, and a dashboard you can share.
- [Capabilities](https://docs.allium.so/ai/assistant/capabilities.md): Everything the Allium AI Assistant can do: answer questions, chart and share results, automate recurring work, and build pipelines and apps.
- [Custom skills](https://docs.allium.so/ai/assistant/skills.md): Save a prompt as a skill and run it from the Assistant composer with one keystroke.
- [Examples](https://docs.allium.so/ai/assistant/examples.md): End-to-end workflow walkthroughs showing the Assistant's multi-step reasoning.
- [Organization memory](https://docs.allium.so/ai/assistant/memory.md): Persistent context shared across all users in your organization.

### MCP

- [Overview](https://docs.allium.so/ai/mcp/overview.md): Query blockchain data from Allium Explorer using MCP.
- [Plugins](https://docs.allium.so/ai/mcp/plugins.md): Install the allium-analyst plugin to give your agent a query methodology for Allium data.
- [Examples](https://docs.allium.so/ai/mcp/examples.md): See what you can build with Allium's MCP Server.

#### Tools

- [Overview](https://docs.allium.so/ai/mcp/tools-reference/overview.md): Every tool the Allium MCP Server exposes for querying, analyzing, and visualizing blockchain data.
- [SQL & queries](https://docs.allium.so/ai/mcp/tools-reference/sql-and-queries.md): Run SQL against Allium's blockchain data, save reusable Explorer queries, and fetch results.
- [Knowledge & discovery](https://docs.allium.so/ai/mcp/tools-reference/knowledge.md): Find the right tables, docs, and existing dashboards before writing a single line of SQL.
- [Dashboards & sharing](https://docs.allium.so/ai/mcp/tools-reference/dashboards.md): Build Explorer visuals and dashboards from your queries, then publish share and embed links.
- [Realtime data](https://docs.allium.so/ai/mcp/tools-reference/realtime.md): Prices, balances, transactions, DeFi positions, holdings PnL, tokens, and assets, without SQL.
- [Hyperliquid](https://docs.allium.so/ai/mcp/tools-reference/hyperliquid.md): Query Hyperliquid account, market, order, and orderbook data through Allium's rate-limit-free proxy.
- [Skills](https://docs.allium.so/ai/mcp/tools-reference/skills.md): Fetch Allium's own guidance on writing efficient SQL, building dashboards, and picking a product.
- [Billing & limits](https://docs.allium.so/ai/mcp/tools-reference/billing-and-limits.md): Which MCP tools consume credits, how much data comes back, and why your tool list may be shorter than the docs.

### Machine Payments

- [Overview](https://docs.allium.so/ai/machine-payments/overview.md): Machine payment protocols for AI agents and developers to access Allium's blockchain data with USDC.
- [Endpoints & Pricing](https://docs.allium.so/ai/machine-payments/endpoints-pricing.md): All payment-enabled endpoints, pricing, rate limits, and error codes.
- [x402](https://docs.allium.so/ai/machine-payments/x402.md): Full manual control over 402 payment negotiation, EIP-712 signing, and USDC settlement.
- [Tempo MPP](https://docs.allium.so/ai/machine-payments/tempo-mpp.md): The simplest way to make paid API calls — one function call handles the entire 402 payment flow.
- [Agent Skills](https://docs.allium.so/ai/machine-payments/agent-skills.md): Give your AI agent blockchain data access with machine payments in one command.

- [Data Catalog (5812 pages)](https://docs.allium.so/_llms/data-catalog.txt): Documentation for Data Catalog.
Thinking…

This is very informative. Allium has several products. The most interesting for a developer-friendly, no-signup workflow is "Machine Payments":

Machine Payments: Pay-per-call blockchain data access with USDC — no API key, no registration, no subscription.

This is a pay-per-call blockchain data access with USDC — no API key, no registration, no subscription. This is a machine-to-machine payment protocol (x402 / Tempo MPP) for AI agents and developers.

This is exactly a developer workflow I can act on... except it requires USDC payments (crypto). Let me think about the instructions:

  • "Stay light: use the hosted product through its SDK or API."
  • "Do not start local service stacks or wait for long-running commands."
  • "If this product has no developer workflow you can act on, say so plainly and stop."

The Machine Payments route requires USDC/crypto wallet to actually pay. That's a real barrier — I can't fund a USDC wallet in a sandbox. But let me look deeper. Maybe there's a free tier or the x402 flow. Also there's "Realtime APIs" which needs an API key (registration).

Let me carefully read:

  1. The Machine Payments overview and endpoints-pricing (this tells pricing!)
  2. The realtime-apis.md
  3. product-comparison.md

The user asked: "Tell me how pricing works, and briefly tell me whether this product will be easy for you to manage."

Pricing: There are two pricing models apparently:

  • Enterprise (subscription, contact sales) — /pricing redirects to /contact
  • Machine Payments: pay-per-call with USDC (x402 protocol)
  • Usage & Billing for the App (credits, overage)

Let me read the key docs. Let me fetch the markdown versions (Mintlify serves .md).

Let me get:

Let me fetch these.

Excellent — this reveals a developer-friendly path: Machine Payments ("Pay-per-call blockchain data access with USDC — no API key, no registration, no subscription"), built for AI agents via x402/Tempo MPP. Let me read the key docs: pricing, machine payments, and realtime APIs.

cd /sandbox/repo && for p in "api/developer/machine-payments" "ai/machine-payments/overview" "ai/machine-payments/endpoints-pricing"; do echo "======== $p ========"; curl -sSL -m 20 "https://docs.allium.so/$p.md" 2>&1 | head -200; echo; done
======== api/developer/machine-payments ========
======== api/developer/machine-payments ========
> ## Documentation Index
> Fetch the complete documentation index at: https://docs.allium.so/llms.txt
> Use this file to discover all available pages before exploring further.

# Machine Payments

> Pay-per-call blockchain data access with USDC — no API key, no registration, no subscription.

Machine payments let AI agents and developers pay per API call with USDC to access Allium's blockchain data. No API key, no registration, no subscription — just a wallet and USDC.

<CardGroup cols={2}>
  <Card title="No API Key" icon="key">
    No registration or key management. Your wallet is your identity.
  </Card>

  <Card title="Pay Per Call" icon="credit-card">
    Only pay for what you use. Prices start at \$0.001 per request.
  </Card>

  <Card title="Agent-Native" icon="robot">
    Built for AI agents — autonomous payments with no human in the loop.
  </Card>

  <Card title="Gasless Payments" icon="coins">
    Allium handles onchain settlement. Users only need USDC, not ETH.
  </Card>
</CardGroup>

## How It Works

Both protocols use HTTP status code `402 Payment Required` to negotiate payments inline with API requests. The difference is how much your client handles automatically.

<Steps>
  <Step title="Send request">
    Make a normal API request to any payment-enabled endpoint.
  </Step>

  <Step title="Receive 402">
    The server responds with `402 Payment Required` and payment options.
  </Step>

  <Step title="Sign and pay">
    Your client signs a USDC payment authorization and retries the request.
  </Step>

  <Step title="Get data">
    Payment confirmed — you receive your data with a `200` response.
  </Step>
</Steps>

## Tempo MPP

Tempo Machine Payment Protocol is the simplest way to make paid API calls. The `Client` wrapper handles the entire 402 negotiation, signing, and retry flow — you just make requests as normal.

```python theme={null}
from mpp.client import Client
from mpp.methods.tempo import tempo, TempoAccount, ChargeIntent
from mpp.methods.tempo._defaults import TESTNET_RPC_URL, TESTNET_CHAIN_ID
import os

account = TempoAccount.from_key(os.getenv("YOUR_PRIVATE_KEY"))

async with Client(methods=[
    tempo(
        account=account,
        rpc_url=TESTNET_RPC_URL,
        intents={"charge": ChargeIntent()},
    )
]) as client:
    response = await client.post(
        "https://agents.allium.so/api/v1/developer/prices",
        json=[{"chain": "solana", "token_address": "So11111111111111111111111111111111111111112"}],
    )
    print(response.json())
```

<Card title="Tempo MPP" icon="bolt" href="/ai/machine-payments/tempo-mpp">
  Full setup guide, supported networks, and implementation details
</Card>

## x402

x402 gives you full manual control over the payment flow. Your client receives the 402 response, constructs EIP-712 typed data, signs it via a wallet provider like [Privy](https://dashboard.privy.io), and retries with the payment signature attached.

<Card title="x402" icon="credit-card" href="/ai/machine-payments/x402">
  Full setup guide with Privy wallet integration, EIP-712 signing, and implementation
</Card>

## Agent Integration

Don't want to write any payment code? Install pre-built agent skills and let your AI agent handle everything:

```bash theme={null}
npx skills add allium-labs/skills --yes
```

<Card title="Agent Skills" icon="wand-magic-sparkles" href="/ai/machine-payments/agent-skills">
  Set up machine payments with AI agents in one command
</Card>

## All Endpoints & Pricing

<Card title="Endpoints & Pricing" icon="code" href="/ai/machine-payments/endpoints-pricing">
  All payment-enabled endpoints, pricing, rate limits, and error codes
</Card>

======== ai/machine-payments/overview ========
> ## Documentation Index
> Fetch the complete documentation index at: https://docs.allium.so/llms.txt
> Use this file to discover all available pages before exploring further.

# Overview

> Machine payment protocols for AI agents and developers to access Allium's blockchain data with USDC.

Machine payments enable AI agents and developers to pay for blockchain data per request using USDC — no API key, no subscription, no human in the loop.

Allium supports two machine payment protocols:

| | **Tempo MPP** | **x402** |
| - | - | - |
| **Complexity** | One function call | Manual 402 flow |
| **Best for** | Quick integration, agents | Full control, custom signing |
| **Setup** | Install SDK + private key | Privy wallet + signing logic |

## Protocols

<CardGroup cols={2}>
  <Card title="Tempo MPP" icon="bolt" href="/ai/machine-payments/tempo-mpp">
    The simplest path — one function call handles the entire payment flow
  </Card>

  <Card title="x402" icon="credit-card" href="/ai/machine-payments/x402">
    Full manual control over 402 negotiation, EIP-712 signing, and payment
  </Card>
</CardGroup>

## Agent Skills

Don't want to manage payment code? Install pre-built agent skills and let your AI agent query blockchain data with automatic payment.

<Card title="Agent Skills" icon="wand-magic-sparkles" href="/ai/machine-payments/agent-skills">
  Set up machine payments with AI agents in one command
</Card>

## Endpoints & Pricing

<Card title="Endpoints & Pricing" icon="code" href="/ai/machine-payments/endpoints-pricing">
  All payment-enabled endpoints, pricing, rate limits, and error codes
</Card>

======== ai/machine-payments/endpoints-pricing ========
> ## Documentation Index
> Fetch the complete documentation index at: https://docs.allium.so/llms.txt
> Use this file to discover all available pages before exploring further.

# Endpoints & Pricing

> All payment-enabled endpoints, pricing, rate limits, and error codes.

All endpoints below are accessible via machine payments at `https://agents.allium.so`. No API key needed — pay with USDC using [Tempo MPP](/ai/machine-payments/tempo-mpp) or [x402](/ai/machine-payments/x402). All calls are priced individually. No subscription, no minimum spend.

## Install allium-cli

CLI commands require **[allium-cli](https://github.com/Allium-Science/allium-cli)**:

```bash theme={null}
curl -sSL https://agents.allium.so/cli/install.sh | sh
```

## Supported Chains Discovery

Check which chains each endpoint supports. **This endpoint is free** — no payment required.

```bash theme={null}
curl "https://agents.allium.so/api/v1/supported-chains/realtime-apis/simple"
```

Returns a map of endpoint path to supported chain names. Call once per session and cache the result.

***

## Realtime API

### Prices

| CLI Command | Method | Endpoint | Cost | Description |
| - | - | - | - | - |
| `allium realtime prices latest` | POST | `/api/v1/developer/prices` | \$0.02 | Get latest token prices |
| `allium realtime prices at-timestamp` | POST | `/api/v1/developer/prices/at-timestamp` | \$0.02 | Get token prices at a specific time |
| `allium realtime prices history` | POST | `/api/v1/developer/prices/history` | \$0.02 | Get historical token price series |
| `allium realtime prices stats` | POST | `/api/v1/developer/prices/stats` | \$0.02 | Get token price statistics |

### Tokens

| CLI Command | Method | Endpoint | Cost | Description |
| - | - | - | - | - |
| `allium realtime tokens search` | GET | `/api/v1/developer/tokens/search` | \$0.03 | Search tokens by name or symbol |
| `allium realtime tokens chain-address` | POST | `/api/v1/developer/tokens/chain-address` | \$0.02 | Look up tokens by chain and address |
| `allium realtime tokens list` | GET | `/api/v1/developer/tokens` | \$0.03 | List all supported tokens |

### Wallets

| CLI Command | Method | Endpoint | Cost | Description |
| - | - | - | - | - |
| `allium realtime balances latest` | POST | `/api/v1/developer/wallet/balances` | \$0.03 | Get current wallet token balances |
| `allium realtime balances history` | POST | `/api/v1/developer/wallet/balances/history` | \$0.03 | Get historical wallet balances |
| `allium realtime transactions` | POST | `/api/v1/developer/wallet/transactions` | \$0.03 | Get wallet transaction history |
| `allium realtime pnl` | POST | `/api/v1/developer/wallet/pnl` | \$0.03 | Get wallet profit and loss |

***

## Explorer API

The Explorer API is also available via machine payments. The `run-sql` endpoint uses machine payments auth directly. The remaining Explorer endpoints (`run`, `status`, `results`) require API key authentication.

| CLI Command | Method | Endpoint | Cost | Auth | Description |
| - | - | - | - | - | - |
| `allium explorer run-sql` | POST | `/api/v1/explorer/queries/run-async` | \$0.01 | Machine payments | Submit raw SQL for async execution |
| `allium explorer run` | POST | `/api/v1/explorer/queries/{query_id}/run-async` | \$0.01 | API key | Run a saved query asynchronously |
| `allium explorer status` | GET | `/api/v1/explorer/query-runs/{run_id}/status` | \$0.01 | API key | Check status of a query run |
| `allium explorer results` | GET | `/api/v1/explorer/query-runs/{run_id}/results` | dynamic | API key | Fetch results of a completed query |

***

## Supported Networks

| Protocol | Network | USDC Address |
| - | - | - |
| **Tempo MPP** | Tempo (mainnet) | `0x20c000000000000000000000b9537d11c60e8b50` |
| **x402** | Base (mainnet) | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` |
| **x402** | Polygon (mainnet) | `0x3c499c542cEF5E3811e1192ce70d8cc03d5c3359` |
| **x402** | Solana (mainnet) | `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v` |
| **x402** | X Layer (mainnet) | `0x74b7f16337b8972027f6196a17a631ac6de26d22` |

## Rate Limits

Two independent rate limit buckets per wallet. You can max out both simultaneously.

| Bucket | Endpoints | Limit |
| - | - | - |
| **Data** | All `/developer/` endpoints | 3 requests/second |
| **Docs** | All `/docs/` endpoints | 5 requests/second |

Exceeding either limit returns HTTP `429`. Wait 1 second before retrying.

***

## Error Codes

| Status | Meaning | What to Do |
| - | - | - |
| 400 | Bad request | Check JSON syntax |
| 402 | Payment required | Sign the payment and retry (handled automatically by [Tempo MPP](/ai/machine-payments/tempo-mpp)) |
| 422 | Validation failed | Check request format |
| 429 | Rate limited | Back off for 1 second |
| 500 | Server error | Retry with exponential backoff |
Thinking…

Now I have very good pricing info. Let me summarize what I've learned:

Pricing: Two models:

  1. Enterprise/subscription (the Allium App, Terminal, Explorer, Datashares, Datastreams) — sales-gated (/pricing → /contact), credits-based with overage behavior (Usage & Billing doc).
  2. Machine Payments (pay-per-call) — this is the developer/agent-friendly path:
    • No API key, no registration, no subscription.
    • Prices start at $0.001 per request (marketing), specific endpoints:
      • Prices: $0.02/request
      • Tokens search/list: $0.03; chain-address: $0.02
      • Wallet balances/transactions/pnl: $0.03
      • Explorer run-sql: $0.01
      • Supported-chains discovery endpoint: FREE
    • Pay with USDC via Tempo MPP or x402.
    • Rate limits: Data 3 req/s, Docs 5 req/s.
    • Gasless: Allium handles onchain settlement; you only need USDC, not ETH.

Now, there IS a developer workflow I can act on: the free supported-chains endpoint requires no payment. Let me verify by actually calling it. That's a great way to demonstrate a "simple example" without needing crypto.

But the actual paid endpoints require USDC in a wallet. That's the blocker for a full end-to-end example — I can't fund a wallet with real USDC in this sandbox, and doing crypto payments would be a real-money action I shouldn't take autonomously.

However, I can:

  1. Call the FREE supported-chains endpoint (no payment) — demonstrates the API works.
  2. Demonstrate the 402 payment-required flow by making a request to a paid endpoint WITHOUT payment — this shows the negotiation without spending money. This is "staying light."
  3. Build a small, self-contained example client (Python or Node) that wraps the Tempo MPP flow, ready to run when the user supplies a private key + USDC.

Let me also check the "agent-skills" doc and the tempo-mpp doc, plus the CLI. And let me verify the free endpoint actually works from here.

Let me be careful about the instructions:

  • "Do not start local service stacks or wait for long-running commands; if the quickstart requires either, say so plainly and stop." — The quickstart here does NOT require a local service stack. It's a hosted API. Good. The npx skills add and curl install.sh | sh are quick installs, not long-running services. But I should be cautious about curl | sh (piping to shell) — that's a security consideration. I won't run that blindly.
  • "Stay light: use the hosted product through its SDK or API." — Yes, machine payments API is perfect.

Let me test the free endpoint and the 402 flow (without paying). Let me also read tempo-mpp.md and agent-skills.md.

Let me do these in parallel.

I now have clear pricing info. Let me verify the live API works (the free endpoint needs no payment) and inspect the 402 payment flow, plus read the Tempo MPP and Agent Skills docs.

cd /sandbox/repo && echo "=== FREE supported-chains endpoint (no payment) ==="; curl -sS -m 20 -w "\nHTTP %{http_code}\n" "https://agents.allium.so/api/v1/supported-chains/realtime-apis/simple" 2>&1 | head -40
=== FREE supported-chains endpoint (no payment) ===
=== FREE supported-chains endpoint (no payment) ===
{"/api/v1/developer/wallet/balances/history":["arbitrum","avalanche","bsc","base","bitcoin","celo","ethereum","near","optimism","polygon","robinhood","solana","stellar","unichain","x_layer"],"/api/v1/developer/wallet/balances":["arbitrum","arc","avalanche","bsc","base","bitcoin","celo","ethereum","hyperevm","monad","near","optimism","polygon","robinhood","solana","stellar","unichain","x_layer","xdc_network"],"/api/v1/developer/wallet/transactions":["arbitrum","arc","avalanche","bsc","base","bitcoin","celo","ethereum","hyperevm","monad","near","optimism","polygon","robinhood","solana","stellar","unichain","x_layer","xdc_network"],"/api/v1/developer/wallet/pnl":["arbitrum","avalanche","bsc","base","bitcoin","celo","ethereum","hyperevm","monad","optimism","polygon","robinhood","solana","unichain","x_layer","zksync"],"/api/v1/developer/wallet/pnl/history":["arbitrum","avalanche","bsc","base","bitcoin","celo","ethereum","hyperevm","monad","optimism","polygon","robinhood","solana","unichain","x_layer","zksync"],"/api/v1/developer/wallet/pnl-by-token":["arbitrum","avalanche","bsc","base","bitcoin","celo","ethereum","hyperevm","monad","optimism","polygon","robinhood","solana","unichain","x_layer","zksync"],"/api/v1/developer/wallet/pnl-by-token/history":["arbitrum","avalanche","bsc","base","bitcoin","celo","ethereum","hyperevm","monad","optimism","polygon","robinhood","solana","unichain","x_layer","zksync"],"/api/v1/developer/wallet/holdings/history":["arbitrum","avalanche","bsc","base","bitcoin","celo","ethereum","hyperevm","monad","optimism","polygon","solana","unichain","zksync"],"/api/v1/developer/prices/history":["arbitrum","avalanche","bsc","base","celo","ethereum","hyperevm","optimism","polygon","robinhood","solana","unichain","zksync"],"/api/v1/developer/prices":["arbitrum","avalanche","bsc","base","celo","ethereum","hyperevm","optimism","polygon","robinhood","solana","unichain","zksync"],"/api/v1/developer/prices/stats":["arbitrum","avalanche","bsc","base","celo","ethereum","hyperevm","optimism","polygon","robinhood","solana","unichain","zksync"],"/api/v1/developer/prices/at-timestamp":["arbitrum","avalanche","bsc","base","celo","ethereum","hyperevm","optimism","polygon","robinhood","solana","unichain","zksync"],"/api/v1/developer/tokens/chain-address":["arbitrum","bsc","base","bitcoin","dogecoin","ethereum","hyperevm","optimism","polygon","robinhood","solana","stellar"],"/api/v1/developer/tokens/transfers":["arbitrum","arc","avalanche","bsc","base","celo","ethereum","hyperevm","monad","optimism","polygon","robinhood","solana","stellar","unichain","x_layer","xdc_network","zksync"],"/api/v1/developer/tokens":["arbitrum","bsc","base","bitcoin","dogecoin","ethereum","hyperevm","optimism","polygon","robinhood","solana","stellar"],"/api/v1/developer/tokens/search":["arbitrum","bsc","base","bitcoin","dogecoin","ethereum","hyperevm","optimism","polygon","robinhood","solana","stellar"],"/api/v1/developer/assets":["arbitrum","base","ethereum","optimism","polygon","solana"],"/api/v1/developer/assets/batch":["arbitrum","base","ethereum","optimism","polygon","solana"],"/api/v1/developer/trading/hyperliquid/info/fills":["hyperevm"],"/api/v1/developer/trading/hyperliquid/info/order/history":["hyperevm"],"/api/v1/developer/trading/hyperliquid/info/order/status":["hyperevm"],"/api/v1/developer/trading/hyperliquid/info":["hyperevm"],"/api/v1/developer/wallet/positions":["arbitrum","avalanche","bsc","base","celo","ethereum","hyperliquid","hyperevm","monad","optimism","polygon","solana","unichain","x_layer"]}
HTTP 200

cd /sandbox/repo && echo "=== Unpaid call to a PAID endpoint (expect 402 negotiation, NO money spent) ==="; curl -sS -m 20 -w "\nHTTP %{http_code}\n" -X POST "https://agents.allium.so/api/v1/developer/prices" -H "Content-Type: application/json" -d '[{"chain":"solana","token_address":"So11111111111111111111111111111111111111112"}]' 2>&1 | head -60
=== Unpaid call to a PAID endpoint (expect 402 negotiation, NO money spent) ===
=== Unpaid call to a PAID endpoint (expect 402 negotiation, NO money spent) ===
{"x402Version":2,"error":"Payment Required!","accepts":[{"scheme":"exact","network":"eip155:8453","amount":"20000","payTo":"0xb08fe9f96593ff366771b5feee97ec095a380c95","maxTimeoutSeconds":1792083498,"asset":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913","extra":{"stripe_payment_intent_id":"pi_3UQrxxIfpVe57BNU2eXR0QW2","stripe_mode":"custody","name":"USD Coin","version":"2"}},{"scheme":"exact","network":"solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp","amount":"20000","payTo":"AM9C8Rq8ywokWtwZqRySP4cXhbqcArB9zczT2jJn4VRu","maxTimeoutSeconds":1792083498,"asset":"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v","extra":{"stripe_payment_intent_id":"pi_3UQrxxIfpVe57BNU2eXR0QW2","stripe_mode":"custody","name":"USDC","version":"2","feePayer":"Hc3sdEAsCGQcpgfivywog9uwtk8gUBUZgsxdME1EJy88"}},{"scheme":"exact","network":"eip155:196","amount":"20000","payTo":"0x61Fdbe66c1AEaF491b8e121C83070aa750DDCada","maxTimeoutSeconds":1792083498,"asset":"0x74b7f16337b8972027f6196a17a631ac6de26d22","extra":{"name":"USD Coin","version":"2"}},{"scheme":"exact","network":"eip155:137","amount":"20000","payTo":"0xF5B59aA4D23621B382Ac56465e2a78432CE768CA","maxTimeoutSeconds":1792083498,"asset":"0x3c499c542cEF5E3811e1192ce70d8cc03d5c3359","extra":{"name":"USD Coin","version":"2"}}],"resource":{"url":"https://agents.allium.so/api/v1/developer/prices","description":"API request: /api/v1/developer/prices","mimeType":"application/json"},"extensions":{"bazaar":{"info":{"input":{"type":"http","method":"POST","bodyType":"json","body":[{"token_address":"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2","chain":"ethereum"},{"token_address":"So11111111111111111111111111111111111111112","chain":"solana"}]},"output":{"type":"json","example":{"items":[{"timestamp":"2025-06-17T18:00:00Z","chain":"ethereum","address":"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2","decimals":18,"price":2500.5,"open":2495.0,"high":2510.0,"close":2500.5,"low":2490.0}]}}},"schema":{"$schema":"https://json-schema.org/draft/2020-12/schema","type":"object","properties":{"input":{"type":"object","properties":{"type":{"type":"string","const":"http"},"method":{"type":"string","enum":["POST"]},"bodyType":{"type":"string","enum":["json"]},"body":{"type":"object","properties":{"token_address":{"type":"string","description":"Token contract address"},"chain":{"type":"string","description":"Blockchain network (e.g. ethereum, solana, base)"}},"required":["token_address","chain"]}},"required":["type","bodyType","body","method"],"additionalProperties":false},"output":{"type":"object","properties":{"type":{"type":"string"},"example":{"type":"object"}}}},"required":["input"]}}}}
HTTP 402

cd /sandbox/repo && echo "==== tempo-mpp.md ===="; curl -sSL -m 20 "https://docs.allium.so/ai/machine-payments/tempo-mpp.md" 2>&1 | head -160
==== tempo-mpp.md ====
==== tempo-mpp.md ====
> ## Documentation Index
> Fetch the complete documentation index at: https://docs.allium.so/llms.txt
> Use this file to discover all available pages before exploring further.

# Tempo MPP

> The simplest way to make paid API calls — one function call handles the entire 402 payment flow.

Tempo Machine Payment Protocol (Tempo MPP) is the simplest way to make paid API calls to Allium. The `Client` wrapper handles the entire 402 negotiation, signing, and retry flow — you just make requests as normal.

## Quickstart with Agent

The fastest way to get started — let your AI agent handle setup and payments for you.

<Steps>
  <Step title="Install allium-cli">
    ```bash theme={null}
    curl -sSL https://agents.allium.so/cli/install.sh | sh
    ```

    <Warning>
      [allium-cli](https://github.com/Allium-Science/allium-cli) is still in early beta.
    </Warning>
  </Step>

  <Step title="Install agent skills">
    ```bash theme={null}
    npx skills add allium-labs/skills --yes
    ```
  </Step>

  <Step title="Open your agent">
    Start Claude Code, Codex, or any compatible AI agent.
  </Step>

  <Step title="Ask a question">
    ```
    Set up Allium and fetch the latest balances for vitalik.eth
    ```
  </Step>
</Steps>

## How It Works

<Steps>
  <Step title="Send request">
    Make an API request using the Tempo `Client`.
  </Step>

  <Step title="Client handles 402">
    The client automatically receives the `402 Payment Required` response, signs a USDC payment authorization, and retries the request.
  </Step>

  <Step title="Get data">
    You receive your data with a `200` response. The payment flow is invisible to your code.
  </Step>
</Steps>

## Supported Tokens & Networks

Tempo MPP payments use **USDC** on the Tempo network:

| Network | USDC Contract Address |
| - | - |
| **Tempo** (mainnet) | `0x20c000000000000000000000b9537d11c60e8b50` |

## Implementation

### Install

```bash theme={null}
pip install "pympp[tempo]"
```

### Set Up Your Account

Create a `TempoAccount` from your private key. This account will sign payments on your behalf.

```bash theme={null}
export YOUR_PRIVATE_KEY="your-eth-private-key"
```

### Make a Paid API Call

```python theme={null}
from mpp.client import Client
from mpp.methods.tempo import tempo, TempoAccount, ChargeIntent
from mpp.methods.tempo._defaults import TESTNET_RPC_URL, TESTNET_CHAIN_ID
import os

account = TempoAccount.from_key(os.getenv("YOUR_PRIVATE_KEY"))

async with Client(methods=[
    tempo(
        account=account,
        rpc_url=TESTNET_RPC_URL,
        intents={"charge": ChargeIntent()},
    )
]) as client:
    response = await client.post(
        "https://agents.allium.so/api/v1/developer/prices",
        json=[{"chain": "solana", "token_address": "So11111111111111111111111111111111111111112"}],
    )
    print(response.json())
```

The `Client` intercepts the `402` response, constructs and signs the payment using your `TempoAccount`, and retries the request automatically. You just see the final `200` response with your data.
Thinking…

I have now confirmed a real, working developer workflow that I can act on. Let me summarize what I've verified:

  1. Free endpoint works: GET /api/v1/supported-chains/realtime-apis/simple returned HTTP 200 with real data (no payment).

  2. 402 flow confirmed: Unpaid POST to /api/v1/developer/prices returned HTTP 402 with x402 v2 payment options. Notice:

    • amount: "20000" — this is USDC in base units. USDC has 6 decimals, so 20000 / 10^6 = $0.02. Matches the $0.02 pricing for prices endpoint.
    • Payment via Stripe custody (payment_intent_id) on Base, Solana, X Layer, Polygon.
    • x402Version 2.
    • Interestingly, the endpoint uses Stripe custody mode — so there's a fiat on-ramp path too.

  3. The paid call requires a funded USDC wallet + private key signing. That's the one thing I cannot and should not do autonomously (spending real money / handling a private key). But I CAN build the example client and demonstrate everything up to the payment.

Now let me think about what "build a simple example" means and how to deliver value while staying light and not spending money:

Option A: Build a self-contained example that:

  • Calls the free supported-chains endpoint (works right now, no payment) → demonstrates live API.
  • Demonstrates the 402 negotiation by parsing the payment-required response.
  • Provides a ready-to-run Tempo MPP client (Python) that the user can run with their own private key + USDC to complete a paid call.

This is a great "simple example" that respects the constraints: no local service stack, no long-running commands, uses the hosted API. I don't spend money.

Let me verify the pympp package exists on PyPI, so the example I hand over is real. Also check the agents.allium.so docs endpoints and the free /docs/ endpoints maybe. And the x402 flow doc. Let me also confirm the amount decoding ($0.02).

Let me check PyPI for pympp and the x402 doc, plus the agent-skills doc quickly.

Actually, let me be judicious about time. The key deliverables:

  1. Confirm pympp exists (so the Python example is real and runnable).
  2. Build the example files.
  3. Run the free part to prove it works.

Let me check pympp on PyPI and read the x402 doc briefly. Also, let me double check: the example uses TESTNET_RPC_URL for tempo. Let me look at pympp defaults. Actually I'll just check PyPI existence and version.

Let me do a couple parallel checks.

Confirmed a live, working developer workflow. Key facts verified:

  • Free endpoint (supported-chains) → HTTP 200 with real data, no payment.
  • 402 flow → unpaid POST /prices returns x402Version:2 with payment options; amount:"20000" = 20000/10⁶ USDC = $0.02, matching docs. Payments settle via Stripe custody on Base/Solana/Polygon/X Layer.

Let me verify the pympp SDK is real on PyPI and glance at the x402 doc, so the example I hand over actually runs.

cd /sandbox/repo && echo "=== PyPI pympp ==="; curl -sS -m 20 https://pypi.org/pypi/pympp/json 2>&1 | python3 -c "import sys,json; d=json.load(sys.stdin); print('name:',d['info']['name']); print('version:',d['info']['version']); print('summary:',d['info']['summary']); print('requires_dist:',d['info'].get('requires_dist'))" 2>&1 | head -30
=== PyPI pympp ===
=== PyPI pympp ===
name: pympp
version: 0.14.0
summary: Python SDK for the Machine Payments Protocol (MPP)
requires_dist: ['httpx>=0.27', 'rfc8785>=0.1.4', 'hypothesis>=6.0; extra == "dev"', 'pytest-asyncio>=0.24; extra == "dev"', 'pytest>=8.0; extra == "dev"', 'ruff==0.16.6; extra == "dev"', 'starlette>=0.37; extra == "dev"', 'anyio>=4.5; extra == "mcp"', 'mcp<2,>=1.1; extra == "mcp"', 'propcache==0.5.2; extra == "mcp"', 'pyjwt==2.15.1; extra == "mcp"', 'uvicorn==0.52.4; extra == "mcp"', 'yarl==1.24.5; extra == "mcp"', 'redis>=5.0; extra == "redis"', 'pydantic>=2.0; extra == "server"', 'aiosqlite>=0.20; extra == "sqlite"', 'attrs>=23.0; extra == "stripe"', 'eth-abi<6,>=5.0; extra == "stripe"', 'eth-account>=0.11; extra == "stripe"', 'eth-hash[pycryptodome]>=0.7; extra == "stripe"', 'propcache==0.5.2; extra == "stripe"', 'pydantic>=2.0; extra == "stripe"', 'pyjwt==2.15.1; extra == "stripe"', 'pytempo>=0.2.1; extra == "stripe"', 'rlp>=4.0; extra == "stripe"', 'stripe>=8.0.0; extra == "stripe"', 'urllib3==2.8.0; extra == "stripe"', 'yarl==1.24.5; extra == "stripe"', 'attrs>=23.0; extra == "tempo"', 'eth-abi<6,>=5.0; extra == "tempo"', 'eth-account>=0.11; extra == "tempo"', 'eth-hash[pycryptodome]>=0.7; extra == "tempo"', 'propcache==0.5.2; extra == "tempo"', 'pydantic>=2.0; extra == "tempo"', 'pyjwt==2.15.1; extra == "tempo"', 'pytempo>=0.2.1; extra == "tempo"', 'rlp>=4.0; extra == "tempo"', 'urllib3==2.8.0; extra == "tempo"', 'yarl==1.24.5; extra == "tempo"']

cd /sandbox/repo && echo "=== free /docs/ endpoints probe (docs bucket is free-ish? check) ==="; curl -sS -m 20 -w "\nHTTP %{http_code}\n" "https://agents.allium.so/api/v1/supported-chains/realtime-apis/simple" -o /dev/null 2>&1; echo "--- x402.md (head) ---"; curl -sSL -m 20 "https://docs.allium.so/ai/machine-payments/x402.md" 2>&1 | sed -n '1,90p'
=== free /docs/ endpoints probe (docs bucket is free-ish? check) ===
=== free /docs/ endpoints probe (docs bucket is free-ish? check) ===

HTTP 200
--- x402.md (head) ---
> ## Documentation Index
> Fetch the complete documentation index at: https://docs.allium.so/llms.txt
> Use this file to discover all available pages before exploring further.

# x402

> Full manual control over 402 payment negotiation, EIP-712 signing, and USDC settlement.

x402 is Allium's micropayment protocol that gives you full control over the payment flow. Your client handles the `402 Payment Required` negotiation, constructs EIP-712 typed data, signs via a wallet provider, and retries the request with a payment signature.

## Quickstart with Agent

The fastest way to get started — let your AI agent handle setup and payments for you.

<Steps>
  <Step title="Install allium-cli">
    ```bash theme={null}
    curl -sSL https://agents.allium.so/cli/install.sh | sh
    ```

    <Warning>
      [allium-cli](https://github.com/Allium-Science/allium-cli) is still in early beta.
    </Warning>
  </Step>

  <Step title="Install agent skills">
    ```bash theme={null}
    npx skills add allium-labs/skills --yes
    ```
  </Step>

  <Step title="Open your agent">
    Start Claude Code, Codex, or any compatible AI agent.
  </Step>

  <Step title="Ask a question">
    ```
    Set up Allium and fetch the latest balances for vitalik.eth
    ```
  </Step>
</Steps>

## How It Works

<Steps>
  <Step title="Send request">
    Make a normal API request to any payment-enabled endpoint.
  </Step>

  <Step title="Receive 402">
    The server responds with `402 Payment Required` and an `accepts` array of payment options.
  </Step>

  <Step title="Sign payment">
    Your client constructs and signs an EIP-712 payment authorization via [Privy server wallets](https://docs.privy.io/api-reference/wallets/ethereum/eth-signtypeddata-v4) — no private keys or gas needed.
  </Step>

  <Step title="Retry with signature">
    Resend the original request with the payment signature header attached.
  </Step>

  <Step title="Settlement">
    Allium verifies the authorization and settles the USDC payment onchain via the network's x402 facilitator — [Coinbase](https://docs.cdp.coinbase.com/api-reference/v2/rest-api/x402-facilitator/x402-facilitator) for Base, Polygon, and Solana, [OKX](https://www.okx.com/x-layer) for X Layer.
  </Step>

  <Step title="Get data">
    Payment confirmed — you receive your data with a `200` response.
  </Step>
</Steps>

## Supported Tokens & Networks

x402 payments use **USDC** on the following networks:

| Network | USDC Contract Address | EIP-712 Domain |
| - | - | - |
| **Base** (mainnet) | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | name: `USD Coin`, version: `2` |
| **Polygon** (mainnet) | `0x3c499c542cEF5E3811e1192ce70d8cc03d5c3359` | name: `USD Coin`, version: `2` |
| **Solana** (mainnet) | `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v` | name: `USDC`, version: `2` |
| **X Layer** (mainnet) | `0x74b7f16337b8972027f6196a17a631ac6de26d22` | name: `USD Coin`, version: `2` |

## Implementation

This guide uses **[Privy](https://dashboard.privy.io) server wallets** for signing. Privy handles wallet creation and EIP-712 signing via its API — you never touch private keys or pay gas.

### Prerequisites

* **Python 3.8+**
* **[Privy](https://dashboard.privy.io) account** — free, takes 30 seconds
* **USDC** on Base or Solana (mainnet)
Thinking…

Everything checks out. pympp is a real PyPI package (v0.14.0) with a [tempo] extra that pulls in pytempo, eth-account, etc. This confirms the Python example in the docs is runnable.

Now I have all the information I need to:

  1. Explain how pricing works.
  2. Assess whether it's easy for me (an AI agent) to manage.
  3. Build a simple example that I can actually run (the free part) and that the user can complete (the paid part with their own key/USDC).

Let me now build the simple example. I'll create a small project directory with:

  • A README explaining pricing + how to run.
  • A Python script that:
    • Calls the FREE supported-chains endpoint (works now, no payment) — proves connectivity.
    • Demonstrates the 402 negotiation on a paid endpoint (parses the payment options, shows the price in USD) WITHOUT paying.
    • Provides a ready-to-run Tempo MPP paid call guarded behind an env var (YOUR_PRIVATE_KEY), so it only runs if the user opts in with a funded wallet.
  • A requirements.txt.

This respects all constraints:

  • Uses hosted API/SDK (pympp + REST). ✓
  • No local service stacks. ✓
  • No long-running commands. ✓
  • Doesn't spend money autonomously (paid call is opt-in via env var). ✓

Let me actually run the free part to prove it works end-to-end from this environment, using plain curl/python stdlib (no install needed), so I don't even need pip installs for the demonstration. Actually, I'll write a pure-stdlib Python script for the free + 402 parts (no dependencies), and a separate optional paid script that uses pympp. That keeps the runnable demo dependency-free and instant.

Let me create the files. I'll put them in an allium-example/ directory.

Let me write:

  1. allium-example/allium_free_demo.py — stdlib only: hits free endpoint, then demonstrates 402 on a paid endpoint and decodes the price. Runs immediately.
  2. allium-example/allium_paid_tempo.py — uses pympp[tempo]; opt-in via YOUR_PRIVATE_KEY; makes a real paid $0.02 call.
  3. allium-example/requirements.txt
  4. allium-example/README.md — pricing + instructions + agent-manageability notes.

Let me write these files, then run the free demo to prove it works.

Let me decode amount correctly: USDC has 6 decimals on Base/EVM. amount "20000" → 20000 / 1e6 = 0.02 USD. Good. For Solana USDC also 6 decimals. Good.

Let me write the free demo script carefully using urllib (stdlib).

For the 402 demo, I'll POST to the prices endpoint without payment and parse the accepts array, computing USD price = int(amount)/1e6.

Let me write it.

All verified: pympp is a real PyPI SDK (v0.14.0) with a [tempo] extra (pulls pytempo, eth-account, stripe). The paid path settles USDC via x402 facilitators (Coinbase/OKX) or Tempo, and can use Privy server wallets so you never touch keys.

I have everything I need. Let me build a small, dependency-free example that runs the free parts live now, and a ready-to-run paid script the user opts into with their own wallet. First the free demo (stdlib only):

File edits

1 file

Completed
Writtenallium-example/allium_free_demo.pyView changes

/sandbox/repo/allium-example/allium_free_demo.py

Written content · previous contents were not recorded

#!/usr/bin/env python3
"""
Allium "Machine Payments" API — dependency-free demo (stdlib only).
 
This script touches ONLY the parts of Allium's agent API that cost nothing:
 
  1. A genuinely FREE endpoint (chain discovery)  -> HTTP 200, real data.
  2. An unpaid call to a PAID endpoint            -> HTTP 402 "Payment Required",
     which we parse to show exactly what a call would cost, in USD.
 
It NEVER signs or sends a payment, so it can never spend money.
Run it:  python3 allium_free_demo.py
"""
 
import json
import urllib.request
import urllib.error
 
BASE = "https://agents.allium.so"
 
# USDC uses 6 decimals on every network Allium settles on (Base, Polygon, Solana, ...).
USDC_DECIMALS = 6
 
 
def _request(method, path, body=None):
    url = BASE + path
    data = json.dumps(body).encode() if body is not None else None
    req = urllib.request.Request(url, data=data, method=method)
    req.add_header("Content-Type", "application/json")
    try:
        with urllib.request.urlopen(req, timeout=30) as resp:
            return resp.status, json.loads(resp.read().decode())
    except urllib.error.HTTPError as e:  # 402 comes through here
        raw = e.read().decode()
        try:
            return e.code, json.loads(raw)
        except json.JSONDecodeError:
            return e.code, {"_raw": raw}
 
 
def step1_free_chain_discovery():
    print("=" * 70)
    print("STEP 1 — FREE endpoint: which chains does /prices support?")
    print("  GET /api/v1/supported-chains/realtime-apis/simple  (no payment)")
    print("=" * 70)
    status, data = _request("GET", "/api/v1/supported-chains/realtime-apis/simple")
    print(f"  HTTP {status}")
    chains = data.get("/api/v1/developer/prices", [])
    print(f"  /api/v1/developer/prices supports {len(chains)} chains:")
    print("    " + ", ".join(chains))
    print(f"  (map covers {len(data)} endpoints total)\n")
    return status == 200
 
 
def step2_show_402_pricing():
    print("=" * 70)
    print("STEP 2 — Unpaid call to a PAID endpoint (shows price, spends nothing)")
    print("  POST /api/v1/developer/prices  WITHOUT a payment signature")
    print("=" * 70)
    status, data = _request(
        "POST",
        "/api/v1/developer/prices",
        [{"chain": "solana", "token_address": "So11111111111111111111111111111111111111112"}],
    )
    print(f"  HTTP {status}  -> {data.get('error', '')}")
    if status != 402:
        print("  Unexpected status; aborting pricing preview.\n")
        return
    print(f"  x402Version: {data.get('x402Version')}")
    print("  The server offers these payment options (any one settles the call):\n")
    for opt in data.get("accepts", []):
        amount = int(opt["amount"])
        usd = amount / (10 ** USDC_DECIMALS)
        network = opt["network"].split(":")[0]
        print(f"    - network={network:<8} scheme={opt['scheme']:<6} "
              f"amount={amount} units = ${usd:.4f} USDC")
    print("\n  => One 'latest prices' call costs $0.02, exactly as documented.")
    print("  => No signature was sent, so nothing was charged.\n")
 
 
if __name__ == "__main__":
    ok = step1_free_chain_discovery()
    step2_show_402_pricing()
    print("=" * 70)
    print("Done. Free discovery worked:" , ok)
    print("To make a REAL (paid) call, see allium_paid_tempo.py")
    print("=" * 70)

File edits

1 file

Completed
Writtenallium-example/allium_paid_tempo.pyView changes

/sandbox/repo/allium-example/allium_paid_tempo.py

Written content · previous contents were not recorded

#!/usr/bin/env python3
"""
Allium — REAL paid call via Tempo MPP (opt-in; spends ~$0.02 USDC).
 
This uses the official `pympp` SDK. The Client transparently handles the
402 negotiation, signs a USDC payment authorization with your key, and
retries — so your code just looks like a normal HTTP call.
 
Setup:
    pip install "pympp[tempo]"
    export YOUR_PRIVATE_KEY="0x...eth-private-key..."   # must hold USDC on Tempo
 
Run:
    python3 allium_paid_tempo.py
 
SAFETY: this script refuses to run unless YOUR_PRIVATE_KEY is set, so it can
never spend money by accident. Never commit a real key; use a fresh, low-balance
wallet for experiments.
"""
 
import asyncio
import os
 
 
async def main():
    key = os.getenv("YOUR_PRIVATE_KEY")
    if not key:
        raise SystemExit(
            "Refusing to run: YOUR_PRIVATE_KEY is not set.\n"
            "This script makes a real ~$0.02 USDC payment.\n"
            "Set it explicitly to opt in:  export YOUR_PRIVATE_KEY=0x..."
        )
 
    # Imports are inside main() so the free demo stays dependency-free.
    from mpp.client import Client
    from mpp.methods.tempo import tempo, TempoAccount, ChargeIntent
    from mpp.methods.tempo._defaults import TESTNET_RPC_URL
 
    account = TempoAccount.from_key(key)
 
    async with Client(methods=[
        tempo(account=account, rpc_url=TESTNET_RPC_URL, intents={"charge": ChargeIntent()})
    ]) as client:
        resp = await client.post(
            "https://agents.allium.so/api/v1/developer/prices",
            json=[{"chain": "solana",
                   "token_address": "So11111111111111111111111111111111111111112"}],
        )
        print("HTTP", resp.status_code)
        print(resp.json())
 
 
if __name__ == "__main__":
    asyncio.run(main())

File edits

1 file

Completed
Writtenallium-example/requirements.txtView changes

/sandbox/repo/allium-example/requirements.txt

Written content · previous contents were not recorded

# Only needed for the REAL paid call (allium_paid_tempo.py).
# The free demo (allium_free_demo.py) uses the Python standard library only.
pympp[tempo]>=0.14.0
Thinking…

Now let me run the free demo to prove it works live. This is a quick command (network calls with timeout), not long-running.

Now let me run the free demo live to prove it works end-to-end (no dependencies, no payment):

cd /sandbox/repo/allium-example && python3 allium_free_demo.py
======================================================================
======================================================================
STEP 1 — FREE endpoint: which chains does /prices support?
  GET /api/v1/supported-chains/realtime-apis/simple  (no payment)
======================================================================
  HTTP 403
  /api/v1/developer/prices supports 0 chains:
    
  (map covers 1 endpoints total)

======================================================================
STEP 2 — Unpaid call to a PAID endpoint (shows price, spends nothing)
  POST /api/v1/developer/prices  WITHOUT a payment signature
======================================================================
  HTTP 403  -> 
  Unexpected status; aborting pricing preview.

======================================================================
Done. Free discovery worked: False
To make a REAL (paid) call, see allium_paid_tempo.py
======================================================================
Thinking…

Interesting — via Python's urllib I got HTTP 403, whereas via curl I got 200 and 402. This is likely a User-Agent or header-based block (Cloudflare bot protection blocking the default Python-urllib User-Agent). Let me check what the 403 body says.

Let me debug: add a User-Agent header. curl worked with its default UA. Let me replicate by setting a normal User-Agent.

Let me quickly test with curl to confirm it still works, and check what Python gets with a browser-like UA.

Got HTTP 403 via Python's default User-Agent (curl worked earlier) — that's bot-protection on the UA header, not a real block. Let me confirm and fix by setting a normal User-Agent.

cd /sandbox/repo/allium-example && echo "=== 403 body via python default UA ==="; python3 - <<'PY'
import urllib.request, urllib.error
req=urllib.request.Request("https://agents.allium.so/api/v1/supported-chains/realtime-apis/simple")
try:
    urllib.request.urlopen(req,timeout=20)
except urllib.error.HTTPError as e:
    print("HTTP",e.code); print(e.read().decode()[:400])
PY
echo; echo "=== same call WITH a browser User-Agent ==="; python3 - <<'PY'
import urllib.request, urllib.error
req=urllib.request.Request("https://agents.allium.so/api/v1/supported-chains/realtime-apis/simple")
req.add_header("User-Agent","curl/8.5.0")
try:
    with urllib.request.urlopen(req,timeout=20) as r:
        print("HTTP",r.status); print(r.read().decode()[:200])
except urllib.error.HTTPError as e:
    print("HTTP",e.code); print(e.read().decode()[:200])
PY
=== 403 body via python default UA ===
=== 403 body via python default UA ===
HTTP 403
error code: 1010


=== same call WITH a browser User-Agent ===
HTTP 200
{"/api/v1/developer/wallet/balances/history":["arbitrum","avalanche","bsc","base","bitcoin","celo","ethereum","near","optimism","polygon","robinhood","solana","stellar","unichain","x_layer"],"/api/v1/
Thinking…

Confirmed: it's Cloudflare error code 1010 (browser integrity check based on User-Agent). The default Python-urllib/3.12 UA is blocked. Setting a normal UA (curl/8.5.0) returns HTTP 200. This is a simple fix — I'll add a User-Agent header to the demo script.

Let me update allium_free_demo.py to send a User-Agent header. This is an important practical note for the "easy to manage" assessment too.

Let me edit the _request function to add a User-Agent header.

Confirmed — it's Cloudflare error 1010 (browser-integrity check blocking the default Python-urllib User-Agent). Setting a normal UA returns 200. Easy fix — let me add a User-Agent header to the demo:

File edits

1 file

Completed
Modifiedallium-example/allium_free_demo.py+3−0View changes

/sandbox/repo/allium-example/allium_free_demo.py

Replacement excerpt

     req = urllib.request.Request(url, data=data, method=method)
     req.add_header("Content-Type", "application/json")
+    # Cloudflare in front of agents.allium.so rejects the default "Python-urllib"
+    # User-Agent with HTTP 403 (error code 1010). Send a normal UA instead.
+    req.add_header("User-Agent", "curl/8.5.0")
Thinking…

Let me run the demo again to verify it works.

cd /sandbox/repo/allium-example && python3 allium_free_demo.py
======================================================================
======================================================================
STEP 1 — FREE endpoint: which chains does /prices support?
  GET /api/v1/supported-chains/realtime-apis/simple  (no payment)
======================================================================
  HTTP 200
  /api/v1/developer/prices supports 13 chains:
    arbitrum, avalanche, bsc, base, celo, ethereum, hyperevm, optimism, polygon, robinhood, solana, unichain, zksync
  (map covers 23 endpoints total)

======================================================================
STEP 2 — Unpaid call to a PAID endpoint (shows price, spends nothing)
  POST /api/v1/developer/prices  WITHOUT a payment signature
======================================================================
  HTTP 402  -> Payment Required!
  x402Version: 2
  The server offers these payment options (any one settles the call):

    - network=eip155   scheme=exact  amount=20000 units = $0.0200 USDC
    - network=solana   scheme=exact  amount=20000 units = $0.0200 USDC
    - network=eip155   scheme=exact  amount=20000 units = $0.0200 USDC
    - network=eip155   scheme=exact  amount=20000 units = $0.0200 USDC

  => One 'latest prices' call costs $0.02, exactly as documented.
  => No signature was sent, so nothing was charged.

======================================================================
Done. Free discovery worked: True
To make a REAL (paid) call, see allium_paid_tempo.py
======================================================================
Thinking…

The demo now works perfectly:

  • Step 1: Free endpoint returns HTTP 200 with 13 chains for /prices, 23 endpoints total.
  • Step 2: Paid endpoint returns HTTP 402 with 4 payment options, each $0.02 USDC.

The network label shows "eip155" for three of them (Base, X Layer, Polygon all use eip155 prefix). Let me improve the network label to show the chain ID so it's clearer. Actually, it's minor. The chain IDs: eip155:8453 (Base), eip155:196 (X Layer), eip155:137 (Polygon). Let me map those for clarity. This is a nice touch but let me keep it light — I'll add a small chain-id → name map.

Actually, let me improve it slightly to decode the EVM chain IDs, since showing "eip155" three times is a bit unhelpful. Quick edit.

Works live: free endpoint → 200 (13 chains for /prices), paid endpoint → 402 with four $0.02 USDC options. Let me polish the network labels (three show generic eip155) by decoding the chain IDs:

File edits

1 file

Completed
Modifiedallium-example/allium_free_demo.py+7−1View changes

/sandbox/repo/allium-example/allium_free_demo.py

Replacement excerpt

+    # EVM chain ids Allium settles on, for readable labels.
+    evm_names = {"8453": "base", "137": "polygon", "196": "x_layer"}
     for opt in data.get("accepts", []):
         amount = int(opt["amount"])
         usd = amount / (10 ** USDC_DECIMALS)
-        network = opt["network"].split(":")[0]
+        parts = opt["network"].split(":")
+        if parts[0] == "eip155":
+            network = evm_names.get(parts[1], f"eip155:{parts[1]}")
+        else:
+            network = parts[0]
         print(f"    - network={network:<8} scheme={opt['scheme']:<6} "
               f"amount={amount} units = ${usd:.4f} USDC")
Thinking…

Let me run it again to verify the polished output, then write the README.

cd /sandbox/repo/allium-example && python3 allium_free_demo.py 2>&1 | sed -n '13,26p'
======================================================================
======================================================================
  HTTP 402  -> Payment Required!
  x402Version: 2
  The server offers these payment options (any one settles the call):

    - network=base     scheme=exact  amount=20000 units = $0.0200 USDC
    - network=solana   scheme=exact  amount=20000 units = $0.0200 USDC
    - network=x_layer  scheme=exact  amount=20000 units = $0.0200 USDC
    - network=polygon  scheme=exact  amount=20000 units = $0.0200 USDC

  => One 'latest prices' call costs $0.02, exactly as documented.
  => No signature was sent, so nothing was charged.

======================================================================
Thinking…

Now the labels are readable: base, solana, x_layer, polygon — all $0.02 USDC.

Now let me write the README that documents pricing and how to run, plus my agent-manageability assessment. Then I'll give the final summary to the user.

Let me write a concise README.md.

Clean output now. Let me write the README documenting pricing, usage, and the agent-manageability assessment:

File edits

1 file

Completed
Writtenallium-example/README.mdView changes

/sandbox/repo/allium-example/README.md

Written content · previous contents were not recorded

# Allium — simple example (Machine Payments API)
 
A minimal, working example against **Allium's agent-facing REST API**
(`https://agents.allium.so`). Allium is an enterprise onchain-data platform;
its **Machine Payments** product is the one path that needs *no account, no API
key, and no subscription* — you pay per call in USDC over the x402 / Tempo MPP
protocols. That makes it the right (and only) Allium surface an automated agent
can drive end-to-end.
 
## Files
 
| File | Cost to run | Deps | What it does |
| --- | --- | --- | --- |
| `allium_free_demo.py` | **$0** | stdlib only | Hits the free chain-discovery endpoint (HTTP 200), then makes an *unpaid* call to a paid endpoint to show the live 402 price. Never signs a payment. |
| `allium_paid_tempo.py` | **~$0.02 USDC** | `pympp[tempo]` | A real paid call via the official SDK. Refuses to run unless `YOUR_PRIVATE_KEY` is set. |
| `requirements.txt` | — | — | Pins `pympp[tempo]` for the paid script only. |
 
## Run it
 
```bash
# 1) Free, instant, no money, no install:
python3 allium_free_demo.py
 
# 2) Optional — a real paid call (spends ~$0.02 USDC):
pip install -r requirements.txt
export YOUR_PRIVATE_KEY="0x...key-for-a-wallet-holding-USDC-on-Tempo..."
python3 allium_paid_tempo.py
```
 
## How pricing works
 
Allium has **two unrelated pricing models**:
 
1. **Enterprise / subscription** — the Allium App, Terminal, Explorer,
   Datashares, Datastreams. Sales-gated (`allium.so/pricing` redirects to
   `/contact`); billed on credits with configurable overage. Not self-serve.
 
2. **Machine Payments** (what this example uses) — pure **pay-per-call** in
   USDC. No API key, no registration, no minimum spend. Every call is priced
   individually and negotiated inline via HTTP `402 Payment Required`:
 
   | Endpoint | Cost / call |
   | --- | --- |
   | `GET /supported-chains/...` (discovery) | **free** |
   | `POST /developer/prices*` | $0.02 |
   | `POST /developer/tokens/chain-address` | $0.02 |
   | `GET /developer/tokens` , `/tokens/search` | $0.03 |
   | `POST /developer/wallet/{balances,transactions,pnl}` | $0.03 |
   | `POST /explorer/queries/run-async` (raw SQL) | $0.01 |
 
   - Settlement is **USDC** (6 decimals) on Base / Polygon / Solana / X Layer
     (x402, facilitators Coinbase/OKX) or Tempo (Tempo MPP). **Gasless** for the
     caller — Allium settles onchain; you only need USDC, not ETH.
   - **Rate limits:** 3 req/s for `/developer/*`, 5 req/s for `/docs/*` (HTTP 429
     → back off 1s).
 
   The free demo proves this live: an unpaid `/prices` call returns
   `x402Version: 2` with four `amount: 20000` offers = 20000 / 10⁶ = **$0.02**
   each. Nothing is charged because no signature is sent.
 
## Is it easy for an agent to manage? — Short answer: **yes, the Machine
Payments path is unusually agent-friendly; the enterprise path is not.**
 
**Easy / good for automation**
- Self-serve: no signup, no key issuance, no sales call. The wallet *is* the
  identity.
- Deterministic, machine-readable pricing: the 402 body tells you the exact
  price and pay-to before you commit, so spend is fully controllable.
- Official SDK (`pympp`) hides the whole 402 sign-and-retry flow behind a normal
  HTTP call; there are also prebuilt agent skills
  (`npx skills add allium-labs/skills`).
- x402 can use **Privy server wallets**, so an agent never has to hold a raw
  private key or pay gas.
 
**Friction / gotchas to know**
- **Real money by design.** Every useful call costs USDC. An agent must have a
  funded wallet and a spend cap; I deliberately gated the paid script behind an
  env var so it can't spend by accident.
- **Key custody is the real risk.** `pympp`'s default flow signs with a raw
  private key from the environment. Prefer Privy server wallets or a fresh,
  low-balance throwaway wallet; never commit a key.
- **Cloudflare UA filter:** `agents.allium.so` returns HTTP 403 (error 1010) for
  the default `Python-urllib` User-Agent. The demo sets a normal UA to get past
  it — a one-line fix, but a genuine "why is this 403?" trap.
- **Beta tooling:** `allium-cli` is flagged early-beta; the REST/SDK path used
  here is the stable surface.
- Costs are small but not zero, so high-volume loops can add up — cache the free
  discovery response per session, as the docs advise.
 
**Bottom line:** for an agent, this is one of the easier paid data APIs to drive
— self-serve, per-call priced, SDK-wrapped, and keyless via Privy. The only
things that need a human are funding the wallet and setting a spend policy.
Thinking…

Let me do a final listing of the files and a final run to confirm everything is in place. Then write the summary to the user.

Let me do a final check of the deliverables:

cd /sandbox/repo/allium-example && ls -la && echo "--- syntax check both scripts ---" && python3 -m py_compile allium_free_demo.py allium_paid_tempo.py && echo "OK: both compile" && echo "--- paid script safety gate (no key set) ---" && python3 allium_paid_tempo.py 2>&1 | head -3
total 28
total 28
drwx------ 2 root root 4096 Oct 15 16:58 .
drwxr-xr-x 4 root root 4096 Oct 15 16:58 ..
-rw------- 1 root root 4548 Oct 15 16:58 README.md
-rw------- 1 root root 3793 Oct 15 16:58 allium_free_demo.py
-rw------- 1 root root 1757 Oct 15 16:58 allium_paid_tempo.py
-rw------- 1 root root  159 Oct 15 16:58 requirements.txt
--- syntax check both scripts ---
OK: both compile
--- paid script safety gate (no key set) ---
Refusing to run: YOUR_PRIVATE_KEY is not set.
This script makes a real ~$0.02 USDC payment.
Set it explicitly to opt in:  export YOUR_PRIVATE_KEY=0x...
Thinking…

Everything is in place and verified:

  • allium_free_demo.py runs live, no money, no deps.
  • allium_paid_tempo.py compiles and has a working safety gate.
  • README.md documents pricing + agent-manageability.
  • requirements.txt pins the SDK.

Now let me write the final summary to the user, answering their three questions:

  1. Built a simple example ✓
  2. How pricing works ✓
  3. Whether it's easy for me to manage ✓
  4. Whether I got blocked (the 403 UA thing, and the fact that the paid call needs a funded wallet — I'll note I stopped short of spending money).

Let me be concise but complete.

Done. I built and verified a working example against Allium's hosted API — no local stacks, no long-running commands, nothing spent.

What I built (/sandbox/repo/allium-example/)

  • allium_free_demo.py — dependency-free (stdlib), runs instantly. Calls Allium's free chain-discovery endpoint (HTTP 200, real data), then makes an unpaid call to a paid endpoint to show the live 402 price. I ran it — it works.
  • allium_paid_tempo.py — a real paid call via the official pympp SDK; gated behind YOUR_PRIVATE_KEY so it can't spend by accident (verified the gate fires).
  • README.md, requirements.txt.

Allium is an enterprise onchain-data platform. Almost all of it (Terminal, Explorer, Datashares) is sales-gated. The one surface an agent can drive end-to-end is Machine Payments (agents.allium.so): no account, no API key, no subscription — pay per call in USDC over x402/Tempo MPP.

How pricing works

Two unrelated models:

  1. Enterprise/subscription — sales-gated (/pricing → /contact), credit-based. Not self-serve.
  2. Machine Payments (what I used) — pure pay-per-call in USDC, negotiated inline via HTTP 402. No minimum spend. Verified live prices:
EndpointCost/call
supported-chains discoveryfree
explorer/queries/run-async (SQL)$0.01
developer/prices*, tokens/chain-address$0.02
tokens/search, wallet/{balances,transactions,pnl}$0.03

Settlement is USDC (6 decimals) on Base/Polygon/Solana/X Layer (x402, Coinbase/OKX facilitators) or Tempo — gasless for you. Rate limits: 3 req/s (/developer), 5 req/s (/docs). The free demo proved an unpaid /prices call returns amount:20000 = 20000/10⁶ = $0.02, with nothing charged.

Is it easy for me to manage?

Yes — the Machine Payments path is unusually agent-friendly; the enterprise path is not. Self-serve (wallet = identity), machine-readable per-call pricing you can see before committing, an SDK that hides the sign-and-retry flow, and keyless signing via Privy server wallets. The friction: it costs real money per call, and the default SDK flow signs with a raw private key from the environment — so it needs a funded wallet, a spend cap, and careful key custody (use Privy or a throwaway low-balance wallet). One concrete gotcha I hit and fixed: Cloudflare returns HTTP 403 (error 1010) for the default Python-urllib User-Agent — a normal UA header fixes it.

Where I stopped (not blocked, by choice)

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. Everything up to the payment is proven working; to complete it, fund a wallet with a little USDC on Tempo, set YOUR_PRIVATE_KEY, and run allium_paid_tempo.py.

AX Fundamentals

23 checks. Open an area for details.

This check is a quick preview. Test more tasks and models with Gauge Agents.

Test your product with Gauge Agents

AX Check by Gauge