ਮੁੱਖ ਸਮੱਗਰੀ 'ਤੇ ਜਾਓ
ਭੁਗਤਾਨ API

AI ਏਜੰਟ ਕੋਡ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤਾ ਗਿਆ ਭੁਗਤਾਨ API।

ਇੱਕ ਛੋਟੀ REST API. ਸਾਈਨ ਕੀਤੇ webhook. ਪੰਜ ਭਾਸ਼ਾਵਾਂ ਵਿੱਚ ਅਧਿਕਾਰਕ SDKs. ਇਸ ਤਰ੍ਹਾਂ ਬਣਾਇਆ ਗਿਆ ਕਿ ਤੁਹਾਡਾ ਏਜੰਟ USDC ਭੇਜ ਸਕਦਾ ਹੈ ਅਤੇ ਸਮਾਪਤ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਕੁਝ ਲਾਈਨਾਂ ਦੇ ਕੋਡ ਵਿੱਚ ਭੁਗਤਾਨ ਦੀ ਪੁਸ਼ਟੀ ਕਰ ਸਕਦਾ ਹੈ.

ਲੈਣ-ਦੇਣ ਦਾ ਦ੍ਰਿਸ਼: ਬੇਸ 'ਤੇ ਪੁਸ਼ਟੀ ਕੀਤੇ ਗਏ ਆਉਣ ਵਾਲੇ USDC ਭੁਗਤਾਨ

Blockchain0x API ਜਾਣਬੂਝ ਕੇ ਛੋਟੀ ਰੱਖੀ ਗਈ ਹੈ। ਅਸੀਂ ਨਹੀਂ ਚਾਹੁੰਦੇ ਕਿ ਤੁਸੀਂ ਆਪਣੀ ਪਹਿਲੀ payment ਕਰਨ ਲਈ ਇੱਕ ਘੰਟਾ documentation ਪੜ੍ਹੋ। ਅਸੀਂ ਚਾਹੁੰਦੇ ਹਾਂ ਕਿ ਤੁਸੀਂ snippet copy ਕਰੋ, ਆਪਣੀ API key paste ਕਰੋ, ਅਤੇ ਇਸਨੂੰ ਚਲਾ ਦਿਓ।

ਮੁੱਖ endpoints

ਇੱਕ ਛੋਟੀ ਸਤਹ, ਏਜੰਟ ਕੋਡ ਲਈ ਬਣਾਈ ਗਈ.

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ਏਜੰਟ ਵਾਲਿਟ ਬਣਾਓ
ਭੇਜੇ ਗਏ webhook events

ਸਾਰੇ HMAC-SHA256 ਨਾਲ ਦਸਤਖਤ ਕੀਤੇ ਗਏ।

ਦਸਤਖਤ ਵਿੱਚ X-Blockchain0x-Signature ਹੈਡਰ। 5 ਮਿੰਟ ਦਾ ਰੀਪਲੇ ਵਿੰਡੋ। ਹਰ POST 'ਤੇ Idempotency ਕੁੰਜੀਆਂ।

payment.received

USDC ਤੁਹਾਡੇ ਇੱਕ ਏਜੰਟ ਵਾਲਿਟ ਵਿੱਚ ਲੈਂਡ ਹੋ ਗਿਆ

payment.sent

ਤੁਹਾਡੇ ਏਜੰਟ ਤੋਂ ਬਾਹਰ ਜਾਣ ਵਾਲਾ ਭੁਗਤਾਨ ਚੇਨ 'ਤੇ ਨਿਪਟ ਗਿਆ

wallet.deployed

ਇੱਕ ਏਜੰਟ ਦਾ ਸਮਾਰਟ ਵੈਲਟ ਤਾਇਨਾਤ ਕੀਤਾ ਗਿਆ

webhook.test

ਇੱਕ ਟੈਸਟ ਡਿਲਿਵਰੀ ਜੋ ਤੁਸੀਂ ਡੈਸ਼ਬੋਰਡ ਤੋਂ ਚਾਲੂ ਕੀਤੀ

ਕੁਝ ਲਾਈਨਾਂ

ਤੁਹਾਡੇ ਏਜੰਟ ਦੇ ਵਾਲਿਟ ਤੋਂ 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 ਲਈ ਟਾਈਪ ਕੀਤੇ ਗਾਹਕ।

