ਮੁੱਖ ਸਮੱਗਰੀ 'ਤੇ ਜਾਓ
ਪ੍ਰਸੰਨਾ 2 ਵੈਰੀਐਂਟ - API ਪ੍ਰਦਾਤਾ

ਆਪਣਾ API AI ਏਜੰਟਾਂ ਨੂੰ ਵੇਚੋ।

AI ਏਜੰਟ ਕ੍ਰੈਡਿਟ ਕਾਰਡ ਫਾਰਮ ਭਰ ਨਹੀਂ ਸਕਦੇ। ਉਹ ਤੁਹਾਨੂੰ USDC ਵਿੱਚ ਭੁਗਤਾਨ ਕਰ ਸਕਦੇ ਹਨ। Blockchain0x ਉਹ ਇੱਕ API ਕਾਲ ਕਰਦਾ ਹੈ।

ਦੁੱਖ

ਤੁਹਾਡੀ API ਮਨੁੱਖਾਂ ਲਈ ਡਿਜ਼ਾਈਨ ਕੀਤੀ ਗਈ ਸੀ। ਤੁਹਾਡੇ ਕਾਲ ਕਰਨ ਵਾਲੇ ਹੁਣ ਏਜੰਟ ਹਨ।

API ਆਮਦਨ ਦਾ ਅਗਲਾ ਦਹਾਕਾ ਮਨੁੱਖੀ ਸਾਈਨਅਪ ਤੋਂ ਨਹੀਂ ਆਵੇਗਾ। ਇਹ AI ਏਜੰਟਾਂ ਦੁਆਰਾ ਉਨ੍ਹਾਂ ਦੇ ਉਪਭੋਗਤਾਵਾਂ ਦੀ ਵਤੀਰੇ APIs ਨੂੰ ਕਾਲ ਕਰਨ ਤੋਂ ਆਵੇਗਾ, ਅਕਸਰ ਪ੍ਰੋਗਰਾਮੈਟਿਕ ਅਤੇ ਕਿਸੇ ਵੀ ਮਨੁੱਖ ਦੇ ਲੂਪ ਤੋਂ ਬਿਨਾਂ। ਉਹ ਏਜੰਟ ਤੁਹਾਡੇ ਮੌਜੂਦਾ ਚੈਕਆਉਟ ਨੂੰ ਵਰਤ ਨਹੀਂ ਸਕਦੇ। ਉਹ ਕ੍ਰੈਡਿਟ ਕਾਰਡ ਫਾਰਮ ਭਰ ਨਹੀਂ ਸਕਦੇ, ਖਾਤਾ ਨਹੀਂ ਬਣਾ ਸਕਦੇ, ਪੁਸ਼ਟੀਕਰਨ ਈਮੇਲ 'ਤੇ ਕਲਿਕ ਨਹੀਂ ਕਰ ਸਕਦੇ, ਪਾਸਵਰਡ ਯਾਦ ਨਹੀਂ ਕਰ ਸਕਦੇ।

ਉਹ ਜੋ ਕਰ ਸਕਦੇ ਹਨ ਉਹ ਹੈ 402 Payment Required response ਪੜ੍ਹਨਾ, JSON body ਤੋਂ USDC amount ਅਤੇ recipient parse ਕਰਨਾ, Base 'ਤੇ pay ਕਰਨਾ, ਅਤੇ proof of payment ਨਾਲ call ਮੁੜ issue ਕਰਨਾ। ਇਹ agent-driven API commerce ਦਾ ਪੂਰਾ ਢਾਂਚਾ ਹੈ। Cost model (stablecoin ਵਿੱਚ per-call billing) ਵੀ card-based subscriptions ਨਾਲੋਂ agent usage pattern ਨਾਲ ਕਾਫੀ ਵਧੀਆ fit ਕਰਦਾ ਹੈ: cards $1 ਤੋਂ ਘੱਟ transactions 'ਤੇ fail ਹੋ ਜਾਂਦੇ ਹਨ; Base ਉੱਤੇ USDC gas ਵਿੱਚ ਕੁਝ cents ਲੈਂਦਾ ਹੈ; machines ਦੇ ਵਿਚਕਾਰ chargebacks ਨਹੀਂ ਹੁੰਦੇ।

