ମୁଖ୍ୟ ବିଷୟବସ୍ତୁକୁ ଛାଡ଼ନ୍ତୁ
ପେମେଣ୍ଟ API

AI agent code ପାଇଁ ଡିଜାଇନ୍ କରାଯାଇଥିବା ଏକ payment API।

ଏକ ଛୋଟ REST API। ସାଇନ୍ ହୋଇଥିବା webhook। ପାଞ୍ଚଟି ଭାଷାରେ ଅଧିକାରିକ SDKs। ଏହା ଏହିପରି ତିଆରି କରାଯାଇଛି ଯେ ଆପଣଙ୍କର ଏଜେଣ୍ଟ USDC ପଠାଇପାରିବ ଏବଂ ସେଟଲ୍ କରିପାରିବ ଏବଂ କିଛି କୋଡ୍ ରେ ଭୁଗତାନଗୁଡିକୁ ସଂଖ୍ୟା କରିପାରିବ।

Transactions view: Base ଉପରେ ନିଶ୍ଚିତ incoming USDC payments

Blockchain0x API ଉଦ୍ଦେଶ୍ୟପୂର୍ବକ ଛୋଟ। ଆମେ ଚାହୁଁନୁ ଯେ ଆପଣ ପ୍ରଥମ payment କରିବା ପାଇଁ ଗୋଟିଏ ଘଣ୍ଟା documentation ପଢ଼ନ୍ତୁ। ଆମେ ଚାହୁଁଛୁ ଯେ ଆପଣ snippet କପି କରନ୍ତୁ, API key paste କରନ୍ତୁ, ଏବଂ ଚଳାନ୍ତୁ।

ମୁଖ୍ୟ ENDPOINTS

ଏକ ଛୋଟ ସର୍ଫେସ୍, ଏଜେଣ୍ଟ କୋଡ୍ ପାଇଁ ତିଆରି କରାଯାଇଛି।

payment-shaped route ଗୁଡ଼ିକ ତଳେ ଅଛି। Webhook, api-keys, ଏବଂ read-only spend-permissions surface କୁ ପୂରଣ କରେ; SDK ସବୁକୁ wrap କରେ।

POST/v1/paymentsAgent wallet ରୁ ଗୋଟିଏ USDC payment ପଠାନ୍ତୁ
GET/v1/transactions/{id}ଏକ ଲେନଦେନର ସ୍ଥିତି ଏବଂ ହ୍ୟାଶ୍ ଆଣନ୍ତୁ
POST/v1/payment-requests/{id}/settleOn-chain proof ସହ invoice settle କରନ୍ତୁ
GET/v1/agents/{id}ଏକ ଏଜେଣ୍ଟ ୱାଲେଟ୍ ଆଣନ୍ତୁ
POST/v1/agentsଏକ ଏଜେଣ୍ଟ ୱାଲେଟ୍ ସୃଷ୍ଟି କରନ୍ତୁ
SHIPPED WEBHOOK EVENTS

ସମସ୍ତ HMAC-SHA256 ସହିତ ସାଇନ୍ ହୋଇଛି।

ସହି ସ୍ଥାନରେ X-Blockchain0x-Signature ହେଡର୍। 5 ମିନିଟ୍ ରିପ୍ଲେ ଜାଲା। ପ୍ରତି POST ଉପରେ ଇଡେମ୍ପୋଟେନ୍ସୀ କୀ।

payment.received

USDC ଆପଣଙ୍କର ଏକ ଏଜେଣ୍ଟ ୱାଲେଟ୍‌ରେ ଲାଣ୍ଡ୍ ହୋଇଛି

payment.sent

ଆପଣଙ୍କ agent ରୁ ହୋଇଥିବା outbound payment chain ଉପରେ settle ହୋଇଥିଲା

wallet.deployed

ଗୋଟିଏ agent ର smart wallet deploy ହୋଇଥିଲା

webhook.test

dashboard ରୁ ଆପଣ ଚାଲୁ କରିଥିବା ଗୋଟିଏ test delivery

କିଛି ଲାଇନ୍

ଆପଣଙ୍କ agent ର wallet ରୁ USDC ପଠାନ୍ତୁ।