ਟਾਈਪਸਕ੍ਰਿਪਟ
npm install @blockchain0x/node

Node 18+ ਨਾਲ ਕੰਮ ਕਰਦਾ ਹੈ। ਮੂਲ TypeScript ਕਿਸਮਾਂ।

PYTHON
pip install blockchain0x

Python 3.9+. ਸਿੰਕ ਅਤੇ ਐਸਿੰਕ ਕਲਾਇੰਟ।

ਪੂਰੀ API ਹਵਾਲਾ
ਪੂਰੀ ਐਂਡਪੋਇੰਟ ਸਕੀਮਾਂ

ਉਹ request bodies ਜਿਨ੍ਹਾਂ ਨੂੰ SDK wrap ਕਰਦਾ ਹੈ।

ਇਹ ਹਰ ਰੂਟ ਲਈ ਪ੍ਰਮਾਣਿਤ ਇਨਪੁਟ ਹਨ। ਜਵਾਬ ਇੱਥੇ ਛੋਟੇ ਦਿਖਾਏ ਗਏ ਹਨ; ਪੂਰੀ ਟਾਈਪ ਕੀਤੀ ਸ਼ੇਪ 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}

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
}
WEBHOOK ਦਸਤਖਤ ਦੀ ਪੁਸ਼ਟੀ

ਹਮੇਸ਼ਾ ਪੇਲੋਡ 'ਤੇ ਭਰੋਸਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਦਸਤਖਤ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ।

ਕੋਈ ਵੀ ਤੁਹਾਡੇ ਕਾਲਬੈਕ URL 'ਤੇ POST ਕਰ ਸਕਦਾ ਹੈ। ਦਸਤਖਤ ਇਹ ਸਾਬਤ ਕਰਦਾ ਹੈ ਕਿ ਘਟਨਾ ਵਾਸਤਵ ਵਿੱਚ ਸਾਡੇ ਤੋਂ ਆਈ ਸੀ।

ਹਰ ਡਿਲਿਵਰੀ ਵਿੱਚ ਇੱਕ X-Blockchain0x-Signature ਹੈਡਰ (t=<unix>,v1=<hex>) - ਇੱਕ HMAC-SHA256 ਸਤਰ `${t}.${rawBody}` 'ਤੇ ਤੁਹਾਡੇ ਵੈਬਹੂਕ ਗੁਪਤ ਕੋਡ ਨਾਲ, 5 ਮਿੰਟ ਦੇ ਦੁਹਰਾਉਣ ਵਾਲੇ ਵਿੰਡੋ ਦੇ ਅੰਦਰ। ਨੋਡ ਵਿੱਚ, @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 secret ਇੱਕ ਵਾਰ ਮਿਲਦਾ ਹੈ ਜਦੋਂ ਤੁਸੀਂ webhook ਬਣਾਉਂਦੇ ਜਾਂ rotate ਕਰਦੇ ਹੋ (webhooks.rotateSecret), ਅਤੇ BLOCKCHAIN0X_WEBHOOK_SECRET ਉਹ ਥਾਂ ਹੈ ਜਿੱਥੇ ਤੁਹਾਡਾ handler ਇਸਨੂੰ ਪੜ੍ਹਦਾ ਹੈ। Rotate ਕਰਨ ਨਾਲ ਪੁਰਾਣਾ secret ਅਣਵੈਧ ਹੋ ਜਾਂਦਾ ਹੈ, ਇਸ ਲਈ rollout ਦਾ ਤਾਲਮੇਲ ਰੱਖੋ: ਨਵਾਂ secret ਆਪਣੇ server ਦੇ env ਵਿੱਚ ਸੈੱਟ ਕਰੋ, deploy ਕਰੋ, ਫਿਰ rotate ਕਰੋ। ਸ਼ਿਪ ਕੀਤੇ events ਹਨ payment.received, payment.sent, wallet.deployed, ਅਤੇ webhook.test - event type ਦੇ ਅਧਾਰ 'ਤੇ branch ਕਰੋ, ਬਾਕੀ ਸਭ ਨੂੰ ignore ਕਰੋ।

IDEMPOTENCY

