Add agent payments in one install.

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 start

pip install voidly-pay-langchain

from 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-crewai

from 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-ai

from 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-mcp

import { 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-ai

import { 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. 42 Voidly Pay tools appear.

npm install @voidly/pay

import { VoidlyPay } from "@voidly/pay";

const pay = await VoidlyPay.create();
console.log("My DID:", pay.did);

await pay.faucet();              // 10 starter credits
await pay.transfer({ to: "did:voidly:provider", amount: 0.5 });

// Auto-pay any HTTP 402 from any server
const r = await pay.fetchWithPay("https://api.voidly.ai/v1/forecast-pro/IR/30day");
const { forecast } = await r.json();

pip install voidly-pay

from 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/forecast-pro/IR/30day")
forecast = r.json()["forecast"]

![Voidly Pay](https://voidly.ai/pay/badge)

# In your README.md
![Voidly Pay](https://voidly.ai/pay/badge)
![24h revenue](https://voidly.ai/pay/badge?metric=24h)
![Paid endpoints](https://voidly.ai/pay/badge?metric=endpoints)
![Lifetime calls](https://voidly.ai/pay/badge?metric=calls)

# 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: forecast
  with:
    url: https://api.voidly.ai/v1/forecast-pro/IR/30day
    voidly-pay-secret: ${{ secrets.VOIDLY_PAY_SECRET }}
    output-path: forecast.json

- run: |
    echo "Paid ${{ steps.forecast.outputs.amount-credits }} credits"
    echo "Transfer: ${{ steps.forecast.outputs.transfer-id }}"
    cat forecast.json | jq '.summary'

npm install @voidly/pay express

import 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 hono

import { 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@0.3.0

# 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 42 Voidly Pay tools, including:
#   voidly_fetch    — country-pinned URL fetch (37+ probes)  $0.05
#   voidly_extract  — PDF → plain text                       $0.01
#   voidly_markdown — HTML → LLM-context markdown            $0.001
#   voidly_meta     — URL metadata (og, title, canonical)    $0.001
#
# 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/pay

import { VoidlyPay } from "@voidly/pay";

const pay = await VoidlyPay.create();
await pay.faucet();   // 10 starter credits, one-shot

// 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 fastapi

from 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"}