PYTHON
from blockchain0x import Client

client = Client(api_key="sk_test_...")  # sk_test_ testnet, sk_live_ mainnet
tx = client.payments.create(body={
    "agentId": "agt_123",
    "to": "0xRecipient",
    "amountWei": "10000",  # USDC base units (6 decimals): 0.01 USDC
})
print(tx)  # may return 503 until the chain adapter is wired for your network
ଅଧିକାରିକ SDKs

TypeScript ଏବଂ Python ପାଇଁ ଟାଇପ୍ କ୍ଲାଇଏଣ୍ଟଗୁଡିକ।

TYPESCRIPT
npm install @blockchain0x/node

Node 18+ ସହିତ କାମ କରେ। ନେଟିଭ୍ TypeScript ପ୍ରକାର।

PYTHON
pip install blockchain0x

Python 3.9+. ସିଙ୍କ୍ ଏବଂ ଏସିଙ୍କ୍ କ୍ଲାଇଏଣ୍ଟଗୁଡିକ।

ପୂର୍ଣ୍ଣ API ସନ୍ଦର୍ଭ
ସମ୍ପୂର୍ଣ୍ଣ ଏଣ୍ଡପଏଣ୍ଟ ସ୍କିମା

SDK wrap କରୁଥିବା request body ଗୁଡ଼ିକ।

ଏଗୁଡିକ ପ୍ରତ୍ୟେକ route ପାଇଁ verified inputs। ଏଠାରେ responses ସଂକ୍ଷିପ୍ତ ଭାବେ ଦେଖାଯାଇଛି; full typed shapes SDK ଏବଂ API reference ରେ ଅଛି। Amounts ହେଉଛି USDC base units (6 decimals)।

POST/v1/payments

ଗୋଟିଏ USDC payment ପଠାନ୍ତୁ (payments.create)। amountWei ହେଉଛି USDC base units (6 decimals)। chain adapter wire ହେବା ପର୍ଯ୍ୟନ୍ତ 503 ଫେରାଇପାରେ।

ବିନନ୍ତି
{
  "agentId": "agt_123",
  "to": "0xRecipient",
  "amountWei": "10000",
  "metadata": { "reason": "Research report" }
}
ପ୍ରତିକ୍ରିୟା
{
  "txHash": "0xff5...e12"
}
POST/v1/payment-requests/{id}/settle

Dashboard ରେ ସୃଷ୍ଟି ହୋଇଥିବା payment request (invoice) କୁ on-chain proof ସହ settle କରନ୍ତୁ (paymentRequests.settle)। create route ନାହିଁ - କେବଳ settle।

ବିନନ୍ତି
{
  "txHash": "0xff5...e12",
  "payerAddress": "0xBuyer...",
  "amountUsdcVerified": "0.10"
}
ପ୍ରତିକ୍ରିୟା
{
  "txHash": "0xff5...e12"
}
GET/v1/transactions/{id}

ID (transactions.get) ଦ୍ୱାରା ଏକ ଏକକ ଲେନଦେନ ଆଣନ୍ତୁ।

ବିନନ୍ତି
(no body)
ପ୍ରତିକ୍ରିୟା
{
  "id": "tx_01J9...",
  "txHash": "0xff5...e12"
}
GET/v1/agents/{id}

ଏକ ଏଜେଣ୍ଟ ୱାଲେଟ୍ (agents.get) ଆଣନ୍ତୁ। ଏହାର ସାଧାରଣ ପୃଷ୍ଠା wallet.blockchain0x.com/a/{slug} ରେ ଅଛି।

ବିନନ୍ତି
(no body)
ପ୍ରତିକ୍ରିୟା
{
  "id": "agt_01J9QKE...",
  "name": "research-bot",
  "public_url": "https://wallet.blockchain0x.com/a/research-bot"
}
GET/v1/agents/{id}/spend-permissions

Agent ର spend permissions ପଢ଼ନ୍ତୁ। API ମାଧ୍ୟମରେ READ-ONLY - creation ଏବଂ changes କେବଳ dashboard ରେ।

