# Vendre via des agents Vendez vos produits via des agents d’IA avec Agentic Commerce Suite. > Agentic Commerce Suite est disponible aux États-Unis. Utilisez Agentic Commerce Suite (ACS) pour commencer à vendre via des agents grâce à une intégration unique. ACS vous aide à rendre vos produits visibles et à accepter les paiements agentiques à travers de multiples protocoles commerciaux. Cette solution vous permet de partager des informations sur les produits, les prix et la disponibilité avec les agents, tout en limitant au maximum les modifications à apporter à vos systèmes de commerce existants. Si vous exploitez une plateforme, consultez le [guide pour les plateformes](https://docs.stripe.com/connect/saas/tasks/enable-in-context-selling-on-ai-agents.md). ## Configurer votre compte Stripe Si vous ne disposez pas encore d’un compte Stripe, [créez-en un](https://stripe.com/register). Après avoir vérifié votre adresse e-mail, activez les paiements en fournissant des informations professionnelles et personnelles, en liant un compte bancaire pour les versements et en configurant l’authentification à deux facteurs. Ensuite, accédez aux paramètres d’[onboarding du commerce agentique](https://dashboard.stripe.com/agentic-commerce) dans le Dashboard Stripe. Cette étape vous guide dans la création d’un [Stripe Profile](https://docs.stripe.com/get-started/account/profile.md) et la configuration des paramètres pour le commerce agentique. ## Configurer les taxes Utilisez [Stripe Tax](https://docs.stripe.com/tax.md) pour gérer les taxes et appliquer des configurations à chaque produit. Suivez le [guide de configuration des taxes](https://docs.stripe.com/tax/set-up.md?dashboard-or-api=api) pour configurer Stripe Tax. Lorsque vous [créez un flux de catalogue](https://docs.stripe.com/agentic-commerce/for-sellers.md#upload-feed), définissez la colonne `stripe_product_tax_code` afin d’associer un produit à un traitement fiscal. Si vous utilisez [Anrok](https://www.anrok.com) pour le calcul des taxes, définissez plutôt la colonne `third_party_tax_code` dans votre flux de catalogue. Consultez la [référence des champs de prix et de promotions](https://docs.stripe.com/agentic-commerce/product-feed.md#price-and-promotions) pour en savoir plus sur ces champs. ## Configurer le service de support et les politiques juridiques Sur la page [Paramètres du commerce agentique](https://dashboard.stripe.com/settings/agentic-commerce), ajoutez des liens vers votre **politique de remboursement et de retour**, vos **conditions d’utilisation du service** et votre **politique de confidentialité**. Vous pouvez également fournir un lien vers votre **politique de la boutique**. ## Créer un flux de catalogue Créez un [flux de catalogue](https://docs.stripe.com/agentic-commerce/product-feed.md) pour partager vos données de produit et de stocks avec les agents. Envoyez vos données via le Dashboard ou l’API. Pour maintenir les données à jour, nous vous recommandons de charger les données produit une fois par jour et d’envoyer des mises à jour incrémentielles plus fréquentes pour l’inventaire et les prix. > Les téléchargements de flux sont traités comme des tâches indépendantes et asynchrones. Nous ne garantissons pas que les téléchargements soient traités ou terminés dans l’ordre dans lequel vous les soumettez. Si vous téléchargez plusieurs fichiers rapidement à la suite, un téléchargement ultérieur peut se terminer avant un téléchargement antérieur. #### API Utilisez les API Stripe pour importer votre fichier CSV de données produit. Nous recommandons d’utiliser l’environnement de test pour valider l’analyse, le mapping des champs et la qualité des données avant d’activer les mises à jour en mode production. > If you use a [restricted API key](https://docs.stripe.com/keys.md#create-restricted-api-key), it must have **Product Catalog Import** write permission. Without this permission, API requests return a `403` error. ### Créer une importation Créez un objet `ProductCatalogImport` à l’aide de l’[API Product Catalog Import](https://docs.stripe.com/api/v2/commerce/product-catalog-imports.md). Une requête réussie renvoie un [objet ProductCatalogImport](https://docs.stripe.com/api/v2/commerce/product-catalog-imports/object.md) à l’état `awaiting_upload`. Le champ `status_details.awaiting_upload.upload_url.url` de la réponse contient l’URL présignée pour le chargement de votre fichier. ```curl curl -X POST https://api.stripe.com/v2/commerce/product_catalog/imports \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" \ --json '{ "feed_type": "product", "mode": "upsert", "metadata": { "file_name": "march_11_2026_product_upload.csv" } }' ``` ```json { "id": "pcimprt_xxx", "object": "v2.commerce.product_catalog_import", "created": "2026-03-26T00:35:01.000Z", "feed_type": "product", "status": "awaiting_upload", "status_details": { "awaiting_upload": { "upload_url": { "expires_at": "2026-03-26T00:40:02.000Z", "url": "https://stripeusercontent.com/files/us-west-2/upload/wksp_xxx" } } }, "livemode": true } ``` ### Charger votre fichier CSV Chargez votre fichier CSV vers l’URL présignée. Le fichier doit être au format CSV ou TSV, où chaque ligne représente un produit ou une variante. La taille maximale du fichier est de 4 Go. ```curl curl -X PUT \ -H "Content-Type: text/csv" \ --data-binary @"/path/to/your/file.csv" \ "{{PRESIGNED_URL}}" ``` Une fois que Stripe reçoit le fichier, l’importation passe de l’état `awaiting_upload` à `processing`. Stripe valide le fichier et ingère les éléments. ### Surveillez l’état du flux et corrigez les erreurs Stripe traite vos données produit, les valide et les nettoie, puis les indexe dans un format que vous pouvez transmettre à des agents IA. Vous pouvez suivre la progression de l’indexation de deux manières : #### API Utilisez une requête `GET` pour interroger l’objet importé et vérifier le champ `status`. Continuez l’interrogation jusqu’à ce que l’objet atteigne un état terminal : `succeeded`, `succeeded_with_errors`, ou `failed`. ```curl curl https://api.stripe.com/v2/commerce/product_catalog/imports/{{PRODUCTCATALOGIMPORT_ID}} \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" ``` Si l’importation se termine sans erreurs, elle atteint l’état `succeeded`. Si le fichier est structurellement valide mais contient des erreurs au niveau de la ligne, l’importation atteint l’état `succeeded_with_errors`. Si l’importation ne peut pas se terminer (par exemple, parce que le fichier n’a jamais été chargé, est illisible ou qu’une erreur interne se produit), elle atteint l’état `failed`. Si le statut de l’importation est `succeeded_with_errors`, vous pouvez télécharger le fichier d’erreur : 1. Recherchez le champ `status_details.succeeded_with_errors.error_file.url` dans la réponse. 1. Téléchargez le fichier CSV directement à partir de cette URL avant son expiration. 1. Le fichier CSV contient uniquement les lignes en échec, avec une colonne `stripe_error_message` décrivant chaque erreur. > Les URL des fichiers d’erreur expirent au bout de 5 minutes. Pour obtenir une nouvelle URL, appelez à nouveau l’[endpoint retrieve](https://docs.stripe.com/api/v2/commerce/product-catalog-imports/retrieve.md). #### Webhooks Stripe envoie des événements webhook terminaux une fois l’indexation des données produit terminée. Configurez un endpoint pour écouter les événements `v2.commerce.product_catalog.imports.succeeded`, `v2.commerce.product_catalog.imports.succeeded_with_errors` et `v2.commerce.product_catalog.imports.failed`. Chaque événement inclut l’objet `v2.commerce.product_catalog_import`. Consultez le [guide des webhooks](https://docs.stripe.com/webhooks.md) pour obtenir des instructions détaillées. Voici un exemple de charge utile webhook `v2.commerce.product_catalog.imports.succeeded` : ```javascript { "id": "evt_65THl3VA5Zt5cTqbP16T9R4DRrSQbEWmWeLUx7WmOR8B", "object": "v2.core.event", "type": "v2.commerce.product_catalog.imports.succeeded", "created": "2026-03-26T00:40:00.000Z", "livemode": true, "reason": null, "related_object": { "id": "pcimprt_61THl3VA5Zt5cTqbP16T9R4DRrSQbEWmWeLUx7WmOR8K", "type": "v2.commerce.product_catalog.imports", "url": "/v2/commerce/product_catalog/imports/pcimprt_61THl3VA5Zt5cTqbP16T9R4DRrSQbEWmWeLUx7WmOR8K" }, "changes": { "before": {"status": "PROCESSING"}, "after": {"status": "SUCCEEDED"} }, "data": {} } ``` Le webhook n’inclut pas l’objet d’importation complet. Utilisez l’URL `related_object.url` pour le récupérer : ```curl curl https://api.stripe.com/v2/commerce/product_catalog/imports/{{PRODUCTCATALOGIMPORT_ID}} \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" ``` Si le statut de l’importation est `succeeded_with_errors`, vous pouvez télécharger le fichier d’erreur : 1. Recherchez le champ `status_details.succeeded_with_errors.error_file.url` dans la réponse. 1. Téléchargez le fichier CSV directement à partir de cette URL avant son expiration. 1. Le fichier CSV contient uniquement les lignes en échec, avec une colonne `stripe_error_message` décrivant chaque erreur. > Les URL des fichiers d’erreur expirent au bout de 5 minutes. Pour obtenir une nouvelle URL, appelez à nouveau l’endpoint retrieve. #### Dashboard Accédez à la page [Historique du flux](https://dashboard.stripe.com/agentic-commerce/feed-history) dans le Dashboard et importez votre fichier CSV de données produit. ## Configurer une URL de commande personnalisée Par défaut, Stripe renvoie un [reçu de paiement](https://docs.stripe.com/receipts.md) au client après confirmation de la commande. Pour fournir l’URL de commande que vous hébergez : 1. Sur la page [Paramètres commerce agentique](https://dashboard.stripe.com/settings/agentic-commerce) dans le Dashboard, sélectionnez **Custom page** (Page personnalisée) dans le menu déroulant **Receipt type** (Type de reçu). 1. Ajoutez l’URL de votre commande dans le champ **Custom page URL** (URL de page personnalisée). Votre URL doit inclure la variable de modèle `{CHECKOUT_SESSION_ID}`. Après confirmation de la commande, Stripe la remplace automatiquement par un ID de session Checkout. Vous pouvez utiliser cet ID pour récupérer la session Checkout et afficher les informations de la commande. ## Gérez les achats et assurez l’exécution des commandes Suivez les commandes passées via des agents d’IA de trois manières. #### Dashboard Affichez les commandes sur la [page Transactions](https://dashboard.stripe.com/payments) du Dashboard, elles sont identifiées en fonction de l’agent qui les a initiées. Vous pouvez également filtrer les transactions par nom d’agent. #### Webhooks Stripe envoie `checkout.session.completed` une fois que l’agent a finalisé une commande. Chaque commande génère un événement `checkout.session.completed` unique. Le webhook inclut l’objet [CheckoutSession](https://docs.stripe.com/api/checkout/sessions/object.md). Configurez un endpoint pour écouter les événements `checkout.session.completed`. Consultez le [guide des webhooks](https://docs.stripe.com/webhooks.md) pour obtenir des instructions détaillées. ```javascript const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY); // Use the secret provided by Stripe CLI for local testing // or your webhook endpoint's secret const endpointSecret = 'whsec_...'; app.post('/webhook', (request, response) => { const sig = request.headers['stripe-signature']; let event; try { event = stripe.webhooks.constructEvent(request.body, sig, endpointSecret); } catch (err) { response.status(400).send(`Webhook Error: ${err.message}`); return; } if (event.type === 'checkout.session.completed') { const session = event.data.object; // Fulfill the order using the session data fulfillCheckout(session.id); } response.status(200).send(); }); ``` Voici un exemple de contenu du webhook `checkout.session.completed` : ```javascript { "id": "evt_1SUz6YRhxngcl2jFHhAi1Wiu", "object": "event", "api_version": "2025-10-29.clover", "created": 1763511518, "data": { "object": { "id": "cs_test_a1exHOZ77Pg40P1hPtcWe2oT2xI8G9ruoQohXq6jkKldIPQaGsNSPQmOGZ", "object": "checkout.session", ... "total_details": { "amount_discount": 0, "amount_shipping": 0, "amount_tax": 0 } } }, "livemode": false, ... "type": "checkout.session.completed" } ``` Une fois le webhook reçu, récupérez tous les champs nécessaires via un unique appel à l’API. Pour limiter le nombre de requêtes, utilisez le paramètre de requête [expand](https://docs.stripe.com/api/expanding_objects.md) avec l’en-tête en version bêta `Stripe-Version: 2025-12-15.preview` afin de développer les sous-paramètres. ```curl curl https://api.stripe.com/v1/checkout/sessions/{{SESSION_ID}}?expand[]=line_items.data.price.product&expand[]=line_items.data.taxes&expand[]=payment_intent.latest_charge \ -u <>: \ -H "Stripe-Version: 2025-12-15.preview" ``` En savoir plus sur les champs de la [CheckoutSession](https://docs.stripe.com/api/checkout/sessions/object.md) étendue, tels que `amount_total`, la quantité et l’ID de l’unité de gestion des stocks. ### Référence du champ de la session de paiement | Champ de commande | Ressource disponible | Chemin API | | -------------------------------------------- | --------------------------------------------- | ----------------------------------------------------------------------------------- | | **Date de commande** | `CheckoutSession.PaymentIntent.LatestCharge` | `CheckoutSessions.PaymentIntent.LatestCharge.created` | | **Quantité de commandes** | `CheckoutSessions` | `CheckoutSession.LineItems.Data[].quantity` | | **SKU** | `CheckoutSessions` | `CheckoutSession.LineItems.Data[].price.external_reference` | | **Description du produit** | `CheckoutSessions` | `CheckoutSession.LineItems.Data[].price.product.description` | | **Prix unitaire** | `CheckoutSessions` | `CheckoutSession.LineItems.Data[].price.unit_amount` | | **Montant des taxes** | `CheckoutSessions` | `CheckoutSession.LineItems.Data[].Taxes[].amount` | | **Type de taxe** | `CheckoutSessions` | `CheckoutSession.LineItems.Data[].Taxes[].Rate.tax_type` | | **Taux d’imposition** | `CheckoutSessions` | `CheckoutSession.LineItems.Data[].Taxes[].Rate.percentage` | | **Adresse de livraison** | `CheckoutSessions` | `CheckoutSessions.CollectedInformation.shipping_details` | | **Adresse de facturation** | `CheckoutSessions.PaymentIntent.LatestCharge` | `CheckoutSessions.PaymentIntent.LatestCharge.billing_details` | | **Derniers4** | `CheckoutSessions.PaymentIntent.LatestCharge` | `CheckoutSessions.PaymentIntent.LatestCharge.payment_method_details.card.last4` | | **MoisExp** | `CheckoutSessions.PaymentIntent.LatestCharge` | `CheckoutSessions.PaymentIntent.LatestCharge.payment_method_details.card.exp_month` | | **AnnéeExp** | `CheckoutSessions.PaymentIntent.LatestCharge` | `CheckoutSessions.PaymentIntent.LatestCharge.payment_method_details.card.exp_year` | | **Type de carte de crédit** | `CheckoutSessions.PaymentIntent.LatestCharge` | `CheckoutSessions.PaymentIntent.LatestCharge.payment_method_details.card.brand` | | **Montant final** | `CheckoutSessions` | `CheckoutSessions.amount_total` | | **GTIN** (Private preview) | `CheckoutSessions` | `CheckoutSession.LineItems.Data[].price.product.identifiers.gtin` | | **MPN** (Private preview) | `CheckoutSessions` | `CheckoutSession.LineItems.Data[].price.product.identifiers.mpn` | | **Détails de l’agent** (Version bêta privée) | `CheckoutSession.PaymentIntent` | `CheckoutSessions.PaymentIntent.agent_details` | | **Num.Commande** | `CheckoutSession.PaymentIntent.LatestCharge` | `CheckoutSessions.PaymentIntent.LatestCharge.receipt_number` | #### Traitement par lots Au lieu de traiter chaque commande séparément, exécutez plusieurs commandes à la fois via l’[endpoint Liste des CheckoutSessions](https://docs.stripe.com/api/checkout/sessions/list.md). ```curl # List all successful CheckoutSessions in the last hour curl https://api.stripe.com/v1/checkout/sessions?created[gt]={{TIMESTAMP}}&status=complete \ -u <>: ``` Pour éviter les exécutions en double, utilisez le paramètre `starting_after`. ```curl curl https://api.stripe.com/v1/checkout/sessions?created[gt]={{TIMESTAMP}}&status=complete&starting_after={{LAST_SESSION_ID}} \ -u <>: ``` ## Tester votre intégration Vous pouvez tester votre intégration directement depuis le Dashboard dans un[environnement de test](https://docs.stripe.com/sandboxes.md) : 1. Accédez à la page [Commerce agentique](https://dashboard.stripe.com/agentic-commerce), puis cliquez sur **Voir le flux**. 1. Survolez le produit que vous souhaitez tester, puis cliquez sur **Test**. ## Activer les ventes sur un agent discutant par chat IA Lorsque vous êtes prêt à vendre via une interface IA, consultez les conditions des agents et activez l’agent dans le Dashboard. Stripe envoie une demande d’approbation à l’agent, que celui-ci doit accepter. Pour suspendre ou arrêter la vente sur un agent de chat IA, désactivez l’agent dans le Dashboard. ## Optional: Configurez la capture manuelle Par défaut, Stripe capture les paiements immédiatement après l’achat. Pour utiliser la capture manuelle, ouvrez la page [Paramètres agentic commerce](https://dashboard.stripe.com/settings/agentic-commerce) dans le Dashboard et définissez le mode de capture sur manuel. Lorsque vous activez la capture manuelle, appelez la méthode `capture` sur le `PaymentIntent`. ```curl curl -X POST https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/capture \ -u <>: \ -H "Stripe-Version: 2025-09-30.preview" ``` ## Optional: Configurer un hook d’approbation de commande Par défaut, et avant de confirmer un paiement, nous vérifions les stocks en fonction des données de votre catalogue des produits et nous pouvons appliquer les contrôles de fraude en fonction de votre configuration de [Radar](https://docs.stripe.com/radar.md). Si vous souhaitez décider vous-même de la finalisation d’un achat, activez un hook d’approbation de la commande. Avant de finaliser le processus de paiement, nous envoyons une requête d’approbation à votre service. Vous devez accepter ou refuser la requête. Stripe impose un délai d’attente de quatre secondes pour votre hook. Si votre hook ne répond pas dans ce délai, Stripe refuse le paiement. Pour configurer un hook d’approbation de commande : 1. Spécifiez l’endpoint sur la page [Paramètres Agentic Commerce](https://dashboard.stripe.com/settings/agentic-commerce) du Dashboard. 1. Activer les **Approbations de commandes** 1. Déployez votre logique sur l’endpoint en respectant les formats de requête et de réponse présentés ci-dessous. > Stripe renvoie un code d’état `424` aux agents si votre point de terminaison renvoie un code d’état autre que `2xx`. Certains agents sont susceptibles de relancer ces requêtes API ; vous devez donc vous assurer que votre point de terminaison est idempotent. ### Format de la requête Stripe envoie la requête suivante à votre endpoint : ```typescript { type: "v1.delegated_checkout.finalize_checkout", id: string, livemode: boolean, // account ID context?: string, // request specific data data: { amount_subtotal?: number, amount_total?: number, billing_details?: { name?: string, address?: { line1?: string, line2?: string, city?: string, state?: string, postal_code?: string, country?: string } }, currency: string, email?: string, line_items_details: Array<{ id: string, unit_amount: number, quantity: number, name: string }>, payment_method_details?: { type: "card" | ..., card?: { brand: "amex" | "visa" | "master_card" | ..., country?: string, exp_month: number, exp_year: number, fingerprint?: string, funding: "credit" | "debit" | "prepaid" | "unknown", iin?: string, last4: string, wallet?: { type: "apple_pay" | "google_pay" | ... } } }, phone?: string, shipping_details?: { name?: string, address?: { line1?: string, line2?: string, city?: string, state?: string, postal_code?: string, country?: string }, }, total_details?: { amount_discount?: number, amount_shipping?: number, amount_tax?: number } } } ``` ### Format de la réponse Votre endpoint doit renvoyer une réponse HTTP `200` au format suivant : ```typescript { manual_approval_details: { type: "approved" | "declined", declined?: { reason: string } }, // Connect only: set an application fee for the transaction application_fee_details?: { application_fee_amount: number, transfer_data?: { amount?: number, } } } ``` ## Optional: Configurer un hook de personnalisation du paiement Par défaut, Stripe calcule les taxes et les options de livraison de vos produits sur la base des options définies dans votre [catalogue de produits](https://docs.stripe.com/agentic-commerce/product-feed.md). Pour calculer les taxes ou les options et coûts de livraison de manière dynamique avec votre logique : 1. Spécifiez l’endpoint sur la page [Paramètres Agentic Commerce](https://dashboard.stripe.com/settings/agentic-commerce) du Dashboard. 1. Activez **Taux d’imposition personnalisé** ou **Options de livraison personnalisées**. 1. Déployez votre logique sur l’endpoint en respectant les formats de requête et de réponse présentés ci-dessous. > Stripe renvoie un code d’état `424` aux agents si votre point de terminaison renvoie un code d’état autre que `2xx`. Certains agents sont susceptibles de relancer ces requêtes API ; vous devez donc vous assurer que votre point de terminaison est idempotent. ### Format de la requête Stripe envoie la requête suivante à votre endpoint : ```typescript { type: "v1.delegated_checkout.customize_checkout", id: string, livemode: boolean, // Connected account ID context?: string, // Request specific data data: { // Used by the seller to determine whether they can set manual tax rates on line items automatic_tax: { enabled: boolean, }, currency: string, line_item_details?: Array<{ id: string, sku_id: string, unit_amount: number, amount_discount: number, amount_subtotal: number, amount_tax: number, amount_total: number, quantity: number, name: string, tax_rates: Array<{ rate: { id: string, display_name: string, percentage: number, inclusive: boolean, } // Amount of tax applied for this rate. amount: number }> }>, shipping_details?: { // Same as the shipping rate object described at https://docs.stripe.com/api/shipping_rates/object#shipping_rate_object shipping_rate?: { id: string, display_name?: string, metadata?: Map, tax_code?: string , tax_behavior: 'unspecified' | 'inclusive' | 'exclusive', fixed_amount: { amount: number, currency: 'usd' | 'cad' | etc., currency_options.: { amount: number, tax_behavior: 'unspecified' | 'inclusive' | 'exclusive', } }, delivery_estimate?: { maximum: { unit: 'business_day' | 'day' | 'hour' | 'month' | 'year', value: number }, minimum: { unit: 'business_day' | 'day' | 'hour' | 'month' | 'year', value: number } } }, // Same as the shipping rate object described at https://docs.stripe.com/api/shipping_rates/object#shipping_rate_object shipping_rates?: Array<{ id: string, display_name?: string, metadata?: Map, tax_code?: string, tax_behavior: 'unspecified' | 'inclusive' | 'exclusive', fixed_amount: { amount: number, currency: 'usd' | 'cad' | etc., currency_options.: { amount: number, tax_behavior: 'unspecified' | 'inclusive' | 'exclusive', } }, delivery_estimate?: { maximum: { unit: 'business_day' | 'day' | 'hour' | 'month' | 'year', value: number }, minimum: { unit: 'business_day' | 'day' | 'hour' | 'month' | 'year', value: number } } }, address?: { line1?: string, line2?: string, city?: string, state?: string, postal_code?: string, country?: string } }, amount_total?: number, amount_subtotal?: number, total_details?: { amount_discount?: number, amount_shipping?: number, amount_tax?: number } } } ``` ### Format de la réponse Votre endpoint doit renvoyer une réponse HTTP `200` au format suivant : ```typescript { shipping_options?: Array<{ // ID of the shipping rate, or data provided to create the shipping rate. Only provide one; not both shipping_rate?: string, shipping_rate_data: { display_name?: string, fixed_amount: { amount: number, currency: 'usd' | 'cad' | etc., }, metadata?: Map, tax_code?: string , tax_behavior?: 'unspecified' | 'inclusive' | 'exclusive', // Same as the shipping rate object described at https://docs.stripe.com/api/shipping_rates/create#create_shipping_rate-delivery_estimate delivery_estimate?: { maximum: { unit: 'business_day' | 'day' | 'hour' | 'month' | 'year', value: number }, minimum: { unit: 'business_day' | 'day' | 'hour' | 'month' | 'year', value: number } } }, }>, line_items?: Array<{ // Corresponding ID of the line item to update id: string, // List of tax rates to apply to this line item // Provide either `rate` or `rate_data` tax_rates: Array<{ // ID of a v1 tax rate rate?: string, // Or `rate_data`. // This will use an existing tax rate that matches the params or will create one if a matching rate does not exist rate_data?: { display_name: string, inclusive: boolean, // percentage out of 100 percentage: number, } }, }> } ``` ## Optional: Tester vos hooks Vous pouvez tester votre hook d’approbation de commande ou de personnalisation de la page de paiement en fournissant un endpoint accessible publiquement qui peut accepter les requêtes de hook avec une méthode `POST`. Configurez votre fonction d’endpoint de sorte qu’elle : 1. gère les requêtes `POST` avec une charge utile JSON 1. renvoie un code d’état de réussite (`200`) Pour le développement local, utilisez un outil de tunneling comme [ngrok](https://ngrok.com/) pour exposer votre endpoint local. ### Exemple d’endpoint Cet extrait de code illustre une fonction d’endpoint qui reçoit des requêtes `v1.delegated_checkout.finalize_checkout` et renvoie une réponse `200`. Vous pouvez trouver la clé secrète de la signature sous la destination de l’événement **Extension de commerce agentique** dans vos paramètres de webhook dans le [Dashboard des développeurs](https://docs.stripe.com/development/dashboard.md). #### Ruby ```ruby require 'json' require 'sinatra' require 'stripe' set :port, 4242 # Replace with your endpoint's secret from your webhook settings endpoint_secret = 'whsec_...' # Using Sinatra post '/hooks' do payload = request.body.read sig_header = request.env['HTTP_STRIPE_SIGNATURE'] # Verify the webhook signature begin Stripe::Webhook::Signature.verify_header( payload, sig_header, endpoint_secret ) rescue Stripe::SignatureVerificationError => e status 400 return end # Handle the payload payload = JSON.parse(payload) case payload['type'] when 'v1.delegated_checkout.finalize_checkout' # Check inventory and accept payment data = { manual_approval_details: { type: 'approved' } } end status 200 body data.to_json end ``` ## Optional: Envoyer des mises à jour incrémentielles de l’inventaire En plus d’importer vos données produit, envoyez des mises à jour d’inventaire pour chaque produit via l’[API Imports](https://docs.stripe.com/api/v2/commerce/product-catalog-imports.md). Utilisez le même processus de chargement que pour les données produit, mais définissez `feed_type` sur `inventory`. Les flux d’inventaire ne prennent en charge que le mode `upsert`. ```curl curl -X POST https://api.stripe.com/v2/commerce/product_catalog/imports \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" \ --json '{ "feed_type": "inventory", "mode": "upsert", "metadata": { "file_name": "march_11_2026_inventory_upload.csv" } }' ``` ## Optional: Envoyer des mises à jour incrémentielles de prix Chargez vos données produit, puis envoyez les mises à jour de prix individuelles via l’[API Imports](https://docs.stripe.com/api/v2/commerce/product-catalog-imports.md). Utilisez le même processus de chargement que pour les données produit, mais définissez `feed_type` sur `pricing`. Les flux de prix ne prennent en charge que le mode `upsert`. ```curl curl -X POST https://api.stripe.com/v2/commerce/product_catalog/imports \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" \ --json '{ "feed_type": "pricing", "mode": "upsert", "metadata": { "file_name": "march_11_2026_pricing_upload.csv" } }' ``` ## Optional: Gérer les remboursements et les litiges Si un client annule la commande sur votre site web ou via le service client après un paiement réussi, initiez un remboursement. Si vous utilisez déjà l’API Payment Sessions ou PaymentIntents, votre flux de remboursement existant fonctionne sans modification pour les paiements agentiques. Gérez les remboursements et les litiges directement dans le Dashboard, sur la [page Transactions](https://dashboard.stripe.com/payments), ou utilisez l’[API Refunds](https://docs.stripe.com/api/refunds.md) pour traiter les annulations et les remboursements par voie programmatique. ## See also - [Tokens de paiement partagés](https://docs.stripe.com/agentic-commerce/concepts/shared-payment-tokens.md)