ਸੁਰੱਖਿਅਤ ਤਰੀਕੇ ਨਾਲ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੋ। API ਦੋ ਵਾਰੀ ਭੁਗਤਾਨ ਨਹੀਂ ਕਰੇਗਾ।

ਏਜੰਟ ਕੋਡ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ। ਨੈੱਟਵਰਕ ਕਨੈਕਸ਼ਨ ਛੱਡ ਦਿੰਦੇ ਹਨ। LLMs ਟੂਲ ਨੂੰ ਦੋ ਵਾਰੀ ਬੁਲਾਉਣ ਦਾ ਫੈਸਲਾ ਕਰਦੇ ਹਨ। ਇਸ ਨੂੰ ਸੁਰੱਖਿਅਤ ਬਣਾਉਣ ਲਈ, ਭੇਜੋ ਇੱਕ Idempotency-Key POST 'ਤੇ ਹੈਡਰ। SDK ਵਿੱਚ payments.create ਤੁਹਾਡੇ ਲਈ ਇੱਕ ਸਥਿਰ ਇੱਕ ਆਟੋ-ਮਿੰਟ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇੱਕ ਦੁਬਾਰਾ ਕੀਤੀ ਗਈ ਕਾਲ ਇੱਕ ਹੀ ਓਨ-ਚੇਨ ਜਮ੍ਹਾਂ 'ਤੇ ਸਹਾਰਾ ਦਿੰਦੀ ਹੈ ਬਜਾਏ ਦੋ ਵਾਰੀ ਭੁਗਤਾਨ ਕਰਨ ਦੇ। ਜਦੋਂ ਤੁਸੀਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਇੱਕੋ ਲਾਜ਼ਮੀ ਕਾਰਵਾਈ ਨੂੰ ਦੁਬਾਰਾ ਨਾ ਕਰਨ ਦੀ ਇੱਛਾ ਰੱਖਦੇ ਹੋ ਤਾਂ ਇਸਨੂੰ ਆਪਣੇ ਆਪਣੇ ਕੁੰਜੀ ਨਾਲ ਓਵਰਰਾਈਡ ਕਰੋ।

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" }'
  • ਪਹਿਲੀ ਕਾਲ: ਭੁਗਤਾਨ ਨੂੰ ਜਮ੍ਹਾਂ ਕਰਦਾ ਹੈ, ਲੈਣ-ਦੇਣ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ।
  • ਇੱਕੋ ਕੁੰਜੀ ਨਾਲ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰੋ: ਦੋ ਵਾਰੀ ਭੁਗਤਾਨ ਕਰਨ ਦੀ ਬਜਾਏ ਇੱਕ ਚੇਨ ਸਬਮਿਸ਼ਨ ਵਿੱਚ ਢਲ ਜਾਂਦਾ ਹੈ।
  • SDK ਇਸਨੂੰ handle ਕਰਦਾ ਹੈ: payments.create ਇੱਕ ਸਥਿਰ Idempotency-Key ਨੂੰ ਆਟੋ-ਮਿੰਟ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇੱਕ ਦੁਬਾਰਾ ਕੀਤੀ ਗਈ ਕਾਲ ਬਾਕਸ ਤੋਂ ਬਾਹਰ ਸੁਰੱਖਿਅਤ ਹੈ।
  • ਇਸ ਨੂੰ ਓਵਰਰਾਈਡ ਕਰੋ: ਜਦੋਂ ਤੁਸੀਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਇੱਕੋ ਹੀ ਤਰਕਾਤਮਕ ਕਾਰਵਾਈ ਨੂੰ ਡਿਡਿਊਪ ਕਰਨ ਦੀ ਇੱਛਾ ਰੱਖਦੇ ਹੋ ਤਾਂ ਆਪਣੀ ਕੁੰਜੀ ਪਾਸ ਕਰੋ।