ବିନନ୍ତି
(no body)
ପ୍ରତିକ୍ରିୟା
{
  "allowance_wei": "5000000",
  "per_tx_wei": "1000000",
  "period_seconds": 86400,
  "start_at": "2026-05-15T00:00:00Z",
  "revoked_at": null
}
ୱେବ୍‌ହୁକ୍ ସହି ସତ୍ୟାପନ

ପେଲୋଡ୍ କୁ ବିଶ୍ୱସ୍ତ କରିବା ପୂର୍ବରୁ ସାଇନ୍ ଯାଞ୍ଚ କରନ୍ତୁ।

କେହି ତୁମର କଲ୍ବ୍ୟାକ୍ URL କୁ POST କରିପାରିବ। ସହିତା ହେଉଛି ଯାହା ସତ୍ୟରେ ଘଟଣା ଆମରୁ ଆସିଛି।

ପ୍ରତି ଡେଲିଭରୀ ଏକ ନେଇଯାଏ X-Blockchain0x-Signature header (t=<unix>,v1=<hex>) - `${t}.${rawBody}` string ଉପରେ ଆପଣଙ୍କ webhook secret ସହିତ ଏକ HMAC-SHA256, 5-minute replay window ଭିତରେ। Node ରେ, @blockchain0x/node ର webhooks.verify ଏହା କରେ ଏବଂ ଆପଣ branch କରିପାରିବା ଏକ discriminated union ଫେରାଇଦିଏ। ଅନ୍ୟ ଭାଷାରେ, ସେହି HMAC ଗଣନା କରନ୍ତୁ ଏବଂ constant time ରେ compare କରନ୍ତୁ। RAW body ପଢ଼ନ୍ତୁ, parsed copy ନୁହେଁ - re-serializing କଲେ signature ଭାଙ୍ଗିଯାଏ।

TYPESCRIPT (NODE + EXPRESS)
import express from "express";
import { webhooks } from "@blockchain0x/node";

const app = express();
// Capture the RAW body. The HMAC is over the exact bytes on the wire.
app.use(express.raw({ type: "application/json" }));

app.post("/webhooks/payment", (req, res) => {
  const result = webhooks.verify({
    headers: req.headers,
    rawBody: req.body, // Buffer, raw bytes
    secret: process.env.BLOCKCHAIN0X_WEBHOOK_SECRET!,
  });
  if (!result.ok) return res.status(400).json({ code: result.code });
  // result.eventType is "payment.received" | "payment.sent" | ...
  handleEvent(result);
  res.status(200).send("ok");
});
PYTHON (FLASK)
import hmac, hashlib, os, time
from flask import Flask, request, abort

app = Flask(__name__)
SECRET = os.environ["BLOCKCHAIN0X_WEBHOOK_SECRET"].encode()

@app.post("/webhooks/payment")
def receive():
    raw = request.get_data()  # RAW bytes - do not parse first
    sig = request.headers.get("X-Blockchain0x-Signature", "")
    ts = request.headers.get("X-Blockchain0x-Timestamp", "")
    # Header is "t=<unix>,v1=<hex>"; some proxies send bare hex + the ts header.
    parts = dict(p.split("=", 1) for p in sig.split(",") if "=" in p)
    t, v1 = parts.get("t", ts), parts.get("v1", sig)
    want = hmac.new(SECRET, t.encode() + b"." + raw, hashlib.sha256).hexdigest()
    if not hmac.compare_digest(want, v1) or abs(time.time() - int(t)) > 300:
        abort(401)
    handle_event(request.headers.get("X-Blockchain0x-Event-Type"), request.get_json())
    return "ok", 200

webhook create କିମ୍ବା rotate କରିବାବେଳେ (webhooks.rotateSecret) webhook secret ଗୋଟିଏଥର ଫେରାଇ ଦିଆଯାଏ, ଏବଂ BLOCKCHAIN0X_WEBHOOK_SECRET ହେଉଛି ଯେଉଁଠାରୁ ଆପଣଙ୍କ handler ଏହାକୁ ପଢ଼େ। Rotate କଲେ ପୁରୁଣା secret invalid ହୋଇଯାଏ, ସେହିପାଇଁ rollout ସମନ୍ୱୟ କରନ୍ତୁ: ନୂତନ secret କୁ ଆପଣଙ୍କ server ର env ରେ set କରନ୍ତୁ, deploy କରନ୍ତୁ, ତାପରେ rotate କରନ୍ତୁ। shipped event ଗୁଡ଼ିକ ହେଉଛି payment.received, payment.sent, wallet.deployed, ଏବଂ webhook.test - event type ଉପରେ branch କରନ୍ତୁ, ଅନ୍ୟ ସବୁକୁ ignore କରନ୍ତୁ।