Blockchain0x ਪੁਲ ਹੈ। ਕੀਮਤਾਂ ਦੀ ਟੇਬਲ ਵਿੱਚ ਉਹ ਰੂਟ ਸੂਚੀਬੱਧ ਕਰੋ ਜਿਨ੍ਹਾਂ ਲਈ ਤੁਸੀਂ ਚਾਰਜ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਅਤੇ x402 ਐਡਾਪਟਰ ਨੂੰ ਮਾਊਂਟ ਕਰੋ। ਜਦੋਂ ਇੱਕ ਬਿਨਾਂ ਭੁਗਤਾਨ ਵਾਲੀ ਕਾਲ ਇੱਕ ਕੀਮਤ ਵਾਲੇ ਰੂਟ 'ਤੇ ਪਹੁੰਚਦੀ ਹੈ, ਤਾਂ ਐਡਾਪਟਰ ਇੱਕ 402 ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੋ ਬਿਲਕੁਲ ਇਹ ਦੱਸਦਾ ਹੈ ਕਿ ਕੀ ਭੁਗਤਾਨ ਕਰਨਾ ਹੈ। ਏਜੰਟ Base 'ਤੇ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ ਅਤੇ X-Payment ਹੈਡਰ ਨਾਲ ਮੁੜ ਕੋਸ਼ਿਸ਼ ਕਰਦਾ ਹੈ; ਐਡਾਪਟਰ ਇਸਨੂੰ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਡਾ ਹੈਂਡਲਰ ਚਲਦਾ ਹੈ। ਤੁਸੀਂ USDC ਇਕੱਠਾ ਕਰਦੇ ਹੋ ਅਤੇ ਆਪਣਾ API ਪਹਿਲਾਂ ਵਾਂਗ ਚਲਾਉਂਦੇ ਹੋ। ਤੁਹਾਡੇ ਕਾਰੋਬਾਰ ਦੀ ਤਰਕ ਵਿੱਚ ਕੁਝ ਵੀ ਬਦਲਦਾ ਨਹੀਂ; ਬਿਲਿੰਗ ਪਰਤ ਨਾਲ ਨਾਲ ਚਲਦੀ ਹੈ।

402 ਭੁਗਤਾਨ ਦੀ ਲੋੜ ਹੈ

HTTP ਸਟੇਟਸ ਕੋਡ ਆਖਿਰਕਾਰ ਇੱਕ ਵਰਤੋਂ ਹੈ.

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.

ਜਦੋਂ ਕਿਸੇ call ਦੀ payment ਨਹੀਂ ਹੋਈ ਹੁੰਦੀ, ਤੁਹਾਡੀ API ਇਹ 402 body ਵਾਪਸ ਕਰਦੀ ਹੈ
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
    }
  ]
}

accepts[] requirement ਦਾ ਕੀ ਮਤਲਬ ਹੈ

  • ਯੋਜਨਾ - ਭੁਗਤਾਨ ਯੋਜਨਾ. exact-usdc ਦਾ ਮਤਲਬ ਹੈ EVM ਚੇਨ 'ਤੇ ਇੱਕ ਸਹੀ USDC ਰਕਮ. ਗਾਹਕ ਭੁਗਤਾਨ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਇਸ 'ਤੇ ਮੇਲ ਖਾਂਦਾ ਹੈ.
  • ਨੈੱਟਵਰਕ / ਚੇਨ ਆਈਡੀ - ਜਿਸ ਚੇਨ 'ਤੇ ਸਮਾਪਤ ਕਰਨਾ ਹੈ (ਮੁੱਖ ਨੈੱਟ ਬੇਸ ਹੈ, CAIP-2 eip155:8453). ਇੱਕ ਮਾਈਗ੍ਰੇਸ਼ਨ ਦੋ ਨੈੱਟਵਰਕਾਂ ਨੂੰ accepts ਵਿੱਚ ਦੋ ਲੋੜਾਂ ਦੀ ਸੂਚੀ ਦੇ ਕੇ ਉਨ੍ਹਾਂ ਦਾ ਉਲਲੇਖ ਕਰ ਸਕਦੀ ਹੈ.
  • payToAddress / amountWeiUsdc - ਪ੍ਰਾਪਤਕਰਤਾ ਵਾਲਿਟ ਅਤੇ USDC ਬੇਸ ਯੂਨਿਟਾਂ ਵਿੱਚ ਸਹੀ ਰਕਮ (500000 = 0.50 USDC, 6 ਦਸ਼ਮਲਵ). ਗਾਹਕ ਭੁਗਤਾਨ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਦੋਹਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ.
  • paymentRequestId - ਭੁਗਤਾਨ ਨੂੰ ਇਸ ਉਲਲੇਖ ਨਾਲ ਜੋੜਦਾ ਹੈ. ਐਡਾਪਟਰ ਇੱਕ X-Payment ਨੂੰ ਰੱਦ ਕਰਦਾ ਹੈ ਜੋ ਉਸ ਰੂਟ ਨਾਲ ਵੱਖਰੇ paymentRequestId ਦਾ ਉਲਲੇਖ ਕਰਦਾ ਹੈ.
  • maxAgeSeconds - ਭੁਗਤਾਨ ਕਿੰਨਾ ਨਵਾਂ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ. ਇਸ ਖਿੜਕੀ ਤੋਂ ਪੁਰਾਣਾ ਭੁਗਤਾਨ ਰੱਦ ਕਰ ਦਿੱਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕਾਲ ਕਰਨ ਵਾਲੇ ਨੂੰ ਦੁਬਾਰਾ ਭੁਗਤਾਨ ਕਰਨਾ ਪੈਂਦਾ ਹੈ.

