Ne remplacez pas Stripe ; exécutez-le en parallèle. Une seule porte fait face à chaque point de terminaison protégé avec deux méthodes d'authentification : un abonnement Stripe actif (pour les humains), sinon l'adaptateur x402 côté réception (pour les agents), qui émet un défi 402 et vérifie l'en-tête X-Payment lors de la nouvelle tentative. La logique du gestionnaire ne change pas.

Écrivez la porte d'authentification double.

La porte est le seul élément de liaison. Elle vérifie d'abord s'il y a un abonnement Stripe actif (le chemin humain) ; s'il n'y en a pas, elle transmet la demande à l'adaptateur de réception x402 (le chemin de l'agent), qui émet le défi 402 et vérifie l'en-tête X-Payment lorsque l'agent réessaie. L'exemple Node utilise createX402Middleware ; un service Python parle le même fil à la main.

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

Déploiement en mode shadow, puis en mode activé.

Ne basculez pas les deux parcours en même temps pour tout le monde. Le schéma de déploiement sûr comporte quatre phases - shadow, activation silencieuse des agents, activation publique des agents, observation. Le flux Stripe reste inchangé tout du long ; le trafic des agents monte progressivement.

# 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.

Une fois que le double rail est actif.

Avec l'architecture en place, le reste est opérationnel. La robustesse des webhooks gère à la fois les flux d'événements Stripe et Blockchain0x. Les contrôles de dépenses protègent tous les agents que vous exploitez. L'examen de sécurité avant le lancement s'applique tout comme une intégration à rail unique.

Référence complète à docs.blockchain0x.com. Surface produit associée : API de paiement. Cadre de comparaison : Comparaisons.