പ്രധാന ഉള്ളടക്കത്തിലേക്ക് കടക്കുക
പേയ്മെന്റ് API

AI ഏജന്റ് കോഡിന് രൂപകൽപ്പന ചെയ്ത ഒരു പേയ്‌മെന്റ് API.

ഒരു ചെറിയ REST API. ഒപ്പിട്ട വെബ്‌ഹുക്കുകൾ. അഞ്ച് ഭാഷകളിൽ ഔദ്യോഗിക SDKകൾ. നിങ്ങളുടെ ഏജന്റ് USDC അയക്കാനും സമാധാനിപ്പിക്കാനും, കുറച്ച് വരികളിൽ പണമടച്ചത് സ്ഥിരീകരിക്കാനും നിർമ്മിച്ചിരിക്കുന്നു.

ഇടപാടുകളുടെ കാഴ്ച: Base-ൽ സ്ഥിരീകരിച്ച വരുന്ന USDC കൈമാറ്റങ്ങൾ

Blockchain0x API ഉദ്ദേശ്യമായും ചെറിയതാണ്. നിങ്ങളുടെ ആദ്യ പേയ്മെന്റ് നടത്താൻ ഒരു മണിക്കൂർ ഡോക്യുമെന്റേഷൻ വായിക്കാൻ ഞങ്ങൾ നിങ്ങളെ ആഗ്രഹിക്കുന്നില്ല. നിങ്ങൾ ഒരു സ്നിപ്പെറ്റ് പകർന്നു, നിങ്ങളുടെ API കീ പേസ്റ്റ് ചെയ്ത്, അത് ഓടിക്കാൻ ആഗ്രഹിക്കുന്നു.

പ്രധാന എൻഡ്‌പോയിന്റുകൾ

ഏജന്റ് കോഡിന് വേണ്ടി നിർമ്മിച്ച ഒരു ചെറിയ ഉപരിതലം.

payment-shaped routes താഴെ നൽകിയിരിക്കുന്നു. Webhooks, api-keys, read-only spend-permissions എന്നിവ surface-നെ പൂർണ്ണമാക്കുന്നു; SDK ഇതെല്ലാം wrap ചെയ്യുന്നു.

POST/v1/paymentsഒരു ഏജന്റ് വാലറ്റിൽ നിന്ന് USDC പേയ്മെന്റ് അയക്കുക
GET/v1/transactions/{id}ഒരു ഇടപാടിന്റെ സ്ഥിതി, ഹാഷ് നേടുക
POST/v1/payment-requests/{id}/settleഓൺ-ചെയിനിൽ തെളിവോടെ ഒരു ഇൻവോയ്സ് നിശ്ചയിക്കുക
GET/v1/agents/{id}ഒരു ഏജന്റ് വാലറ്റ് നേടുക
POST/v1/agentsഏജന്റ് വാലറ്റ് സൃഷ്ടിക്കുക
അയച്ച വെബ്‌ഹുക്ക് ഇവന്റുകൾ

എല്ലാം HMAC-SHA256 ഉപയോഗിച്ച് ഒപ്പിട്ടിരിക്കുന്നു.

സിഗ്നേച്ചർ X-Blockchain0x-Signature ഹെഡർ. 5 മിനിറ്റ് പുനരാവൃത്തി വിൻഡോ. ഓരോ പോസ്റ്റിലും idempotency കീകൾ.

payment.received

USDC നിങ്ങളുടെ ഏജന്റ് വാലറ്റുകളിൽ ഒന്നിൽ എത്തി

payment.sent

നിങ്ങളുടെ agent-ിൽ നിന്നുള്ള outbound payment chain-ൽ settle ചെയ്തു

wallet.deployed

ഒരു agent-ന്റെ smart wallet deploy ചെയ്തു

webhook.test

ഡാഷ്ബോർഡിൽ നിന്ന് നിങ്ങൾ ആരംഭിച്ച ഒരു test delivery

ചില വരികൾ

നിങ്ങളുടെ ഏജന്റിന്റെ വാലറ്റിൽ നിന്ന് 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
അധികൃത SDKകൾ

TypeScript-നും Python-നും വേണ്ടി ടൈപ്പ് ചെയ്ത ക്ലയന്റുകൾ.