x402 ਮਸ਼ੀਨ-ਤੋਂ-ਮਸ਼ੀਨ ਹੈ: ਇੱਕ x402-ਜਾਣੂ ਕਲਾਇੰਟ accepts ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ, ਚੁਣੀ ਗਈ ਲੋੜ 'ਤੇ ਚੇਨ 'ਤੇ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ, ਫਿਰ ਇੱਕ X-Payment ਹੈਡਰ ਨਾਲ ਬੇਨਤੀ ਨੂੰ ਦੁਬਾਰਾ ਜਾਰੀ ਕਰਦਾ ਹੈ ਜਿਸਨੂੰ ਐਡਾਪਟਰ ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ। ਇੱਕ ਕਲਾਇੰਟ ਜੋ x402 ਨਹੀਂ ਬੋਲਦਾ ਸਿਰਫ 402 ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਕੋਈ ਨਤੀਜਾ ਨਹੀਂ ਮਿਲਦਾ, ਜੋ ਸਹੀ ਨਤੀਜਾ ਹੈ (ਕਾਲ ਭੁਗਤਾਨ ਨਹੀਂ ਕੀਤਾ ਗਿਆ)। ਇਸ ਪ੍ਰਵਾਹ ਵਿੱਚ ਕੋਈ ਹੋਸਟ ਕੀਤੀ ਚੈਕਆਉਟ ਪੇਜ ਨਹੀਂ ਹੈ; ਭੁਗਤਾਨ ਕਾਲ ਕਰਨ ਵਾਲੇ ਦੇ ਵੈਲਟ ਦੁਆਰਾ ਪ੍ਰੋਗਰਾਮੈਟਿਕ ਤੌਰ 'ਤੇ ਨਿਪਟਾਰਾ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।

ਐਡਾਪਟਰ ਪੈਟਰਨ

ਇੱਕ ਕੀਮਤ ਦੀ ਟੇਬਲ। ਤਿੰਨ ਭਾਸ਼ਾਵਾਂ। ਇੱਕੋ ਆਕਾਰ।

ਤੁਸੀਂ ਇੱਕ ਐਡਾਪਟਰ ਮਾਊਂਟ ਕਰਦੇ ਹੋ ਅਤੇ ਇਸਨੂੰ METHOD ਅਤੇ ਪਾਥ ਦੁਆਰਾ ਕੁੰਜੀ ਕੀਤੀ ਕੀਮਤਾਂ ਦੀ ਸੂਚੀ ਦਿੰਦੇ ਹੋ। ਇਹ ਸਿਰਫ਼ ਉਹ ਰੂਟਾਂ ਨੂੰ ਗੇਟ ਕਰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਸੂਚੀਬੱਧ ਕੀਤੇ ਹਨ; ਤੁਹਾਡਾ ਹੈਂਡਲਰ ਕਦੇ ਵੀ ਬਿਨਾਂ ਭੁਗਤਾਨ ਵਾਲੀ ਕਾਲ ਨਹੀਂ ਦੇਖਦਾ, ਕਿਉਂਕਿ ਜਦ ਇਹ ਚੱਲਦਾ ਹੈ ਤਾਂ X-Payment ਹੈਡਰ ਪਹਿਲਾਂ ਹੀ ਪ੍ਰਮਾਣਿਤ ਹੋ ਚੁੱਕਾ ਹੈ। ਆਕਾਰ Python, TypeScript, ਅਤੇ Go ਵਿੱਚ ਇੱਕਸਾਰ ਹੈ - X-Payment ਵਾਇਰ ਫਾਰਮੈਟ ਇੱਕੋ ਹੀ ਹੈ, ਇਸ ਲਈ Go ਸਰਵਰ Python ਕਲਾਇੰਟ ਦੁਆਰਾ ਬਣੇ ਹੋਏ ਹੈਡਰਾਂ ਨੂੰ ਸਵੀਕਾਰ ਕਰਦਾ ਹੈ।

PYTHON (FLASK)
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 verifies
ਟਾਈਪਸਕ੍ਰਿਪਟ (ਐਕਸਪ੍ਰੈੱਸ)
import 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
});
ਜਾਓ (NET/HTTP)
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)
}

