# Activer les achats en contexte via les agents d’IA

Découvrez comment permettre à vos entreprises de vendre leurs produits via des agents de chat basés sur l’IA.

> Si votre plateforme souhaite utiliser le commerce agentique pour vendre les produits de vos entreprises, [inscrivez-vous sur la liste d’attente](https://go.stripe.global/agentic-commerce-contact-sales). Le commerce agentique pour les plateformes est disponible pour les entreprises aux États-Unis et nécessite une approbation après inscription sur la liste d’attente.

Utilisez le commerce agentique pour permettre à vos comptes connectés de vendre des produits par l’intermédiaire d’agents par chat IA. Votre plateforme charge des [données sur le flux de produits](https://docs.stripe.com/agentic-commerce/product-feed.md) et configure les hooks de paiement pour les taxes et les frais, et les comptes connectés s’inscrivent à des canaux d’agent. Lorsqu’un client effectue un achat par l’intermédiaire d’un agent, Stripe exécute le paiement et appelle les hooks de votre plateforme avant de finaliser la transaction.
Un aperçu simplifié du flux de commerce agentique pour les plateformes (See full diagram at https://docs.stripe.com/connect/saas/tasks/enable-in-context-selling-on-ai-agents)
## Installer votre plateforme

Rendez-vous sur la page [Paramètres de commerce agentique](https://dashboard.stripe.com/settings/connect/agentic-commerce) dans le Dashboard pour inscrire votre plateforme. L’assistant d’onboarding vous guide à travers :

- Créer un [Profil Stripe](https://docs.stripe.com/get-started/account/profile.md) pour votre plateforme.
- Choisir votre type de paiement (*direct* (A charge type where customers transact directly with a connected account, which is always the merchant of record. With each payment, the connected account pays fees to Stripe and, optionally, to your platform) ou *indirect* (A charge type where customers transact with your platform for products or services provided by a connected account. Your platform pays Stripe fees and immediately transfers funds to the connected account with each payment) avec *on\_behalf\_of* (A parameter that allows a Connect platform to create an indirect payment where the connected account is the merchant of record (MoR))).
- Activez les canaux d’agents IA par lesquels vos comptes connectés peuvent effectuer des ventes.
- Configurer les paramètres de commerçant, y compris votre endpoint webhook, le type de reçu et les politiques de prise en charge.

Après avoir terminé l’onboarding, vous pouvez gérer ces paramètres depuis la même page.

## Choisir votre type de paiement

Dans le flux d’achat en contexte, Stripe crée une session de paiement agentique pour votre plateforme. Pour créer la session, Stripe doit savoir quel type de paiement utiliser. Stripe prend en charge les paiements direct et indirects avec `on_behalf_of`. Dans les deux types de paiement, le compte connecté agit comme commerçant.

Configurez votre type de paiement pendant[l’onboarding de la plateforme](https://docs.stripe.com/connect/saas/tasks/enable-in-context-selling-on-ai-agents.md#set-up-platform), ou mettez-le à jour plus tard depuis la page [Paramètres de commerce agentique](https://dashboard.stripe.com/settings/connect/agentic-commerce) dans le Dashboard.

## Charger les données de votre catalogue de produits dans Stripe

### Préparer votre catalogue de produits

Pour chaque compte connecté, créez un fichier CSV conforme aux [spécifications du catalogue produits Stripe](https://docs.stripe.com/agentic-commerce/product-feed.md).

### Chargez les données du catalogue de produits sur Stripe

Téléchargez les données du catalogue de produits pour chaque compte connecté séparément. Vous pouvez envoyer des mises à jour toutes les 15 minutes. Utilisez un environnement de test pour valider l’analyse, le mappage des champs et la qualité des données avant d’activer les mises à jour en mode production.

#### API

Créez un `ProductCatalogImport` pour le compte connecté. 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. La taille maximale du fichier est de 4 Go.

```curl
curl -X POST https://api.stripe.com/v2/commerce/product_catalog/imports \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-04-22.preview" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  --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
}
```

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&nbsp;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`.

### Surveiller l’état du flux

Stripe valide et nettoie les données du catalogue de produits, les indexe et les convertit dans un format que les agents d’IA peuvent utiliser. Interrogez l’[objet Import](https://docs.stripe.com/api/v2/commerce/product-catalog-imports/object.md) jusqu’à ce qu’il atteigne un état terminal&nbsp;: `succeeded`, `succeeded_with_errors` ou `failed`.

```curl
curl https://api.stripe.com/v2/commerce/product_catalog/imports/{{PRODUCTCATALOGIMPORT_ID}} \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-04-22.preview" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}"
```

Vous pouvez également écouter les événements webhook terminaux `v2.commerce.product_catalog.imports.succeeded`, `v2.commerce.product_catalog.imports.succeeded_with_errors` et `v2.commerce.product_catalog.imports.failed`. Le webhook inclut l’ID d’importation dans `related_object.id`, que vous pouvez utiliser pour récupérer l’objet complet.

Si l’importation se termine sans erreurs, elle atteint l’état `succeeded`. Si le fichier est structurellement valide mais contient des problèmes de validation 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é, qu’il 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&nbsp;:

1. Trouvez 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&nbsp;minutes. Pour obtenir une nouvelle URL, appelez à nouveau l’[endpoint retrieve](https://docs.stripe.com/api/v2/commerce/product-catalog-imports/retrieve.md).

#### Dashboard

Allez sur la page **Comptes connectés** et sélectionnez le compte, puis faites défiler jusqu’à la section **Gestion des fonds**. Dans **Commerce agentique**, téléchargez un catalogue produit CSV pour ce compte. Vous pouvez consulter les erreurs de catalogue et l’état du catalogue de produits depuis cette page.

Vous pouvez aussi filtrer la liste de vos comptes connectés par **État du catalogue de produits** pour voir quels comptes ont des catalogues chargés.

## Configurer les taxes pour vos comptes connectés

Utilisez Stripe Tax pour des calculs de taxes entièrement gérés, ou implémentez un hook fiscal dans votre intégration si vous avez besoin d’une logique fiscale personnalisée ou si vous devez intégrer un fournisseur fiscal tiers.

#### Calcul automatisé des taxes avec Stripe Tax

Utilisez Stripe Tax pour calculer et collecter les taxes pour chacun de vos comptes connectés. Consultez la documentation [Configuration des taxes pour les plateformes](https://docs.stripe.com/tax/tax-for-platforms.md) pour configurer Stripe Tax.

Dans l’import CSV de votre catalogue de produits, définissez la colonne `stripe_product_tax_code` afin d’associer chaque produit à un traitement fiscal.

Consultez la documentation [codes fiscaux](https://docs.stripe.com/tax/tax-codes.md) pour obtenir la liste complète des codes fiscaux pris en charge.

Vous pouvez également calculer les taxes via des [fournisseurs fiscaux tiers](https://docs.stripe.com/tax/third-party-apps.md), tels que Anrok, Avalara et Sphere.

#### Calcul fiscal personnalisé avec des hooks

Utilisez un [hook de personnalisation du paiement](https://docs.stripe.com/connect/saas/tasks/enable-in-context-selling-on-ai-agents.md#checkout-customization-hook) pour gérer l’événement `v1.delegated_checkout.customize_checkout` et renvoyer `tax_rates` pour chaque poste.

Pour configurer le hook de taxe&nbsp;:

1. Créez un endpoint sur votre serveur pour recevoir les événements de personnalisation du paiement.

Consultez [webhooks](https://docs.stripe.com/webhooks.md) pour plus d’informations sur la configuration des webhooks dans votre formulaire d’inscription.

#### Node.js

```javascript
const stripe = require('stripe');
const express = require('express');
const app = express();

app.use("/checkout-customization-hook", express.raw({ type: "application/json" }));
app.post("/checkout-customization-hook", (req, res) => {
  const sig = req.headers["stripe-signature"];
  const endpointSecret = process.env.WEBHOOK_SECRET; // Store this securely

  try {
    stripe.webhooks.signature.verifyHeader(req.body, sig, endpointSecret, stripe.webhooks.DEFAULT_TOLERANCE);
  } catch (err) {
    console.log(`Webhook signature verification failed: ${err.message}`);
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  const event = JSON.parse(req.body);
  if (event.type === "v1.delegated_checkout.customize_checkout") {
    const data = event.data;
    const connectedAccount = event.context;

    const response = {
      line_items:
        data.line_item_details?.map((item) => ({
          id: item.id,
          tax_rates: [
            {
              rate_data: {
                display_name: "Sales tax",
                inclusive: false,
                percentage: 8.5, // Replace with your actual tax rate
              },
            },
            {
              rate_data: {
                display_name: "Environmental fee",
                inclusive: false,
                percentage: 1.0, // Replace with your actual fee rate
              },
            },
          ],
        })) || [],
    };

    return res.status(200).json(response);
  }

  return res.status(400).json({ error: "Unsupported webhook type" });
});

app.listen(4567, () => console.log("Server is running on port 4567"));
```

1. Inscrivez votre URL endpoint webhook sur la page [Paramètres de commerce agentique](https://dashboard.stripe.com/settings/connect/agentic-commerce) dans le Dashboard.
1. Gérez l’événement `v1.delegated_checkout.customize_checkout` et renvoyez les taux de taxe pour chaque poste, comme indiqué dans l’exemple de code.

## Monétiser les transactions

Par défaut, lorsque vous créez une session de paiement agentique, aucune commission de la plateforme n’est appliquée.

> Vous devez ajouter une commission de la plateforme lorsque votre plateforme paie les frais Stripe pour un compte connecté. Sans commission de la plateforme, vous pouvez perdre de l’argent sur chaque transaction.

#### Hook pour la commission de la plateforme

Utilisez un [hook de personnalisation du paiement](https://docs.stripe.com/connect/saas/tasks/enable-in-context-selling-on-ai-agents.md#checkout-customization-hook) pour gérer l’événement `v1.delegated_checkout.finalize_checkout` et renvoyer des commissions de plateforme.

Consultez la documentation sur les [webhooks](https://docs.stripe.com/webhooks.md) pour plus d’informations sur la configuration des webhooks dans votre formulaire d’inscription.

#### Node.js

```javascript
const stripe = require('stripe');
const express = require('express');
const app = express();

app.use("/agentic-commerce-hook", express.raw({ type: "application/json" }));
app.post("/agentic-commerce-hook", async (req, res) => {
  const sig = req.headers["stripe-signature"];
  const endpointSecret = process.env.WEBHOOK_SECRET; // Store this securely

  try {
    stripe.webhooks.signature.verifyHeader(req.body, sig, endpointSecret, stripe.webhooks.DEFAULT_TOLERANCE);
  } catch (err) {
    console.log(`Webhook signature verification failed: ${err.message}`);
    return res.status(400).send(`Webhook Error: ${err.message}`);
  }

  const event = JSON.parse(req.body);
  console.log("Received event:", event.type);
  if (event.type === "v1.delegated_checkout.finalize_checkout") {
    const data = event.data;
    // Perform validation checks for order approval
    const orderAmount = data.amount_total || 0;
    const lineItems = data.line_items_details || [];
    const connectedAccount = event.context;
    const stripeCheckoutSessionId = data.checkout_session;

    const applicatonFee = await calculateApplicationFee(lineItems);
    const {reason, isApproved} = await calculateOrderApproval();

    if (isApproved) {
      return res.status(200).json({
        manual_approval_details: {
          type: "approved"
        },
        application_fee_details: {
          application_fee_amount: applicatonFee
        }
      });
    } else {
      return res.status(200).json({
        manual_approval_details: {
          type: "declined",
          declined: {
            reason,
          }
        }
      });
    }
  }

  return res.status(400).json({ error: "Unsupported webhook type" });
});

app.listen(4567, () => console.log("Server is running on port 4567"));
```

#### Facturer une commission de la plateforme avec l’outil de tarification de la plateforme

Si un compte connecté utilise une configuration de payeur de frais dans laquelle votre plateforme paie les frais Stripe, vous pouvez utiliser l’[outil de tarification](https://docs.stripe.com/connect/platform-pricing-tools.md) de la plateforme pour facturer une commission de la plateforme.

## Activez vos comptes connectés pour vendre avec des agents

Les comptes connectés doivent vérifier les conditions de l’agent et activer un agent pour vendre via celui-ci. Stripe envoie à l’agent une requête d’approbation que ce dernier doit accepter. Les comptes connectés peuvent gérer quels agents d’IA vendent leurs produits, personnaliser l’apparence de leur entreprise sur les plateformes d’agents, et mettre en pause ou arrêter la vente à n’importe quel agent.

#### Composant intégré

Intégrez directement le composant de paramétrage du commerce agentique dans l’interface utilisateur de votre plateforme afin de proposer aux comptes connectés un onboarding et une expérience de gestion de manière native. Pour plus de détails sur l’intégration des fonctionnalités du Dashboard dans votre site web, consultez [Démarrer avec les composants embarqués Connect](https://docs.stripe.com/connect/get-started-connect-embedded-components.md).

#### Ruby

```ruby
require 'sinatra'
require 'stripe'
# This is a placeholder - it should be replaced with your secret API key.
# Sign in to see your own test API key embedded in code samples.
# Don't submit any personally identifiable information in requests made with this key.
# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/account_session' do
  content_type 'application/json'

  begin
    account_session = client.v1.account_sessions.create({
      account: '{{CONNECTED_ACCOUNT_ID}}',
      components: {
        agentic_commerce_settings: {
          enabled: true,
        }
      }
    })

    {
      client_secret: account_session[:client_secret]
    }.to_json
  rescue => error
    puts "An error occurred when calling the Stripe API to create an account session: #{error.message}";
    return [500, { error: error.message }.to_json]
  end
end
```

#### HTML + JS

```html
<head>
  <script type="module" src="index.js" defer></script>
</head>
<body>
  <h1>Payments</h1>
  <div id="container"></div>
  <div id="error" hidden>Something went wrong!</div>
</body>
```

```javascript
import {loadConnectAndInitialize} from '@stripe/connect-js';

const fetchClientSecret = async () => {
  // Fetch the AccountSession client secret
  const response = await fetch('/account_session', { method: "POST" });
  if (!response.ok) {
    // Handle errors on the client side here
    const {error} = await response.json();
    console.error('An error occurred: ', error);
    document.querySelector('#error').removeAttribute('hidden');
    return undefined;
  } else {
    const {client_secret: clientSecret} = await response.json();
    document.querySelector('#error').setAttribute('hidden', '');
    return clientSecret;
  }
}

const stripeConnectInstance = loadConnectAndInitialize({
    // This is a placeholder - it should be replaced with your publishable API key.
    // Sign in to see your own test API key embedded in code samples.
    // Don’t submit any personally identifiable information in requests made with this key.
    publishableKey: "<<YOUR_PUBLISHABLE_KEY>>",
    fetchClientSecret: fetchClientSecret,
  });
const paymentComponent = stripeConnectInstance.create("agentic-commerce-settings");
const container = document.getElementById("container");
container.appendChild(paymentComponent);
```

#### Dashboard Stripe complet

Les comptes connectés ayant accès à l’intégralité du Dashboard Stripe peuvent s’inscrire au commerce agentique en se rendant sur **Paramètres > Paiements > Commerce agentique**. Depuis cette page, ils peuvent créer un profil Stripe, configurer leur paramètres de commerçant, et activer ou désactiver les canaux d’agent.

#### Dashboard Express

Les comptes connectés via le Dashboard Express peuvent se rendre dans les **Paramètres** et trouver la section **Commerce agentique**. À partir de là, ils peuvent gérer leur profil de commerçant, configurer les paramètres et activer ou désactiver les canaux d’agent.

## Assurer le traitement des achats et des commandes

Écoutez les webhooks Stripe pour suivre les commandes passées via des agents de chat IA.

Lorsqu’une commande est confirmée, Stripe émet des événements webhook que votre serveur peut traiter pour exécuter la logique de traitement. Configurez un endpoint sur votre serveur pour accepter, traiter et accuser réception de ces événements. Consultez le [Guide des webhooks](https://docs.stripe.com/webhooks.md) pour obtenir des instructions détaillées sur l’intégration et le test des webhooks Stripe.

Stripe émet les événements `checkout.session.completed` et `payment_intent.succeeded`. Si votre logique de traitement des commandes gère déjà ces événements, aucune modification d’intégration supplémentaire n’est nécessaire. Vous pouvez personnaliser cette logique pour la vente agentique en contexte, par exemple en indiquant dans l’e-mail de confirmation de commande que le paiement a été effectué via un agent.

Pour en savoir plus sur la configuration des webhooks pour les comptes connectés, consultez la [documentation Connect webhooks](https://docs.stripe.com/connect/webhooks.md).

#### Node.js

```javascript
const stripe = require('stripe')(process.env.STRIPE_SECRET_KEY);
const express = require('express');
const app = express();

// Use the secret provided by Stripe CLI for local testing
// or your webhook endpoint's secret
const endpointSecret = 'whsec_...';

app.post('/webhook', async (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') {
    let session = event.data.object;
    // For V1 webhooks event.account is the connected account
    session = await stripe.checkout.sessions.retrieve(
      session.id,
      {
        expand: ["line_items.data.price.product", "line_items.data.price"],
      },
      // If using direct charges, the checkout session is created on the connected account and the `stripeAccount` parameter must be passed. If using destination charges the checkout session is created on the platform account and `stripeAccount` parameter can be ignored.
      {
        stripeAccount: "{{CONNECTED_ACCOUNT_ID}}",
      },
    );

    // SKU id is available at session.line_items.data[number].price.external_reference
    fulfillCheckout(event.account, session);
  }

  response.status(200).send();
});
```

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 <<YOUR_SECRET_KEY>>: \
  -H "Stripe-Version: 2025-12-15.preview" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"
```

Consultez les champs disponibles dans la [session Checkout](https://docs.stripe.com/api/checkout/sessions/object.md) étendue, tels que `amount_total`, quantity ou encore l’ID du SKU.

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

## 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)&nbsp;:

1. Ouvrez le [blueprint Trigger Agentic Purchase](https://dashboard.stripe.com/test/workbench/blueprints/agentic-commerce-turnkey-agentic-purchase) dans Workbench.
1. Saisissez l’ID du compte connecté et un ID d’unité de gestion des stocks
1. Cliquez sur **Exécuter** pour simuler le paiement d’un agent

## Optional: Capture manuelle

Par défaut, Stripe enregistre les paiements immédiatement après la finalisation d’un achat. Pour utiliser la capture manuelle, activez-la sur la page [Paramètres de commerce agentique](https://dashboard.stripe.com/settings/connect/agentic-commerce) dans le Dashboard. Après avoir activé la capture manuelle, appelez la méthode de capture sur le `PaymentIntent` retourné dans le webhook décrit dans la section précédente.

```curl
curl -X POST https://api.stripe.com/v1/payment_intents/pi_3MrPBM2eZvKYlo2C1TEMacFD/capture \
  -u "<<YOUR_SECRET_KEY>>:"
```

## 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&nbsp;:

1. Spécifiez l’endpoint sur la page [Paramètres Agentic Commerce](https://dashboard.stripe.com/settings/connect/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&nbsp;; 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&nbsp;:

```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&nbsp;`200` au format suivant&nbsp;:

```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&nbsp;:

1. Spécifiez l’endpoint sur la page [Paramètres Agentic Commerce](https://dashboard.stripe.com/settings/connect/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&nbsp;; 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&nbsp;:

```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<string,string>,
        tax_code?: string ,
        tax_behavior: 'unspecified' | 'included' | 'excluded',
        fixed_amount: {
          amount: number,
          currency: 'usd' | 'cad' | etc.,
          currency_options.<currency>: {
            amount: number,
            tax_behavior: 'unspecified' | 'included' | 'excluded',
          }
        },
        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<string,string>,
        tax_code?: string,
        tax_behavior: 'unspecified' | 'included' | 'excluded',
        fixed_amount: {
          amount: number,
          currency: 'usd' | 'cad' | etc.,
          currency_options.<currency>: {
            amount: number,
            tax_behavior: 'unspecified' | 'included' | 'excluded',
          }
        },
        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&nbsp;`200` au format suivant&nbsp;:

```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<string,string>,
      tax_code?: string ,
      tax_behavior?: 'unspecified' | 'included' | 'excluded',
      // 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&nbsp;:

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 est une fonction d’endpoint configurée pour recevoir une requête `v1.delegated_checkout.finalize_checkout` et renvoyer une réponse `200`.

#### 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: Gérer le contrat avec les agents

> Cette API est en version bêta privée. Les exemples ci-dessous sont susceptibles d’être modifiés.

Lorsqu’un compte connecté s’inscrit à un agent, Stripe crée un objet Agreement entre le marchand et l’agent. Stripe émet des événements webhook à la plateforme et à l’agent chaque fois que l’état de l’objet Agreement change&nbsp;:

- `v2.orchestrated_commerce.agreement.created`&nbsp;: un Agreement a été créé entre le marchand et l’agent.
- `v2.orchestrated_commerce.agreement.partially_confirmed`&nbsp;: le marchand a confirmé l’Agreement.
- `v2.orchestrated_commerce.agreement.confirmed`&nbsp;: l’agent a confirmé l’Agreement.
- `v2.orchestrated_commerce.agreement.terminated`&nbsp;: le marchand ou l’agent a résilié l’Agreement.

Surveillez les événements suivants sur votre endpoint webhook afin de maintenir l’état de votre plateforme synchronisé (par ex. mettre à jour l’interface utilisateur, activer ou désactiver l’accès des agents ou notifier les commerçants).

### Récupérer un Agreement

Récupérez un objet Agreement à l’aide de l’API Agreements&nbsp;:

```curl
curl https://api.stripe.com/v2/orchestrated_commerce/agreements/{{AGREEMENT_ID}} \
  -H "Authorization: Bearer {{API_KEY}}" \
  -H "Stripe-Version: 2025-12-19-17.internal" \
  -H "Stripe-Account: {{CONNECTED_ACCOUNT_ID}}"
```

## Optional: Envoyer des mises à jour d’inventaire incrémentielles

En plus d’importer votre catalogue de produits, vous pouvez envoyer 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 catalogues, 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 <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-04-22.preview" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  --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 de catalogue de 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 catalogues, 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 <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-04-22.preview" \
  -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \
  --json '{
    "feed_type": "pricing",
    "mode": "upsert",
    "metadata": {
        "file_name": "march_11_2026_pricing_upload.csv"
    }
  }'
```

## Optional: Gérer les remboursements et les litiges

Si vous utilisez déjà l’[API Payment Intents](https://docs.stripe.com/api/payment_intents.md) ou l’[API Checkout Sessions](https://docs.stripe.com/api/checkout/sessions.md), vos flux de remboursement et de liitige existants fonctionnent sans modifications pour la vente agentique en contexte. Stripe crée des `PaymentIntents` pour les flux de paiement agentiques, permettant votre intégration de continuer de fonctionner tant que vous associez l’identifiant de `PaymentIntent` avec votre commande.

Si un client annule la commande depuis votre site web ou via le service client après un paiement réussi, vous pouvez initier un remboursement. Gérez les remboursements et les litiges dans le Dashboard depuis la [Page des transactions](https://dashboard.stripe.com/payments), ou utiliser l’[API Refunds](https://docs.stripe.com/api/refunds.md) pour les traiter par voie programmatique.