IDEMPOTENCY

ସୁରକ୍ଷିତ ଭାବେ ପୁଣି ଚେଷ୍ଟା କରନ୍ତୁ। API ଦୁଇଥର ଦେୟ କରିବ ନାହିଁ।

ଏଜେଣ୍ଟ କୋଡ୍ ପୁନର୍ବାର ଚେଷ୍ଟା। ନେଟୱର୍କ୍‌ଗୁଡିକ ସଂଯୋଗ ଛାଡ଼ିଦେଇଥାଏ। LLMs ଟୁଲ୍‌କୁ ଦୁଇଥର କଲ୍ କରିବାକୁ ନିଷ୍ପତ୍ତି ନେଉଛି। ଏହାକୁ ସୁରକ୍ଷିତ କରିବାକୁ, ପଠାନ୍ତୁ ଏକ Idempotency-Key POST ଉପରେ header. SDK ର payments.create ଆପଣଙ୍କ ପାଇଁ ସ୍ୱୟଂଚାଳିତ ଭାବେ ଏକ stable one mint କରେ, ତେଣୁ retry କଲାପରେ call ଟି ଦୁଇଥର ପେମେଣ୍ଟ କରିବା ପରିବର୍ତ୍ତେ ଏକେ on-chain submission ରେ collapse ହୋଇଯାଏ। ଏକେ logical operation କୁ processes ମଧ୍ୟରେ dedupe କରିବାକୁ ଚାହିଲେ ନିଜ key ସହିତ override କରନ୍ତୁ।

BASH
curl -X POST https://api.blockchain0x.com/v1/payments \
  -H "Authorization: Bearer $BLOCKCHAIN0X_API_KEY" \
  -H "Idempotency-Key: 8e2c3a40-pay-vendor-once" \
  -H "Content-Type: application/json" \
  -d '{ "agentId": "agt_123", "to": "0xRecipient", "amountWei": "10000" }'
  • ପ୍ରଥମ କଲ୍: payment କୁ submit କରେ, transaction ଫେରାଏ।
  • ସେହି key ସହ ପୁଣି ଚେଷ୍ଟା କରନ୍ତୁ: ଦୁଇଥର ଭୁଗତାନ କରିବା ପ୍ରତିବଦଳରେ ଗୋଟିଏ on-chain submission କୁ ସଙ୍କୋଚିତ ହୋଇଯାଏ।
  • SDK ଏହାକୁ handle କରେ: payments.create ସ୍ୱୟଂଚାଳିତ ଭାବରେ ଗୋଟିଏ stable Idempotency-Key ସୃଷ୍ଟି କରେ, ସେଥିପାଇଁ retried call default ରୁ ନିରାପଦ।
  • ଏହାକୁ ଓଭର୍ରାଇଡ୍ କରନ୍ତୁ: ବିଭିନ୍ନ process ମଧ୍ୟରେ ସେହି ଏକେ logical operation କୁ dedupe କରିବାକୁ ଚାହିଲେ ନିଜର key ପଠାନ୍ତୁ।

ସୁପାରିଶିତ pattern ହେଉଛି ଆପଣଙ୍କ agent code ରେ ପ୍ରତ୍ୟେକ logical operation ପାଇଁ ଗୋଟିଏ UUID generate କରିବା (ଉଦାହରଣ, "order Y ପାଇଁ vendor X କୁ pay କରିବା" ପାଇଁ ଗୋଟିଏ UUID) ଏବଂ operation ସଫଳ ହେଉଅବଧି retries ମଧ୍ୟରେ ଏହାକୁ reuse କରିବା। ଆପଣ specify ନକଲେ official SDKs payments.create ପାଇଁ ସ୍ୱୟଂଚାଳିତଭାବେ ଗୋଟିଏ auto-generate କରେ।