ਅਸੀਂ Express ਅਤੇ Fastify (Node), ASGI (Starlette ਅਤੇ FastAPI) ਅਤੇ Flask (Python), ਅਤੇ Go ਦੇ net/http ਲਈ server adapters ship ਕਰਦੇ ਹਾਂ। ਹੋਰ frameworks ਲਈ, 402 body ਅਤੇ X-Payment header ਸਧਾਰਨ HTTP ਹਨ, ਜਿਨ੍ਹਾਂ ਨੂੰ @blockchain0x/x402 ਦੇ wire helpers build ਅਤੇ parse ਕਰਦੇ ਹਨ - ਆਪਣੇ stack ਦੇ idiom ਵਿੱਚ check ਖੁਦ ਲਿਖੋ। Ruby ਅਤੇ JVM x402 packages client side ਲਈ published ਹਨ।

VS STRIPE CHECKOUT

ਹਰ ਟੂਲ ਲਈ ਕਦੋਂ ਪਹੁੰਚਣਾ ਹੈ।

Stripe ਮਨੁੱਖੀ ਚੈਕਆਉਟ ਲਈ ਸਹੀ ਟੂਲ ਹੈ। Blockchain0x ਏਜੰਟ ਚੈਕਆਉਟ ਲਈ ਸਹੀ ਟੂਲ ਹੈ। ਉਹ ਵੱਖ-ਵੱਖ ਸਮੱਸਿਆਵਾਂ ਨੂੰ ਹੱਲ ਕਰਦੇ ਹਨ ਅਤੇ ਅਕਸਰ ਇੱਕੋ API 'ਤੇ ਇੱਕ ਦੂਜੇ ਦੇ ਬਗਲ ਵਿੱਚ ਬੈਠੇ ਹੁੰਦੇ ਹਨ।

DimensionBlockchain0xStripe Checkout
ਖਰੀਦਦਾਰਕੋਈ ਵੀ HTTP ਕਲਾਇੰਟ (ਇਨਸਾਨ ਜਾਂ AI ਏਜੰਟ)ਇੱਕ ਬ੍ਰਾਉਜ਼ਰ 'ਤੇ ਮਨੁੱਖ
ਭੁਗਤਾਨ ਤੋਂ ਪਹਿਲਾਂ ਪ੍ਰਮਾਣਿਕਤਾ ਦੀ ਲੋੜ ਹੈਨਹੀਂ - ਪਹਿਲੀ ਕਾਲ ਭੁਗਤਾਨ ਦੀਆਂ ਲੋੜਾਂ ਨਾਲ 402 ਵਾਪਸ ਕਰਦੀ ਹੈਹਾਂ - ਈਮੇਲ + ਕਾਰਡ ਫਾਰਮ
ਸਮਾਪਤੀ ਦੀ ਗਤੀ5 ਸਕਿੰਟ (USDC on Base)2-7 ਦਿਨ (ਕਾਰਡ ਨੈੱਟਵਰਕ)
ਚਾਰਜਬੈਕ ਖਤਰਾਕੋਈ ਨਹੀਂ (USDC ਅੰਤਿਮ ਹੈ)120 ਦਿਨਾਂ ਤੱਕ ਦਾ ਚਾਰਜਬੈਕ ਖਿੜਕੀ
ਪ੍ਰਤੀ-ਲੈਣ-ਦੇਣ ਦੀ ਲਾਗਤ ਅਰਥਸ਼ਾਸਤਰਕਾਲ 'ਤੇ $0.01-$0.10 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ (ਬੇਸ ਗੈਸ + ਸਾਡੀ ਫੀਸ)ਕਾਰਡ ਫੀਸਾਂ $1 ਤੋਂ ਘੱਟ ਦੇ ਲੈਣ-ਦੇਣ ਨੂੰ ਅਰਥਸ਼ਾਸਤਰੀ ਬਣਾਉਂਦੀਆਂ ਹਨ
ਰਿਫੰਡਮੈਨੁਅਲ - ਤੁਹਾਡਾ ਕੋਡ USDC ਨੂੰ ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਪਤੇ 'ਤੇ ਵਾਪਸ ਭੇਜਦਾ ਹੈStripe ਡੈਸ਼ਬੋਰਡ ਰਾਹੀਂ ਆਟੋਮੈਟਿਕ
ਅੰਤਰਰਾਸ਼ਟਰੀ ਸਹਾਇਤਾਉਸੇ ਵੈਲਟ, ਕਿਸੇ ਵੀ ਦੇਸ਼, ਕੋਈ ਵਾਧੂ ਸੰਰਚਨਾ ਨਹੀਂਪ੍ਰਤੀ ਦੇਸ਼ ਲਾਇਸੈਂਸਿੰਗ, ਮੁਦਰਾ ਬਦਲਾਅ, ਖੇਤਰੀ ਨਿਯਮ
ਸਭ ਤੋਂ ਵਧੀਆਪ੍ਰੋਗ੍ਰਾਮੈਟਿਕ ਏਜੰਟ-ਚਲਿਤ API ਖਪਤਮਨੁੱਖ-ਚਲਿਤ ਚੈਕਆਉਟ (SaaS ਸਾਈਨਅਪ, ਈ-ਵਪਾਰ)

