Venda sua API para agentes de IA.
Agentes de IA não podem preencher um formulário de cartão de crédito. Eles podem te pagar em USDC. Blockchain0x faz essa única chamada de API.
Sua API foi projetada para humanos. Seus chamadores agora são agentes.
A próxima década de receita de API não virá de inscrições humanas. Virá de agentes de IA chamando APIs em nome de seus usuários, muitas vezes programaticamente e sem qualquer humano no loop. Esses agentes não podem usar seu checkout existente. Eles não podem preencher um formulário de cartão de crédito, não podem criar uma conta, não podem clicar em um e-mail de confirmação, não podem lembrar uma senha.
O que eles podem fazer é ler uma resposta 402 Payment Required, analisar o valor USDC e o destinatário do corpo JSON, pagar no Base e reemitir a chamada com prova de pagamento. Essa é toda a forma do comércio de API impulsionado por agentes. O modelo de custo (cobrança por chamada em stablecoin) também se adapta muito melhor à forma de uso do agente do que assinaturas baseadas em cartão: cartões falham em transações abaixo de $1; USDC no Base custa centavos em gás; estornos não acontecem entre máquinas.
Blockchain0x é a ponte. Liste as rotas que você deseja cobrar em uma tabela de preços e monte o adaptador x402. Quando uma chamada não paga atinge uma rota com preço, o adaptador retorna um 402 descrevendo exatamente o que pagar. O agente paga no Base e tenta novamente com um cabeçalho X-Payment; o adaptador verifica e seu manipulador é executado. Você coleta USDC e executa sua API como antes. Nada sobre a lógica do seu negócio muda; a camada de faturamento opera ao lado.
O código de status HTTP finalmente tem um uso.
HTTP 402 was reserved in the original spec for "future use" and never standardized. For thirty years it sat unused while the internet built per-account subscription billing on top of 200/401/403. With Coinbase's x402 protocol, 402 finally has a standard implementation: any API that needs payment-before-it-runs can return a structured 402, and any client that understands the spec can pay and retry.
HTTP/1.1 402 Payment Required
Content-Type: application/json
{
"resource": "POST /api/expensive-operation",
"accepts": [
{
"scheme": "exact-usdc",
"network": "mainnet",
"chainId": "eip155:8453",
"payToAddress": "0xYourAgentWalletAddress",
"amountWeiUsdc": "500000",
"paymentRequestId": "pr_demo",
"maxAgeSeconds": 60
}
]
}O que significa o requisito accepts[]
- scheme - o esquema de pagamento. exact-usdc significa um valor exato de USDC em uma cadeia EVM. O cliente corresponde a isso antes de pagar.
- network / chainId - a cadeia para liquidar (mainnet é Base, CAIP-2 eip155:8453). Uma migração pode citar ambas as redes listando dois requisitos em accepts.
- payToAddress / amountWeiUsdc - a carteira do destinatário e o valor exato em unidades base de USDC (500000 = 0.50 USDC, 6 casas decimais). O cliente verifica ambos antes de pagar.
- paymentRequestId - vincula o pagamento a esta cotação. O adaptador rejeita um X-Payment que referencia um paymentRequestId diferente do que a rota citada.
- maxAgeSeconds - quão recente o pagamento deve ser. Um pagamento mais antigo do que esta janela é rejeitado e o chamador deve pagar novamente.
x402 é máquina-para-máquina: um cliente ciente de x402 lê accepts, paga o requisito escolhido na cadeia, e então reemite a solicitação com um cabeçalho X-Payment que o adaptador verifica. Um cliente que não entende x402 simplesmente recebe o 402 e não obtém resultado, que é o resultado correto (a chamada não foi paga). Não há uma página de checkout hospedada neste fluxo; o pagamento é liquidado programaticamente pela carteira do chamador.
Uma tabela de preços. Três idiomas. Mesmo formato.
Você monta um adaptador e fornece uma tabela de preços chaveada por MÉTODO mais caminho. Ele filtra apenas as rotas que você lista; seu manipulador nunca vê uma chamada não paga, porque quando ele é executado, o cabeçalho X-Payment já foi verificado. A forma é idêntica em Python, TypeScript e Go - o formato de wire X-Payment é o mesmo, então um servidor Go aceita cabeçalhos construídos por um cliente Python.
from flask import Flask
from blockchain0x import Client
from blockchain0x_x402.server import x402_before_request_factory, PricingEntry
sdk = Client() # reads BLOCKCHAIN0X_API_KEY
app = Flask(__name__)
# Only routes named in the pricing table are gated.
app.before_request(x402_before_request_factory(
sdk=sdk,
pricing={
"POST /api/expensive-operation": PricingEntry(
amount_usdc="0.50",
pay_to_address="0xYourAgentWalletAddress",
payment_request_id="pr_demo",
),
},
))
@app.route("/api/expensive-operation", methods=["POST"])
def expensive_operation():
return run_the_work() # only runs after X-Payment verifiesimport express from "express";
import { createClient } from "@blockchain0x/node";
import { createX402Middleware } from "@blockchain0x/x402/server/express";
const sdk = createClient({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! });
const app = express();
// Only routes named in the pricing table are gated.
app.use(createX402Middleware({
sdk,
pricing: {
"POST /api/expensive-operation": {
amountUsdc: "0.50",
payToAddress: "0xYourAgentWalletAddress",
paymentRequestId: "pr_demo",
},
},
}));
app.post("/api/expensive-operation", async (req, res) => {
res.json(await runTheWork()); // req.x402Payment holds the verified payment
});import (
"net/http"
x402 "tosh-labs/blockchain0x-x402-go"
)
func main() {
pricing := map[string]x402.PricingEntry{
"POST /api/expensive-operation": {
AmountUSDC: "0.50",
PayToAddress: "0xYourAgentWalletAddress",
PaymentRequestID: "pr_demo",
},
}
// serverSdk is your Blockchain0x Go SDK client.
h := x402.Middleware(x402.ServerOptions{Sdk: serverSdk, Pricing: pricing})(
http.HandlerFunc(expensiveOperation))
http.Handle("/api/expensive-operation", h)
http.ListenAndServe(":8080", nil)
}Oferecemos adaptadores de servidor para Express e Fastify (Node), ASGI (Starlette e FastAPI) e Flask (Python), além de net/http do Go. Para outros frameworks, o corpo 402 e o header X-Payment são HTTP puro, que os helpers de wire em @blockchain0x/x402 montam e interpretam - escreva a checagem manualmente no idiomático da sua stack. Pacotes x402 para Ruby e JVM são publicados para o lado do cliente.
Quando recorrer a cada ferramenta.
Stripe é a ferramenta certa para checkout humano. Blockchain0x é a ferramenta certa para checkout de agentes. Eles resolvem problemas diferentes e frequentemente estão lado a lado na mesma API.
| Dimensão | Blockchain0x | Stripe Checkout |
|---|---|---|
| Comprador | Qualquer cliente HTTP (humano ou agente de IA) | Humano em um navegador |
| Autenticação necessária antes do pagamento | Não - a primeira chamada retorna 402 com os requisitos de pagamento. | Sim - e-mail + formulário de cartão |
| Velocidade de liquidação | 5 segundos (USDC na Base) | 2-7 dias (redes de cartões) |
| Risco de chargeback | Nenhum (USDC é final) | Até 120 dias de janela de contestação |
| Economia de custo por transação | Funciona a $0,01-$0,10 por chamada (gás Base + nossa taxa) | As taxas de cartão tornam transações abaixo de $1 economicamente inviáveis |
| Reembolsos | Manual - seu código envia USDC de volta para o endereço do pagador | Automatizado através do painel do Stripe |
| Suporte internacional | Mesma carteira, qualquer país, sem configuração extra | Licenciamento por país, conversão de moeda, regras regionais |
| Melhor para | Consumo de API dirigido por agente programático | Checkout dirigido por humanos (inscrição SaaS, e-commerce) |
O padrão que a maioria dos provedores de API adota: mantenha o Stripe para o fluxo de inscrição humano (seu painel, sua página de produto de assinatura); adicione Blockchain0x na borda da API para acesso programático de agentes. O adaptador x402 apenas restringe as rotas que você colocou em sua tabela de preços, então suas rotas autenticadas por Stripe para humanos permanecem intocadas. Aponte os agentes para as rotas com preço e os humanos para o resto, e ambos os públicos são atendidos pelo mesmo código da API.
Pro para tráfego inicial. Business quando logs de auditoria se tornam um requisito.
Provedores de API quase sempre começam no Pro desde o primeiro dia: o gratuito é somente leitura, e o adaptador x402 precisa do acesso à API para verificar e liquidar pagamentos, além de webhooks para rastreá-los. APIs de alto tráfego cruzam para o território Business à medida que o volume mensal aumenta. Veja a página de preços para o custo exato por agente e onde os níveis se situam.
- Free: útil apenas para o dashboard e exploração de metadados. Somente leitura, então o adapter não consegue liquidar pagamentos.
- Pro: padrão para monetização de API ao vivo. Acesso total à API, webhooks, exports.
- Business: quando você precisa de logs de auditoria para compliance, ou limites de taxa de API mais altos.