ରେଟ୍ ସୀମା

ଆପଣଙ୍କ limit response ରୁ ପଢ଼ନ୍ତୁ, ଟେବୁଲ୍ ରୁ ନୁହେଁ।

Limits ଆପଣଙ୍କ plan ସହିତ scale ହୁଏ। ବଦଳିଯାଉଥିବା numbers କୁ hard-code କରିବା ପରିବର୍ତ୍ତେ, ପ୍ରତ୍ୟେକ response ଆପଣ କେଉଁ ସ୍ଥାନରେ ଅଛନ୍ତି ତାହା କହେ ଏବଂ SDKs backoff ଆପଣଙ୍କ ପାଇଁ handle କରେ।

ପ୍ରତ୍ୟେକ ସଫଳ ପ୍ରତିକ୍ରିୟାରେ ହେଡର୍‌ଗୁଡିକ

  • X-RateLimit-Limit: ଆପଣଙ୍କର ପ୍ଲାନର ସ୍ଥିର ଦର
  • X-RateLimit-Remaining: ଏହି ୱିଣ୍ଡୋରେ କେତେ କଲ୍ ବାକୀ ଅଛି
  • X-RateLimit-Reset: ଯେତେବେଳେ ୱିଣ୍ଡୋ ପୁନସ୍ଥାପିତ ହୁଏ ସେତେବେଳେ ୟୁନିକ୍ ସେକେଣ୍ଡ୍

ଯେତେବେଳେ ଆପଣ କ୍ୟାପ୍ କୁ ହିଟ୍ କରନ୍ତି (HTTP 429)

  • ପ୍ରତିକ୍ରିୟାରେ ଅନ୍ତର୍ଗତ ଅଛି Retry-After ସେକେଣ୍ଡରେ
  • official SDKs 429 ଏବଂ 5xx ଉପରେ exponential backoff ସହିତ retry କରେ, Retry-After କୁ ମାନିକରି
  • ଅଧିକାଂଶ code 429 କୁ ହାତେ handle କରେନାହିଁ କାରଣ SDK ପୂର୍ବରୁ ଏହା କରେ
X402 ସହିତ ସମ୍ପର୍କିତ

x402 ଫ୍ଲୁଏଣ୍ଟ୍ ଭାବେ କଥା ହୁଏ। ଏହା ବିନା ମଧ୍ୟ କାମ କରେ।

x402 ହେଉଛି HTTP-native payments ପାଇଁ open protocol। ମୂଳ ଧାରଣା: 402 Payment Required ଫେରାଇଥିବା ଯେକୌଣସି API response ଭିତରେ payment requirements ଘୋଷଣା କରିପାରେ, ଏବଂ spec ବୁଝୁଥିବା ଯେକୌଣସି client pay କରି retry କରିପାରେ - signup ନାହିଁ, API key ନାହିଁ, out-of-band negotiation ନାହିଁ। Blockchain0x ସତ୍ୟ x402 packages ଦିଏ: ଗୋଟିଏ pay-side client ଏବଂ receive-side server adapters। ଆଜିର ଏକମାତ୍ର scheme ହେଉଛି exact-usdc, on Base।

CALLER ଦେୟ ନକରିଲେ SERVER ଯେ 402 ଫେରାଇଥାଏ
HTTP/1.1 402 Payment Required
Content-Type: application/json

{
  "version": 1,
  "resource": "https://api.example.com/paid-endpoint",
  "accepts": [
    { "scheme": "exact-usdc", "network": "eip155:8453" }
  ]
}

ଏଜେଣ୍ଟ କଲର୍ କଣ କରେ

  1. 402 body ପଢ଼େ: version 1, resource, ଏବଂ payment requirements ର non-empty accepts[] (scheme exact-usdc, network eip155:8453 for Base).
  2. ଏକ payment build କରେ ଏବଂ X-Payment: exact-usdc:<base64(json)> header ସହ request କୁ ପୁନଃପ୍ରେଷଣ କରେ।
  3. pay side ରେ, @blockchain0x/x402 ର createX402Client({ sdk }) ଏହାକୁ ଆପଣଙ୍କ ପାଇଁ କରେ - ଏହା 402s କୁ ସ୍ୱୟଂଚାଳିତ ଭାବରେ ଉତ୍ତର ଦିଏ।
  4. ଆପଣଙ୍କ server X-Payment header ଯାଞ୍ଚ କରେ ଏବଂ original request ପୂରଣ କରେ।