ਜਿਸ pattern 'ਤੇ ਜ਼ਿਆਦਾਤਰ API providers ਆਖ਼ਰਕਾਰ ਪਹੁੰਚਦੇ ਹਨ: human signup flow ਲਈ Stripe ਰੱਖੋ (ਤੁਹਾਡਾ dashboard, ਤੁਹਾਡਾ subscription product page); programmatic agent access ਲਈ API edge 'ਤੇ Blockchain0x add ਕਰੋ। x402 adapter ਸਿਰਫ਼ ਉਹ routes gate ਕਰਦਾ ਹੈ ਜੋ ਤੁਸੀਂ ਉਸਦੀ pricing table ਵਿੱਚ ਰੱਖਦੇ ਹੋ, ਇਸ ਲਈ ਤੁਹਾਡੇ human, Stripe-authenticated routes ਅਛੁੱਤੇ ਰਹਿੰਦੇ ਹਨ। Agents ਨੂੰ priced routes 'ਤੇ ਅਤੇ humans ਨੂੰ ਬਾਕੀ routes 'ਤੇ point ਕਰੋ, ਅਤੇ ਦੋਵੇਂ audiences ਨੂੰ ਇੱਕੋ API code serve ਕਰਦਾ ਹੈ।

ਕਿਹੜਾ ਯੋਜਨਾ ਫਿੱਟ ਹੈ

ਪ੍ਰੋ ਸ਼ੁਰੂਆਤੀ ਟ੍ਰੈਫਿਕ ਲਈ। ਵਪਾਰ ਜਦੋਂ ਆਡੀਟ ਲੌਗ ਇੱਕ ਜ਼ਰੂਰਤ ਬਣ ਜਾਂਦੇ ਹਨ।

API ਪ੍ਰਦਾਤਾ ਲਗਭਗ ਹਮੇਸ਼ਾਂ ਪਹਿਲੇ ਦਿਨ ਤੋਂ ਪ੍ਰੋ 'ਤੇ ਸ਼ੁਰੂ ਹੁੰਦੇ ਹਨ: ਮੁਫਤ ਪੜ੍ਹਨ ਲਈ ਹੀ ਹੈ, ਅਤੇ x402 ਐਡਾਪਟਰ ਨੂੰ ਭੁਗਤਾਨਾਂ ਦੀ ਪੁਸ਼ਟੀ ਕਰਨ ਅਤੇ ਸਮਾਪਤ ਕਰਨ ਲਈ API ਪਹੁੰਚ ਦੀ ਲੋੜ ਹੈ ਨਾਲ ਹੀ ਉਨ੍ਹਾਂ ਨੂੰ ਟ੍ਰੈਕ ਕਰਨ ਲਈ webhook. ਉੱਚ-ਟ੍ਰੈਫਿਕ API ਮਹੀਨਾਵਾਰ ਮਾਤਰਾ ਵਧਣ ਦੇ ਨਾਲ ਕਾਰੋਬਾਰੀ ਖੇਤਰ ਵਿੱਚ ਦਾਖਲ ਹੁੰਦੇ ਹਨ. ਸਹੀ ਪ੍ਰਤੀ-ਏਜੰਟ ਲਾਗਤ ਅਤੇ ਜਿੱਥੇ ਟੀਅਰ ਬੈਠਦੇ ਹਨ, ਲਈ ਕੀਮਤਾਂ ਦੀ ਪੰਨਾ ਵੇਖੋ.

  • Free: ਸਿਰਫ dashboard ਅਤੇ metadata exploration ਲਈ ਉਪਯੋਗੀ। Read-only, ਇਸ ਲਈ adapter payments settle ਨਹੀਂ ਕਰ ਸਕਦਾ।
  • Pro: live API monetization ਲਈ default. Full API access, webhooks, exports.
  • Business: ਜਦੋਂ ਤੁਹਾਨੂੰ compliance ਲਈ audit logs ਜਾਂ ਉੱਚੇ API rate limits ਦੀ ਲੋੜ ਹੋਵੇ।
ਪੂਰੀ ਕੀਮਤ ਵੇਖੋ
ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ

ਪੰਜ API-ਪ੍ਰਦਾਤਾ ਸਵਾਲ।