ਸਿਫਾਰਸ਼ੀ ਪੈਟਰਨ ਇਹ ਹੈ ਕਿ ਆਪਣੇ agent code ਵਿੱਚ ਹਰ logical operation ਲਈ ਇੱਕ UUID ਬਣਾਓ (ਉਦਾਹਰਨ ਲਈ, "pay vendor X for order Y" ਲਈ ਇੱਕ UUID) ਅਤੇ operation ਸਫਲ ਹੋਣ ਤੱਕ retries ਵਿੱਚ ਉਸੇ ਨੂੰ ਦੁਬਾਰਾ ਵਰਤੋ। ਜੇ ਤੁਸੀਂ payments.create ਲਈ ਇਹ specify ਨਹੀਂ ਕਰਦੇ, ਤਾਂ official SDKs ਆਪਣੇ ਆਪ ਇੱਕ UUID generate ਕਰ ਦਿੰਦੇ ਹਨ।

ਦਰਜਾ ਸੀਮਾਵਾਂ

ਤੁਹਾਡੀ ਸੀਮਾ ਜਵਾਬ ਤੋਂ ਪੜ੍ਹੋ, ਕਿਸੇ ਟੇਬਲ ਤੋਂ ਨਹੀਂ।

ਸੀਮਾਵਾਂ ਤੁਹਾਡੇ ਯੋਜਨਾ ਨਾਲ ਮਾਪਦੰਡ ਹਨ। ਜੋ ਨੰਬਰਾਂ ਨੂੰ ਸਖਤ-ਕੋਡ ਕਰਨ ਦੀ ਬਜਾਏ ਜੋ ਭਟਕਦੇ ਹਨ, ਹਰ ਜਵਾਬ ਤੁਹਾਨੂੰ ਦੱਸਦਾ ਹੈ ਕਿ ਤੁਸੀਂ ਕਿੱਥੇ ਖੜੇ ਹੋ ਅਤੇ SDKs ਤੁਹਾਡੇ ਲਈ ਬੈਕਆਫ਼ ਨੂੰ ਸੰਭਾਲਦੇ ਹਨ।

ਹਰ ਸਫਲਤਾ ਦੇ ਜਵਾਬ 'ਤੇ ਹੈਡਰ

  • X-RateLimit-Limit: ਤੁਹਾਡੇ ਯੋਜਨਾ ਦੀ ਸਥਿਰ ਦਰ
  • X-RateLimit-Remaining: ਇਸ ਵਿੰਡੋ ਵਿੱਚ ਕਿੰਨੇ ਕਾਲਾਂ ਬਾਕੀ ਹਨ
  • X-RateLimit-Reset: ਯੂਨਿਕਸ ਸਕਿੰਡ ਜਦੋਂ ਵਿੰਡੋ ਰੀਸੈਟ ਹੁੰਦੀ ਹੈ

ਜਦੋਂ ਤੁਸੀਂ ਕੈਪ ਨੂੰ ਹਿੱਟ ਕਰਦੇ ਹੋ (HTTP 429)

  • ਜਵਾਬ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈ Retry-After ਸਕਿੰਟਾਂ ਵਿੱਚ
  • Official SDKs 429 ਅਤੇ 5xx 'ਤੇ exponential backoff ਨਾਲ retry ਕਰਦੇ ਹਨ, Retry-After ਨੂੰ honour ਕਰਦੇ ਹੋਏ
  • ਜ਼ਿਆਦਾਤਰ ਕੋਡ ਕਦੇ ਵੀ 429 ਨੂੰ ਹੱਥ ਨਾਲ ਨਹੀਂ ਸੰਭਾਲਦਾ ਕਿਉਂਕਿ SDK ਪਹਿਲਾਂ ਹੀ ਕਰਦਾ ਹੈ
X402 ਅਨੁਕੂਲਤਾ

x402 ਨੂੰ ਧਾਰਾਪੂਰਕ ਬੋਲਦਾ ਹੈ। ਇਹ ਬਿਨਾਂ ਵੀ ਕੰਮ ਕਰਦਾ ਹੈ।

