Voidly Pay vs Stripe Agent Toolkit

Feature matrix

registerPaidTool — same pattern, two settlement layers

Both toolkits ship a registerPaidTool that wraps any MCP tool with a paywall. First call returns a 402-shaped response with quote details; second call (with the quote ID passed back) verifies + runs the tool. The interface is nearly identical — the difference is what backs the quote.

Stripe (settles to your Stripe USD balance)

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { registerPaidTool } from "@stripe/agent-toolkit/modelcontextprotocol";
import Stripe from "stripe";

const stripe = new Stripe(process.env.STRIPE_API_KEY!);
const server = new Server({ name: "paid", version: "1" }, { capabilities: { tools: {} } });

registerPaidTool(server, "summarize", "Summarize a PDF.", schema, handler, {
  stripe,
  priceId: "price_…",          // a Stripe Price object
  paymentReason: "PDF summary",
  successUrl: "https://you.example/done",
  meterEvent: "summarize_call", // optional usage-metered billing
});

// First call → returns Stripe Checkout URL.
// Server polls checkout.sessions.list until completed_at appears.
// Second call → unlocked for ~30 days based on session.

Voidly Pay (settles in credits or USDC on Base, no merchant-of-record)

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.",
  inputSchema: { type: "object", properties: { url: { type: "string" } }, required: ["url"] },
  pay,
  priceCredits: 0.01,            // $0.01/call in Stage 2
  reason: "PDF summarization (Llama 3.1 8B)",
  handler: async ({ url }) => ({ summary: await summarizePdf(url) }),
});

// First call → returns { status: "payment_required", quote_id, pay_url }.
// Caller pays via /v1/pay/x402/quote (any x402 client works).
// Second call (with x_voidly_quote: "<id>") → on-chain verify, run handler.

Key difference: Stripe's version polls checkout.sessions.list for ~30s to detect payment, then unlocks session-keyed access for ~30 days. Voidly Pay's version verifies the quote cryptographically on the next call — single round-trip, no polling, no session state on the server. The provider DID earns immediately and atomically.

Where Stripe is ahead

• Hosted remote MCP at scale (mcp.stripe.com with OAuth).
• DXT manifest + Gemini CLI extension + Cursor/Claude/Kiro plugins for one-click install.
• Universal token billing via @stripe/ai-sdk + @stripe/token-meter (proxy LLM calls through llm.stripe.com).
• Connected Accounts: one toolkit instance manages many sub-merchants via Stripe-Account header.
• Distribution: 250k+ weekly PyPI downloads, listed in every AI agent framework cookbook.
• Card path: needed if a real human ever hands over a credit card.
• Co-author of MPP (Machine Payments Protocol) with Tempo — Visa, Mastercard, OpenAI, Anthropic, DoorDash, Shopify all aboard.

If you have a Stripe account, your customers pay with cards, you need to onboard human merchants, or you want a 250k-weekly-download install base on day one — Stripe is the right pick. Their agent-toolkit is well-engineered, MIT-licensed, and battle-tested.

Where Voidly Pay is ahead

• Agent-as-merchant. Provider DID earns directly without filing for a Stripe account.
• Universal x402 reverse proxy: paywall ANY HTTPS URL with one query parameter, no SDK on the seller side.
• Public proof-of-reserves dashboard with on-chain Sourcify verification — independently auditable.
• No US-only restriction. No KYC. No 2-day card payout schedule.
• Sub-cent settlements. $0.005 min charge. Cards can't go below ~$0.50 cleanly.
• Browser-only onboarding via /pay/claim. Zero install for the agent.
• 9-check atomicity rule + signed envelopes + per-DID idempotency keys, all documented.
• Programmatic SEO & ambient discovery: every free-tier API response leaks _voidly_pay hints to AI crawlers.
• CC BY 4.0 data + MIT SDKs end-to-end.

If you're shipping autonomous agents that need to charge each other for work, run sub-cent micropayments, or want a public reserves dashboard journalists can audit — Voidly Pay is the right pick. The proof of reserves and universal x402 proxy are unique to this rail.

Use both: the sidecar pattern

The two rails compose. Use Stripe to charge the human at the top of the funnel (cards, wallets, BNPL), use Voidly Pay to settle micropayments between sub-agents at the bottom:

Customer ──(Stripe Checkout, USD)──> Orchestrator agent
                                       │
        Orchestrator splits work across sub-agents
                                       │
                                       ▼
       [Sub-agent A]   [Sub-agent B]   [Sub-agent C]
            ╲              │              ╱
             Voidly Pay (cents/microcents, instant, signed)
                          │
   Orchestrator sweeps Voidly credits at run-end →
   optional bridge → USDC on Base → Stripe payout

This is the cleanest narrative: Stripe owns the customer relationship and the dollar on-ramp; Voidly Pay handles the per-call settlement between agents that would otherwise be lost in card fees.

A note on standards (MPP, x402, UCP)

At Sessions 2026, Stripe + Tempo announced Machine Payments Protocol (MPP) as an open standard with Visa, Anthropic, OpenAI, Mastercard, DoorDash, Shopify on board. Stripe also expanded its x402 facilitator to Base + Solana + Tempo, and partnered with Google on the Universal Commerce Protocol (UCP) for Gemini-side checkout.

Voidly Pay's position: x402 is our native protocol; we're an interop facilitator, not a card-network alternative. MPP's core abstraction (PaymentIntent-shaped envelopes between machines) maps cleanly to Voidly Pay's signed-envelope flow — an MPP-compat shim is a small worker-route addition. None of these standards have an identity primitive at the agent level; did:voidly: fills that gap.