ଦୁଇପକ୍ଷ, ବାସ୍ତବିକ ପ୍ୟାକେଜ୍

ଦେୟ ପାଇଁ, createX402Client({ sdk }) @blockchain0x/x402 ରୁ fetch କୁ wrap କରେ ଏବଂ 402 କୁ ସ୍ୱୟଂଚାଳିତ ଭାବେ ଉତ୍ତର ଦେଇଥାଏ। ଗ୍ରହଣ ପକ୍ଷରେ, createX402Plugin (Fastify) ଏବଂ createX402Middleware (Express) ଆପଣଙ୍କ ନିଜ endpoints କୁ gate କରନ୍ତୁ। କିମ୍ବା x402 କୁ ଛାଡ଼ି ସିଧା REST API ବ୍ୟବହାର କରନ୍ତୁ - ଦୁଇଟି ଏକସାଥିରେ କାମ କରେ, ସେଥିପାଇଁ ଆପଣ ପ୍ରସ୍ତୁତ ହେଲେ x402 ଯୋଡ଼ିପାରିବେ।

ପ୍ରାୟତଃ ପ୍ରଶ୍ନ

ପ୍ରଥମେ ଡେଭେଲପର୍‌ମାନେ ପଚାରିଥିବା ପାଞ୍ଚ API ପ୍ରଶ୍ନ।

ମୁଁ SDK ବିନା API ବ୍ୟବହାର କରିପାରିବି କି?

ହଁ। SDKs bearer-token auth ସହିତ HTTPS ଉପରେ standard JSON ର ପତଳା wrapper ମାତ୍ର। HTTP ଏବଂ HMAC-SHA256 କହିପାରୁଥିବା ଯେକୌଣସି କିଛି API କୁ ସିଧା ବ୍ୟବହାର କରିପାରେ। SDKs ergonomic typing, retries, ଏବଂ idempotency-key generation ପାଇଁ ଅଛି; ସେଗୁଡ଼ିକ ସୁବିଧାଜନକ, ଆବଶ୍ୟକ ନୁହେଁ। ଆମେ Node, Python, Ruby, Go, ଏବଂ JVM ପାଇଁ clients ship କରୁ; ଅନ୍ୟ ଯେକୌଣସି language ରେ raw API call କରନ୍ତୁ।

ଯଦି ଘଟଣା ଘଟିବା ସମୟରେ ମୋର webhook ଏଣ୍ଡପଏଣ୍ଟ ଡାଉନ୍ ହୁଏ, ତେବେ କଣ ଘଟେ?

ଡେଲିଭରୀଗୁଡିକ ବ୍ୟାକଅଫ୍ ସହିତ ପୁନର୍ପ୍ରୟାସ କରେ ଏବଂ ପ୍ରତି ଚେଷ୍ଟା ଡ୍ୟାସ୍‌ବୋର୍ଡରେ ତାହାର HTTP ପ୍ରତିକ୍ରିୟା କୋଡ୍ ସହିତ ଲଗ୍ କରାଯାଇଛି। ଯଦି ଆପଣ ଘଟଣା ମିସ୍ କରନ୍ତି, ଆପଣ API ରୁ ସମ୍ପର୍କ କରିପାରିବେ - GET /v1/transactions/{id} ସହିତ ID ଦ୍ୱାରା ଲେନଦେନ ଆଣନ୍ତୁ - କେବଳ ୱେବହୁକ୍ ଉପରେ ନିର୍ଭର କରିବା ବଦଳରେ। ଏହାକୁ ବିଶ୍ୱାସ କରିବା ପୂର୍ବରୁ webhooks.verify (କିମ୍ବା ଡକ୍ୟୁମେଣ୍ଟ କରାଯାଇଥିବା HMAC) ସହିତ ପ୍ରତି ଡେଲିଭରୀକୁ ଯାଞ୍ଚ କରନ୍ତୁ, ଏବଂ ଦ୍ରୁତ 2xx ପ୍ରତିକ୍ରିୟା ଦିଅନ୍ତୁ ଯାହାକି ଏକ ଧୀର ହ୍ୟାଣ୍ଡଲର ବିଫଳତା ଭାବରେ ଦେଖାଯାଉନାହିଁ।