ਕੀ ਮੈਂ ਇੱਕੋ API ਲਈ Blockchain0x ਦੇ ਨਾਲ Stripe ਚਲਾ ਸਕਦਾ ਹਾਂ?

ਹਾਂ, ਅਤੇ ਕਈ API providers ਐਸਾ ਕਰਦੇ ਹਨ। pattern ਇਹ ਹੈ: ਆਪਣਾ ਮੌਜੂਦਾ Stripe-based human signup flow ਜਿਉਂ ਦਾ ਤਿਉਂ ਰੱਖੋ, ਅਤੇ x402 pricing table ਵਿੱਚ ਸਿਰਫ਼ agent-facing routes ਹੀ list ਕਰੋ। adapter ਠੀਕ ਉਹੀ routes gate ਕਰਦਾ ਹੈ; ਜੋ ਕੁਝ table ਵਿੱਚ ਨਹੀਂ ਹੈ (ਉਨ੍ਹਾਂ routes ਸਮੇਤ ਜੋ ਤੁਹਾਡੇ Stripe-authenticated customers call ਕਰਦੇ ਹਨ) ਉਹ ਬਿਨਾਂ ਪ੍ਰਭਾਵਿਤ ਹੋਏ ਸਿੱਧਾ pass through ਹੋ ਜਾਂਦਾ ਹੈ। ਜੇ ਤੁਸੀਂ ਇੱਕ ਹੀ route ਨਾਲ ਦੋਵਾਂ ਨੂੰ serve ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ handler ਵਿੱਚ ਆਪਣੀ API key check ਕਰੋ ਅਤੇ authenticated callers ਲਈ priced path ਨੂੰ skip ਕਰੋ। ਦੋਵੇਂ audiences ਨੂੰ ਉਹ ਮਿਲਦਾ ਹੈ ਜੋ ਉਹ ਚਾਹੁੰਦੇ ਹਨ, ਬਿਨਾਂ ਇੱਕ path ਦੇ ਦੂਜੇ ਨੂੰ block ਕੀਤੇ।

ਜੇ ਇੱਕ AI ਏਜੰਟ ਭੁਗਤਾਨ ਕਰਦਾ ਹੈ ਫਿਰ ਕਾਲ ਨੂੰ ਦੁਬਾਰਾ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਬਾਹਰ ਨਿਕਲ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਕੀ?

Payment ਹਾਲੇ ਵੀ on-chain valid ਹੈ; ਇਹ ਸਿਰਫ਼ unused ਰਹਿ ਜਾਂਦੀ ਹੈ। Agent ਦੇ wallet ਵਿੱਚ ਤੁਹਾਡੇ address ਨੂੰ ਇੱਕ successful USDC transfer ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ। Agent ਦੇ ਨਜ਼ਰੀਏ ਤੋਂ ਇਸਨੇ USDC ਗਵਾ ਦਿੱਤੇ; ਤੁਹਾਡੇ ਲਈ, ਤੁਹਾਨੂੰ ਇੱਕ ਐਸੀ call ਲਈ ਭੁਗਤਾਨ ਮਿਲ ਗਿਆ ਜੋ ਕਦੇ execute ਹੀ ਨਹੀਂ ਹੋਈ। ਇਹ practice ਵਿੱਚ ਕਦੇ-ਕਦੇ ਹੀ ਹੁੰਦਾ ਹੈ (x402 client paying ਤੋਂ ਤੁਰੰਤ retry ਕਰਦਾ ਹੈ), ਪਰ ਜੇ ਤੁਸੀਂ defensive ਰਹਿਣਾ ਚਾਹੁੰਦੇ ਹੋ ਤਾਂ ਤੁਸੀਂ ਉਹ verified payments track ਕਰ ਸਕਦੇ ਹੋ ਜਿਨ੍ਹਾਂ ਨੇ ਕਦੇ completed call ਨਹੀਂ ਦਿੱਤੀ ਅਤੇ payments.create ਨਾਲ ਖੁਦ USDC ਵਾਪਸ ਭੇਜ ਸਕਦੇ ਹੋ, original payer address ਨੂੰ pay ਕਰਕੇ। ਕੋਈ separate refund endpoint ਨਹੀਂ ਹੈ - refund ਸਿਰਫ਼ ਉਲਟੀ ਦਿਸ਼ਾ ਵਿੱਚ ਇੱਕ payment ਹੈ।

ਮੈਂ ਆਪਣੀ API ਅਤੇ ਕੀਮਤ ਬਦਲਾਵਾਂ ਨੂੰ ਕਿਵੇਂ ਵਰਜਨ ਕਰਾਂ?

