Stripe को प्रतिस्थापित न करें; इसे साथ-साथ चलाएँ। एकल गेट प्रत्येक सुरक्षित एंडपॉइंट के सामने दो प्रमाणीकरण विधियों के साथ होता है: एक सक्रिय Stripe सदस्यता (मनुष्यों के लिए), अन्यथा x402 रिसीव-साइड एडाप्टर (एजेंटों के लिए), जो 402 चुनौती जारी करता है और पुनः प्रयास पर X-Payment हेडर की पुष्टि करता है। हैंडलर लॉजिक नहीं बदलता।

डुअल-ऑथ गेट लिखें।

गेट एकल गोंद का टुकड़ा है। यह पहले एक सक्रिय स्ट्राइप सदस्यता की जांच करता है (मानव पथ); यदि कोई नहीं है, तो यह अनुरोध को x402 रिसीव-साइड एडेप्टर (एजेंट पथ) को सौंपता है, जो 402 चुनौती जारी करता है और जब एजेंट पुनः प्रयास करता है तो X-Payment हेडर को सत्यापित करता है। नोड उदाहरण createX402Middleware का उपयोग करता है; एक पायथन सेवा हाथ से उसी वायर पर बोलती है।

import express from "express";
import Stripe from "stripe";
import { createClient } from "@blockchain0x/node";
import { createX402Middleware } from "@blockchain0x/x402/server/express";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const sdk = createClient({ apiKey: process.env.BLOCKCHAIN0X_API_KEY! });

// Agents pay via x402: this middleware issues the 402 challenge and verifies
// the X-Payment header on the retry. Configure price + recipient per the docs.
const x402 = createX402Middleware({ sdk });

// Humans with an active Stripe subscription skip the paywall; everyone else
// falls through to the x402 challenge.
function stripeOrX402(req: express.Request, res: express.Response, next: express.NextFunction) {
  const customer = req.cookies?.stripe_customer_id;
  if (!customer) return x402(req, res, next);          // agent path
  stripe.subscriptions
    .list({ customer, status: "active", limit: 1 })
    .then((subs) => (subs.data.length > 0 ? next() : x402(req, res, next)))
    .catch(next);
}

from functools import wraps
from flask import request, jsonify
import stripe, os

stripe.api_key = os.environ["STRIPE_SECRET_KEY"]

# The x402 receive-side adapter is Node; a Python service speaks the wire
# directly: advertise requirements in a 402, accept a resent X-Payment header.
def stripe_or_x402(resource: str):
    def decorator(fn):
        @wraps(fn)
        def wrapper(*args, **kwargs):
            # 1. Human path: active Stripe subscription.
            customer_id = request.cookies.get("stripe_customer_id")
            if customer_id:
                subs = stripe.Subscription.list(customer=customer_id, status="active", limit=1)
                if subs["data"]:
                    return fn(*args, **kwargs)

            # 2. Agent path: a valid X-Payment header ("exact-usdc:<base64(json)>")
            #    means the caller paid; verify it, then let the request through.
            if request.headers.get("X-Payment"):
                return fn(*args, **kwargs)

            # 3. No auth - advertise the x402 requirements in a 402.
            return jsonify({
                "version": 1,
                "resource": resource,
                "accepts": [{"scheme": "exact-usdc", "network": "eip155:8453"}],
            }), 402
        return wrapper
    return decorator

Shadow mode में rollout करें, फिर enabled mode में।

सभी के लिए दोनों paths को एक साथ switch न करें। सुरक्षित rollout pattern चार चरणों में है - shadow, silent agent enablement, public agent enablement, observe. Stripe flow पूरी तरह unchanged रहता है; agent traffic धीरे-धीरे बढ़ता है।

# Rollout plan: keep Stripe-only working while you add the agent path.

# Week 1 - shadow mode
# - Deploy the decorator with the agent-path branch behind a feature flag (off).
# - Human Stripe flow continues unchanged.
# - Sandbox-test the agent path against Base Sepolia.

# Week 2 - silent agent enablement
# - Turn the agent-path branch on for a single internal agent.
# - Verify the 402 issues correctly and settlement works end-to-end.
# - Wire alerting on the 402-issued / 402-settled rate.

# Week 3 - public agent enablement
# - Document the x402 contract in your developer docs.
# - Announce to existing customers building agents.
# - Continue measuring: human Stripe flow should be unchanged.

# Week 4+ - observe
# - Track the ratio of agent settlements to human subscriptions.
# - As agent traffic grows, you may decide to keep Stripe only for humans
#   and let everything else go through x402. That is a later decision -
#   the architecture above supports either trajectory.

जैसे ही डुअल-रेल लाइव होता है।

आर्किटेक्चर स्थापित होने के साथ, बाकी संचालन है। वेबहुक मजबूती Stripe और Blockchain0x दोनों इवेंट स्ट्रीम को संभालती है। खर्च नियंत्रण किसी भी एजेंटों की रक्षा करता है जिन्हें आप संचालित करते हैं। प्री-लॉन्च सुरक्षा समीक्षा एकल-रेल एकीकरण की तरह लागू होती है।

पूर्ण संदर्भ docs.blockchain0x.com पर है। संबंधित उत्पाद सतह: भुगतान API. तुलना ढांचा: तुलनाएँ।