ടൈപ്പ്‌സ്‌ക്രിപ്റ്റ്
npm install @blockchain0x/node

Node 18+ ലെ പ്രവർത്തിക്കുന്നു. നേഡീവ് TypeScript തരം.

PYTHON
pip install blockchain0x

Python 3.9+. സിങ്ക്, അസിങ്ക് ക്ലയന്റുകൾ.

മുഴുവൻ API റഫറൻസ്
മുഴുവൻ എൻഡ്പോയിന്റ് സ്കീമകൾ

SDK മൂടുന്ന അഭ്യർത്ഥന ശരീരങ്ങൾ.

പ്രതിയിടത്തിനുള്ള ഈ സ്ഥിരീകരിച്ച ഇൻപുട്ടുകൾ ആണ്. ഇവിടെ ചുരുക്കമായ മറുപടികൾ കാണിക്കുന്നു; മുഴുവൻ ടൈപ്പ് ചെയ്ത രൂപങ്ങൾ SDK-ൽ, API റഫറൻസിൽ ജീവിക്കുന്നു. അളവുകൾ USDC അടിസ്ഥാന യൂണിറ്റുകളാണ് (6 ദശലക്ഷങ്ങൾ).

POST/v1/payments

USDC പേയ്മെന്റ് അയക്കുക (payments.create). amountWei USDC അടിസ്ഥാന യൂണിറ്റുകൾ ആണ് (6 ദശലക്ഷങ്ങൾ). ചൈന അഡാപ്റ്റർ വയർ ചെയ്യുന്നത് വരെ 503-ന് മറുപടി നൽകാം.

അഭ്യർത്ഥിക്കുക
{
  "agentId": "agt_123",
  "to": "0xRecipient",
  "amountWei": "10000",
  "metadata": { "reason": "Research report" }
}
പ്രതികരണം
{
  "txHash": "0xff5...e12"
}
POST/v1/payment-requests/{id}/settle

ഡാഷ്ബോർഡിൽ സൃഷ്ടിച്ച ഒരു പേയ്മെന്റ് അഭ്യർത്ഥന (ഇൻവോയ്സ്) ഓൺ-ചെയിനിൽ തെളിവോടെ നിശ്ചയിക്കുക (paymentRequests.settle). സൃഷ്ടിക്കാൻ ഒരു വഴി ഇല്ല - നിശ്ചയിക്കുക മാത്രം.

