ಪ್ರಮುಖ ವಿಷಯಕ್ಕೆ ಬಿಟ್ಟುಬಿಡಿ
ಪಾವತಿ API

AI ಏಜೆಂಟ್ ಕೋಡ್‌ಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ ಪಾವತಿ API.

A small REST API. Signed webhooks. ಐದು ಭಾಷೆಗಳಲ್ಲಿ ಅಧಿಕೃತ SDKಗಳು. ನಿಮ್ಮ ಏಜೆಂಟ್ USDC ಅನ್ನು ಕಳುಹಿಸಲು ಮತ್ತು ನಿಗದಿತಗೊಳಿಸಲು ಮತ್ತು ಕೆಲವು ಕೋಡ್ ಸಾಲುಗಳಲ್ಲಿ ಪಾವತಿಗಳನ್ನು ಪರಿಶೀಲಿಸಲು ನಿರ್ಮಿಸಲಾಗಿದೆ.

ವ್ಯವಹಾರಗಳ ದೃಶ್ಯ: Base ನಲ್ಲಿ ದೃಢೀಕರಿಸಲಾದ ಬರುವ USDC ಪಾವತಿಗಳು

Blockchain0x API ಉದ್ದೇಶಪೂರ್ವಕವಾಗಿ ಚಿಕ್ಕದಾಗಿದೆ. ನಿಮ್ಮ ಮೊದಲ payment ಮಾಡಲು ನೀವು ಒಂದು ಗಂಟೆ documentation ಓದಬೇಕೆಂದು ನಾವು ಬಯಸುವುದಿಲ್ಲ. ನೀವು ಒಂದು snippet copy ಮಾಡಿ, ನಿಮ್ಮ API key paste ಮಾಡಿ, ಮತ್ತು ಅದನ್ನು run ಮಾಡಬೇಕು ಎಂದು ನಾವು ಬಯಸುತ್ತೇವೆ.

ಮೂಲ ENDPOINTS

ಏಜೆಂಟ್ ಕೋಡ್‌ಗಾಗಿ ನಿರ್ಮಿತ ಒಂದು ಸಣ್ಣ ಮೇಲ್ಮೈ.

ಪಾವತಿ-ಆಕಾರದ 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ಏಜೆಂಟ್ ವಾಲೆಟ್ ಅನ್ನು ರಚಿಸಿ
ship ಮಾಡಲಾದ webhook events

ಎಲ್ಲಾ HMAC-SHA256 ಮೂಲಕ ಸಹಿ ಮಾಡಲಾಗಿದೆ.

ಹಸ್ತಾಕ್ಷರದಲ್ಲಿ X-Blockchain0x-Signature ಶೀರ್ಷಿಕೆ. 5 ನಿಮಿಷಗಳ ಪುನರಾವೃತ್ತ ಕಿಟಕಿ. ಪ್ರತಿಯೊಂದು ಪೋಸ್ಟ್‌ನಲ್ಲಿ ಐಡೆಂಪೊಟೆನ್ಸಿ ಕೀಗಳು.

payment.received

USDC ನಿಮ್ಮ ಏಜೆಂಟ್ ವಾಲೆಟ್ಗಳಲ್ಲಿ ಒಂದರಲ್ಲಿ ನೆಲೆಸಿತು

payment.sent

ನಿಮ್ಮ ಏಜೆಂಟ್‌ನಿಂದ ಹೊರಹೋಗುವ ಪಾವತಿ ಶ್ರೇಣಿಯಲ್ಲಿ ನಿಗಮವಾಯಿತು

wallet.deployed

ಏಜೆಂಟ್‌ನ ಸ್ಮಾರ್ಟ್ ವಾಲೆಟ್ ನಿಯೋಜಿಸಲಾಯಿತು

webhook.test

ನೀವು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಿಂದ ಪ್ರೇರಿತವಾದ ಪರೀಕ್ಷಾ ವಿತರಣಾ

ಕೆಲವೇ ಸಾಲುಗಳು

ನಿಮ್ಮ ಏಜೆಂಟ್‌ನ ವಾಲೆಟ್‌ನಿಂದ USDC ಕಳುಹಿಸಿ.

ಪೈಥಾನ್
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 ಪ್ರಕಾರಗಳು.