ਕੀਮਤਾਂ ਦੀ ਟੇਬਲ ਵਿੱਚ ਹਰ ਦਾਖਲਾ ਪ੍ਰਤੀ-ਰੂਟ ਹੈ, ਇਸ ਲਈ ਵੱਖ-ਵੱਖ ਰੂਟ ਵੱਖ-ਵੱਖ ਕੀਮਤਾਂ ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹਨ। ਵਰਜਨਿੰਗ ਲਈ, ਸੁਝਾਏ ਗਏ ਪੈਟਰਨ ਵਿੱਚ v2 ਐਂਡਪੋਇੰਟਾਂ ਨੂੰ v1 ਦੇ ਨਾਲ ਨਵੇਂ ਕੀਮਤਾਂ ਦੇ ਨਵੇਂ ਕੀਮਤਾਂ ਦੀ ਟੇਬਲ ਦੇ ਦਾਖਲ ਵਜੋਂ ਪ੍ਰਗਟ ਕਰਨਾ ਸ਼ਾਮਿਲ ਹੈ; ਗਾਹਕ v2 ਰੂਟ 'ਤੇ ਆਪਣੇ ਪਹਿਲੇ 402 ਜਵਾਬ ਵਿੱਚ ਨਵੀਂ ਰਕਮ ਵੇਖਦੇ ਹਨ ਅਤੇ ਇਸ ਅਨੁਸਾਰ ਭੁਗਤਾਨ ਕਰਦੇ ਹਨ। ਸਥਿਰ ਰੂਟਾਂ 'ਤੇ ਅਚਾਨਕ ਕੀਮਤਾਂ ਵਧਾਉਣਾ ਬੁਰਾ ਪ੍ਰੋਟੋਕੋਲ ਨਾਗਰਿਕਤਾ ਹੈ; ਅਸੀਂ ਪੁਰਾਣੇ ਰੂਟ ਨੂੰ ਰੱਦ ਕਰਨ ਅਤੇ ਨਵੇਂ ਕੀਮਤ 'ਤੇ ਨਵੇਂ ਰੂਟ ਵੱਲ ਇਸ਼ਾਰਾ ਕਰਨ ਵਾਲੀ 410 Gone ਸੇਵਾ ਦੀ ਸਿਫਾਰਿਸ਼ ਕਰਦੇ ਹਾਂ।

ਨਿਗਰਾਨੀ ਕਿਵੇਂ ਦਿਖਾਈ ਦਿੰਦੀ ਹੈ - ਲਾਗ, ਮੈਟ੍ਰਿਕਸ, ਅਲਰਟ?

ਹਰ ਭੁਗਤਾਨ Blockchain0x ਡੈਸ਼ਬੋਰਡ ਵਿੱਚ ਭੁਗਤਾਨ ਕਰਨ ਵਾਲੇ ਵਾਲਿਟ, ਰਕਮ, ਅਤੇ ਟਾਈਮਸਟੈਂਪ ਨਾਲ ਪ੍ਰਗਟ ਹੁੰਦਾ ਹੈ, ਅਤੇ ਉਹੀ ਡੇਟਾ ਤੁਹਾਡੇ payment.received ਵੈਬਹੂਕ 'ਤੇ ਆਉਂਦਾ ਹੈ ਤਾਂ ਕਿ ਤੁਸੀਂ ਇਸਨੂੰ Datadog, Splunk, ਜਾਂ ਆਪਣੇ ਆਪਣੇ ਲੌਗਿੰਗ ਸਟੈਕ ਵਿੱਚ ਸਟ੍ਰੀਮ ਕਰ ਸਕੋ। ਐਡਾਪਟਰ ਤੁਹਾਡੇ ਸਰਵਰ ਦੇ ਅੰਦਰ ਚਲਦਾ ਹੈ, ਇਸ ਲਈ ਬੇਨਤੀ-ਸਤਰ ਦੇ ਸੰਕੇਤ (ਕਿਹੜਾ ਰੂਟ ਕੋਟ ਕੀਤਾ ਗਿਆ, ਹਰ 402 ਜੋ ਤੁਸੀਂ ਵਾਪਸ ਕੀਤਾ, ਹਰ X-Payment ਜੋ ਤੁਸੀਂ ਪੁਸ਼ਟੀ ਕੀਤੀ) ਤੁਹਾਡੇ ਲਈ ਲੌਗ ਕਰਨ ਅਤੇ ਮੈਟਰਿਕਸ ਵਜੋਂ ਜਾਰੀ ਕਰਨ ਲਈ ਹਨ ਜੋ ਤੁਹਾਡਾ ਸਟੈਕ ਵਰਤਦਾ ਹੈ। ਸਪਸ਼ਟ ਵਾਲੇ ਸੰਕੇਤਾਂ 'ਤੇ ਚੇਤਾਵਨੀ ਲਗਾਓ: 402 ਜਵਾਬਾਂ ਵਿੱਚ ਅਚਾਨਕ ਵਾਧਾ, ਜਾਂ ਪੁਸ਼ਟੀ ਕੀਤੇ ਭੁਗਤਾਨ ਦਰ ਵਿੱਚ ਕਮੀ।

