Voidly Pay

Overview

Voidly Pay was built around a simple observation: AI agents need to pay for HTTP services, but no existing payment rail fits them. Stripe assumes a human checkout, API keys assume a long-lived billing relationship, and most crypto rails assume a wallet UI. Agents have none of these. They have a cryptographic identity (a did:voidly:<base58> derived from an Ed25519 public key) and a budget.

Voidly Pay treats every paid HTTP call as an x402 transaction: the server returns HTTP 402 Payment Required with a Voidly-signed quote, the agent settles a transfer to the recipient DID, and retries with an X-Payment header. Settlement is atomic on Cloudflare D1 and completes in under 200 ms. The same protocol works whether the underlying balance is held off-chain (Stage 1, instant) or backed by on-chain USDC (Stage 2, current).

The marketplace surface is two-sided. Voidly publishes 17 paid endpoints — the agent-utility belt every autonomous agent might call mid-task. Anyone else can register their own paid HTTP endpoint at /pay/list-your-service with a browser-only signing flow. Stage 1 has zero platform cut.

How it works

A complete paid call is three round-trips compressed into one logical operation:

1. Agent calls the URL. If unpaid, the server returns 402 with a Voidly-signed quote (price, recipient DID, expiry, resource label).
2. Agent signs a transfer envelope with its Ed25519 secret key, POSTs it to /v1/pay/transfer, and receives a settlement receipt.
3. Agent retries the URL with header X-Payment: voidly-credit transfer_id=…; quote_id=…. The server verifies + executes + responds.

The SDK does all three in one call:

import { VoidlyPay } from "@voidly/pay";
const pay = await VoidlyPay.create();          // mints + persists keypair
await pay.faucet();                              // 10 free starter credits
const r = await pay.fetchWithPay(
  "https://api.voidly.ai/v1/pay/wiki?title=Alan%20Turing"
);
const receipt = await r.json();

Receipts are Ed25519-signed and verifiable offline using the public key at /v1/pay/x402/facilitator-key.

Available endpoints

The 17 paid endpoints Voidly itself runs. Live machine-readable catalog at api.voidly.ai/v1/pay/marketplace (merged with self-serve listings).

Generic utilities

Agent-fetch toolkit

Research SKUs

Installation

The fastest way to give an agent access to all 17 endpoints is to install the MCP server. Add this to your client's MCP config:

{
  "mcpServers": {
    "voidly-pay": {
      "command": "npx",
      "args": ["-y", "@voidly/pay-mcp@latest"]
    }
  }
}

Per-client paths and one-click install buttons are at /pay/install. Restart your client; the 42 voidly_* tools appear automatically. The first call mints + persists an Ed25519 keypair to ~/.voidly-pay/keypair.json (mode 0600) and triggers the faucet for 10 free starter credits.

Or claim a wallet directly in the browser at /pay/claim — Ed25519 generated locally, no signup, no install.

Listing your endpoint

Voidly Pay is a two-sided marketplace. Anyone can list a paid HTTP endpoint and have it discovered by every Voidly-aware agent client. The flow is browser-only:

1. Visit /pay/list-your-service.
2. The page generates an Ed25519 keypair locally; the resulting DID becomes your owner identity.
3. Fill in name, tagline, URL, price, optional category and tags.
4. The page signs a canonical envelope with your secret key and POSTs to /v1/pay/listings.
5. Your listing is live in the marketplace immediately; agents browsing /v1/pay/marketplace see it on the next refresh.

Voidly takes zero platform cut on Stage 1. Per-DID limit is 25 active listings; edits cool down at one per minute. Listings can be deactivated by the owner at any time.

Your endpoint must speak x402 (return HTTP 402 with a payment quote when called without an X-Payment header). The fastest way is to drop in our middleware — Express, Hono, FastAPI, or Flask — see /pay/for-builders.

Pricing & caps

SDKs & framework adapters

Server-side x402 middleware ships with the TS and Python SDKs: x402Express, x402Hono, withX402 (TS) and fastapi_x402, flask_x402 (Py).

Trust model

Every credit on the rail is backed 1:1 by USDC held in a Sourcify-verified vault on Base mainnet at 0xb592512932a7b354969bb48039c2dc7ad6ad1c12. A public proof-of-reserves dashboard at /pay/proof refreshes every 15 seconds and shows on-chain USDC holdings vs. credits in circulation.

Quotes are signed by the Voidly facilitator key (Ed25519); clients verify the signature against the public key at /v1/pay/x402/facilitator-key to detect MitM substitution. The SDK's pay.healthCheck() is a one-call 6-check trust report (api reachable, system not frozen, manifest declares Stage 2 vault, vault on Base mainnet, source-verified link present, vault holds USDC).

Operator emergency controls: an admin-signed /v1/pay/admin/freeze_all halts every state-changing route. Existing escrows still refund on deadline; accepted receipts still record.

Frequently asked questions

References & links

• Marketplace JSON catalog — every paid endpoint, machine-readable
• Live discovery manifest — full API + tool surface
• /pay/install — one-click MCP install for every client
• /pay/marketplace — visual marketplace browser
• /pay/list-your-service — list your endpoint in 60 seconds
• /pay/claim — free 10-credit faucet
• /pay/proof — live proof-of-reserves dashboard
• intelligence.voidly.ai/voidly-pay-status/ — hourly e2e test of all 17 paid endpoints (machine-readable JSON at /status.json)
• intelligence.voidly.ai/voidly-pay-demo/ — autonomous demo agent's hourly receipts
• /pay/for-builders — middleware for every server framework
• /pay/security — security model, threat model, audit history
• /pay/compare — vs. ATXP, Coinbase x402, Stripe
• /pay/changelog — release history
• github.com/voidly-ai/voidly-pay — source
• @voidly/pay-mcp on npm
• voidly-pay on PyPI
• x402 protocol — HTTP 402 spec