x402 HTTP-ਮੂਲ ਭੁਗਤਾਨਾਂ ਲਈ ਖੁਲਾ ਪ੍ਰੋਟੋਕੋਲ ਹੈ। ਧਾਰਨਾ: ਕੋਈ ਵੀ API ਜੋ 402 ਭੁਗਤਾਨ ਦੀ ਲੋੜ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਵਾਬ ਵਿੱਚ ਭੁਗਤਾਨ ਦੀਆਂ ਲੋੜਾਂ ਦਾ ਪ੍ਰਚਾਰ ਕਰ ਸਕਦਾ ਹੈ, ਅਤੇ ਕੋਈ ਵੀ ਕਲਾਇੰਟ ਜੋ ਵਿਸ਼ੇਸ਼ਤਾ ਨੂੰ ਸਮਝਦਾ ਹੈ, ਭੁਗਤਾਨ ਕਰ ਸਕਦਾ ਹੈ ਅਤੇ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰ ਸਕਦਾ ਹੈ - ਕੋਈ ਸਾਈਨਅਪ, ਕੋਈ API ਕੁੰਜੀ, ਕੋਈ ਬਾਹਰੀ ਮੋਲ-ਤੋਲ ਨਹੀਂ। Blockchain0x ਵਾਸਤਵਿਕ x402 ਪੈਕੇਜ ਭੇਜਦਾ ਹੈ: ਇੱਕ ਭੁਗਤਾਨ-ਪਾਸੇ ਦਾ ਕਲਾਇੰਟ ਅਤੇ ਪ੍ਰਾਪਤ-ਪਾਸੇ ਦੇ ਸਰਵਰ ਐਡਾਪਟਰ। ਅੱਜ ਦਾ ਇੱਕੋ ਹੀ ਯੋਜਨਾ exact-usdc ਹੈ, ਜੋ Base 'ਤੇ ਹੈ।

THE 402 ਜੋ server ਤਦ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜਦੋਂ caller ਨੇ pay ਨਹੀਂ ਕੀਤਾ ਹੁੰਦਾ
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 Base ਲਈ)।
  2. ਇੱਕ payment ਬਣਾਉਂਦਾ ਹੈ ਅਤੇ request ਨੂੰ X-Payment: exact-usdc:<base64(json)> header ਨਾਲ ਦੁਬਾਰਾ ਭੇਜਦਾ ਹੈ।
  3. Pay side 'ਤੇ, @blockchain0x/x402 ਤੋਂ createX402Client({ sdk }) ਇਹ ਕੰਮ ਤੁਹਾਡੇ ਲਈ ਕਰਦਾ ਹੈ - ਇਹ 402s ਦਾ ਆਪਣੇ ਆਪ ਜਵਾਬ ਦਿੰਦਾ ਹੈ।
  4. ਤੁਹਾਡਾ server X-Payment header verify ਕਰਦਾ ਹੈ ਅਤੇ original request fulfill ਕਰਦਾ ਹੈ।

ਦੋਹਾਂ ਪਾਸੇ, ਅਸਲ ਪੈਕੇਜ

ਭੁਗਤਾਨ ਪਾਸੇ, createX402Client({ sdk }) @blockchain0x/x402 ਤੋਂ ਫੈਚ ਨੂੰ ਲਪੇਟਦਾ ਹੈ ਅਤੇ ਆਪਣੇ ਆਪ 402s ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ। ਪ੍ਰਾਪਤ ਪਾਸੇ 'ਤੇ, createX402Plugin (Fastify) ਅਤੇ createX402Middleware (Express) ਆਪਣੇ ਆਪਣੇ ਐਂਡਪੋਇੰਟਸ ਨੂੰ ਗੇਟ ਕਰੋ। ਜਾਂ x402 ਨੂੰ ਛੱਡੋ ਅਤੇ ਸਿੱਧਾ REST API ਵਰਤੋਂ - ਦੋਹਾਂ ਮਿਲਦੇ ਹਨ, ਤਾਂ ਜੋ ਤੁਸੀਂ ਜਦੋਂ ਤਿਆਰ ਹੋਵੋਗੇ ਤਾਂ x402 ਸ਼ਾਮਲ ਕਰ ਸਕਦੇ ਹੋ।

ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ

ਪੰਜ API ਸਵਾਲ ਜੋ ਵਿਕਾਸਕ ਪਹਿਲਾਂ ਪੁੱਛਦੇ ਹਨ।

ਕੀ ਮੈਂ SDK ਦੇ ਬਿਨਾਂ API ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦਾ ਹਾਂ?

