# paiements x402 Utilisez x402 pour les paiements machine à machine. Le [x402](https://x402.org) est un protocole de paiement sur Internet. Lorsqu’un client demande une ressource payante, votre serveur renvoie une réponse HTTP 402 contenant les informations de paiement. Le client règle le montant, puis renvoie la requête avec une autorisation. Stripe gère les adresses de dépôt et *capture* (Another way to say that you receive payment for a charge is to say that you "capture" the charge. Capturing the charge is often asynchronous and takes place after authorization. The capture is what transfers the money from the customer to you) automatiquement le [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) une fois que les fonds sont confirmés sur la blockchain. Vous trouverez le [code source complet](https://github.com/stripe-samples/machine-payments) de l’application sur GitHub. ## Before you begin Les paiements automatisés doivent être activés pour votre compte. Demandez l’accès aux paiements automatisés [en remplissant le formulaire d’inscription](https://docs.stripe.com/payments/machine.md#sign-up). > Vos clients peuvent utiliser des stablecoins comme moyen de paiement à l’échelle mondiale, mais seules les entreprises basées aux États-Unis peuvent accepter des paiements en stablecoins. Pour commencer à accepter les paiements en stablecoins: 1. Assurez-vous que [votre compte Stripe est bien configuré](https://docs.stripe.com/get-started/account/set-up.md). 1. Accédez aux paramètres [Moyens de paiement](https://dashboard.stripe.com/settings/payment_methods) dans le Dashboard et activez le moyen de paiement **Stablecoins et Cryptomonnaie**. Si vous souhaitez accepter uniquement des paiements en stablecoins ou en cryptomonnaie pour les [paiements automatisés](https://docs.stripe.com/payments/machine.md), nous vous recommandons de créer une [configuration de moyens de paiement](https://docs.stripe.com/payments/payment-method-configurations.md) distincte dédiée à ces paiements. 1. Stripe examine votre demande d’accès et vous contacte si des informations complémentaires sont nécessaires. Le moyen de paiement apparaît comme **Pending** pendant l’examen de votre demande. 1. Une fois votre demande approuvée, **Stablecoins et Cryptomonnaie** devient actif dans le Dashboard. ## Cycle de vie des paiements Dans ce guide, vous créez le serveur. Votre serveur indique qu’un paiement est requis et renvoie le contenu après un paiement réussi. Vous interagissez avec Stripe et un facilitateur pour finaliser le paiement. Diagramme illustrant le tunnel de paiement x402 entre le client, le serveur, Stripe et le facilitateur (See full diagram at https://docs.stripe.com/payments/machine/x402) ## Création de votre endpoint Ajoutez un intergiciel de paiement à votre endpoint pour exiger un paiement. Dans cet exemple, 0,01 USD payé en USDC est nécessaire par requête `/paid`. #### Node.js ```node import { paymentMiddleware } from "@x402/hono"; import { x402ResourceServer, HTTPFacilitatorClient } from "@x402/core/server"; import { ExactEvmScheme } from "@x402/evm/exact/server"; app.use( paymentMiddleware( { "GET /paid": { accepts: [ { scheme: "exact", price: "$0.01", network: "eip155:84532", payTo: createPayToAddress, } ], description: "Data retrieval endpoint", mimeType: "application/json", } }, new x402ResourceServer(facilitatorClient).register( "eip155:84532", new ExactEvmScheme() ) ) ) ``` ## Créer un PaymentIntent Pour traiter les paiements, créez un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) qui accepte le *moyen de paiement* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) `en cryptomonnaie`. Utilisez la méthode `payTo` définie précédemment. > #### Version de l’API > > Cette fonctionnalité nécessite la version d’API `2026-03-04.preview`. Définissez l’en-tête `Stripe-Version` sur `2026-03-04.preview` lors de l’initialisation de votre client Stripe. #### Node.js ```node import Stripe from "stripe"; import NodeCache from 'node-cache'; const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, { apiVersion: "2026-03-04.preview", }); // In-memory cache for deposit addresses (TTL: 5 minutes) // NOTE: For production, use a distributed cache like Redis instead of node-cache const paymentCache = new NodeCache({ stdTTL: 300, checkperiod: 60 }); async function createPayToAddress(context) { // If a payment header exists, extract the destination address from it if (context.paymentHeader) { const decoded = JSON.parse( Buffer.from(context.paymentHeader, "base64").toString() ); const toAddress = decoded.payload?.authorization?.to; if (toAddress && typeof toAddress === "string") { if (!paymentCache.has(toAddress)) { throw new Error("Invalid payTo address: not found in server cache"); } return toAddress; } throw new Error( "PaymentIntent did not return expected crypto deposit details" ); } // Create a new PaymentIntent to get a fresh crypto deposit address const decimals = 6; // USDC has 6 decimals const amountInCents = Number(10000) / Math.pow(10, decimals - 2); const paymentIntent = await stripe.paymentIntents.create({ amount: amountInCents, currency: "usd", payment_method_types: ["crypto"], payment_method_data: { type: "crypto", }, payment_method_options: { crypto: { mode: "deposit", deposit_options: { networks: ["base"], }, }, }, confirm: true, }); if ( !paymentIntent.next_action || !("crypto_display_details" in paymentIntent.next_action) ) { throw new Error( "PaymentIntent did not return expected crypto deposit details" ); } // Extract the Base network deposit address from the PaymentIntent const depositDetails = paymentIntent.next_action .crypto_display_details; const payToAddress = depositDetails.deposit_addresses["base"].address; console.log( `Created PaymentIntent ${paymentIntent.id} for $${( amountInCents / 100 ).toFixed(2)} -> ${payToAddress}` ); paymentCache.set(payToAddress, true); return payToAddress; } ``` Cette fonction renvoie une adresse de versement de cryptomonnaie que le client reçoit et utilise pour le paiement. La réponse [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) inclut des adresses de dépôt avec `supported_tokens`, qui répertorie les tokens acceptés et leurs adresses de contrat pour chaque réseau : ```json { "id": "pi_123", "amount": 5000, "currency": "usd", "status": "requires_action", "next_action": { "type": "crypto_display_details", "crypto_display_details": { "deposit_addresses": { "base": { "address": "0xbase_address", "supported_tokens": [ { "token_currency": "usdc", "token_contract_address": "0x…" } ] } } } } } ``` > #### PaymentIntents en cryptomonnaie > > Pour en savoir plus sur le fonctionnement des PaymentIntent en cryptomonnaie, y compris les adresses de dépôt, le cycle de vie des paiements et les réseaux pris en charge, consultez le [guide d’intégration du mode dépôt](https://docs.stripe.com/payments/deposit-mode-stablecoin-payments.md). ## Tester votre endpoint Envoyez une requête à votre serveur sans client admissible pour confirmer qu’elle renvoie un code d’état `402`. ```bash curl http://localhost:3000/paid ``` Vous voyez un code d’état `402.` Ensuite, effectuez une requête avec un client admissible. Utilisez le [purl](https://github.com/stripe/purl) de Stripe pour effectuer des tests dans la ligne de commande. ```bash purl http://localhost:3000/paid ``` > #### Environnements de test et testnet > > Les [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) que vous créez dans un [environnement de test](https://docs.stripe.com/sandboxes.md) ne surveillent pas les testnets crypto. Nous ne pouvons donc pas détecter automatiquement les transactions sur testnet que vous envoyez. Pour tester les `PaymentIntent` dans l’environnement de test, utilisez l’[endpoint d’assistance aux tests](https://docs.stripe.com/api/payment_intents/simulate_crypto_deposit.md?api-version=2026-03-04.preview) afin de simuler des dépôts en cryptomonnaie. [Pour en savoir plus, consultez la section consacrée au test de votre intégration](https://docs.stripe.com/payments/deposit-mode-stablecoin-payments.md#test-your-integration). Si vous avez connecté un wallet, le serveur renvoie le contenu et vous pouvez confirmer le paiement. Rendez-vous sur la page le [Stripe Dashboard Payments](https://dashboard.stripe.com/payments) pour consulter la transaction. Vous pouvez également utiliser curl pour récupérer les derniers paiements depuis l’API de Stripe : ```bash curl https://api.stripe.com/v1/payment_intents?limit=10 \ -u <>: ``` ## Exécuter des transactions sur le mainnet Pour exécuter des transactions sur le mainnet, intégrez un facilitateur x402 compatible avec le mainnet. Consultez le guide de la plateforme développeur Coinbase [utiliser le CDP Facilitator](https://docs.cdp.coinbase.com/x402/quickstart-for-sellers#running-on-mainnet). ## Prise en charge des tokens et des réseaux Les `PaymentIntent` utilisant le moyen de paiement `crypto` en `mode: deposit` prennent en charge l’USDC sur les réseaux suivants : | Réseau | Token | Adresse du contrat token | | ------ | ----- | ---------------------------------------------- | | Tempo | USDC | `0x20c000000000000000000000b9537d11c60e8b50` | | Base | USDC | `0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913` | | Solana | USDC | `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v` |