ମୋର ଏଜେଣ୍ଟ ନେଟୱର୍କ ତ୍ରୁଟିରେ ପୁନର୍ପ୍ରୟାସ କଲେ ମୁଁ କିପରି ଡୁପ୍ଲିକେଟ୍ ଭୁଗତାନଗୁଡିକୁ ବନ୍ଦ କରିବି?

POST ଉପରେ Idempotency-Key header ପଠାନ୍ତୁ। SDK ଭିତରେ payments.create ଆପଣଙ୍କ ପାଇଁ ଗୋଟିଏ stable key auto-mint କରେ, ସେଥିପାଇଁ ପୁଣି ଚେଷ୍ଟା କରାଯାଇଥିବା call ଦୁଇଥର ଦେୟ କରିବା ପରିବର୍ତ୍ତେ ଗୋଟିଏ on-chain submission ରେ collapse ହୋଇଯାଏ। ଯେତେବେଳେ ଆପଣ ସମାନ logical operation କୁ processes across dedupe କରିବାକୁ ଚାହାନ୍ତି, ତେବେ ଏହାକୁ ନିଜ key ସହ override କରନ୍ତୁ। ଆପଣଙ୍କ agent କିମ୍ବା network mid-flight ରେ retry କରିବାର ସେଇ ମାମଲା ପାଇଁ key ହେଉଛି safety net।

rate limit ଅଛି କି?

ହଁ, ଏବଂ ଏହା ଆପଣଙ୍କ plan ସହିତ scale କରେ। ଭ୍ରମଣଶୀଳ numbers hard-code କରିବା ପରିବର୍ତ୍ତେ response ଠାରୁ ସେଗୁଡିକୁ ପଢନ୍ତୁ: ପ୍ରତ୍ୟେକ call X-RateLimit-Limit, X-RateLimit-Remaining, ଏବଂ X-RateLimit-Reset ଫେରାଏ, ଏବଂ 429 ରେ seconds ରେ Retry-After ଥାଏ। official SDKs ପୂର୍ବରୁ ହିଁ 429 ଏବଂ 5xx ଉପରେ exponential backoff ସହିତ retry କରେ ଏବଂ Retry-After ମାନେ, ସେହିପାଇଁ ଅଧିକାଂଶ code କୁ ଏହାକୁ ହାତେ handle କରିବାକୁ ପଡେନାହିଁ।

ଏହା x402-compatible କି?

ହଁ। x402 packages ଆସଲେ ଅଛି: @blockchain0x/x402 ର createX402Client({ sdk }) pay side ରେ 402 challenges କୁ answer କରେ, ଏବଂ createX402Plugin (Fastify) / createX402Middleware (Express) receive side ରେ ଆପଣଙ୍କ endpoints କୁ gate କରେ। ଆଜିର ଏକମାତ୍ର scheme exact-usdc, ଏବଂ wire format ହେଉଛି X-Payment: exact-usdc:<base64(json)> request header, 402 body ଯାହା version 1 ଏବଂ accepts[] list କୁ ଘୋଷଣା କରେ। ଆପଣ x402 କୁ ଅଗ୍ରାହ୍ୟ କରି ସିଧା REST API ମଧ୍ୟ ବ୍ୟବହାର କରିପାରନ୍ତି।

ଆପଣଙ୍କ ପ୍ରଥମ payment ship କରନ୍ତୁ।

ଆରମ୍ଭ କରିବାକୁ ମାଗଣା। API କୀରୁ ଆପଣଙ୍କର ପ୍ରଥମ USDC ହସ୍ତାନ୍ତର ପାଇଁ କିଛି ଲାଇନ୍।