ਹਾਂ। SDKs HTTPS over standard JSON ਦੇ ਆਲੇ-ਦੁਆਲੇ bearer-token auth ਵਾਲੀਆਂ ਪਤਲੀਆਂ wrappers ਹਨ। ਜੋ ਕੁਝ HTTP ਅਤੇ HMAC-SHA256 ਬੋਲ ਸਕਦਾ ਹੈ, ਉਹ ਸਿੱਧੀ API ਵਰਤ ਸਕਦਾ ਹੈ। SDKs ergonomic typing, retries, ਅਤੇ idempotency-key generation ਲਈ ਹਨ; ਇਹ ਸੁਵਿਧਾਜਨਕ ਹਨ, ਲਾਜ਼ਮੀ ਨਹੀਂ। ਅਸੀਂ Node, Python, Ruby, Go, ਅਤੇ JVM ਲਈ clients ਭੇਜਦੇ ਹਾਂ; ਕਿਸੇ ਹੋਰ ਭਾਸ਼ਾ ਵਿੱਚ raw API call ਕਰੋ।

ਜੇ ਮੇਰਾ ਵੈਬਹੂਕ ਐਂਡਪੌਇੰਟ ਢਹਿ ਜਾਂਦਾ ਹੈ ਜਦੋਂ ਕੋਈ ਘਟਨਾ ਫਾਇਰ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਕੀ ਹੁੰਦਾ ਹੈ?

ਡਿਲਿਵਰੀਆਂ ਬੈਕਆਫ ਨਾਲ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਦੀਆਂ ਹਨ ਅਤੇ ਹਰ ਕੋਸ਼ਿਸ਼ ਨੂੰ ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਇਸਦੇ HTTP ਜਵਾਬ ਕੋਡ ਨਾਲ ਲੌਗ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਜੇਕਰ ਤੁਸੀਂ ਕਿਸੇ ਇਵੈਂਟ ਨੂੰ ਛੱਡ ਦਿੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ API ਤੋਂ ਮਿਲਾਪ ਕਰ ਸਕਦੇ ਹੋ - GET /v1/transactions/{id} ਨਾਲ id ਦੁਆਰਾ ਲੈਣ-ਦੇਣ ਨੂੰ ਫੈਚ ਕਰੋ - ਨਾ ਕਿ ਸਿਰਫ ਵੈਬਹੂਕ 'ਤੇ ਨਿਰਭਰ ਕਰਨਾ। ਇਸਨੂੰ ਭਰੋਸਾ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਹਰ ਡਿਲਿਵਰੀ ਦੀ ਪੁਸ਼ਟੀ ਕਰੋ webhooks.verify (ਜਾਂ ਦਸਤਾਵੇਜ਼ਿਤ HMAC) ਨਾਲ, ਅਤੇ 2xx ਤੇਜ਼ੀ ਨਾਲ ਜਵਾਬ ਦਿਓ ਤਾਂ ਕਿ ਇੱਕ ਹੌਲੀ ਹੈਂਡਲਰ ਨਾਕਾਮੀ ਵਾਂਗ ਨਾ ਲੱਗੇ।

ਜੇ ਮੇਰਾ ਏਜੰਟ ਨੈੱਟਵਰਕ ਗਲਤੀਆਂ 'ਤੇ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ ਤਾਂ ਮੈਂ ਦੁਹਰਾਏ ਭੁਗਤਾਨਾਂ ਤੋਂ ਕਿਵੇਂ ਬਚਾਂ?

POST 'ਤੇ Idempotency-Key ਹੈਡਰ ਭੇਜੋ। SDK ਵਿੱਚ payments.create ਤੁਹਾਡੇ ਲਈ ਇੱਕ ਸਥਿਰ ਇੱਕ ਆਟੋ-ਮਿੰਟ ਕਰਦਾ ਹੈ, ਇਸ ਲਈ ਇੱਕ ਦੁਬਾਰਾ ਕੀਤੀ ਗਈ ਕਾਲ ਇੱਕ ਸਿੰਗਲ ਓਨ-ਚੇਨ ਜਮ੍ਹਾਂ ਵਿੱਚ ਸਹੀ ਹੁੰਦੀ ਹੈ ਬਜਾਏ ਦੋ ਵਾਰੀ ਭੁਗਤਾਨ ਕਰਨ ਦੇ। ਜਦੋਂ ਤੁਸੀਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਇੱਕੋ ਲਾਜਿਕਲ ਓਪਰੇਸ਼ਨ ਨੂੰ ਡਿਡੂਪ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਇਸਨੂੰ ਆਪਣੀ ਕੁੰਜੀ ਨਾਲ ਓਵਰਰਾਈਡ ਕਰੋ। ਕੁੰਜੀ ਉਸ ਮਾਮਲੇ ਲਈ ਸੁਰੱਖਿਆ ਜਾਲ ਹੈ ਜਿੱਥੇ ਤੁਹਾਡਾ ਏਜੰਟ ਜਾਂ ਨੈੱਟਵਰਕ ਮਿਡ-ਫਲਾਈਟ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ।