ಪೈಥಾನ್
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}

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 ಮೂಲಕ ಓದಲು ಮಾತ್ರ - ಸೃಷ್ಟಿ ಮತ್ತು ಬದಲಾವಣೆಗಳು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್-ಮಾತ್ರ.

ಕೋರಿಕೆ
(no body)
ಪ್ರತಿಕ್ರಿಯೆ
{
  "allowance_wei": "5000000",
  "per_tx_wei": "1000000",
  "period_seconds": 86400,
  "start_at": "2026-05-15T00:00:00Z",
  "revoked_at": null
}
ವೆಬ್‌ಹುಕ್ ಕೈಹಾಕುವಿಕೆ ಪರಿಶೀಲನೆ

ಪೇಲೋಡ್ ಅನ್ನು ನಂಬುವ ಮೊದಲು ಸಹಿ ಪರಿಶೀಲಿಸಿ.

ಯಾರಾದರೂ ನಿಮ್ಮ ಕallback URL ಗೆ ಪೋಸ್ಟ್ ಮಾಡಬಹುದು. ಸಹಿ ಎಂದರೆ ಈ ಘಟನೆ ವಾಸ್ತವವಾಗಿ ನಮ್ಮಿಂದ ಬಂದಿದೆ ಎಂದು ತೋರಿಸುತ್ತದೆ.