അഭ്യർത്ഥിക്കുക
{
  "txHash": "0xff5...e12",
  "payerAddress": "0xBuyer...",
  "amountUsdcVerified": "0.10"
}
പ്രതികരണം
{
  "txHash": "0xff5...e12"
}
GET/v1/transactions/{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

ഒരു ഏജന്റിന്റെ ചെലവു അനുമതികൾ വായിക്കുക. API വഴി READ-ONLY - സൃഷ്ടിയും മാറ്റങ്ങളും ഡാഷ്ബോർഡിൽ മാത്രം.

അഭ്യർത്ഥിക്കുക
(no body)
പ്രതികരണം
{
  "allowance_wei": "5000000",
  "per_tx_wei": "1000000",
  "period_seconds": 86400,
  "start_at": "2026-05-15T00:00:00Z",
  "revoked_at": null
}
വെബ്‌ഹുക്ക് സിഗ്നേച്ചർ സ്ഥിരീകരണം

പേലോഡിനെ വിശ്വസിക്കുന്നതിന് മുമ്പ് ഒപ്പിടൽ ഉറപ്പാക്കുക.

എല്ലാവരും നിങ്ങളുടെ കോൾബാക്ക് URL-ലേക്ക് പോസ്റ്റ് ചെയ്യാൻ കഴിയും. ഒപ്പിടൽ സംഭവിക്കുന്നത് യഥാർത്ഥത്തിൽ ഞങ്ങളിലേക്കാണ് എന്ന് തെളിയിക്കുന്നു.

ഓരോ ഡെലിവറിയും ഒരു X-Blockchain0x-Signature header (t=<unix>,v1=<hex>) - `${t}.${rawBody}` എന്ന സ്ട്രിംഗിൽ നിങ്ങളുടെ വെബ്‌ഹുക്ക് രഹസ്യത്തോടെ HMAC-SHA256. 5-മിനിറ്റ് റിപ്ലേ വിൻഡോയിൽ. Node-ൽ, @blockchain0x/node ലെ webhooks.verify ഇത് ചെയ്യുന്നു, നിങ്ങൾ ബ്രാഞ്ച് ചെയ്യുന്ന ഒരു വ്യത്യസ്ത യൂണിയൻ തിരികെ നൽകുന്നു. മറ്റ് ഭാഷകളിൽ, ഒരേ HMAC കണക്കാക്കുക, സ്ഥിരമായ സമയത്ത് താരതമ്യം ചെയ്യുക. RAW ബോഡി വായിക്കുക, പാഴ്സുചെയ്ത കോപ്പി അല്ല - വീണ്ടും സീരിയലൈസിംഗ് സിഗ്നേച്ചർ തകർത്ത്.

ടൈപ്പ്‌സ്‌ക്രിപ്റ്റ് (നോഡ് + എക്സ്പ്രസ്)
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 സൃഷ്ടിക്കുമ്പോഴും rotate ചെയ്യുമ്പോഴും webhook secret ഒരിക്കൽ മാത്രം തിരികെ ലഭിക്കും (webhooks.rotateSecret), handler അത് BLOCKCHAIN0X_WEBHOOK_SECRET-യിൽ നിന്ന് വായിക്കുന്നു. rotate ചെയ്യുന്നത് പഴയ secret അസാധുവാക്കുന്നു, അതിനാൽ rollout ഏകോപിപ്പിക്കുക: പുതിയ secret നിങ്ങളുടെ server-ന്റെ env-ൽ സെറ്റ് ചെയ്യുക, deploy ചെയ്യുക, തുടർന്ന് rotate ചെയ്യുക. ship ചെയ്തിരിക്കുന്ന events payment.received, payment.sent, wallet.deployed, webhook.test എന്നിവയാണ് - event type അനുസരിച്ച് branch ചെയ്യുക, ബാക്കി അവഗണിക്കുക.

IDEMPOTENCY

സുരക്ഷിതമായി വീണ്ടും ശ്രമിക്കുക. API രണ്ടുതവണ പേയ്‌മെന്റ് ചെയ്യില്ല.

എജന്റ് കോഡ് വീണ്ടും ശ്രമിക്കുന്നു. നെറ്റ്‌വർക്കുകൾ ബന്ധങ്ങൾ നഷ്ടപ്പെടുത്തുന്നു. LLMകൾ ഉപകരണം രണ്ടുതവണ വിളിക്കാൻ തീരുമാനിക്കുന്നു. ഇത് സുരക്ഷിതമാക്കാൻ, ഒരു Idempotency-Key POST-ൽ header. SDK-ൽ payments.create നിങ്ങളുടെ വേണ്ടി ഒരു സ്ഥിരമായത് സ്വയം മിന്റ് ചെയ്യുന്നു, അതിനാൽ ഒരു വീണ്ടും വിളി രണ്ടുതവണ പണമടയ്ക്കുന്നതിന് പകരം ഒരു ഏക on-chain സമർപ്പണത്തിലേക്ക് തകർന്നു. പ്രക്രിയകളുടെ ഇടയിൽ ഒരേ തർക്ക പ്രവർത്തനം ഡ്യൂപ്പ്ലിക്കേറ്റ് ചെയ്യാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നപ്പോൾ നിങ്ങളുടെ സ്വന്തം കീ ഉപയോഗിച്ച് അതിനെ ഓവർറൈഡ് ചെയ്യുക.

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" }'
  • പ്രഥമ വിളി: പേയ്‌മെന്റ് സമർപ്പിക്കുന്നു, transaction തിരികെ നൽകുന്നു.
  • അതിനാൽ തന്നെ കീ ഉപയോഗിച്ച് വീണ്ടും ശ്രമിക്കുക: രണ്ട് പ്രാവശ്യം പണം അടയ്ക്കുന്നതിനുപകരം ഒറ്റ on-chain submission ആയി ചുരുങ്ങുന്നു.
  • SDK ഇത് കൈകാര്യം ചെയ്യുന്നു: payments.create സ്വയം സ്ഥിരമായ Idempotency-Key സൃഷ്ടിക്കുന്നു, അതിനാൽ വീണ്ടും ശ്രമിക്കുന്ന കോളുകൾ ഡിഫോൾട്ടായി സുരക്ഷിതമാണ്.
  • ഇത് മറികടക്കുക: വ്യത്യസ്ത പ്രോസസ്സുകളിലുടനീളം ഒരേ logical operation ഡ്യൂപ്ലിക്കേറ്റ് ആവാതിരിക്കാൻ നിങ്ങളുടെ സ്വന്തം key പാസ് ചെയ്യുക.

ശുപാർശ ചെയ്ത മാതൃക നിങ്ങളുടെ ഏജന്റ് കോഡിൽ ഓരോ തർക്ക പ്രവർത്തനത്തിനും UUID സൃഷ്ടിക്കുക (ഉദാഹരണത്തിന്, "ഓർഡർ Y-ക്കായി വിതരണക്കാരൻ X-നെ പണം നൽകുക" എന്നതിന് ഒരു UUID) എന്നതാണ്, പ്രവർത്തനം വിജയിക്കുന്നതുവരെ അത് വീണ്ടും ഉപയോഗിക്കുക. നിങ്ങൾ അത് വ്യക്തമാക്കുന്നില്ലെങ്കിൽ, ഔദ്യോഗിക SDK-കൾ payments.create-ക്കായി ഒരു UUID സ്വയം സൃഷ്ടിക്കുന്നു.

റേറ്റ് പരിധികൾ

ഒരു പട്ടികയല്ല, മറിച്ച് പ്രതികരണത്തിൽ നിന്നുള്ള നിങ്ങളുടെ പരിധി വായിക്കുക.

നിങ്ങളുടെ പദ്ധതിയുമായി പരിധികൾ സ്കെയിൽ ചെയ്യുന്നു. നമ്പറുകൾ കഠിനമായി കോഡ് ചെയ്യുന്നതിന് പകരം, ഓരോ പ്രതികരണവും നിങ്ങൾ എവിടെ നിൽക്കുന്നു എന്ന് പറയുന്നു, SDK-കൾ നിങ്ങളുടെ പിന്‍വലിക്കൽ കൈകാര്യം ചെയ്യുന്നു.

എല്ലാ വിജയ പ്രതികരണങ്ങളിലും ഹെഡറുകൾ

  • X-RateLimit-Limit: നിങ്ങളുടെ പദ്ധതിയുടെ സ്ഥിരമായ നിരക്ക്
  • X-RateLimit-Remaining: ഈ വിൻഡോയിലുള്ള എത്ര വിളികൾ ശേഷിക്കുന്നു
  • X-RateLimit-Reset: വിൻഡോ പുനരാരംഭിക്കുമ്പോൾ യൂണിക്‌സ് സെക്കൻഡുകൾ

നിങ്ങൾ ക്യാപ് അടിക്കുമ്പോൾ (HTTP 429)

  • പ്രതികരണം ഉൾക്കൊള്ളുന്നു Retry-After സെക്കൻഡുകളിൽ
  • അധികാരിക SDK-കൾ 429, 5xx എന്നിവയിൽ വീണ്ടും ശ്രമിക്കുന്നു, എക്സ്പോനൻഷ്യൽ ബാക്കോഫ് ഉപയോഗിച്ച്, Retry-After-നെ ആദരിക്കുന്നു
  • SDK ഇതിനകം ചെയ്യുന്നതുകൊണ്ടു, കൂടുതലായ കോഡ് 429 കൈമാറുന്നില്ല
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 ആണ്, Base-ൽ.

ഒരു വിളിക്കാരൻ പണമടച്ചിട്ടില്ലെങ്കിൽ സർവർ തിരികെ നൽകുന്ന 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, Base-നായി network eip155:8453).
  2. ഒരു payment സൃഷ്ടിച്ച് X-Payment: exact-usdc:<base64(json)> header ഉപയോഗിച്ച് request വീണ്ടും അയയ്ക്കുന്നു.
  3. pay side-ൽ, @blockchain0x/x402 ലെ createX402Client({ sdk }) ഇത് നിങ്ങൾക്കായി ചെയ്യുന്നു - അത് 402-കൾക്ക് സ്വയമേവ മറുപടി നൽകുന്നു.
  4. നിങ്ങളുടെ server X-Payment header verify ചെയ്ത് original request നിറവേറ്റുന്നു.

