# Authentification avec 3D Secure

Intégrez 3D Secure (3DS) à votre tunnel de paiement.

> Les principales marques de cartes bancaires ne prennent plus en charge 3D Secure 1. Si votre implémentation utilise 3D Secure 1, mettez-la à niveau pour utiliser les API [Payment Intents](https://docs.stripe.com/api/payment_intents.md) et [Setup Intents](https://docs.stripe.com/api/setup_intents.md). Utiliser ces API permet de :
> 
> - Prend en charge [3D Secure 2 (3DS2)](https://stripe.com/guides/3d-secure-2).
- Tirer parti de [3D Secure Dynamic](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#three-ds-radar).
- Respecter la réglementation européenne sur l’[authentification forte du client](https://docs.stripe.com/strong-customer-authentication.md).

Vous pouvez intégrer l’authentification 3D Secure (3DS) à votre tunnel de paiement sur différentes plateformes, notamment web, iOS, Android et React Native. Cette intégration exécute [3D Secure 2 (3DS2)](https://stripe.com/guides/3d-secure-2) si cette version est prise en charge par la banque du client, ou 3D Secure 1 dans le cas contraire. Vous pouvez également effectuer une authentification 3DS sur Stripe lors de l’acquisition de la transaction auprès d’un autre prestataire de services de paiement (PSP) en utilisant le produit [Standalone 3DS](https://docs.stripe.com/payments/3d-secure/standalone-three-d-secure.md).

#### Web
![Page de paiement](https://b.stripecdn.com/docs-statics-srv/assets/3ds-flow-1-checkout-page.039294e0dee3a6dede8ea8a32185aae5.png)

Le client saisit ses informations de carte.
![Symbole de chargement](https://b.stripecdn.com/docs-statics-srv/assets/3ds-flow-2-frictionless-flow.417618d0570c469cfb6bbc43630c7896.png)

La banque du client évalue la transaction et peut lancer l’authentification 3D Secure.
![Fenêtre modale d'authentification](https://b.stripecdn.com/docs-statics-srv/assets/3ds-flow-3-challenge-flow.9052a220f336bbdb75a51799622c6477.png)

Si la banque le demande, le client se soumet à une étape d’authentification supplémentaire.

#### iOS
![Écran de paiement](https://b.stripecdn.com/docs-statics-srv/assets/3ds2-checkout.1cd901263328cbb76020b66c173da8b7.png)

Le client saisit ses informations de carte.
![Écran de chargement](https://b.stripecdn.com/docs-statics-srv/assets/3ds2-loading.f93743ad15b9120027f93f49ed45b26d.png)

Le SDK présente un écran de chargement pendant que la banque du client vérifie si une authentification est requise.
![Écran du flux d'authentification](https://b.stripecdn.com/docs-statics-srv/assets/3ds2-otp.ce1e46e0a853d7d6e3238750a07bca86.png)

Si la banque le demande, le SDK authentifie le client.

#### Android
![Écran de paiement](https://b.stripecdn.com/docs-statics-srv/assets/auth-flow-step01-confirm.399f5a4abbd7f303861689d186b79557.png)

Le client saisit ses informations de paiement.
![Initier l'authentification](https://b.stripecdn.com/docs-statics-srv/assets/auth-flow-step02-processing.3877946d74743878ec86cec56dd69085.png)

Le SDK présente un écran de chargement pendant que la banque du client vérifie si une authentification est requise.
![Écran du flux d'authentification](https://b.stripecdn.com/docs-statics-srv/assets/auth-flow-step03-otp.f42397e1ce4ec5975e05f1bada72d195.png)

Si la banque le demande, le SDK authentifie le client.

## Contrôler le flux 3DS

Stripe déclenche automatiquement l’authentification 3DS lorsque des réglementations telles que l’[authentification forte du client](https://docs.stripe.com/strong-customer-authentication.md) en Europe s’appliquent, si des directives du secteur (telles que les directives de sécurité relatives aux cartes de crédit au Japon) l’exigent, si un émetteur le demande avec un code de [refus temporaire](https://docs.stripe.com/declines/codes.md) ou lorsque certaines optimisations Stripe s’appliquent.

Vous pouvez également [utiliser Radar](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#three-ds-radar) ou [l’API](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#manual-three-ds) pour décider quand inviter les utilisateurs à s’authentifier par 3DS. Cela vous permet de personnaliser le processus d’authentification pour chaque utilisateur en fonction des paramètres que vous avez choisis. Cependant, certaines transactions ne prennent pas en charge 3DS, par exemple les wallets ou les *paiements hors session* (A payment is described as off-session if it occurs without the direct involvement of the customer, using previously-collected payment information).

Lorsqu’un paiement déclenche l’authentification 3DS, l’émetteur de la carte peut exiger que le client s’authentifie pour finaliser le paiement, à condition que l’authentification 3DS soit prise en charge pour cette carte. Bien que Stripe initie la demande d’authentification, l’exigence provient de l’émetteur. Selon le front-end que vous utilisez, cela peut vous obliger à [afficher le flux 3DS](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#when-to-use-3d-secure).

Dans le cas d’un flux classique de l’API Payment Intent qui déclenche l’authentification 3DS :

1. L’utilisateur saisit ses informations de paiement, qui confirment un PaymentIntent, un SetupIntent ou associent un PaymentMethod à un objet Customer.
1. Stripe détermine si la transaction prend en charge et nécessite 3DS sur la base des mandats réglementaires, des règles Radar, des requêtes manuelles à l’API, des refus de paiement provisoires de l’émetteur et d’autres critères.
1. Si 3DS est :
   - **Non requis** : en raison, par exemple, d’une *exemption* (Some transactions that are deemed low risk, based on the volume of fraud rates associated with the payment provider or bank, may be exempt from Europe's Strong Customer Authentication requirements), Stripe tente le paiement. Le PaymentIntent passe à l’état `processing`. Si l’émetteur le demande via un [refus partiel](https://docs.stripe.com/declines/codes.md) de paiement, nous effectuons automatiquement une nouvelle tentative et poursuivons comme si 3DS était exigé.
   - **Non pris en charge** : le PaymentIntent passe à l’état `requires_payment_method`. En fonction de la raison pour laquelle 3DS a été déclenché, il peut être possible de poursuivre l’étape d’autorisation du paiement. Dans ce cas, le PaymentIntent passe à l’état `processing`.
   - **Obligatoire** : Stripe lance le flux d’authentification 3DS en contactant le serveur de contrôle d’accès 3DS (ACS) de l’émetteur de la carte et en lançant le flux 3DS.
1. Lorsque les informations sur le flux 3DS sont reçues de l’émetteur, Stripe soumet la requête à l’émetteur afin d’authentifier le titulaire de la carte. Le PaymentIntent passe à l’état `requires_action` :
   - Découvrez ci-dessous comment [afficher l’action 3DS requise](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#when-to-use-3d-secure). Les émetteurs peuvent demander différents types d’actions de flux 3DS, qui peuvent ne pas toujours se traduire par l’affichage d’une demande d’authentification 3DS (par exemple, un flux simple).
   - Si l’émetteur ne prend pas du tout en charge 3DS ou en cas de panne, Stripe peut tenter d’effectuer le paiement sans authentification, si cela est autorisé.
   - Les données des demandes d’authentification 3DS sont généralement fournies par le client au moment de la transaction. Pour faciliter la transaction et réduire le risque d’échec de l’authentification, nous pouvons compléter ces demandes par des informations provenant d’autres sources. Il peut s’agir de données saisies par votre client dans le tunnel de paiement, de données de transactions antérieures entre vous et un client, ou d’informations pertinentes provenant de la carte du client ou de l’émetteur.
   - Si Stripe a déjà accès à toutes les données 3DS requises, notre serveur 3DS optimisé peut tenter de compléter la demande d’authentification pour vous tout en confirmant le PaymentIntent. Le PaymentIntent peut alors passer directement à l’état `processing` si le flux 3DS aboutit, ou à l’état `requires_action` si des étapes ou des données supplémentaires sont nécessaires pour compléter le flux 3DS.
1. En fonction du résultat de l’authentification 3DS :
   - **Authentifié** : Stripe tente le paiement et le PaymentIntent passe à l’état `processing`.
   - **Échec** : le PaymentIntent passe à l’état `requires_payment_method`, indiquant que vous devez utiliser un autre moyen de paiement, ou que vous pouvez effectuer une nouvelle tentative d’authentification 3DS après une nouvelle confirmation.
   - **Autres scénarios** : en fonction de la raison pour laquelle le paiement a déclenché l’authentification 3DS, il peut être permis de poursuivre l’autorisation dans des [cas particuliers](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card-three_d_secure-result). Par exemple, un résultat `attempt_acknowledged` entraîne un paiement et le PaymentIntent passe à l’état `processing`.
     - La création de [mandats électroniques indiens pour les paiements récurrents](https://docs.stripe.com/india-recurring-payments.md) constitue une exception. Tout résultat autre que `authenticated` est considéré comme un échec.
1. En fonction du résultat du paiement, le PaymentIntent passe à l’un des états suivants : `succeeded`, `requires_capture` ou `requires_payment_method`.

Pour déterminer si un paiement par carte a fait l’objet d’une tentative d’authentification 3DS ou prenait en charge cette méthode, lisez la propriété [three_d_secure](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card-three_d_secure) sur les informations de la carte au niveau de l’élément `payment_method_details` du paiement. Stripe renseigne la propriété `three_d_secure` lorsque le client tente d’authentifier la carte. L’attribut `three_d_secure.result` indique le résultat de l’authentification.

### Utiliser des règles Radar dans le Dashboard

Stripe propose des [contrôles anti-fraude](https://docs.stripe.com/radar/rules.md#request-3d-secure) pour exiger l’authentification 3DS de manière dynamique lors de la création ou de la confirmation d’un [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) ou d’un [SetupIntent](https://docs.stripe.com/api/setup_intents.md). Vous pouvez configurer ces règles dans votre [Dashboard](https://dashboard.stripe.com/settings/radar/rules).

Si vous disposez de [Radar for Fraud Teams](https://stripe.com/radar/fraud-teams), vous pouvez ajouter des [règles 3DS personnalisées](https://docs.stripe.com/radar/rules.md#request-3d-secure).

### Demander manuellement une authentification 3DS avec l’API

La méthode par défaut pour déclencher le 3DS consiste à [utiliser Radar pour demander dynamiquement le 3D Secure](https://docs.stripe.com/radar/risk-settings.md#adaptive-3ds) en fonction du niveau de risque et d’autres exigences. Le déclenchement manuel du 3DS est destiné aux utilisateurs avancés qui intègrent Stripe à leur propre moteur de détection des fraudes.

Pour déclencher 3DS manuellement, définissez `payment_method_options[card][request_three_d_secure]` en fonction de ce pour quoi vous souhaitez optimiser soit lors de la création ou de la confirmation d’une [PaymentIntent](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-card-request_three_d_secure) ou [SetupIntent](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_options-card-request_three_d_secure), soit lors de la création d’une [Checkout Session](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_method_options-card-request_three_d_secure). Ce processus est le même pour les paiements uniques ou lors de la mise en place d’un moyen de paiement pour les paiements futurs. Lorsque vous fournissez ce paramètre, Stripe tente d’effectuer 3DS et remplace toute [dynamic 3D Secure Radar rules](https://docs.stripe.com/radar/rules.md) sur PaymentIntent, SetupIntent ou Paiement Session.

#### API Payment Intents

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1000 \
  -d currency=usd \
  -d "payment_method_options[card][request_three_d_secure]=any"
```

#### API Setup Intents

```curl
curl https://api.stripe.com/v1/setup_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_options[card][request_three_d_secure]=any"
```

#### API Checkout Session

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d mode=payment \
  --data-urlencode "success_url=https://example.com/success" \
  -d "line_items[0][price]={{PRICE_ID}}" \
  -d "line_items[0][quantity]=1" \
  -d "payment_method_options[card][request_three_d_secure]=any"
```

Pour savoir quand vous devez fournir ce paramètre, définissez à quel moment votre moteur de fraude détecte le risque. Par exemple, si votre moteur de fraude n’inspecte que les informations de carte, vous savez s’il faut demander ou non une authentification 3DS avant de créer l’objet PaymentIntent ou SetupIntent. Si le moteur de fraude inspecte les informations de carte et de transaction, fournissez le paramètre pendant la confirmation, une fois que vous disposez de davantage d’informations. Transmettez ensuite le PaymentIntent ou le SetupIntent à votre client pour finaliser l’opération.

Découvrez comment utiliser le paramètre `request_three_d_secure` pour chaque cas de figure dans la documentation sur l’API&nbsp;:

- [Créer un PaymentIntent](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-card-request_three_d_secure)
- [Confirmer un PaymentIntent](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-payment_method_options-card-request_three_d_secure)
- [Créer un SetupIntent](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_options-card-request_three_d_secure)
- [Confirmer un SetupIntent](https://docs.stripe.com/api/setup_intents/confirm.md#confirm_setup_intent-payment_method_options-card-request_three_d_secure)
- [Créer une session Checkout](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_method_options-card-request_three_d_secure)

Définissez `request_three_d_secure` sur `any` pour déclencher manuellement l’authentification 3DS en favorisant un flux de type `frictionless` (simple), ce qui augmentera la probabilité que l’authentification soit effectuée sans solliciter d’informations supplémentaires de la part du client.

Définissez `request_three_d_secure` sur `challenge` pour déclencher l’authentification 3DS via un flux de type `challenge` (complexe), qui oblige le client à répondre à une demande d’authentification active.

Stripe ne peut pas garantir votre choix, car c’est l’émetteur qui détermine le flux d’authentification final. Pour prendre connaissance du flux d’authentification utilisé, examinez l’attribut `authentication_flow` de la propriété `three_d_secure` de l’objet [Charge](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card-three_d_secure-authentication_flow) ou [SetupAttempt](https://docs.stripe.com/api/setup_attempts/object.md#setup_attempt_object-payment_method_details-card-three_d_secure-authentication_flow). Pour en savoir plus sur les flux 3DS, lisez notre [guide](https://stripe.com/guides/3d-secure-2#frictionless-authentication).

> Stripe invite votre client à s’authentifier uniquement si l’authentification 3DS est disponible pour sa carte. Si ce n’est pas le cas ou si une erreur se produit lors du processus d’authentification, le paiement se poursuit normalement.

Les règles d’authentification obligatoires de Stripe s’exécutent automatiquement, que vous demandiez ou non 3DS manuellement. Toute demande 3DS que vous effectuez s’ajoute à celles requises pour la SCA.

## Afficher le flux 3DS

#### Web

Lors de l’appel de `confirmCardPayment` et `handleCardAction`, Stripe affiche automatiquement l’interface utilisateur d’authentification dans une fenêtre modale contextuelle. Vous pouvez également choisir de rediriger l’utilisateur vers le site Web de la banque ou d’utiliser une balise iframe.

Stripe.js collecte des [informations de base sur l’appareil](https://support.stripe.com/questions/3d-secure-2-device-information) pendant l’authentification 3DS2 et les envoie à la banque émettrice à des fins d’analyse des risques.

### Rediriger l’utilisateur vers le site Web de la banque

Pour rediriger votre client vers la page d’authentification 3DS, transmettez l’URL `return_url` à l’objet PaymentIntent lors de la confirmation côté [serveur](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-return_url) ou côté [client](https://docs.stripe.com/js/payment_intents/confirm_card_payment).

Après la confirmation, si un objet PaymentIntent affiche l’état *requires\_action* (This status appears as "requires_source_action" in API versions before 2019-02-11), vérifiez sa propriété `next_action`. Si elle a pour valeur `redirect_to_url`, cela signifie que l’authentification 3DS est requise.

```js
next_action: {
    type: 'redirect_to_url',
    redirect_to_url: {
      url: 'https://hooks.stripe.com/...',
      return_url: 'https://mysite.com'
    }
}
```

Dans le navigateur, redirigez le client vers l’`url` de la valeur redirect_to_url pour terminer l’authentification.

```javascript
  var action = intent.next_action;
  if (action && action.type === 'redirect_to_url') {
    window.location = action.redirect_to_url.url;
  }
```

Lorsque le client termine le processus d’authentification, il est redirigé vers la page `return_url` que vous avez spécifiée lors de la création ou de la confirmation du PaymentIntent. La redirection ajoute également les paramètres de requête d’URL `payment_intent` et `payment_intent_client_secret`, que votre application peut utiliser pour identifier le PaymentIntent associé à l’achat.

### Afficher dans un iframe

Vous ne pouvez pas personnaliser l’interface utilisateur d’authentification sur le Web pour qu’elle corresponde au design de votre site Web. La banque qui a émis la carte contrôle les polices et les couleurs.

Cependant, vous pouvez choisir *comment* et *où* afficher l’interface utilisateur 3DS. La plupart des entreprises l’affichent dans une boîte de dialogue modale au-dessus de leur page de paiement. Si vous disposez de votre propre composant modal, vous pouvez y placer le cadre 3DS. Vous pouvez également afficher le contenu de l’authentification dans votre formulaire de paiement.

#### Confirmer le PaymentIntent

Lorsque le client est prêt à effectuer son achat, vous *confirmez* (Confirming a PaymentIntent indicates that the customer intends to pay with the current or provided payment method. Upon confirmation, the PaymentIntent attempts to initiate a payment) le PaymentIntent pour commencer le processus d’encaissement du paiement.

Si vous souhaitez contrôler l’affichage de 3DS, indiquez une URL `return_url`, vers laquelle `<iframe>` 3DS est redirigé une fois l’authentification terminée. Si votre site utilise une [politique de sécurité du contenu](https://docs.stripe.com/security/guide.md#content-security-policy), vérifiez qu’elle autorise les iframes de `https://js.stripe.com`, de `https://hooks.stripe.com` et de l’origine de l’URL que vous avez transmise à `return_url`.

Si la confirmation se fait à partir du front-end, utilisez la méthode [confirmCardPayment](https://docs.stripe.com/js.md#stripe-confirm-card-payment) dans Stripe.js. Par exemple, si vous recueillez les informations de carte bancaire à l’aide de Stripe Elements&nbsp;:

```javascript
stripe.confirmCardPayment(
  '{{PAYMENT_INTENT_CLIENT_SECRET}}',
  {
    payment_method: {card: cardElement},
    return_url: 'https://example.com/return_url'
  },
  // Disable the default next action handling.
  {handleActions: false}
).then(function(result) {
  // Handle result.error or result.paymentIntent
  // More details in Step 2.
});
```

Si la confirmation se fait à partir de votre serveur, indiquez une `return_url`. Selon votre intégration, vous devrez peut-être transmettre également d’autres informations à [confirm](https://docs.stripe.com/api/payment_intents/confirm.md).

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  --data-urlencode "return_url=https://example.com/return_url"
```

#### Vérifier l’état du PaymentIntent  (Server-side)

Ensuite, examinez la [propriété d’état](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) du PaymentIntent confirmé pour savoir si le paiement a abouti. La liste suivante décrit les valeurs `status` possibles et leur signification&nbsp;:

| État                      | Description                                                                                                                                                                                                                                                                                                                                                                  |
| ------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `requires_payment_method` | La requête a échoué avec un code d’état HTTP `402`, ce qui signifie que le paiement n’a pas abouti. Vérifiez la propriété [last_payment_error](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error) et retentez d’effectuer le paiement, même si vous devez pour cela collecter à nouveau les informations de paiement du client. |
| `requires_capture`        | La requête a abouti sans authentification. Vous pouvez continuer à [capturer les fonds](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md#capture-funds).                                                                                                                                                                                                 |
| `requires_action`         | Une étape supplémentaire telle qu’une authentification 3DS est nécessaire pour effectuer le paiement. Demandez au client de rouvrir votre application pour finaliser le paiement.                                                                                                                                                                                            |
| `succeeded`               | Le paiement a été effectué et un débit a été créé avec le moyen de paiement fourni. Aucune autre étape n’est requise.                                                                                                                                                                                                                                                        |

Sur les versions de l’API antérieures au [11/02/2019](https://docs.stripe.com/upgrades.md#2019-02-11), `requires_payment_method` correspond à `requires_source` et `requires_action` correspond à `requires_source_action`.

#### Afficher l’iframe 3D Secure (Client-side)

Lorsque la valeur de la propriété `status` est définie sur `requires_action`, cela signifie que le traitement du paiement nécessite une action supplémentaire de votre part. Pour un paiement par carte nécessitant 3DS, la propriété `status` du PaymentIntent a la valeur `requires_action`, et sa propriété [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action) a la valeur `redirect_to_url`. La charge utile de `redirect_to_url` contient une URL qui s’ouvre dans un iframe pour afficher 3DS&nbsp;:

```javascript
  var iframe = document.createElement('iframe');
  iframe.src = paymentIntent.next_action.redirect_to_url.url;
  iframe.width = 600;
  iframe.height = 400;
  yourContainer.appendChild(iframe);
```

Pour 3DS2, les émetteurs de cartes doivent prendre en charge l’affichage du contenu 3DS aux tailles 250&nbsp;x&nbsp;400, 390&nbsp;x&nbsp;400, 500&nbsp;x&nbsp;600, 600&nbsp;x&nbsp;400 et plein écran (largeur x hauteur). Vous pouvez améliorer l’interface utilisateur 3DS en ouvrant l’iframe à exactement l’une de ces tailles.

> Vous ne pouvez pas utiliser l’attribut `sandbox` sur l’iframe 3DS. En mode production, l’émetteur de carte contrôle une partie du contenu de l’iframe. Si elles sont utilisées en environnement de test, les implémentations de certains émetteurs échoueront et le paiement ne pourra pas aboutir.

#### Gérer la redirection (côté client)

Une fois que le client a effectué l’authentification 3DS, l’iframe le redirige vers la `return_url` que vous avez indiquée au moment de la confirmation du PaymentIntent. Cette page doit `postMessage` sur votre page de niveau supérieur pour l’informer que l’authentification 3D Secure est terminée. Votre page de niveau supérieur doit ensuite déterminer si le paiement a abouti ou si le client doit effectuer des actions supplémentaires.

Vous pouvez, par exemple, faire en sorte que votre page `return_url` exécute&nbsp;:

```javascript
  window.top.postMessage('3DS-authentication-complete');
```

Votre page de paiement principale doit écouter ce postMessage pour savoir quand l’authentification est terminée. Vous devez ensuite récupérer le PaymentIntent actualisé et vérifier l’état du paiement. Si l’authentification a échoué, l’état du PaymentIntent est `requires_payment_method`. Si le paiement a abouti, l’état est `succeeded`. Si vous effectuez [l’autorisation et la capture séparément](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md), l’état est `requires_capture`.

```javascript
  function on3DSComplete() {
    // Hide the 3DS UI
    yourContainer.remove();

    // Check the PaymentIntent
    stripe.retrievePaymentIntent('{{PAYMENT_INTENT_CLIENT_SECRET}}')
      .then(function(result) {
        if (result.error) {
          // PaymentIntent client secret was invalid
        } else {
          if (result.paymentIntent.status === 'succeeded') {
            // Show your customer that the payment has succeeded
          } else if (result.paymentIntent.status === 'requires_payment_method') {
            // Authentication failed, prompt the customer to enter another payment method
          }
        }
      });
  }

  window.addEventListener('message', function(ev) {
    if (ev.data === '3DS-authentication-complete') {
      on3DSComplete();
    }
  }, false);
```

#### iOS

> [PaymentSheet](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet) et [PaymentSheet.FlowController](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller) prennent automatiquement en charge le protocole d’authentification 3DS. Si vous utilisez l’une de ces classes, les informations contenues dans ce guide ne sont pas adaptées.

La classe [STPPaymentHandler](https://stripe.dev/stripe-ios/stripepayments/documentation/stripepayments/stppaymenthandler) présente les UIViewControllers sur l’application pour l’authentification. [STPPaymentHandler.threeDSCustomizationSettings](https://stripe.dev/stripe-ios/stripepayments/documentation/stripepayments/stpthreedscustomizationsettings) contient les éléments personnalisables pour l’authentification 3DS.

La propriété [authenticationTimeout](https://stripe.dev/stripe-ios/stripepayments/documentation/stripepayments/stpthreedscustomizationsettings/authenticationtimeout) contrôle la durée d’exécution du processus d’authentification 3DS avant son expiration. Cette durée comprend le temps de traitement par le réseau, ainsi que la durée de saisie par le client, et ne peut pas être inférieure à 5&nbsp;minutes. Si l’authentification expire, `STPPaymentHandler` signale une erreur à l’aide du code `STPPaymentHandlerTimedOutErrorCode` dans le bloc de finalisation.

La propriété [uiCustomization](https://stripe.dev/stripe-ios/stripepayments/documentation/stripepayments/stpthreedscustomizationsettings/uicustomization) vous permet de fournir une instance de [STPThreeDSUICustomization](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPThreeDSUICustomization.html) pour contrôler l’apparence de l’interface utilisateur d’authentification. Pour chaque élément personnalisable de l’interface utilisateur, comme la barre de navigation ou le bouton **Envoyer**, il existe une classe correspondante comprenant des propriétés pour la configuration des couleurs, polices de caractère, textes, bordures, etc. Consultez la [documentation STPThreeDSUICustomization](https://stripe.dev/stripe-ios/stripepayments/documentation/stripepayments/stpthreedsuicustomization) pour obtenir une explication détaillée de chaque paramètre.

Le SDK iOS de Stripe collecte des [informations de base sur l’appareil](https://support.stripe.com/questions/3d-secure-2-device-information) pendant l’authentification 3DS2 et les envoie à la banque émettrice à des fins d’analyse des risques.
![Personnalisation de l'interface utilisateur](https://b.stripecdn.com/docs-statics-srv/assets/3ds2-customization.4c49ec979d27637fcc3ad11b1dca10f8.png)

L’exemple de code suivant montre certaines des configurations associées à un thème d’interface utilisateur aux couleurs sombres.

#### Swift

```swift
      let uiCustomization = STPPaymentHandler.shared().threeDSCustomizationSettings.uiCustomization
      uiCustomization.textFieldCustomization.keyboardAppearance = .dark
      uiCustomization.navigationBarCustomization.barStyle = .black
      uiCustomization.navigationBarCustomization.textColor = .white
      uiCustomization.buttonCustomization(for: .cancel).textColor = .white
```

Vous disposez de quatre types d’écrans de vérification que vous pouvez présenter à votre client. [Testez la personnalisation de votre interface utilisateur](https://docs.stripe.com/payments/3d-secure/authentication-flow.md#three-ds-cards) avec ces différents écrans.

Vous pouvez également choisir le contrôleur d’affichage qui présente l’interface utilisateur d’authentification et les autres comportements à l’aide du [STPAuthenticationContext](https://stripe.dev/stripe-ios/stripepayments/documentation/stripepayments/stpauthenticationcontext) transmis à `STPPaymentHandler`.

### Configurer une URL de redirection

Le SDK iOS peut présenter une vue Web (plutôt qu’une vue native) dans votre application pour authentifier le client (par exemple, si votre client utilise une version obsolète). Une fois l’authentification effectuée, la vue Web peut disparaître automatiquement sans que votre client ait besoin de la fermer. Pour cela, [définissez un schéma d’URL personnalisé](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app) ou [un lien universel](https://developer.apple.com/documentation/xcode/allowing-apps-and-websites-to-link-to-your-content) et configurez votre délégation d’application de façon à transférer l’URL au SDK.

#### Swift

```swift
// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool {
    let stripeHandled = StripeAPI.handleURLCallback(with: url)
    if (stripeHandled) {
        return true
    } else {
        // This was not a Stripe url – handle the URL normally as you would
    }
    return false
}

// This method handles opening universal link URLs (for example, "https://example.com/stripe_ios_callback")
func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool {
    if userActivity.activityType == NSUserActivityTypeBrowsingWeb {
        if let url = userActivity.webpageURL {
            let stripeHandled = StripeAPI.handleURLCallback(with: url)
            if (stripeHandled) {
                return true
            } else {
                // This was not a Stripe url – handle the URL normally as you would
            }
        }
    }
    return false
}
```

Ensuite, transmettez l’URL en tant que `return_url` lorsque vous [confirmez le PaymentIntent](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-return_url) (si vous encaissez un paiement) ou le [SetupIntent](https://docs.stripe.com/api/setup_intents/confirm.md#confirm_setup_intent-return_url) (si vous enregistrez des informations de carte bancaire). Une fois l’authentification terminée sur la vue Web, Stripe redirige l’utilisateur vers votre application ou page Web au moyen de la `return_url` que vous avez fournie.

#### Android

> [PaymentSheet](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/index.html) et [PaymentSheet.FlowController](https://stripe.dev/stripe-android/paymentsheet/com.stripe.android.paymentsheet/-payment-sheet/-flow-controller/index.html) prennent automatiquement en charge le protocole d’authentification 3DS. Si vous utilisez l’une de ces classes, les informations contenues dans ce guide ne sont pas adaptées.

[PaymentAuthConfig.Stripe3ds2Config](https://stripe.dev/stripe-android/payments-core/com.stripe.android/-payment-auth-config/-stripe3ds2-config/index.html) contient les éléments personnalisables de l’authentification 3DS.

La [propriété timeout](https://stripe.dev/stripe-android/payments-core/com.stripe.android/-payment-auth-config/-stripe3ds2-config/-builder/set-timeout.html) contrôle la durée d’exécution du processus d’authentification 3DS avant son expiration. Cette durée comprend le temps de traitement par le réseau ainsi que la durée de saisie par le client. Cette valeur doit être d’au moins 5&nbsp;minutes pour rester conforme à la réglementation sur l’authentification forte du *client* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments). Une valeur inférieure à cette durée entraînera une erreur.

La propriété [uiCustomization](https://stripe.dev/stripe-android/payments-core/com.stripe.android/-payment-auth-config/-stripe3ds2-config/-builder/set-ui-customization.html) vous permet de fournir une instance de `StripeUiCustomization` pour contrôler l’apparence des vues présentées par le SDK Android durant l’authentification 3DS. À l’heure actuelle, Stripe prend en charge la personnalisation des couleurs, polices de caractère, textes, bordures, barres, libellés, champs de texte et boutons. Pour en savoir plus sur chaque paramètre, consultez la documentation sur le [SDK Android](https://stripe.dev/stripe-android/).

Le SDK Android de Stripe collecte des [informations de base sur l’appareil](https://support.stripe.com/questions/3d-secure-2-device-information) pendant l’authentification 3DS2 et les envoie à la banque émettrice à des fins d’analyse des risques.

#### Java

```java
  final PaymentAuthConfig.Stripe3ds2UiCustomization uiCustomization =
          new PaymentAuthConfig.Stripe3ds2UiCustomization.Builder()
                  .setLabelCustomization(
                          new PaymentAuthConfig.Stripe3ds2LabelCustomization.Builder()
                                  .setTextFontSize(12)
                                  .build())
                  .build();
  PaymentAuthConfig.init(new PaymentAuthConfig.Builder()
          .set3ds2Config(new PaymentAuthConfig.Stripe3ds2Config.Builder()
                  .setTimeout(5)
                  .setUiCustomization(uiCustomization)
                  .build())
          .build());
```

#### React&nbsp;Native

> Vous n’avez pas besoin de suivre ce guide si vous utilisez [PaymentSheet](https://stripe.dev/stripe-react-native/api-reference/modules/PaymentSheet.html), car il prend automatiquement en charge l’authentification 3DS.

La propriété `threeDSecureParams` de `StripeProvider` contient les éléments personnalisables de l’authentification 3DS.

Pour fermer automatiquement la vue Web une fois l’authentification terminée, [configurez un schéma d’URL personnalisé](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app) ou un [lien universel](https://developer.apple.com/documentation/xcode/allowing-apps-and-websites-to-link-to-your-content) et définissez votre schéma dans le paramètre `urlScheme`.

Vous pouvez utiliser la valeur `timeout` pour spécifier le délai d’expiration du processus d’authentification 3DS. Ce délai, qui ne peut pas être inférieur à 5&nbsp;minutes, comprend le temps de traitement par le réseau ainsi que la durée de saisie par le client.

D’autres propriétés vous permettent de gérer l’apparence de l’interface utilisateur d’authentification. Pour en savoir plus, consultez la [documentation sur le SDK React Native](https://stripe.dev/stripe-react-native/api-reference/index.html).

Vous trouverez ci-dessous un exemple de personnalisation&nbsp;:

```javascript
function PaymentScreen() {
  return (
    <StripeProvider
      publishableKey="<<YOUR_PUBLISHABLE_KEY>>"
      urlScheme="your-url-scheme"
      threeDSecureParams={{
        backgroundColor: '#FFFFFF', // iOS only
        timeout: 5,
        label: {
          headingTextColor: '#0000',
          headingFontSize: 13,
        },
        navigationBar: {
          headerText: '3d secure',
        },
        footer: { // iOS only
          backgroundColor: '#FFFFFF',
        },
        submitButton: {
          backgroundColor: '#000000',
          cornerRadius: 12,
          textColor: '#FFFFFF',
          textFontSize: 14,
        },
      }}
    >
      // ....
      </StripeProvider>
  );
}
```

## Tester le flux 3DS

Utilisez une carte de test Stripe avec un code CVC, un code postal et date d’expiration future pour déclencher des flux de contestation d’authentification 3DS dans un environnement de test.

Lorsque vous créez une intégration avec vos clés API de test, une page d’authentification factice s’affiche. Sur cette page, vous pouvez autoriser ou annuler le paiement. L’autorisation du paiement simule une authentification réussie et vous redirige vers l’URL de redirection spécifiée. En cliquant sur le bouton **Échec**, vous simulez une tentative d’authentification infructueuse.

#### Web

#### Numéros de carte

| Numéro           | Utilisation de 3DS | Description                                                                                                                                                                                                                                                                                                               |
| ---------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| 4000000000003220 | Obligatoire        | Une authentification 3DS2 est toujours requise pour que le paiement aboutisse. Par défaut, vos règles Radar exigeront l’authentification 3DS pour cette carte.                                                                                                                                                            |
| 4000002500003155 | Obligatoire        | Cette carte requiert une authentification 3DS2 pour les paiements hors session, sauf si vous la [configurez](https://docs.stripe.com/payments/save-and-reuse.md) en vue de paiements ultérieurs. Une fois configurée, l’authentification n’est plus requise pour les paiements hors session.                              |
| 4000008400001629 | Obligatoire        | L’authentification 3DS est requise, mais les paiements seront ensuite refusés avec le code d’échec `card_declined`. Par défaut, vos règles Radar exigeront l’authentification 3DS pour cette carte.                                                                                                                       |
| 4000000000003055 | Pris en charge     | L’authentification 3DS peut être effectuée, mais elle n’est pas obligatoire. Par défaut, vos règles Radar n’exigeront pas l’authentification 3DS pour cette carte.                                                                                                                                                        |
| 4242424242424242 | Pris en charge     | Cette carte prend en charge l’authentification 3DS, mais elle n’est pas inscrite sur 3DS. Cela signifie que si vos règles Radar exigent l’authentification 3DS, le client ne sera pas soumis à une authentification supplémentaire. Par défaut, vos règles Radar n’exigeront pas l’authentification 3DS pour cette carte. |
| 378282246310005  | Non pris en charge | Cette carte ne prend pas en charge l’authentification 3DS et vous ne pouvez pas l’invoquer. Le PaymentIntent va continuer sans authentification.                                                                                                                                                                          |

#### PaymentMethods

| Moyen de paiement                            | Utilisation de 3DS | Description                                                                                                                                                                                                                                                                                                               |
| -------------------------------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `pm_card_threeDSecure2Required`              | Obligatoire        | Une authentification 3DS2 est requise pour que le paiement aboutisse. Par défaut, vos règles Radar exigeront l’authentification 3DS pour cette carte.                                                                                                                                                                     |
| `pm_card_threeDSecureRequiredChargeDeclined` | Obligatoire        | L’authentification 3D&nbsp;Secure est requise, mais les paiements seront ensuite refusés avec le code d’échec `card_declined`. Par défaut, vos règles Radar exigeront l’authentification 3DS pour cette carte.                                                                                                            |
| `pm_card_threeDSecureOptional`               | Pris en charge     | L’authentification 3DS peut être effectuée, mais elle n’est pas obligatoire. Par défaut, vos règles Radar n’exigeront pas l’authentification 3DS pour cette carte.                                                                                                                                                        |
| `pm_card_visa`                               | Pris en charge     | Cette carte prend en charge l’authentification 3DS, mais elle n’est pas inscrite sur 3DS. Cela signifie que si vos règles Radar exigent l’authentification 3DS, le client ne sera pas soumis à une authentification supplémentaire. Par défaut, vos règles Radar n’exigeront pas l’authentification 3DS pour cette carte. |
| `pm_card_amex_threeDSecureNotSupported`      | Non pris en charge | Cette carte ne prend pas en charge l’authentification 3DS et vous ne pouvez pas l’invoquer. Le PaymentIntent va continuer sans authentification.                                                                                                                                                                          |

#### iOS

Lors du test de votre intégration iOS, choisissez une carte de test pour déclencher une demande d’authentification spécifique.

| Numéro           | Demande d’authentification | Description                                                                                                                                                                                      |
| ---------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 4000582600000094 | Externe à Stripe           | L’authentification 3D Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche le flux d’authentification avec une interface utilisateur autre que celle de Stripe.             |
| 4000582600000045 | Code à usage unique        | L’authentification 3D&nbsp;Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche le flux d’authentification avec une interface utilisateur demandant un code à usage unique. |
| 4000582600000102 | Sélection unique           | L’authentification 3D&nbsp;Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche le flux d’authentification avec une interface utilisateur à sélection unique.               |
| 4000582600000110 | Sélection multiple         | L’authentification 3D&nbsp;Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche la demande d’authentification avec une interface utilisateur à sélection multiple.          |

#### Android

Lors du test de votre intégration Android, choisissez une carte de test pour déclencher une demande d’authentification spécifique.

| Numéro           | Demande d’authentification | Description                                                                                                                                                                                      |
| ---------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 4000582600000094 | Externe à Stripe           | L’authentification 3D Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche le flux d’authentification avec une interface utilisateur autre que celle de Stripe.             |
| 4000582600000045 | Code à usage unique        | L’authentification 3D&nbsp;Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche le flux d’authentification avec une interface utilisateur demandant un code à usage unique. |
| 4000582600000102 | Sélection unique           | L’authentification 3D&nbsp;Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche le flux d’authentification avec une interface utilisateur à sélection unique.               |
| 4000582600000110 | Sélection multiple         | L’authentification 3D&nbsp;Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche la demande d’authentification avec une interface utilisateur à sélection multiple.          |

#### React&nbsp;Native

Lors du test de votre intégration React Native personnalisée, choisissez une carte de test pour déclencher une demande d’authentification spécifique.

| Numéro           | Demande d’authentification | Description                                                                                                                                                                                      |
| ---------------- | -------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| 4000582600000094 | Externe à Stripe           | L’authentification 3D Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche le flux d’authentification avec une interface utilisateur autre que celle de Stripe.             |
| 4000582600000045 | Code à usage unique        | L’authentification 3D&nbsp;Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche le flux d’authentification avec une interface utilisateur demandant un code à usage unique. |
| 4000582600000102 | Sélection unique           | L’authentification 3D&nbsp;Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche le flux d’authentification avec une interface utilisateur à sélection unique.               |
| 4000582600000110 | Sélection multiple         | L’authentification 3D&nbsp;Secure&nbsp;2 doit être effectuée pour toutes les transactions. Déclenche la demande d’authentification avec une interface utilisateur à sélection multiple.          |

Pour les autres [cartes de test](https://docs.stripe.com/testing.md) Visa et Mastercard, aucune authentification ne sera demandée.

Vous pouvez créer des [règles Radar personnalisées dans un environnement de test](https://dashboard.stripe.com/settings/radar/rules) pour déclencher l’authentification sur des cartes de test. En savoir plus sur les [moyens de tester vos règles Radar](https://docs.stripe.com/radar/testing.md).

## Litiges et transfert de responsabilité

La règle de *transfert de responsabilité* (With some 3D Secure transactions, the liability for fraudulent chargebacks (stolen or counterfeit cards) shifts from you to the card issuer) s’applique généralement aux paiements authentifiés à l’aide de 3DS. Dans certains cas, elle s’applique à l’aide d’un cryptogramme équivalent comme [Apple Pay](https://docs.stripe.com/apple-pay.md) ou [Google Pay](https://docs.stripe.com/google-pay.md). Si un titulaire de carte [conteste](https://docs.stripe.com/disputes.md) un paiement 3DS pour fraude, vous transférez généralement la responsabilité à l’émetteur de la carte.

Si une carte ne prend pas en charge 3DS ou qu’une erreur survient pendant le processus d’authentification, le paiement se poursuit normalement. Dans ce cas, la responsabilité n’est généralement pas transférée à l’émetteur, car aucune authentification 3DS n’a été effectuée.

En pratique, cela signifie généralement que vous ne recevrez pas de litiges pour fraude si le paiement était couvert par la règle de transfert de responsabilité, mais que vous pourrez tout de même recevoir une [alerte de suspicion de fraude](https://docs.stripe.com/disputes/how-disputes-work.md#early-fraud-warnings). Il se peut que vous receviez un faible pourcentage de litiges pour fraude&nbsp;: vous trouverez ci-dessous une liste de quelques cas où la règle du transfert de responsabilité est susceptible de ne pas s’appliquer.

Il est possible que vous receviez une [demande d’informations](https://docs.stripe.com/disputes/how-disputes-work.md#inquiries) concernant un paiement authentifié à l’aide de 3DS. Ce type de litige n’entraîne pas de contestation de paiement car il s’agit uniquement d’une demande de renseignements.

Si vous recevez une demande pour un paiement authentifié par 3D&nbsp;Secure, vous *devez* y répondre, faute de quoi la banque du titulaire de la carte peut initier une contestation de paiement «&nbsp;sans réponse&nbsp;» qui pourrait invalider le transfert de responsabilité. Pour éviter cette situation, vous devez soumettre suffisamment d’informations sur le paiement. Indiquez notamment ce qui a été commandé (biens matériels, produits électroniques ou services, etc.), mais aussi comment et à quel destinataire la livraison a été effectuée.

> Si un client conteste un paiement pour une autre raison, par exemple parce qu’il n’a [pas reçu le produit](https://docs.stripe.com/disputes/categories.md), le processus de litige standard s’applique. Il vous revient de prendre les décisions appropriées concernant la gestion de votre entreprise, et en particulier d’éviter la survenue de litiges et de gérer les litiges existants.

Un transfert de responsabilité peut également intervenir lorsque le réseau de la carte exige une authentification 3DS, mais que cette méthode n’est pas disponible pour la carte ou pour l’émetteur. Cela peut se produire si le fournisseur 3DS de l’émetteur est indisponible ou si l’émetteur ne prend pas en charge 3DS, alors que le réseau de la carte l’impose. En effet, dans un tel cas, le titulaire de la carte n’est pas invité à procéder à l’authentification 3DS au cours du processus de paiement puisque sa carte n’y est pas inscrite. Même si le titulaire de la carte n’a pas effectué l’authentification 3DS, la responsabilité de la transaction peut être transférée à l’émetteur.

Stripe renvoie l’*indicateur d’e-commerce* (An Electronic Commerce Indicator (ECI) is a code returned alongside a 3D Secure authentication result. It indicates the authentication method and result and may be used subsequently to, for example, determine eligibility for liability shift) (ECI) demandé dans le `electronic_commerce_indicator` du [résultat de l’authentification 3DS](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card-three_d_secure). Cet indicateur peut aider à déterminer si un paiement doit respecter la règle du transfert de responsabilité. Dans la mesure où l’authentification 3DS intervient après la réponse initiale du Payment Intent, elle provient généralement d’un événement `charge.succeeded` envoyé à l’un de vos [endpoints de webhook configurés ou à d’autres destinations d’événement](https://docs.stripe.com/event-destinations.md). L’ECI demandé peut être déclassé dans la réponse de l’émetteur, ce que nous n’affichons pas.

> Certains paiements font l’objet d’une authentification&nbsp;3DS réussie sans transfert de responsabilité. Cette situation est rare, mais peut par exemple se produire si votre compte présente un niveau excessif de fraude et que vous avez intégré un [programme de surveillance contre la fraude](https://docs.stripe.com/disputes/monitoring-programs.md#visa-programs). Certains réseaux ont également exempté certains secteurs d’activité du transfert de responsabilité. Par exemple, Visa ne prend pas en charge le transfert de responsabilité des entreprises effectuant des virements bancaires ou des mandats postaux, des établissements non financiers proposant des devises étrangères ou non fiduciaires, ni des achats ou chargements de cartes prépayées.

Il est également possible que le transfert de responsabilité soit déclassé après l’autorisation, ou que le système de rejet du litige du réseau de cartes ne réussisse pas à capturer le transfert de responsabilité pour une transaction. Dans ce cas, si vous réfutez le litige, Stripe ajoute automatiquement l’ECI demandée et le [résultat de l’authentification 3DS](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-card-three_d_secure-result) du paiement à vos informations de preuve, mais nous vous recommandons également d’inclure des détails supplémentaires pour augmenter vos chances de remporter le litige.

### Règles Radar personnalisées pour 3DS et transfert de responsabilité

Si vous disposez de [Radar for Fraud Teams](https://stripe.com/radar/fraud-teams), vous pouvez [personnaliser vos règles](https://docs.stripe.com/radar/rules.md#request-3d-secure) pour déterminer quand exiger 3DS et comment gérer chaque résultat d’authentification et transfert de responsabilité spécifique. Les règles d’[authentification forte du client](https://stripe.com/guides/strong-customer-authentication) (SCA) de Stripe s’exécutent automatiquement et indépendamment des règles Radar personnalisées, et bloquent les paiements non authentifiés, sauf exemption.

## See also

- [Importer les résultats 3DS](https://docs.stripe.com/payments/payment-intents/three-d-secure-import.md)
- [Analyse de l’authentification](https://docs.stripe.com/payments/analytics/authentication.md)