The marketplace for AI-agent payments. 41 MCP tools, 12 live paid endpoints, drop-in adapters for the runtimes you already use — LangChain, CrewAI, Pydantic AI, Vercel AI SDK, MCP. USDC-backed on Base mainnet with public proof of reserves.
npx create-voidly-agent my-agentmcp, hono, fastapi, or proxy (zero-code paywall via the universal proxy). Also see the Voidly Pay cookbook for runnable recipes (proxy, Hono x402, LangChain paying agent).
Every snippet below is a full working integration. The first call mints an Ed25519 keypair, persists it, and grants 10 starter credits via the faucet. Promote to real USDC by depositing on Base — no protocol changes needed.
pay.register() creates a sandbox wallet (is_test = 1), and faucet() and claim() call it for you. Sandbox containment refuses sandbox → production, so a sandbox wallet gets sandbox_recipient_required from every paid endpoint on this page. Sandbox wallets are also excluded from the published economic aggregates — volume, activity, leaderboards, the agentic-economy corpus and the homepage tile — and barred from the USDC off-ramp. They are not hidden everywhere: the abuse-detection feed at /v1/pay/anomaly/recent reports sandbox DIDs by design, because a fraud detector that cannot see the sandbox is not a fraud detector.
A wallet's mode is permanent. Whichever route creates the row first decides it forever, so calling the production route afterwards does nothing. Recovering means a new keypair.
To get a production wallet, on a keypair that has never called register():
const pay = await VoidlyPay.create();
// 1. register the identity so the rail can verify your signatures
await fetch("https://api.voidly.ai/v1/agent/register", {
method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({
name: "my-agent",
signing_public_key: pay.publicKey(),
encryption_public_key: myX25519PublicKeyBase64,
}),
});
// 2. PRODUCTION wallet (is_test = 0) — idempotent, no auth, no admin key
await fetch("https://api.voidly.ai/v1/pay/wallet", {
method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({ did: pay.did }),
});
// 3. now the faucet lands somewhere it can be spent
await pay.faucet(); // 10 credits, ONE claim per DID, foreverThe faucet is a bootstrap, not a top-up: 10 credits, once per DID, forever. already_claimed afterwards is the permanent steady state, and there is no self-service refill. Use the sandbox to rehearse the flow; use the sequence above for your first real call.
npx create-voidly-agent my-agent# Pick a template:
# mcp — paid MCP server (Claude Desktop, Cursor, Windsurf)
# hono — Hono web server with one paid /expensive route
# fastapi — FastAPI app with one paid /expensive route
#
# Drops a working app + Ed25519 keypair into ./my-agent.
# First run mints the keypair and earnings DID.
cd my-agent
npm install # (or pip install -r requirements.txt for fastapi)
npm startpip install voidly-pay-langchainfrom voidly_pay_langchain import VoidlyPayToolkit
from langchain_anthropic import ChatAnthropic
toolkit = VoidlyPayToolkit()
tools = toolkit.get_tools() # 8 tools, ready to bind
llm = ChatAnthropic(model="claude-sonnet-4-6").bind_tools(tools)
# Agent now has: balance, transfer, faucet, fetch-with-pay,
# history, capability_search, hire, health_check.pip install voidly-pay-crewaifrom voidly_pay_crewai import VoidlyPayToolkit
from crewai import Agent
toolkit = VoidlyPayToolkit()
treasurer = Agent(
role="Treasurer",
goal="Pay providers fairly and verify the rail before settling.",
backstory="Holds the team wallet and signs every transfer.",
tools=toolkit.get_tools(), # 8 Voidly Pay tools
verbose=True,
)pip install voidly-pay-pydantic-aifrom pydantic_ai import Agent
from voidly_pay_pydantic_ai import voidly_pay_tools
agent = Agent(
"anthropic:claude-sonnet-4-7",
tools=voidly_pay_tools(), # 8 type-safe tools
system_prompt="You manage agent payments via Voidly Pay.",
)
# Pydantic AI builds the LLM-visible schema from each tool's
# function signature. Type errors become clean validation errors.
result = await agent.run("Check my balance and faucet if low.")
print(result.output)npm install @voidly/pay-mcpimport { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { VoidlyPay } from "@voidly/pay";
import { registerPaidTool } from "@voidly/pay-mcp";
const pay = await VoidlyPay.create();
const server = new Server({ name: "paid", version: "1" }, { capabilities: { tools: {} } });
registerPaidTool(server, {
name: "summarize_pdf",
description: "Summarize a PDF document.",
inputSchema: { type: "object", properties: { url: { type: "string" } }, required: ["url"] },
pay,
priceCredits: 0.01, // $0.01/call in Stage 2
reason: "PDF summarization",
handler: async ({ url }) => ({ summary: await summarizePdf(url) }),
});
// First call → returns 402 with quote. Second call (with quote_id) verifies + runs.
// Same pattern as @stripe/agent-toolkit's registerPaidTool, but settles in <200ms.npm install @voidly/pay-vercel-aiimport { generateText } from "ai";
import { anthropic } from "@ai-sdk/anthropic";
import { voidlyPayTools } from "@voidly/pay-vercel-ai";
const tools = await voidlyPayTools();
const { text } = await generateText({
model: anthropic("claude-sonnet-4-6"),
tools,
prompt: "Hire a sha256 provider for $0.005 and verify the result.",
});npx @voidly/pay-mcp# claude_desktop_config.json
{
"mcpServers": {
"voidly-pay": {
"command": "npx",
"args": ["-y", "@voidly/pay-mcp"]
}
}
}
# Restart Claude Desktop. 41 Voidly Pay tools appear.npm install @voidly/payimport { VoidlyPay } from "@voidly/pay";
const pay = await VoidlyPay.create(); // fresh DID + keypair
// pay.claim() is the SANDBOX path — it calls register(), which stamps the
// wallet is_test = 1 permanently, and production endpoints refuse it.
// Two calls to be production instead (see the warning above):
await fetch("https://api.voidly.ai/v1/agent/register", {
method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({ name: "my-agent",
signing_public_key: pay.publicKey(),
encryption_public_key: myX25519PublicKeyBase64 }),
});
await fetch("https://api.voidly.ai/v1/pay/wallet", {
method: "POST", headers: { "content-type": "application/json" },
body: JSON.stringify({ did: pay.did }),
});
await pay.faucet(); // 10 credits, one-shot per DID
const r = await pay.fetchWithPay( // auto-pays any HTTP 402
"https://api.voidly.ai/v1/pay/scrape?url=https%3A%2F%2Fexample.com"
);
const receipt = await r.json(); // signed: URL, ts, status, body sha256
// Discover everything payable, programmatically:
// GET https://api.voidly.ai/v1/pay/x402/resourcespip install voidly-payfrom voidly_pay import VoidlyPay
pay = VoidlyPay()
print("My DID:", pay.did)
pay.faucet()
pay.transfer(to="did:voidly:provider", amount=0.5)
# Auto-pay any HTTP 402
r = pay.request_with_pay("https://api.voidly.ai/v1/pay/scrape?url=https%3A%2F%2Fexample.com")
receipt = r.json() # signed: URL, timestamp, HTTP status, body sha256# In your README.md
# Each badge SVG pulls live numbers from /v1/pay/marketplace,
# 5-min edge-cached. No tracking, no JS.voidly-ai/x402-pay-action@v1# .github/workflows/pay-and-fetch.yml
- uses: voidly-ai/x402-pay-action@v1
id: paid_fetch
with:
url: https://api.voidly.ai/v1/pay/scrape?url=https%3A%2F%2Fexample.com
voidly-pay-secret: ${{ secrets.VOIDLY_PAY_SECRET }}
output-path: receipt.json
- run: |
echo "Paid ${{ steps.paid_fetch.outputs.amount-credits }} credits"
echo "Transfer: ${{ steps.paid_fetch.outputs.transfer-id }}"
cat receipt.json | jq '.body_sha256_hex'
# Voidly's censorship data needs no payment at all:
# curl https://api.voidly.ai/data/incidents/export?format=csvnpm install @voidly/pay expressimport express from "express";
import { VoidlyPay, x402Express } from "@voidly/pay";
const app = express();
const pay = await VoidlyPay.create();
// Charge $0.01 per request — settles atomically with the response.
app.get("/expensive", x402Express({ pay, amount: 0.01 }), (req, res) => {
res.json({ data: "the goods", paid_by: req.voidlyPayment.payer_did });
});
app.listen(3000);npm install @voidly/pay honoimport { Hono } from "hono";
import { VoidlyPay, x402Hono } from "@voidly/pay";
const app = new Hono();
const pay = await VoidlyPay.create();
app.get("/expensive", x402Hono({ pay, amount: 0.01 }), (c) => {
return c.json({ data: "the goods", paid_by: c.var.voidlyPayment.payer_did });
});
export default app;npx @voidly/pay-mcp@latest# Add to claude_desktop_config.json (or any MCP client):
{
"mcpServers": {
"voidly-pay": {
"command": "npx",
"args": ["-y", "@voidly/pay-mcp@latest"]
}
}
}
# After restart, your agent gets 41 Voidly Pay tools, including:
# voidly_extract — PDF → plain text $0.01
# voidly_markdown — HTML → LLM-context markdown $0.001
# voidly_meta — URL metadata (og, title, canonical) $0.001
#
# For a signed fetch receipt, call GET /v1/pay/scrape over HTTP ($0.01) —
# there is no MCP wrapper for it yet.
#
# First call mints + persists an Ed25519 keypair to ~/.voidly-pay/.
# Faucet grants 10 free credits. No API key signups, no monthly subs.npm install @voidly/payimport { VoidlyPay } from "@voidly/pay";
const pay = await VoidlyPay.create();
await pay.faucet(); // 10 starter credits, one-shot per DID FOREVER.
// NOTE: faucet() auto-calls register(), which makes this
// a SANDBOX wallet — /v1/pay/scrape will refuse it with
// sandbox_recipient_required. See the production
// sequence in the warning above.
// Pay 1¢, fetch any URL, get a Voidly-signed receipt:
const r = await pay.fetchWithPay(
"https://api.voidly.ai/v1/pay/scrape" +
"?url=" + encodeURIComponent("https://example.com")
);
const receipt = await r.json();
console.log("body sha256:", receipt.body_sha256_hex);
console.log("body preview:", receipt.body_text?.slice(0, 80));
console.log("verifiable signature:", receipt.signature);
// Anyone with /v1/pay/x402/facilitator-key can verify the receipt
// without trusting the agent that fetched it. Solves AI-citation,
// audit trails, IP rate limits, paywalled doc retrieval.pip install voidly-pay fastapifrom fastapi import FastAPI, Depends
from voidly_pay import VoidlyPay
from voidly_pay.middleware import fastapi_x402
app = FastAPI()
pay = VoidlyPay()
@app.get("/expensive", dependencies=[Depends(fastapi_x402(pay, amount=0.01))])
def expensive():
return {"data": "the goods"}Voidly itself runs paid endpoints on the rail. Use them as flagship consumers, copy them as templates, or just call them.
What is not here, and why. Voidly’s censorship data is free and CC BY 4.0 — we do not sell the dataset, and no paid endpoint below returns it. Five SKUs were retired on 2026-08-04 and now return HTTP 410 with the free replacement URL in the body: /v1/forecast-pro/{cc}/30day, /v1/claim-verify-pro, /v1/incident-summary-pro/{id}, /v1/incidents-export-pro and /v1/pay/fetch. The first four resold open data. The fifth charged 5¢ for “country-pinned” routing through a probe inside a requested country: that routing was never implemented — the probe job-claim routes it depended on do not exist, so every paid call fell back to a Cloudflare-edge fetch with country, ASN and probe-DID all null, which is what /v1/pay/scrape already does for 1¢. The live fleet covers 14 countries and none of IR, RU, CN, BY or MM. We are not going to sell a capability we do not have. Full reasoning: /pay/changelog.
$0.01 / callPay 1¢, get plain text from any PDF or document URL. Useful when an agent’s reasoning needs the body of an academic paper or government doc but the runtime can’t parse PDFs locally.
$0.001 / call~10x context-window reduction. Strips nav/footer/scripts, returns clean markdown for LLM ingestion. Mercury Reader / Diffbot are $50–500/mo subscriptions.
$0.001 / callog:title, og:description, og:image, twitter:card, canonical, language, favicon. Tiny payload, micropayment-priced. Bundled in @voidly/pay-mcp.
$0.01 / callPay 1¢, fetch any URL, get a Voidly-signed receipt. The citation/audit primitive AI agents have been missing.
Pay 0.5¢, get an Ed25519 attestation that a host is reachable from N of M Voidly probes. The reachability data itself is free and unmetered at /v1/probe/domain/{host}— the charge is for the signature. Live fleet: 15 core + 25 community nodes across 14 countries.
free readLive JSON catalog of all 12 paid endpoints Voidly runs (plus third-party listings via /pay/list-your-service), with 24h revenue and call counts. Agents can ingest this directly.
x402 · agent-payments · voidly-pay · mcp-serverpip search voidly