രണ്ട് വശങ്ങളും, യഥാർത്ഥ പാക്കേജുകൾ

പണമടവിന്റെ വശത്ത്, createX402Client({ sdk }) @blockchain0x/x402 fetch നെ വെട്ടുന്നു, 402s സ്വയം മറുപടി നൽകുന്നു. സ്വീകരണ ഭാഗത്ത്, createX402Plugin (Fastify) കൂടാതെ createX402Middleware (Express) നിങ്ങളുടെ സ്വന്തം എൻഡ്‌പോയിന്റുകൾ ഗേറ്റുചെയ്യുക. അല്ലെങ്കിൽ x402 ഒഴിവാക്കി REST API നേരിട്ട് ഉപയോഗിക്കുക - രണ്ടും സംയോജിക്കുന്നു, അതിനാൽ നിങ്ങൾ തയ്യാറായപ്പോൾ x402 ചേർക്കാൻ കഴിയും.

അവലംബമായി ചോദിച്ച

വികസകരുടെ ആദ്യത്തെ അഞ്ച് API ചോദ്യങ്ങൾ.

ഞാൻ SDK ഇല്ലാതെ API ഉപയോഗിക്കാമോ?

അതെ. SDKകൾ ബിയർ-ടോക്കൺ അഥവാ HTTPS-ൽ സ്റ്റാൻഡേർഡ് JSON-ന്റെ ചുറ്റളവുകളാണ്. HTTPയും HMAC-SHA256-യും സംസാരിക്കാൻ കഴിയുന്ന ഏതെങ്കിലും കാര്യങ്ങൾ API നേരിട്ടു ഉപയോഗിക്കാം. എർഗോണമിക് ടൈപ്പിംഗ്, റിട്രൈകൾ, ഐഡെംപോടൻസി-കീ നിർമ്മാണത്തിനായി SDKകൾ ഉണ്ട്; അവ സൗകര്യപ്രദമാണ്, ആവശ്യമായവ അല്ല. നോട്, പൈതൺ, റൂബി, ഗോ, JVM എന്നിവയ്ക്കായി ക്ലയന്റുകൾ ഞങ്ങൾ അയയ്ക്കുന്നു; മറ്റേതെങ്കിലും ഭാഷയിൽ, കച്ചവട API വിളിക്കുക.