ਕੀ ਕੋਈ ਦਰ ਦਰਜ ਹੈ?

ਹਾਂ, ਅਤੇ ਇਹ ਤੁਹਾਡੇ plan ਦੇ ਨਾਲ scale ਕਰਦਾ ਹੈ। ਬਦਲਦੇ numbers ਨੂੰ hard-code ਕਰਨ ਦੀ ਬਜਾਏ, response ਤੋਂ ਉਹਨਾਂ ਨੂੰ read ਕਰੋ: ਹਰ call X-RateLimit-Limit, X-RateLimit-Remaining, ਅਤੇ X-RateLimit-Reset ਵਾਪਸ ਕਰਦੀ ਹੈ, ਅਤੇ 429 ਵਿੱਚ Retry-After seconds ਵਿੱਚ ਹੁੰਦਾ ਹੈ। official SDKs ਪਹਿਲਾਂ ਹੀ 429 ਅਤੇ 5xx 'ਤੇ exponential backoff ਨਾਲ retry ਕਰਦੀਆਂ ਹਨ ਅਤੇ Retry-After ਨੂੰ honour ਕਰਦੀਆਂ ਹਨ, ਇਸ ਲਈ ਜ਼ਿਆਦਾਤਰ code ਨੂੰ ਇਹ ਹੱਥੋਂ handle ਨਹੀਂ ਕਰਨਾ ਪੈਂਦਾ।

ਕੀ ਇਹ x402-ਅਨੁਕੂਲ ਹੈ?

ਹਾਂ। x402 ਪੈਕੇਜ ਸੱਚਮੁੱਚ ਹਨ: createX402Client({ sdk }) @blockchain0x/x402 ਤੋਂ ਭੁਗਤਾਨ ਪਾਸੇ 'ਤੇ 402 ਚੁਣੌਤੀਆਂ ਦਾ ਜਵਾਬ ਦਿੰਦਾ ਹੈ, ਅਤੇ createX402Plugin (Fastify) / createX402Middleware (Express) ਤੁਹਾਡੇ ਆਪਣੇ ਐਂਡਪੋਇੰਟਸ ਨੂੰ ਪ੍ਰਾਪਤ ਪਾਸੇ 'ਤੇ ਗੇਟ ਕਰਦਾ ਹੈ। ਅੱਜ ਦਾ ਇਕੱਲਾ ਸਕੀਮ exact-usdc ਹੈ, ਅਤੇ ਵਾਇਰ ਫਾਰਮੈਟ ਇੱਕ X-Payment ਹੈ: exact-usdc:<base64(json)> ਬੇਨਤੀ ਹੈਡਰ 402 ਦੇ ਖਿਲਾਫ ਜਿਸਦਾ ਸ਼ਰੀਰ ਵਰਜਨ 1 ਅਤੇ accepts[] ਸੂਚੀ ਦਾ ਵਿਗਿਆਨ ਕਰਦਾ ਹੈ। ਤੁਸੀਂ x402 ਨੂੰ ਅਣਡਿੱਠਾ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਸਿੱਧਾ REST API ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।

ਤੁਹਾਡਾ ਪਹਿਲਾ ਭੁਗਤਾਨ ਭੇਜੋ।

ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਮੁਫਤ। API ਕੁੰਜੀ ਤੋਂ ਤੁਹਾਡੇ ਪਹਿਲੇ USDC ਟ੍ਰਾਂਸਫਰ ਤੱਕ ਕੁਝ ਲਾਈਨਾਂ।