ಪ್ರತಿ ಡೆಲಿವರಿ ಒಯ್ಯುತ್ತದೆ X-Blockchain0x-Signature ಹೆಡರ್ (t=<unix>,v1=<hex>) - ನಿಮ್ಮ ವೆಬ್‌ಹುಕ್ ಗುಪ್ತಚರದೊಂದಿಗೆ `${t}.${rawBody}` ಸ್ಟ್ರಿಂಗ್‌ನ ಮೇಲೆ HMAC-SHA256, 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");
});
ಪೈಥಾನ್ (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 ಅನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ, ಮತ್ತು ನಿಮ್ಮ 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 ಮಾಡಿ, ಉಳಿದವುಗಳನ್ನು ನಿರ್ಲಕ್ಷಿಸಿ.

ಐಡೆಂಪೊಟೆನ್ಸಿ

ಸುರಕ್ಷಿತವಾಗಿ ಪುನರಾವೃತ್ತ ಮಾಡಿ. API ಎರಡು ಬಾರಿ ಪಾವತಿಸುವುದಿಲ್ಲ.

ಏಜೆಂಟ್ ಕೋಡ್ ಪುನರಾವೃತ್ತಗಳು. ನೆಟ್ವರ್ಕ್ ಸಂಪರ್ಕಗಳನ್ನು ಬಿಟ್ಟುಬಿಡುತ್ತದೆ. LLM ಗಳು ಸಾಧನವನ್ನು ಎರಡು ಬಾರಿ ಕರೆ ಮಾಡಲು ನಿರ್ಧಾರಿಸುತ್ತವೆ. ಇದನ್ನು ಸುರಕ್ಷಿತವಾಗಿಡಲು, ಕಳುಹಿಸಿ 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 ಅನ್ನು ಮಿಂಟ್ಸ್ ಮಾಡುತ್ತದೆ, ಆದ್ದರಿಂದ ಪುನರಾವೃತ್ತ ಕರೆ ಬಾಕ್ಸ್‌ನಿಂದ ಸುರಕ್ಷಿತವಾಗಿದೆ.
  • ಅದರ ಮೇಲೆ ಮೀರಿಸಿ: ನೀವು ಪ್ರಕ್ರಿಯೆಗಳ ನಡುವೆ ಒಂದೇ ತಾರ್ಕಿಕ ಕಾರ್ಯವನ್ನು ಡಿಡ್ಯೂಪ್ ಮಾಡಲು ಬಯಸಿದಾಗ ನಿಮ್ಮದೇ ಆದ ಕೀ ಅನ್ನು ಒದಗಿಸಿ.

ನಿಮ್ಮ ಏಜೆಂಟ್ ಕೋಡ್‌ನಲ್ಲಿ ಪ್ರತಿ ತಾರ್ಕಿಕ ಕಾರ್ಯಕ್ಕಾಗಿ UUID ಅನ್ನು ಉತ್ಪಾದಿಸಲು ಶಿಫಾರಸು ಮಾಡಲಾದ ಮಾದರಿಯು (ಉದಾಹರಣೆಗೆ, "ಆರ್ಡರ್ Y ಗೆ ವENDOR X ಗೆ ಪೇ" ಗೆ ಒಂದು UUID) ಮತ್ತು ಕಾರ್ಯ ಯಶಸ್ವಿಯಾಗುವವರೆಗೆ ಪುನರಾವೃತ್ತಗಳಲ್ಲಿ ಅದನ್ನು ಪುನಃ ಬಳಸುವುದು. ನೀವು ಅದನ್ನು ನಿರ್ಧರಿಸದಿದ್ದರೆ ಅಧಿಕೃತ SDK ಗಳು payments.create ಗೆ ಒಂದು UUID ಅನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಉತ್ಪಾದಿಸುತ್ತವೆ.

ಮಿತಿಗಳನ್ನು ಮಿತಿಯಿಡಿ

ನಿಮ್ಮ ಮಿತಿಯನ್ನು ಪ್ರತಿಕ್ರಿಯೆಯಿಂದ ಓದಿ, ಟೇಬಲ್ ಅಲ್ಲ.

ನಿಮ್ಮ ಯೋಜನೆಯೊಂದಿಗೆ ಮಿತಿಗಳನ್ನು ವಿಸ್ತಾರಗೊಳಿಸುತ್ತದೆ. ಸಂಖ್ಯೆಗಳ ಕಠಿಣ ಕೋಡ್ ಬದಲಾಗಿ, ಪ್ರತಿಯೊಂದು ಪ್ರತಿಸ್ಪಂದನವು ನೀವು ಎಲ್ಲಿದ್ದೀರಿ ಎಂದು ಹೇಳುತ್ತದೆ ಮತ್ತು SDK ಗಳು ನಿಮ್ಮಿಗಾಗಿ ಹಿಂತಿರುಗಿಸುತ್ತವೆ.

ಪ್ರತಿಯೊಂದು ಯಶಸ್ವಿ ಪ್ರತಿಸ್ಪಂದನದಲ್ಲಿ ಶೀರ್ಷಿಕೆಗಳು

  • X-RateLimit-Limit: ನಿಮ್ಮ ಯೋಜನೆಯ ಸ್ಥಿರ ದರ
  • X-RateLimit-Remaining: ಈ ಕಿಟಕಿಯಲ್ಲಿ ಎಷ್ಟು ಕರೆಗಳು ಉಳಿದಿವೆ
  • X-RateLimit-Reset: ಕಿಟಕಿ ಪುನರಾರಂಭವಾಗುವಾಗ ಯುನಿಕ್ಸ್ ಸೆಕೆಂಡುಗಳು

ನೀವು ಕ್ಯಾಪ್ ಅನ್ನು ತಲುಪಿದಾಗ (HTTP 429)

  • ಪ್ರತಿಕ್ರಿಯೆ ಒಳಗೊಂಡಿದೆ Retry-After ಸೆಕೆಂಡುಗಳಲ್ಲಿ
  • official SDKs 429 ಮತ್ತು 5xx ಗಳಲ್ಲಿ exponential backoff ಸಹಿತ retry ಮಾಡುತ್ತವೆ, Retry-After ಅನ್ನು ಗೌರವಿಸುತ್ತವೆ
  • ಬಹಳಷ್ಟು ಕೋಡ್ 429 ಅನ್ನು ಕೈಯಿಂದ ನಿರ್ವಹಿಸುತ್ತಿಲ್ಲ ಏಕೆಂದರೆ SDK ಈಗಾಗಲೇ ಮಾಡುತ್ತದೆ
X402 ಹೊಂದಾಣಿಕೆ

x402 ಅನ್ನು ಧಾರ್ಮಿಕವಾಗಿ ಮಾತನಾಡುತ್ತದೆ. ಇದಿಲ್ಲದೆ ಸಹ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

x402 HTTP-ಸ್ಥಾನೀಯ ಪಾವತಿಗಳಿಗೆ ತೆರೆಯುವ ಪ್ರೋಟೋಕಾಲ್. ಆಧಾರ: 402 ಪಾವತಿ ಅಗತ್ಯವಿದೆ ಅನ್ನು ಹಿಂತಿರುಗಿಸುವ ಯಾವುದೇ API ಪ್ರತಿಕ್ರಿಯೆಯಲ್ಲಿ ಪಾವತಿ ಅಗತ್ಯಗಳನ್ನು ಜಾಹೀರಾತು ಮಾಡಬಹುದು, ಮತ್ತು ನಿರ್ದಿಷ್ಟವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವ ಯಾವುದೇ ಕ್ಲೈಂಟ್ ಪಾವತಿಸಬಹುದು ಮತ್ತು ಪುನರಾವೃತ್ತ ಮಾಡಬಹುದು - ಯಾವುದೇ ಸೈನ್ ಅಪ್, ಯಾವುದೇ API ಕೀ, ಯಾವುದೇ ಔಟ್-ಆಫ್-ಬ್ಯಾಂಡ್ ಒಪ್ಪಂದವಿಲ್ಲ. Blockchain0x ವಾಸ್ತವ x402 ಪ್ಯಾಕೇಜ್‌ಗಳನ್ನು ಸಾಗಿಸುತ್ತದೆ: ಪಾವತಿ-ಬದಿಯ ಕ್ಲೈಂಟ್ ಮತ್ತು ಸ್ವೀಕರಿಸುವ-ಬದಿಯ ಸರ್ವರ್ ಅಡಾಪ್ಟರ್‌ಗಳು. ಇಂದು ಏಕೈಕ ಯೋಜನೆಯು exact-usdc, Base ನಲ್ಲಿ.

CALLER pay ಮಾಡದಿದ್ದಾಗ server return ಮಾಡುವ 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 ನ ಖಾಲಿಯಲ್ಲದ accepts[] (scheme exact-usdc, network Base ಗಾಗಿ eip155:8453).
  2. ಒಂದು payment ಅನ್ನು build ಮಾಡಿ ಮತ್ತು X-Payment: exact-usdc:<base64(json)> header ಜೊತೆಗೆ request ಅನ್ನು ಮರುಕಳುಹಿಸುತ್ತದೆ.
  3. pay side ನಲ್ಲಿ, @blockchain0x/x402 ನ createX402Client({ sdk }) ಇದನ್ನು ನಿಮಗಾಗಿ ಮಾಡುತ್ತದೆ - ಇದು 402 ಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಉತ್ತರಿಸುತ್ತದೆ.
  4. ನಿಮ್ಮ server X-Payment header ಅನ್ನು ಪರಿಶೀಲಿಸಿ ಮೂಲ request ಅನ್ನು ಪೂರ್ಣಗೊಳಿಸುತ್ತದೆ.

ಎರಡು ಬದಿಗಳು, ವಾಸ್ತವ ಪ್ಯಾಕೇಜ್‌ಗಳು

ಪಾವತಿ ಬದಿಯಲ್ಲಿ, createX402Client({ sdk }) @blockchain0x/x402 fetch ಅನ್ನು ಲಿಪ್ತಗೊಳಿಸುತ್ತದೆ ಮತ್ತು 402ಗಳಿಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಉತ್ತರಿಸುತ್ತದೆ. ಸ್ವೀಕರಿಸುವ ಭಾಗದಲ್ಲಿ, createX402Plugin (Fastify) ಮತ್ತು createX402Middleware (Express) ನಿಮ್ಮದೇ ಆದ ಎಂಡ್ಪಾಯಿಂಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಿ. ಅಥವಾ x402 ಅನ್ನು ಬಿಟ್ಟು REST API ಅನ್ನು ನೇರವಾಗಿ ಬಳಸಿರಿ - ಇವು ಎರಡು ಸೇರಿವೆ, ಆದ್ದರಿಂದ ನೀವು ನೀವು ಸಿದ್ಧವಾಗಿರುವಾಗ x402 ಅನ್ನು ಸೇರಿಸಬಹುದು.

ಅತ್ಯಂತ ಕೇಳುವ

ದೇವನಿಯರು ಮೊದಲಿಗೆ ಕೇಳುವ ಐದು API ಪ್ರಶ್ನೆಗಳು.

ನಾನು SDK ಇಲ್ಲದೆ API ಅನ್ನು ಬಳಸಬಹುದೆ?

ಹೌದು. SDKಗಳು bearer-token auth ಹೊಂದಿರುವ HTTPS ಮೇಲಿನ standard JSON ನ thin wrappers ಮಾತ್ರ. HTTP ಮತ್ತು HMAC-SHA256 ಮಾತನಾಡಬಲ್ಲ ಯಾವುದಾದರೂ API ಅನ್ನು ನೇರವಾಗಿ ಬಳಸಬಹುದು. SDKಗಳು ergonomic typing, retries, ಮತ್ತು idempotency-key generation ಗಾಗಿ ಇವೆ; ಅವು ಉಪಯುಕ್ತ, ಅಗತ್ಯವಲ್ಲ. ನಾವು Node, Python, Ruby, Go, ಮತ್ತು JVM ಗಾಗಿ clients ಅನ್ನು ship ಮಾಡುತ್ತೇವೆ; ಇತರ ಯಾವುದೇ ಭಾಷೆಯಲ್ಲಿ raw API ಅನ್ನು ಕರೆಮಾಡಿ.

ಘಟನೆ ಉಲ್ಲೇಖಿಸುವಾಗ ನನ್ನ ವೆಬ್‌ಹುಕ್ ಎಂಡ್ಪಾಯಿಂಟ್ ಡೌನ್ ಆಗಿದ್ದರೆ ಏನಾಗುತ್ತದೆ?

ಡೆಲಿವರಿ ಪುನರಾವೃತ್ತವನ್ನು ಹಿಂಬಾಲಿಸುತ್ತವೆ ಮತ್ತು ಪ್ರತಿ ಪ್ರಯತ್ನವು ಡ್ಯಾಶ್‌ಬೋರ್ಡ್‌ನಲ್ಲಿ ಅದರ HTTP ಪ್ರತಿಕ್ರಿಯಾ ಕೋಡ್‌ನೊಂದಿಗೆ ಲಾಗ್ ಮಾಡಲಾಗುತ್ತದೆ. ನೀವು ಒಂದು ಘಟನೆ ತಪ್ಪಿದರೆ, ನೀವು API ಯಿಂದ ಪುನಃ ಸಮಾನೀಕರಣ ಮಾಡಬಹುದು - GET /v1/transactions/{id} ಮೂಲಕ id ಮೂಲಕ ವ್ಯವಹಾರವನ್ನು ಪಡೆಯಿರಿ - ವೆಬ್‌ಹುಕ್‌ಗೆ ಮಾತ್ರ ಅವಲಂಬಿತವಾಗುವುದಿಲ್ಲ. ನೀವು ಅದನ್ನು ನಂಬುವ ಮೊದಲು webhooks.verify (ಅಥವಾ ದಾಖಲೆಗೊಳಿಸಿದ HMAC) ನೊಂದಿಗೆ ಪ್ರತಿಯೊಂದು ಡೆಲಿವರಿಯನ್ನು ದೃಢೀಕರಿಸಿ, ಮತ್ತು ನಿಧಾನವಾದ ಹ್ಯಾಂಡ್ಲರ್ ವಿಫಲವಾಗದಂತೆ 2xx ಅನ್ನು ಶೀಘ್ರವಾಗಿ ಪ್ರತಿಸ್ಪಂದಿಸಿ.

ನನ್ನ ಏಜೆಂಟ್ ನೆಟ್‌ವರ್ಕ್ ದೋಷಗಳ ಮೇಲೆ ಪುನರಾವೃತ್ತವಾದರೆ ನಾನು ನಕಲಿ ಪಾವತಿಗಳನ್ನು ಹೇಗೆ ತಡೆಯುತ್ತೇನೆ?

POST ನಲ್ಲಿ Idempotency-Key ಹೆಡರ್ ಅನ್ನು ಕಳುಹಿಸಿ. SDK ನಲ್ಲಿ payments.create ನಿಮ್ಮಿಗಾಗಿ ಸ್ಥಿರವಾದದ್ದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ನಿರ್ಮಿಸುತ್ತದೆ, ಆದ್ದರಿಂದ ಪುನರಾವೃತ್ತವಾದ ಕರೆ ಎರಡು ಬಾರಿ ಪಾವತಿಸುವ ಬದಲು ಒಂದೇ ಆನ್-ಚೈನ್ ಸಲ್ಲಿಕೆಗೆ ಕುಸಿಯುತ್ತದೆ. ನೀವು ಪ್ರಕ್ರಿಯೆಗಳಾದ್ಯಂತ ಒಂದೇ ತಾರ್ಕಿಕ ಕಾರ್ಯವನ್ನು ಡಿಡ್ಯೂಪ್ ಮಾಡಲು ಬಯಸಿದಾಗ ನಿಮ್ಮದೇ ಆದ ಕೀ ಮೂಲಕ ಅದನ್ನು ಮೀರಿಸಿ. ಕೀ ನಿಮ್ಮ ಏಜೆಂಟ್ ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಮಧ್ಯೆ ಪುನರಾವೃತ್ತವಾದಾಗ ಖಚಿತವಾಗಿ ಇರುವ ಪ್ರಕರಣಕ್ಕಾಗಿ ಸುರಕ್ಷತಾ ನೆಟ್.

ಏನಾದರೂ ದರ ಮಿತಿ ಇದೆಯೆ?

ಹೌದು, ಮತ್ತು ಇದು ನಿಮ್ಮ plan ಜೊತೆಗೆ scale ಆಗುತ್ತದೆ. ತಪ್ಪಿಹೋಗುವ ಸಂಖ್ಯೆಗಳನ್ನು hard-code ಮಾಡುವ ಬದಲು response ನಿಂದಲೇ ಓದಿ: ಪ್ರತಿಯೊಂದು call X-RateLimit-Limit, X-RateLimit-Remaining, ಮತ್ತು X-RateLimit-Reset ಅನ್ನು ಮರಳಿಸುತ್ತದೆ, ಮತ್ತು 429 ನಲ್ಲಿ Retry-After seconds ನಲ್ಲಿ ಇರುತ್ತದೆ. ಅಧಿಕೃತ SDKಗಳು ಈಗಾಗಲೇ 429 ಮತ್ತು 5xx ಮೇಲೆ exponential backoff ಜೊತೆಗೆ retry ಮಾಡುತ್ತವೆ ಮತ್ತು Retry-After ಅನ್ನು ಗೌರವಿಸುತ್ತವೆ, ಆದ್ದರಿಂದ ಹೆಚ್ಚಿನ code ಇದನ್ನು ಕೈಯಾರೆ handle ಮಾಡುವ ಅಗತ್ಯವಿಲ್ಲ.

ಇದು x402-ಅನುಕೂಲಕರವೇ?

ಹೌದು. x402 packages ನಿಜವಾಗಿವೆ: @blockchain0x/x402 ನಿಂದ createX402Client({ sdk }) pay side ನಲ್ಲಿ 402 challenges ಗಳಿಗೆ ಉತ್ತರಿಸುತ್ತದೆ, ಮತ್ತು createX402Plugin (Fastify) / createX402Middleware (Express) ನಿಮ್ಮ own endpoints ಅನ್ನು receive side ನಲ್ಲಿ gate ಮಾಡುತ್ತವೆ. ಈಗಿನ ಏಕೈಕ scheme exact-usdc ಆಗಿದೆ, ಮತ್ತು wire format ಎಂದರೆ version 1 ಮತ್ತು accepts[] list ಅನ್ನು body ಯಲ್ಲಿ ತೋರಿಸುವ 402 ಗೆ ವಿರುದ್ಧವಾಗಿ X-Payment: exact-usdc:<base64(json)> request header. ನೀವು x402 ಅನ್ನು ಬಿಟ್ಟು ನೇರವಾಗಿ REST API ಯನ್ನೂ ಬಳಸಬಹುದು.

ನಿಮ್ಮ ಮೊದಲ ಪಾವತಿಯನ್ನು ಸಾಗಿಸಿ.

ಆರಂಭಿಸಲು ಉಚಿತ. API ಕೀದಿಂದ ನಿಮ್ಮ ಮೊದಲ USDC ವರ್ಗಾವಣೆಗಾಗಿ ಕೆಲವು ಸಾಲುಗಳು.