ഒരു സംഭവം പ്രവർത്തിക്കുമ്പോൾ എന്റെ വെബ്‌ഹുക്ക് എൻഡ്‌പോയിന്റ് ഡൗൺ ആയാൽ എന്ത് സംഭവിക്കും?

ഡെലിവറികൾ തിരിച്ചുപിടിക്കാൻ ശ്രമിക്കുന്നു, ഓരോ ശ്രമവും HTTP പ്രതികരണ കോഡുമായി ഡാഷ്ബോർഡിൽ രേഖപ്പെടുത്തുന്നു. നിങ്ങൾ ഒരു ഇവന്റ് നഷ്ടപ്പെടുകയാണെങ്കിൽ, API-യിൽ നിന്ന് പുനഃസമന്വയം ചെയ്യാം - GET /v1/transactions/{id} ഉപയോഗിച്ച് ഐഡിയിൽ ഇടപാട് നേടുക - വെബ് ഹുക്ക് മാത്രം ആശ്രയിക്കുന്നതിനു പകരം. അതിനെ വിശ്വസിക്കുന്നതിന് മുമ്പ് webhooks.verify (അല്ലെങ്കിൽ രേഖപ്പെടുത്തിയ HMAC) ഉപയോഗിച്ച് ഓരോ ഡെലിവറിയും സ്ഥിരീകരിക്കുക, ഒരു മന്ദമായ ഹാൻഡ്ലർ പരാജയം പോലെയാകുന്നില്ലെന്ന് ഉറപ്പാക്കാൻ 2xx വേഗത്തിൽ പ്രതികരിക്കുക.

എന്റെ ഏജന്റ് നെറ്റ്‌വർക്കിലെ പിശകുകളിൽ വീണ്ടും ശ്രമിക്കുമ്പോൾ ഞാൻ ഡ്യൂപ്ലിക്കേറ്റ് പണമിടപാടുകൾ എങ്ങനെ തടയാം?

POST-ൽ Idempotency-Key ഹെഡർ അയക്കുക. SDK-യിലെ payments.create നിങ്ങൾക്കായി ഒരു സ്ഥിരമായത് സ്വയം നിർമ്മിക്കുന്നു, അതിനാൽ വീണ്ടും ശ്രമിച്ച വിളി രണ്ടുതവണ പേയ്‌മെന്റ് ചെയ്യുന്നതിന് പകരം ഒരു ഏക ഓൺ-ചെയിൻ സമർപ്പണത്തിലേക്ക് ചുരുക്കുന്നു. പ്രോസസുകൾക്കിടയിൽ ഒരേ തത്വപരമായ പ്രവർത്തനം ഡ്യൂപ്പുചെയ്യാൻ നിങ്ങൾക്ക് ആഗ്രഹിക്കുമ്പോൾ നിങ്ങളുടെ സ്വന്തം കീ ഉപയോഗിച്ച് അതിനെ മറികടക്കുക. നിങ്ങളുടെ ഏജന്റ് അല്ലെങ്കിൽ നെറ്റ്‌വർക്കിന്റെ മിഡ്-ഫ്ലൈറ്റ് വീണ്ടും ശ്രമിക്കുന്ന സാഹചര്യത്തിൽ കീ സുരക്ഷാ നെറ്റ് ആണ്.

ഒരു നിരക്ക് പരിധിയുണ്ടോ?

അതെ, ഇത് നിങ്ങളുടെ പദ്ധതിയുമായി സ്കെയിൽ ചെയ്യുന്നു. നമ്പറുകൾ കഠിനമായി കോഡ് ചെയ്യുന്നതിന് പകരം, അവയെ പ്രതികരണത്തിൽ നിന്ന് വായിക്കുക: ഓരോ വിളിയും X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset എന്നിവ തിരികെ നൽകുന്നു, 429-ൽ Retry-After സെക്കൻഡുകളിൽ ഉൾക്കൊള്ളുന്നു. ഔദ്യോഗിക SDK-കൾ ഇതിനകം 429, 5xx-ൽ എക്സ്പോനൻഷ്യൽ ബാക്കോഫ് ഉപയോഗിച്ച് വീണ്ടും ശ്രമിക്കുന്നു, Retry-After-നെ ആദരിക്കുന്നു, അതിനാൽ കൂടുതലായും കോഡ് കൈയൊപ്പുചെയ്യേണ്ടതില്ല.

ഇത് x402-സംഗതമായതാണോ?

അതെ. x402 പാക്കേജുകൾ യാഥാർത്ഥ്യമാണെന്ന്: @blockchain0x/x402-ൽ നിന്ന് createX402Client({ sdk }) പേയ്മെന്റ് വശത്ത് 402 വെല്ലുവിളികൾക്ക് മറുപടി നൽകുന്നു, createX402Plugin (Fastify) / createX402Middleware (Express) നിങ്ങളുടെ സ്വന്തം എന്റ്പോയിന്റുകൾ സ്വീകരിക്കുന്ന വശത്തേക്ക് ഗേറ്റ് ചെയ്യുന്നു. ഇന്ന് ഏക സ്കീം exact-usdc ആണ്, വയർ ഫോർമാറ്റ് X-Payment ആണ്: exact-usdc:<base64(json)> 402-ന്റെ ശരീരത്തിൽ പതിപ്പ് 1 പ്രചരിപ്പിക്കുന്നതും accepts[] പട്ടികയും ഉള്ള ഒരു അഭ്യർത്ഥന ഹെഡർ. നിങ്ങൾ x402 അവഗണിക്കാനും നേരിട്ട് REST API ഉപയോഗിക്കാനും കഴിയും.

നിങ്ങളുടെ ആദ്യ പേയ്മെന്റ് അയക്കുക.

ആരംഭിക്കാൻ സൗജന്യമാണ്. API കീയിൽ നിന്ന് നിങ്ങളുടെ ആദ്യ USDC കൈമാറ്റത്തിലേക്ക് കുറച്ച് വരികൾ.