ਨਿਯਮਕ ਸਵਾਲਾਂ ਬਾਰੇ ਕੀ - ਕੀ ਮੈਂ ਇਹ ਕਰਨ 'ਤੇ ਇੱਕ ਪੈਸੇ ਦੀਆਂ ਸੇਵਾਵਾਂ ਦਾ ਕਾਰੋਬਾਰ ਹਾਂ?

ਸ਼ਾਇਦ ਨਹੀਂ, ਪਰ ਇਹ ਅਧਿਕਾਰ ਖੇਤਰ-ਵਿਸ਼ੇਸ਼ ਹੈ ਅਤੇ ਅਸੀਂ ਤੁਹਾਡੇ ਵਕੀਲ ਨਹੀਂ ਹਾਂ। ਕਾਰਨ: ਤੁਸੀਂ ਉਹਨਾਂ ਸੇਵਾਵਾਂ ਲਈ ਭੁਗਤਾਨ ਪ੍ਰਾਪਤ ਕਰ ਰਹੇ ਹੋ ਜੋ ਤੁਸੀਂ ਪ੍ਰਦਾਨ ਕਰਦੇ ਹੋ, ਨਾ ਕਿ ਤੀਜੀ ਪਾਰਟੀਆਂ ਵਿਚਕਾਰ ਪੈਸਾ ਭੇਜਣਾ (ਜੋ ਕਿ ਅਮਰੀਕਾ ਵਿੱਚ MSB ਸਥਿਤੀ ਲਈ ਟ੍ਰਿਗਰ ਹੈ)। USDC ਨੂੰ ਬਹੁਤ ਸਾਰੇ ਅਧਿਕਾਰ ਖੇਤਰਾਂ ਵਿੱਚ ਭੁਗਤਾਨ-ਸਟੇਬਲਕੋਇਨ ਵਜੋਂ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਤੁਸੀਂ USD-ਸਮਾਨ ਰੇਵਨਿਊ 'ਤੇ ਕਰ ਦੇਣੇ ਹੋ; ਅਸੀਂ ਇਸ ਲਈ ਤੁਹਾਨੂੰ ਲੋੜੀਂਦੇ ਰਿਕਾਰਡ ਬਣਾਉਂਦੇ ਹਾਂ। ਜੇ ਤੁਸੀਂ ਉੱਚ-ਵਾਲੀਅਮ B2B ਸੰਦਰਭ ਵਿੱਚ ਜਾਂ ਕਿਸੇ ਅਧਿਕਾਰ ਖੇਤਰ ਵਿੱਚ ਸਖਤ ਕ੍ਰਿਪਟੋ ਨਿਯਮਾਂ (ਜਰਮਨੀ, ਸਿੰਗਾਪੁਰ ਕੁਝ ਆਕਾਰਾਂ ਲਈ) ਵਿੱਚ ਕੰਮ ਕਰਦੇ ਹੋ, ਤਾਂ ਉਤਪਾਦਨ ਟ੍ਰੈਫਿਕ ਨੂੰ ਚਾਲੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ ਵਿਸ਼ੇਸ਼ ਕਾਨੂੰਨੀ ਸਲਾਹ ਲਓ। ਅਸੀਂ ਤੁਹਾਨੂੰ ਉਹਨਾਂ ਫਰਮਾਂ ਦੇ ਕੋਲ ਰਿਫਰ ਕਰ ਸਕਦੇ ਹਾਂ ਜਿਨ੍ਹਾਂ ਨੇ ਪਿਛਲੇ ਗ੍ਰਾਹਕਾਂ ਲਈ ਇਹ ਕੰਮ ਕੀਤਾ ਹੈ।

ਏਜੰਟਾਂ ਨੂੰ ਤੁਹਾਡੇ API ਲਈ ਭੁਗਤਾਨ ਕਰਨ ਦਿਓ।

ਕੀਮਤਾਂ ਦੀ ਟੇਬਲ ਵਿੱਚ ਇੱਕ ਰੂਟ ਸ਼ਾਮਲ ਕਰੋ ਅਤੇ ਐਡਾਪਟਰ ਨੂੰ ਮਾਊਂਟ ਕਰੋ। ਸਟ੍ਰਾਈਪ ਮਨੁੱਖਾਂ ਲਈ ਹੈ। ਦੋਹਾਂ ਦਰਸ਼ਕਾਂ ਨੂੰ ਸੇਵਾ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ।