# Accepter les paiements en stablecoins

Commencez à accepter les stablecoins en activant le moyen de paiement en cryptomonnaie.

Vous pouvez accepter les paiements en *stablecoins* (A cryptocurrency that's pegged to the value of a fiat currency or other asset in order to limit volatility) via *Payment Links* (A link to a secure, hosted payment page that you can generate without code. Share it directly with your customers, or point them to it with a button or QR code), *Checkout* (A low-code payment integration that creates a customizable form for collecting payments. You can embed Checkout directly in your website, redirect customers to a Stripe-hosted payment page, or create a customized checkout page with Stripe Elements), *Elements* (A set of UI components for building a web checkout flow. They adapt to your customer's locale, validate input, and use tokenization, keeping sensitive customer data from touching your server) ou l’API *Payment Intents* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods). Lorsque les clients paient avec des stablecoins, tels que l’USDC, ils sont redirigés vers **crypto.stripe.com** afin de connecter leur wallet de cryptomonnaie et de finaliser la transaction. Les fonds sont versés sur votre solde Stripe en USD.

## Before you begin

> Vos clients peuvent utiliser des stablecoins comme moyen de paiement à l’échelle mondiale, mais seules les entreprises basées aux États-Unis peuvent accepter des paiements en stablecoins.

Pour commencer à accepter les paiements en stablecoins:

1. Assurez-vous que votre compte Stripe est [actif](https://docs.stripe.com/get-started/account/activate.md).
1. Accédez aux paramètres [Moyens de paiement](https://dashboard.stripe.com/settings/payment_methods) dans le Dashboard et activez le moyen de paiement **Stablecoins et Cryptomonnaie**.
1. Stripe examine votre demande d’accès et vous contacte si des informations complémentaires sont nécessaires. Le moyen de paiement apparaît comme **Pending** pendant l’examen de votre demande.
1. Une fois votre demande approuvée, **Stablecoins et Cryptomonnaie** devient actif dans le Dashboard.

## Utiliser avec des moyens de paiement dynamiques (Recommended)

Si vous utilisez les [moyens de paiement dynamiques](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md) par défaut de Stripe avec Payment Links, Paiement hébergé, Paiement intégré ou Elements, vous n’avez pas besoin d’effectuer d’autres mises à jour. Stripe affiche automatiquement les options de paiement en stablecoins aux clients admissibles.

## Utilisation avec une intégration Custom

Si nécessaire, vous pouvez ajouter le moyen de paiement cryptomonnaie à votre intégration de paiement manuellement.

# Checkout

> This is a Checkout for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/accept-stablecoin-payments?payment-ui=checkout.

Lors de la création d’une nouvelle [session Checkout](https://docs.stripe.com/api/checkout/sessions.md), vous devez :

1. ajouter `crypto` à la liste `payment_method_types`.

1. vous assurer que tous les `line_items` utilisent `usd`.

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u <<YOUR_SECRET_KEY>>: \
  -d mode=payment \
  -d "payment_method_types[0]"=crypto \
  -d "line_items[0][price_data][currency]"=usd \
  -d "line_items[0][price_data][product_data][name]"=T-shirt \
  -d "line_items[0][price_data][unit_amount]"=2000 \
  -d "line_items[0][quantity]"=1 \
  --data-urlencode success_url="https://example.com/success"
```

## Tester votre intégration

Testez votre intégration de paiement en cryptomonnaie en ouvrant la page de redirection des paiements à l’aide de vos clés API de test. Vous pouvez tester gratuitement un tunnel de paiement réussi à l’aide des [ressources de testnet](https://docs.stripe.com/payments/accept-stablecoin-payments.md#testnet-assets).

1. Dans un *environnement de test* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes), créez une nouvelle transaction avec la méthode d’intégration choisie, puis ouvrez l’URL de redirection.
1. Connectez votre wallet et votre réseau de paiement préférés.
1. Effectuez le paiement et vérifiez que vous pouvez accéder à l’URL attendue.

### Paiements tests avec des actifs testnet

La plupart des cryptomonnaies proposent des actifs testnet, ou des tokens qui n’ont aucune valeur monétaire, que vous pouvez utiliser pour tester les transactions blockchain. Stripe recommande le wallet MetaMask, le testnet Polygon Amoy et le faucet Circle pour les tests, mais vous pouvez utiliser vos propres services préférés.

#### Installez un wallet

1. [Téléchargez l’extension MetaMask](https://metamask.io/download) pour votre navigateur Web.
1. [Créez un wallet](https://support.metamask.io/start/creating-a-new-wallet/) ou [importez un wallet existant](https://support.metamask.io/start/use-an-existing-wallet/).

#### Activer un testnet

1. Dans votre wallet MetaMask, sélectionnez **Réseaux** dans le menu principal.
1. Cliquez sur **Ajouter un réseau personnalisé**.
1. Saisissez les informations suivantes&nbsp;:
   - **Nom du réseau**&nbsp;: `Amoy`
   - **URL RPC par défaut**&nbsp;: `https://rpc-amoy.polygon.technology/`
   - **ID de chaîne**&nbsp;: `80002`
   - **Symbole devise**&nbsp;: `POL`
   - **Bloquer l’URL de l’explorateur**&nbsp;: `https://amoy.polygonscan.com/`
1. Cliquez sur **Enregistrer**.

#### Importez un token

1. Dans votre wallet MetaMask, sous **Tokens**, sélectionnez **Amoy** dans la liste déroulante du réseau.
1. Cliquez sur le menu de débordement (⋯) et sélectionnez **Importer des tokens**.
1. Cliquez sur **Sélectionner un réseau** > **Amoy**.
1. Sous **Adresse du contrat token**, collez l’adresse du contrat testnet Polygon Amoy&nbsp;:
   ```
   0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582
   ```
Le champ **Symbole du token** se met automatiquement à jour avec `USDC` et le champ **Décimales** avec `6`.
1. Cliquez sur **Suivant**.
1. Vérifiez que vous importez le token `USDC`, puis cliquez sur **Importer**.

Votre wallet MetaMask affiche désormais **POL** et **USDC** dans la liste des tokens.

Lors des tests de remboursements, le token envoyé à votre wallet peut avoir un contrat différent de celui utilisé pour le paiement. Nous vous recommandons de vérifier le [transaction_hash](https://docs.stripe.com/api/refunds/object.md?rds=1#refund_object-destination_details-crypto-reference) de votre remboursement sur un explorateur de blocs et d’ajouter le contrat de ce token à votre wallet. Par exemple, vous pourriez voir l’adresse de contrat de token `0x58277ebcabbe2a6694fbca8daf9e23163dbacf3e` pour les remboursements Sepolia ETH USDC.

#### Obtenir des ressources testnet

> Pour utiliser certains faucets de testnet, vous pourriez avoir besoin de détenir une petite quantité de tokens du mainnet.

1. Ouvrir le paramètre [faucet.circle.com](https://faucet.circle.com/)
1. Cliquez sur **USDC**.
1. Sous **Réseau**, sélectionnez **Polygon PDV Amoy**.
1. Sous l’onglet **Envoyer vers**, collez l’adresse de votre wallet.
1. Cliquez sur **Envoyer&nbsp;20&nbsp;USDC**.

En plus de l’USDC pour effectuer des paiements, vous avez besoin de POL pour payer les frais de transaction&nbsp;:

1. Ouvrir [faucet.polygon.technology](https://faucet.polygon.technology/).
1. Sous **Sélectionner la chaîne et le Token**, sélectionnez **Polygon Amoy** et **POL**.
1. Sous **Vérifier votre identité**, cliquez sur la plateforme tierce avec laquelle vous souhaitez vous authentifier, puis suivez la procédure de connexion.
1. Sous **Saisir l’adresse wallet**, collez l’adresse de votre wallet.
1. Cliquez sur **Réclamer**.

La finalisation des transactions Testnet peut prendre quelques minutes. Vérifiez votre wallet pour confirmer que l’USDC et le POL ont bien été transférés.

### Plus de faucets testnet

Consultez ces sites de faucets pour plus d’options de tokens de test&nbsp;:

- [Paxos USDP](https://faucet.paxos.com/)
- [Devnet SOL](https://faucet.solana.com/)
- [Sepolia ETH](https://faucets.chain.link/sepolia)
- [Amoy POL](https://faucet.polygon.technology/)


# API Checkout Sessions

> This is a API Checkout Sessions for when payment-ui is elements and api-integration is checkout. View the full page at https://docs.stripe.com/payments/accept-stablecoin-payments?payment-ui=elements&api-integration=checkout.

Pour déterminer quelle API répond aux besoins de votre entreprise, consultez la section[guide de comparaison](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md).

Utilisez le [Payment Element](https://docs.stripe.com/payments/payment-element.md) pour intégrer un formulaire de paiement Stripe personnalisé sur votre site Web ou application et proposer des moyens de paiement à vos clients. Pour les configurations et personnalisations avancées, consultez le guide d’intégration [Accepter un Paiement](https://docs.stripe.com/payments/accept-a-payment.md).

Intégrez un formulaire de paiement personnalisé à votre site web ou application utilisant le composant [Payment Element](https://docs.stripe.com/payments/payment-element.md). Le composant Payment Element prend automatiquement en charge les cryptomonnaies et les autres moyens de paiement. Pour obtenir des options de configuration et de personnalisation supplémentaires, consultez la page [accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=elements&api-integration=checkout).

## Configurer le serveur [Côté serveur]

Utilisez les bibliothèques officielles de Stripe pour accéder à l’API depuis votre application.

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

## Créer une session Checkout [Côté serveur]

Ajoutez à votre serveur un endpoint qui crée un objet [Checkout Session](https://docs.stripe.com/api/checkout/sessions/create.md) et renvoie la [clé secrète du client](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-client_secret) à votre front-end. Une session Checkout représente la session d’un client qui paie des achats ponctuels ou des abonnements. Les sessions Checkout expirent 24&nbsp;heures après leur création.

Nous recommandons d’utiliser des [méthodes de paiement dynamiques](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md) pour afficher automatiquement les moyens de paiement les plus pertinents à chaque client, afin d’optimiser le taux de conversion. Vous pouvez également [lister manuellement les méthodes de paiement](https://docs.stripe.com/payments/payment-methods/integration-options.md#listing-payment-methods-manually), ce qui désactive les options dynamiques.

#### Gérer les moyens de paiement depuis le Dashboard

#### TypeScript

```javascript
import express, {Express} from 'express';

const app: Express = express();

app.post('/create-checkout-session', async (req: Express.Request, res: Express.Response) => {
  const session = await stripe.checkout.sessions.create({
    line_items: [
      {
        price_data: {
          currency: 'usd',
          product_data: {
            name: 'T-shirt',
          },
          unit_amount: 1099,
        },
        quantity: 1,
      },
    ],
    mode: 'payment',
    ui_mode: 'elements',
    return_url: 'https://example.com/return?session_id={CHECKOUT_SESSION_ID}'
  });

  res.json({checkoutSessionClientSecret: session.client_secret});
});

app.listen(3000, () => {
  console.log('Running on port 3000');
});
```

#### Saisir manuellement les moyens de paiement

#### TypeScript

```javascript
import express, {Express} from 'express';

const app: Express = express();

app.post('/create-checkout-session', async (req: Express.Request, res: Express.Response) => {
  const session = await stripe.checkout.sessions.create({
    line_items: [
      {
        price_data: {
          currency: 'usd',
          product_data: {
            name: 'T-shirt',
          },
          unit_amount: 1099,
        },
        quantity: 1,
      },
    ],
    mode: 'payment',
    ui_mode: 'elements',
    payment_method_types: ['crypto'],
    return_url: 'https://example.com/return?session_id={CHECKOUT_SESSION_ID}'
  });

  res.json({checkoutSessionClientSecret: session.client_secret});
});

app.listen(3000, () => {
  console.log('Running on port 3000');
});
```

## Configurer le front-end [Côté client]

#### HTML + JS

Intégrez le script Stripe.js à votre page de paiement en l’ajoutant dans le `head` de votre fichier HTML. Chargez toujours Stripe.js directement depuis js.stripe.com afin de rester conforme à PCI. N’incluez pas le script dans un bundle et n’en hébergez pas de copie.

Assurez-vous d’utiliser la dernière version de Stripe.js en incluant la balise de script suivante `<script src=“https://js.stripe.com/dahlia/stripe.js”>`</script>. En savoir plus sur la [gestion des versions de Stripe.js](https://docs.stripe.com/sdks/stripejs-versioning.md).

```html
<head>
  <title>Checkout</title>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
```

> Stripe propose un package npm que vous pouvez utiliser pour charger Stripe.js en tant que module. Consultez le [projet sur GitHub](https://github.com/stripe/stripe-js). La version [7.0.0](https://www.npmjs.com/package/%40stripe/stripe-js/v/7.0.0)&nbsp;ou ultérieure est requise.

Initialiser stripe.js

```js
// Set your publishable key: remember to change this to your live publishable key in production
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = Stripe(
  '<<YOUR_PUBLISHABLE_KEY>>',
);
```

#### React

Installez [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) et le [Stripe.js loader](https://www.npmjs.com/package/@stripe/stripe-js) depuis le registre public npm. Vous devez disposer au minimum de la version&nbsp;5.0.0&nbsp;pour React Stripe.js et de la version&nbsp;8.0.0&nbsp;pour le Stripe.js loader.

```bash
npm install --save @stripe/react-stripe-js@^5.0.0 @stripe/stripe-js@^8.0.0
```

Initialisez une instance `stripe` côté front-end à l’aide de votre clé publiable.

```javascript
import {loadStripe} from '@stripe/stripe-js';
const stripe = loadStripe("<<YOUR_PUBLISHABLE_KEY>>");
```

## Initialiser Checkout [Côté client]

#### HTML + JS

Appelez [initCheckoutElementsSdk](https://docs.stripe.com/js/custom_checkout/init), en transmettant `clientSecret`.

`initCheckoutElementsSdk` renvoie un objet [Checkout](https://docs.stripe.com/js/custom_checkout) contenant les données de la Session Checkout et les méthodes pour les mettre à jour.

Lisez le `total` et les `lineItems` de [actions.getSession()](https://docs.stripe.com/js/custom_checkout/session), et affichez-les dans votre interface utilisateur. Cela vous permet d’activer de nouvelles fonctionnalités avec un minimum de modifications de code. Par exemple, l’ajout de [prix manuels des devises](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) ne nécessite aucune modification de l’interface utilisateur si vous affichez le `total`.

```html
<div id="checkout-container"></div>
```

```javascript
const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
  .then((response) => response.json())
  .then((json) => json.client_secret);

const checkout = stripe.initCheckoutElementsSdk({clientSecret});
const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const session = loadActionsResult.actions.getSession();
  const checkoutContainer = document.getElementById('checkout-container');

  checkoutContainer.append(JSON.stringify(session.lineItems, null, 2));
  checkoutContainer.append(document.createElement('br'));
  checkoutContainer.append(`Total: ${session.total.total.amount}`);
}
```

#### React

Encapsulez votre application avec le composant [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider), en lui transmettant `clientSecret` et l’instance `stripe`.

```jsx
import React from 'react';
import {CheckoutElementsProvider} from '@stripe/react-stripe-js/checkout';
import CheckoutForm from './CheckoutForm';

const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
  .then((response) => response.json())
  .then((json) => json.client_secret);

const App = () => {
  return (
    <CheckoutElementsProvider
      stripe={stripe}options={{clientSecret}}
    >
      <CheckoutForm />
    </CheckoutElementsProvider>
  );
};

export default App;
```

Accédez à l’objet [Checkout](https://docs.stripe.com/js/custom_checkout) dans votre composant de formulaire de paiement en utilisant le hook `useCheckout()`. L’objet `Checkout` contient les données de la Checkout Session et les méthodes pour la mettre à jour.

Lisez le `total` et les `lineItems` de l’objet `Checkout`, et affichez-les dans votre interface utilisateur. Cela vous permet d’activer des fonctionnalités avec un minimum de modifications de code. Par exemple, l’ajout de [prix manuels des devises](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) ne nécessite aucune modification de l’interface utilisateur si vous affichez le `total`.

```jsx
import React from 'react';
import {useCheckout} from '@stripe/react-stripe-js/checkout';

const CheckoutForm = () => {const checkoutState = useCheckout();

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  }

  if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }

  return (
    <form>{JSON.stringify(checkoutState.checkout.lineItems, null, 2)}
      {/* A formatted total amount */}
      Total: {checkoutState.checkout.total.total.amount}
    </form>
  );
};
```

## Collecter les adresses e-mail des clients [Côté client]

#### HTML + JS

Vous devez fournir une adresse e-mail client valide lors d’une Checkout Session.

Ces instructions créent une saisie d’e-mail et utilisent [updateEmail](https://docs.stripe.com/js/custom_checkout/update_email) à partir de l’objet `Checkout`.

Vous pouvez également&nbsp;:

- Transmettre [customer_email](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email) ou [customer](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) lors de la création de la Checkout Session. Stripe valide les e-mails ainsi fournis.
- Transmettre un e-mail que vous avez déjà validé sur [checkout.confirm](https://docs.stripe.com/js/custom_checkout/confirm).

```html
<input type="text" id="email" />
<div id="email-errors"></div>
```

```javascript
const checkout = stripe.initCheckoutElementsSdk({clientSecret});
const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const {actions} = loadActionsResult;
  const emailInput = document.getElementById('email');
  const emailErrors = document.getElementById('email-errors');

  emailInput.addEventListener('input', () => {
    // Clear any validation errors
    emailErrors.textContent = '';
  });

  emailInput.addEventListener('blur', () => {
    const newEmail = emailInput.value;actions.updateEmail(newEmail).then((result) => {
      if (result.error) {
        emailErrors.textContent = result.error.message;
      }
    });
  });
}
```

#### React

Vous devez fournir une adresse e-mail client valide lors d’une Checkout Session.

Ces instructions créent une saisie d’e-mail et utilisent [updateEmail](https://docs.stripe.com/js/react_stripe_js/checkout/update_email) à partir de l’objet `Checkout`.

Vous pouvez également&nbsp;:

- Transmettre [customer_email](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email) ou [customer](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) lors de la création de la Checkout Session. Stripe valide les e-mails ainsi fournis.
- Transmettre une adresse e-mail que vous avez déjà validée avec [confirm](https://docs.stripe.com/js/react_stripe_js/checkout/confirm).

```jsx
import React from 'react';
import {useCheckout} from '@stripe/react-stripe-js/checkout';

const EmailInput = () => {
  const checkoutState = useCheckout();
  const [email, setEmail] = React.useState('');
  const [error, setError] = React.useState(null);

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  } else if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }

  const handleBlur = () => {checkoutState.checkout.updateEmail(email).then((result) => {
      if (result.type === 'error') {
        setError(result.error);
      }
    })
  };

  const handleChange = (e) => {
    setError(null);
    setEmail(e.target.value);
  };

  return (
    <div>
      <label htmlFor="checkout-form-email">Email</label>
      <input
        id="checkout-form-email"
        type="email"
        value={email}
        onChange={handleChange}
        onBlur={handleBlur}
      />
      {error && <div>{error.message}</div>}
    </div>
  );
};

export default EmailInput;
```

## Collecter les informations de paiement [Côté client]

Collectez les informations de paiement de votre client à l’aide de [Payment Element](https://docs.stripe.com/payments/payment-element.md). Payment Element est un composant d’interface utilisateur préconfiguré qui simplifie la collecte des informations pour de nombreux moyens de paiement.

Le Payment&nbsp;Element contient un iframe qui envoie les informations de paiement à Stripe de manière sécurisée via une connexion HTTPS. Évitez de placer le Payment&nbsp;Element dans un autre iframe, car certains moyens de paiement nécessitent une redirection vers une autre page pour la confirmation du paiement.

Si vous choisissez d’utiliser un iframe et que vous souhaitez accepter Apple Pay ou Google Pay, l’attribut [allow](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-allowpaymentrequest) de l’iframe doit être défini sur égal à `"payment *"`.

Pour que votre intégration fonctionne, l’adresse de la page de paiement doit commencer par `https://` et non par `http://`. Vous pouvez tester votre intégration sans utiliser le protocole HTTPS, mais n’oubliez pas de l’[activer](https://docs.stripe.com/security/guide.md#tls) lorsque vous souhaitez commencer à accepter des paiements réels.

#### HTML + JS

Tout d’abord, créez un élément DOM de conteneur pour monter le composant [Payment Element](https://docs.stripe.com/payments/payment-element.md). Créez ensuite une instance du `Payment Element` à l’aide de [checkout.createPaymentElement](https://docs.stripe.com/js/custom_checkout/create_payment_element) et montez-la en appelant [element.mount](https://docs.stripe.com/js/element/mount) et en fournissant soit un sélecteur CSS, soit l’élément DOM du conteneur.

```html
<div id="payment-element"></div>
```

```javascript
const paymentElement = checkout.createPaymentElement();
paymentElement.mount('#payment-element');
```

Consultez la [documentation Stripe.js](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options) pour connaître les options prises en charge.

Vous pouvez [personnaliser l’apparence](https://docs.stripe.com/payments/checkout/customization/appearance.md) de tous les Elements en transmettant [elementsOptions.appearance](https://docs.stripe.com/js/custom_checkout/init#custom_checkout_init-options-elementsOptions-appearance) lors de l’initialisation de Checkout sur le front-end.

#### React

Montez le composant [Payment Element](https://docs.stripe.com/payments/payment-element.md) dans le [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider).

```jsx
import React from 'react';import {PaymentElement, useCheckout} from '@stripe/react-stripe-js/checkout';

const CheckoutForm = () => {
  const checkoutState = useCheckout();

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  }

  if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }

  return (
    <form>

      {JSON.stringify(checkoutState.checkout.lineItems, null, 2)}
      {/* A formatted total amount */}
      Total: {checkoutState.checkout.total.total.amount}
<PaymentElement options={{layout: 'accordion'}}/>
    </form>
  );
};

export default CheckoutForm;
```

Consultez la [documentation Stripe.js](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options) pour connaître les options prises en charge.

Vous pouvez [personnaliser l’apparence](https://docs.stripe.com/payments/checkout/customization/appearance.md) de tous les Elements en transmettant [elementsOptions.appearance](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider#react_checkout_provider-options-elementsOptions-appearance) au composant [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider).

## Envoyer le paiement [Côté client]

#### HTML + JS

Affichez un bouton **Payer** qui appelle [confirm](https://docs.stripe.com/js/custom_checkout/confirm) depuis l’instance `Checkout` pour soumettre le paiement.

```html
<button id="pay-button">Pay</button>
<div id="confirm-errors"></div>
```

```js
const checkout = stripe.initCheckoutElementsSdk({clientSecret});

checkout.on('change', (session) => {
  document.getElementById('pay-button').disabled = !session.canConfirm;
});

const loadActionsResult = await checkout.loadActions();

if (loadActionsResult.type === 'success') {
  const {actions} = loadActionsResult;
  const button = document.getElementById('pay-button');
  const errors = document.getElementById('confirm-errors');
  button.addEventListener('click', () => {
    // Clear any validation errors
    errors.textContent = '';

    actions.confirm().then((result) => {
      if (result.type === 'error') {
        errors.textContent = result.error.message;
      }
    });
  });
}
```

#### React

Affichez un bouton **Payer** qui appelle [confirm](https://docs.stripe.com/js/custom_checkout/confirm) depuis [useCheckout](https://docs.stripe.com/js/react_stripe_js/checkout/use_checkout) pour soumettre le paiement.

```jsx
import React from 'react';
import {useCheckout} from '@stripe/react-stripe-js/checkout';

const PayButton = () => {
  const checkoutState = useCheckout();
  const [loading, setLoading] = React.useState(false);
  const [error, setError] = React.useState(null);

  if (checkoutState.type !== "success") {
    return null;
  }

  const handleClick = () => {
    setLoading(true);checkoutState.checkout.confirm().then((result) => {
      if (result.type === 'error') {
        setError(result.error)
      }
      setLoading(false);
    })
  };

  return (
    <div>
      <button disabled={!checkoutState.checkout.canConfirm || loading} onClick={handleClick}>
        Pay
      </button>
      {error && <div>{error.message}</div>}
    </div>
  )
};

export default PayButton;
```

## Tester votre intégration

Testez votre intégration de paiement en cryptomonnaie en ouvrant la page de redirection des paiements à l’aide de vos clés API de test. Vous pouvez tester gratuitement un tunnel de paiement réussi à l’aide des [ressources de testnet](https://docs.stripe.com/payments/accept-stablecoin-payments.md#testnet-assets).

1. Dans un *environnement de test* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes), créez une nouvelle transaction avec la méthode d’intégration choisie, puis ouvrez l’URL de redirection.
1. Connectez votre wallet et votre réseau de paiement préférés.
1. Effectuez le paiement et vérifiez que vous pouvez accéder à l’URL attendue.

### Paiements tests avec des actifs testnet

La plupart des cryptomonnaies proposent des actifs testnet, ou des tokens qui n’ont aucune valeur monétaire, que vous pouvez utiliser pour tester les transactions blockchain. Stripe recommande le wallet MetaMask, le testnet Polygon Amoy et le faucet Circle pour les tests, mais vous pouvez utiliser vos propres services préférés.

#### Installez un wallet

1. [Téléchargez l’extension MetaMask](https://metamask.io/download) pour votre navigateur Web.
1. [Créez un wallet](https://support.metamask.io/start/creating-a-new-wallet/) ou [importez un wallet existant](https://support.metamask.io/start/use-an-existing-wallet/).

#### Activer un testnet

1. Dans votre wallet MetaMask, sélectionnez **Réseaux** dans le menu principal.
1. Cliquez sur **Ajouter un réseau personnalisé**.
1. Saisissez les informations suivantes&nbsp;:
   - **Nom du réseau**&nbsp;: `Amoy`
   - **URL RPC par défaut**&nbsp;: `https://rpc-amoy.polygon.technology/`
   - **ID de chaîne**&nbsp;: `80002`
   - **Symbole devise**&nbsp;: `POL`
   - **Bloquer l’URL de l’explorateur**&nbsp;: `https://amoy.polygonscan.com/`
1. Cliquez sur **Enregistrer**.

#### Importez un token

1. Dans votre wallet MetaMask, sous **Tokens**, sélectionnez **Amoy** dans la liste déroulante du réseau.
1. Cliquez sur le menu de débordement (⋯) et sélectionnez **Importer des tokens**.
1. Cliquez sur **Sélectionner un réseau** > **Amoy**.
1. Sous **Adresse du contrat token**, collez l’adresse du contrat testnet Polygon Amoy&nbsp;:
   ```
   0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582
   ```
Le champ **Symbole du token** se met automatiquement à jour avec `USDC` et le champ **Décimales** avec `6`.
1. Cliquez sur **Suivant**.
1. Vérifiez que vous importez le token `USDC`, puis cliquez sur **Importer**.

Votre wallet MetaMask affiche désormais **POL** et **USDC** dans la liste des tokens.

Lors des tests de remboursements, le token envoyé à votre wallet peut avoir un contrat différent de celui utilisé pour le paiement. Nous vous recommandons de vérifier le [transaction_hash](https://docs.stripe.com/api/refunds/object.md?rds=1#refund_object-destination_details-crypto-reference) de votre remboursement sur un explorateur de blocs et d’ajouter le contrat de ce token à votre wallet. Par exemple, vous pourriez voir l’adresse de contrat de token `0x58277ebcabbe2a6694fbca8daf9e23163dbacf3e` pour les remboursements Sepolia ETH USDC.

#### Obtenir des ressources testnet

> Pour utiliser certains faucets de testnet, vous pourriez avoir besoin de détenir une petite quantité de tokens du mainnet.

1. Ouvrir le paramètre [faucet.circle.com](https://faucet.circle.com/)
1. Cliquez sur **USDC**.
1. Sous **Réseau**, sélectionnez **Polygon PDV Amoy**.
1. Sous l’onglet **Envoyer vers**, collez l’adresse de votre wallet.
1. Cliquez sur **Envoyer&nbsp;20&nbsp;USDC**.

En plus de l’USDC pour effectuer des paiements, vous avez besoin de POL pour payer les frais de transaction&nbsp;:

1. Ouvrir [faucet.polygon.technology](https://faucet.polygon.technology/).
1. Sous **Sélectionner la chaîne et le Token**, sélectionnez **Polygon Amoy** et **POL**.
1. Sous **Vérifier votre identité**, cliquez sur la plateforme tierce avec laquelle vous souhaitez vous authentifier, puis suivez la procédure de connexion.
1. Sous **Saisir l’adresse wallet**, collez l’adresse de votre wallet.
1. Cliquez sur **Réclamer**.

La finalisation des transactions Testnet peut prendre quelques minutes. Vérifiez votre wallet pour confirmer que l’USDC et le POL ont bien été transférés.

### Plus de faucets testnet

Consultez ces sites de faucets pour plus d’options de tokens de test&nbsp;:

- [Paxos USDP](https://faucet.paxos.com/)
- [Devnet SOL](https://faucet.solana.com/)
- [Sepolia ETH](https://faucets.chain.link/sepolia)
- [Amoy POL](https://faucet.polygon.technology/)


# API Payment Intents

> This is a API Payment Intents for when payment-ui is elements and api-integration is paymentintents. View the full page at https://docs.stripe.com/payments/accept-stablecoin-payments?payment-ui=elements&api-integration=paymentintents.

Pour déterminer quelle API répond aux besoins de votre entreprise, consultez la section[guide de comparaison](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md).

Utilisez le [Payment Element](https://docs.stripe.com/payments/payment-element.md) pour intégrer un formulaire de paiement Stripe personnalisé sur votre site Web ou application et proposer des moyens de paiement à vos clients. Pour les configurations et personnalisations avancées, consultez le guide d’intégration [Accepter un Paiement](https://docs.stripe.com/payments/accept-a-payment.md).

## Configurer Stripe [Côté serveur]

Pour commencer, [créez un compte Stripe](https://dashboard.stripe.com/register).

Utilisez nos bibliothèques officielles pour accéder à l’API Stripe depuis votre application&nbsp;:

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

## Collecter les informations de paiement [Côté client]

Vous êtes prêt à recueillir les informations de paiement de votre client à l’aide du composant Element Payment, un composant préconfiguré de l’interface utilisateur qui simplifie cette collecte pour de nombreux moyens de paiement.

Le Payment Element contient un iframe qui envoie les informations de paiement à Stripe de manière sécurisée via une connexion HTTPS. Évitez de placer le Payment Element dans un autre iframe, car certains moyens de paiement nécessitent une redirection vers une autre page pour la confirmation du paiement.

Pour que votre intégration fonctionne, l’adresse de la page de paiement doit commencer par `https://` et non par `http://`. Vous pouvez tester votre intégration sans utiliser le protocole HTTPS, mais n’oubliez pas de l’[activer](https://docs.stripe.com/security/guide.md#tls) lorsque vous souhaitez commencer à accepter des paiements réels.

#### HTML + JS

### Configurer Stripe.js

Le Payment Element est automatiquement disponible en tant que fonctionnalité de Stripe.js. Intégrez le script Stripe.js à votre page de paiement en l’ajoutant au `head` votre fichier HTML. Chargez toujours Stripe.js directement à partir de js.stripe.com pour rester conforme aux normes PCI. N’incluez pas le script dans un lot et n’en hébergez pas de copie.

```html
<head>
  <title>Checkout</title>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
```

Créez une instance de Stripe avec le code JavaScript suivant sur votre page de paiement&nbsp;:

```javascript
// Set your publishable key: remember to change this to your live publishable key in production
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = Stripe('<<YOUR_PUBLISHABLE_KEY>>');
```

### Ajouter le composant Payment&nbsp;Element à votre page de paiement

Le Payment Element doit avoir un emplacement sur votre page de paiement. Créez un nœud DOM (conteneur) vide avec un ID unique dans votre formulaire de paiement&nbsp;:

```html
<form id="payment-form">
  <div id="payment-element">
    <!-- Elements will create form elements here -->
  </div>
  <button id="submit">Submit</button>
  <div id="error-message">
    <!-- Display error message to your customers here -->
  </div>
</form>
```

#### Contrôler les moyens de paiement dans le Dashboard

Une fois le formulaire ci-dessus chargé, créez une instance Elements avec les paramètres `mode`, `amount` et `currency`. Ces valeurs déterminent les moyens de paiement présentés à votre client. Pour proposer un nouveau moyen de paiement dans votre formulaire, veillez à l’activer dans le [Dashboard](https://dashboard.stripe.com/settings/payment_methods).

```javascript
const options = {mode:'payment',
  amount:1099,
  currency: 'usd',
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout formconst elements = stripe.elements(options);

// Create and mount the Payment Element
const paymentElementOptions = { layout: 'accordion'};
const paymentElement = elements.create('payment', paymentElementOptions);
paymentElement.mount('#payment-element');
```

#### Répertorier manuellement les moyens de paiement

Pour lister manuellement les moyens de paiement que vous souhaitez proposer, ajoutez chacun d’eux à `paymentMethodTypes`.

Ensuite, créez une instance de l’Element Payment et montez-la sur le nœud DOM conteneur.

```javascript
const options = {mode:'payment',
  amount:1099,
  currency: 'usd',
  paymentMethodTypes: ['crypto'],
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout formconst elements = stripe.elements(options);

// Create and mount the Payment Element
const paymentElementOptions = { layout: 'accordion'};
const paymentElement = elements.create('payment', paymentElementOptions);
paymentElement.mount('#payment-element');
```

#### React

### Configurer Stripe.js

Installez [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) et le [chargeur Stripe.js](https://www.npmjs.com/package/@stripe/stripe-js) à partir du registre public npm.

```bash
npm install --save @stripe/react-stripe-js @stripe/stripe-js
```

### Ajouter et configurer le fournisseur Elements sur votre page de paiement

Pour utiliser le composant Payment&nbsp;Element, incluez votre composant de page de paiement dans un [fournisseur Elements](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider). Appelez `loadStripe` avec votre clé publique et transmettez le paramètre `Promise` renvoyé au fournisseur `Elements`.

#### Contrôler les moyens de paiement dans le Dashboard

Le fournisseur `Elements` accepte également les paramètres `mode`, `amount` et `currency`. Ces valeurs déterminent les moyens de paiement présentés à votre client. Pour proposer un nouveau moyen de paiement dans votre formulaire, veillez à l’activer dans le [Dashboard](https://dashboard.stripe.com/settings/payment_methods).

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CheckoutForm from './CheckoutForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {mode:'payment',
    amount:1099,
    currency: 'usd',
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

  return (
    <Elements stripe={stripePromise} options={options}>
      <CheckoutForm />
    </Elements>
  );
};

ReactDOM.render(<App />, document.getElementById('root'));
```

#### Répertorier manuellement les moyens de paiement

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import {Elements} from '@stripe/react-stripe-js';
import {loadStripe} from '@stripe/stripe-js';

import CheckoutForm from './CheckoutForm';

// Make sure to call `loadStripe` outside of a component’s render to avoid
// recreating the `Stripe` object on every render.
const stripePromise = loadStripe('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {mode:'payment',
    amount:1099,
    currency: 'usd',
    paymentMethodTypes: ['crypto'],
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

  return (
    <Elements stripe={stripePromise} options={options}>
      <CheckoutForm />
    </Elements>
  );
};

ReactDOM.render(<App />, document.getElementById('root'));
```

### Ajouter le composant Payment Element

Utilisez le composant `PaymentElement` pour créer votre formulaire.

```jsx
import React from 'react';
import {PaymentElement} from '@stripe/react-stripe-js';

const CheckoutForm = () => {
  return (
    <form><PaymentElement />
      <button>Submit</button>
    </form>
  );
};

export default CheckoutForm;
```

Vous pouvez personnaliser le Payment&nbsp;Element pour l’adapter au design de votre site en transmettant l’[objet Appearance](https://docs.stripe.com/elements/appearance-api.md) dans les `options` lors de la création du fournisseur `Elements`.

### Collecter les adresses

Par défaut, le Payment Element ne collecte que les informations nécessaires à la facturation. Certaines opérations, telles que le [calcul des taxes](https://docs.stripe.com/api/tax/calculations/create.md) ou la saisie des informations de livraison, nécessitent l’adresse complète de votre client. Vous pouvez&nbsp;:

- Utilisez l’[Address Element](https://docs.stripe.com/elements/address-element.md) pour tirer parti des fonctionnalités de saisie automatique et de localisation et recueillir l’adresse complète de votre client. Cela permet de garantir un calcul des taxes le plus précis possible.
- Recueillez l’adresse à l’aide de votre propre formulaire personnalisé.

## Créer un PaymentIntent [Côté serveur]

> #### Exécuter une logique métier personnalisée immédiatement avant la confirmation du paiement
> 
> Accédez à l’[étape&nbsp;5](https://docs.stripe.com/payments/finalize-payments-on-the-server.md?platform=web&type=payment#submit-payment) du guide «&nbsp;Finaliser&nbsp;» les paiements pour exécuter votre logique métier personnalisée immédiatement avant la confirmation du paiement. Sinon, suivez la procédure ci-dessous pour une intégration plus simple, qui utilise `stripe.confirmPayment` au niveau du client afin de confirmer le paiement et gérer les actions qui pourraient suivre.

#### Contrôler les moyens de paiement dans le Dashboard

Lorsque le client envoie votre formulaire de paiement, utilisez un *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods) pour faciliter le processus de confirmation et de paiement. Créez un PaymentIntent sur votre serveur avec les paramètres `amount` et `currency`. Pour éviter que des clients malveillants ne choisissent eux-mêmes leurs tarifs, fixez systématiquement le montant à débiter côté serveur (un environnement sécurisé) plutôt que côté client.

L’objet PaymentIntent contient une *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Renvoyez cette valeur côté client afin que Stripe.js l’utilise pour finaliser le processus de paiement en toute sécurité.

#### Ruby

```ruby
require 'stripe'
Stripe.api_key = '<<YOUR_SECRET_KEY>>'

post '/create-intent' do
  intent = Stripe::PaymentIntent.create({
    # To allow saving and retrieving payment methods, provide the Customer ID.
    customer: customer.id,
    amount: 1099,
    currency: 'usd',
  })
  {client_secret: intent.client_secret}.to_json
end
```

#### Répertorier manuellement les moyens de paiement

Lorsque le client envoie votre formulaire de paiement, utilisez un *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods) pour faciliter le processus de confirmation et de paiement. Créez un PaymentIntent sur votre serveur avec un `amount`, une `currency` et un ou plusieurs moyens de paiement à l’aide de `payment_method_types`. Pour éviter que des clients malveillants ne puissent définir eux-mêmes leurs tarifs, fixez systématiquement le montant à débiter côté serveur (un environnement sécurisé) plutôt que côté client.

L’objet PaymentIntent contient une *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Renvoyez cette valeur côté client afin que Stripe.js l’utilise pour finaliser le processus de paiement en toute sécurité.

#### Ruby

```ruby
require 'stripe'
Stripe.api_key = '<<YOUR_SECRET_KEY>>'

post '/create-intent' do
  intent = Stripe::PaymentIntent.create({
    # To allow saving and retrieving payment methods, provide the Customer ID.
    customer: customer.id,
    amount: 1099,
    currency: 'usd',
    payment_method_types: ['crypto'],
  })
  {client_secret: intent.client_secret}.to_json
end
```

## Envoyer le paiement à Stripe [Côté client]

Utilisez [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) pour finaliser le paiement à l’aide des informations du composant Payment&nbsp;Element.

Ajoutez un paramètre [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) à cette fonction pour indiquer à Stripe où rediriger l’utilisateur une fois le paiement effectué. Dans un premier temps, votre utilisateur sera peut-être redirigé vers un site intermédiaire, comme une page d’autorisation bancaire, avant d’être redirigé vers l’URL `return_url`. Une fois le paiement par carte abouti, l’utilisateur est immédiatement redirigé vers l’URL `return_url`.

Si vous ne souhaitez pas effectuer de redirection à la fin des paiements par carte, vous pouvez définir le paramètre [redirect](https://docs.stripe.com/js/payment_intents/confirm_payment#confirm_payment_intent-options-redirect) sur `if_required`. De cette manière, seuls les clients qui choisissent un moyen de paiement avec redirection seront redirigés.

#### HTML + JS

```javascript

const form = document.getElementById('payment-form');
const submitBtn = document.getElementById('submit');

const handleError = (error) => {
  const messageContainer = document.querySelector('#error-message');
  messageContainer.textContent = error.message;
  submitBtn.disabled = false;
}

form.addEventListener('submit', async (event) => {
  // We don't want to let default form submission happen here,
  // which would refresh the page.
  event.preventDefault();

  // Prevent multiple form submissions
  if (submitBtn.disabled) {
    return;
  }

  // Disable form submission while loading
  submitBtn.disabled = true;

  // Trigger form validation and wallet collection
  const {error: submitError} = await elements.submit();
  if (submitError) {
    handleError(submitError);
    return;
  }

  // Create the PaymentIntent and obtain clientSecret
  const res = await fetch("/create-intent", {
    method: "POST",
  });

  const {client_secret: clientSecret} = await res.json();

  // Confirm the PaymentIntent using the details collected by the Payment Element
  const {error} = await stripe.confirmPayment({
    elements,
    clientSecret,
    confirmParams: {
      return_url: 'https://example.com/order/123/complete',
    },
  });

  if (error) {
    // This point is only reached if there's an immediate error when
    // confirming the payment. Show the error to your customer (for example, payment details incomplete)
    handleError(error);
  } else {
    // Your customer is redirected to your `return_url`. For some payment
    // methods like iDEAL, your customer is redirected to an intermediate
    // site first to authorize the payment, then redirected to the `return_url`.
  }
});

```

#### React

```jsx
import React, {useState} from 'react';
import {useStripe, useElements, PaymentElement} from '@stripe/react-stripe-js';

export default function CheckoutForm() {
  const stripe = useStripe();
  const elements = useElements();

  const [errorMessage, setErrorMessage] = useState();
  const [loading, setLoading] = useState(false);

  const handleError = (error) => {
    setLoading(false);
    setErrorMessage(error.message);
  }

  const handleSubmit = async (event) => {
    // We don't want to let default form submission happen here,
    // which would refresh the page.
    event.preventDefault();

    if (!stripe) {
      // Stripe.js hasn't yet loaded.
      // Make sure to disable form submission until Stripe.js has loaded.
      return;
    }

    setLoading(true);

    // Trigger form validation and wallet collection
    const {error: submitError} = await elements.submit();
    if (submitError) {
      handleError(submitError);
      return;
    }

    // Create the PaymentIntent and obtain clientSecret
    const res = await fetch("/create-intent", {
      method: "POST",
    });

    const {client_secret: clientSecret} = await res.json();

    // Confirm the PaymentIntent using the details collected by the Payment Element
    const {error} = await stripe.confirmPayment({
      elements,
      clientSecret,
      confirmParams: {
        return_url: 'https://example.com/order/123/complete',
      },
    });

    if (error) {
      // This point is only reached if there's an immediate error when
      // confirming the payment. Show the error to your customer (for example, payment details incomplete)
      handleError(error);
    } else {
      // Your customer is redirected to your `return_url`. For some payment
      // methods like iDEAL, your customer is redirected to an intermediate
      // site first to authorize the payment, then redirected to the `return_url`.
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <PaymentElement />
      <button type="submit" disabled={!stripe || loading}>
        Submit Payment
      </button>
      {errorMessage && <div>{errorMessage}</div>}
    </form>
  );
}
```

## Optional: Récupérer des mises à jour à partir du serveur [Côté client]

Pour modifier des attributs du Paymentintent tels que le [montant](https://docs.stripe.com/api/payment_intents/update.md#update_payment_intent-amount) (par exemple, les codes de réduction ou les frais d’expédition) après l’affichage du composant Payment&nbsp;Element, vous pouvez [modifier le PaymentIntent](https://docs.stripe.com/api/payment_intents/update.md) sur votre serveur, puis appeler [elements.fetchUpdates](https://docs.stripe.com/js/elements_object/fetch_updates) pour faire apparaître le nouveau montant dans le composant Payment&nbsp;Element. Cet exemple vous montre comment créer un endpoint de serveur capable de mettre à jour le montant du PaymentIntent&nbsp;:

#### Ruby

```ruby
get '/update' do
  intent = Stripe::PaymentIntent.update(
    '{{PAYMENT_INTENT_ID}}',
    {amount: 1499},
  )
  {status: intent.status}.to_json
end
```

Cet exemple vous montre comment mettre à jour l’interface utilisateur pour refléter ces modifications côté client&nbsp;:

```javascript
(async () => {
  const response = await fetch('/update');
  if (response.status === 'requires_payment_method') {
    const {error} = await elements.fetchUpdates();
  }
})();
```

## Optional: Gérer la redirection manuellement [Côté serveur]

Le meilleur moyen de gérer les redirections est d’utiliser Stripe.js avec `confirmPayment`. Si vous devez rediriger manuellement vos clients&nbsp;:

1. Indiquez l’URL vers laquelle vos clients seront redirigés une fois leur paiement terminé.

```curl
curl https://api.stripe.com/v1/payment_intents/pi_1DRuHnHgsMRlo4MtwuIAUe6u/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d payment_method=pm_1EnPf7AfTbPYpBIFLxIc8SD9 \
  --data-urlencode "return_url=https://shop.example.com/crtA6B28E1"
```

1. Vérifiez que l’état du `PaymentIntent` est bien `requires_action`. Le type de `next_action` sera `redirect_to_url`.

```json
"next_action": {
  "type": "redirect_to_url",
  "redirect_to_url": {
    "url": "https://hooks.stripe.com/...",
    "return_url": "https://example.com/checkout/complete"
  }
}
```

1. Redirigez le client vers l’URL indiquée dans la propriété `next_action`.

À l’issue du processus de paiement, le client est redirigé vers la destination `return_url`. Les paramètres de requête d’URL `payment_intent` et `payment_intent_client_secret` sont inclus et vous pouvez par ailleurs transmettre vos propres paramètres de requête, comme indiqué plus haut.

## Optional: Gérer les événements post-paiement

Stripe envoie un événement [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) à l’issue du paiement. Utilisez le Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personnalisé ou une solution partenaire pour recevoir ces événements et exécuter des actions, comme envoyer une confirmation de commande par e-mail à votre client, enregistrer la vente dans une base de données ou lancer un workflow de livraison.

Plutôt que d’attendre un rappel de votre client, écoutez ces événements. En effet, côté client, l’acheteur pourrait fermer la fenêtre de son navigateur ou quitter l’application avant l’exécution du rappel. Des personnes malveillantes peuvent en profiter pour manipuler la réponse. Si vous configurez votre intégration de manière à écouter les événements asynchrones, cela vous permettra également d’accepter de nouveaux moyens de paiement plus facilement à l’avenir. Apprenez-en davantage sur les [différences entre les différents moyens de paiement pris en charge](https://stripe.com/payments/payment-methods-guide).

- **Gérer les événements manuellement dans le Dashboard**

  Utilisez le Dashboard pour [afficher vos paiements de test dans le Dashboard](https://dashboard.stripe.com/test/payments), envoyer des reçus par e-mail, gérer les virements ou réessayer les paiements échoués.

- **Créer un webhook personnalisé**

  [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the Stripe CLI.

- **Intégrer une application prédéfinie**

  Gérez les événements commerciaux courants, tels que l’[automatisation](https://stripe.partners/?f_category=automation) ou le [marketing et les ventes](https://stripe.partners/?f_category=marketing-and-sales), en intégrant une application partenaire.

## Tester votre intégration

Testez votre intégration de paiement en cryptomonnaie en ouvrant la page de redirection des paiements à l’aide de vos clés API de test. Vous pouvez tester gratuitement un tunnel de paiement réussi à l’aide des [ressources de testnet](https://docs.stripe.com/payments/accept-stablecoin-payments.md#testnet-assets).

1. Dans un *environnement de test* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes), créez une nouvelle transaction avec la méthode d’intégration choisie, puis ouvrez l’URL de redirection.
1. Connectez votre wallet et votre réseau de paiement préférés.
1. Effectuez le paiement et vérifiez que vous pouvez accéder à l’URL attendue.

### Paiements tests avec des actifs testnet

La plupart des cryptomonnaies proposent des actifs testnet, ou des tokens qui n’ont aucune valeur monétaire, que vous pouvez utiliser pour tester les transactions blockchain. Stripe recommande le wallet MetaMask, le testnet Polygon Amoy et le faucet Circle pour les tests, mais vous pouvez utiliser vos propres services préférés.

#### Installez un wallet

1. [Téléchargez l’extension MetaMask](https://metamask.io/download) pour votre navigateur Web.
1. [Créez un wallet](https://support.metamask.io/start/creating-a-new-wallet/) ou [importez un wallet existant](https://support.metamask.io/start/use-an-existing-wallet/).

#### Activer un testnet

1. Dans votre wallet MetaMask, sélectionnez **Réseaux** dans le menu principal.
1. Cliquez sur **Ajouter un réseau personnalisé**.
1. Saisissez les informations suivantes&nbsp;:
   - **Nom du réseau**&nbsp;: `Amoy`
   - **URL RPC par défaut**&nbsp;: `https://rpc-amoy.polygon.technology/`
   - **ID de chaîne**&nbsp;: `80002`
   - **Symbole devise**&nbsp;: `POL`
   - **Bloquer l’URL de l’explorateur**&nbsp;: `https://amoy.polygonscan.com/`
1. Cliquez sur **Enregistrer**.

#### Importez un token

1. Dans votre wallet MetaMask, sous **Tokens**, sélectionnez **Amoy** dans la liste déroulante du réseau.
1. Cliquez sur le menu de débordement (⋯) et sélectionnez **Importer des tokens**.
1. Cliquez sur **Sélectionner un réseau** > **Amoy**.
1. Sous **Adresse du contrat token**, collez l’adresse du contrat testnet Polygon Amoy&nbsp;:
   ```
   0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582
   ```
Le champ **Symbole du token** se met automatiquement à jour avec `USDC` et le champ **Décimales** avec `6`.
1. Cliquez sur **Suivant**.
1. Vérifiez que vous importez le token `USDC`, puis cliquez sur **Importer**.

Votre wallet MetaMask affiche désormais **POL** et **USDC** dans la liste des tokens.

Lors des tests de remboursements, le token envoyé à votre wallet peut avoir un contrat différent de celui utilisé pour le paiement. Nous vous recommandons de vérifier le [transaction_hash](https://docs.stripe.com/api/refunds/object.md?rds=1#refund_object-destination_details-crypto-reference) de votre remboursement sur un explorateur de blocs et d’ajouter le contrat de ce token à votre wallet. Par exemple, vous pourriez voir l’adresse de contrat de token `0x58277ebcabbe2a6694fbca8daf9e23163dbacf3e` pour les remboursements Sepolia ETH USDC.

#### Obtenir des ressources testnet

> Pour utiliser certains faucets de testnet, vous pourriez avoir besoin de détenir une petite quantité de tokens du mainnet.

1. Ouvrir le paramètre [faucet.circle.com](https://faucet.circle.com/)
1. Cliquez sur **USDC**.
1. Sous **Réseau**, sélectionnez **Polygon PDV Amoy**.
1. Sous l’onglet **Envoyer vers**, collez l’adresse de votre wallet.
1. Cliquez sur **Envoyer&nbsp;20&nbsp;USDC**.

En plus de l’USDC pour effectuer des paiements, vous avez besoin de POL pour payer les frais de transaction&nbsp;:

1. Ouvrir [faucet.polygon.technology](https://faucet.polygon.technology/).
1. Sous **Sélectionner la chaîne et le Token**, sélectionnez **Polygon Amoy** et **POL**.
1. Sous **Vérifier votre identité**, cliquez sur la plateforme tierce avec laquelle vous souhaitez vous authentifier, puis suivez la procédure de connexion.
1. Sous **Saisir l’adresse wallet**, collez l’adresse de votre wallet.
1. Cliquez sur **Réclamer**.

La finalisation des transactions Testnet peut prendre quelques minutes. Vérifiez votre wallet pour confirmer que l’USDC et le POL ont bien été transférés.

### Plus de faucets testnet

Consultez ces sites de faucets pour plus d’options de tokens de test&nbsp;:

- [Paxos USDP](https://faucet.paxos.com/)
- [Devnet SOL](https://faucet.solana.com/)
- [Sepolia ETH](https://faucets.chain.link/sepolia)
- [Amoy POL](https://faucet.polygon.technology/)

## Codes d’erreur

Le tableau suivant détaille les codes d’erreur courants et les actions recommandées&nbsp;:

| Code d’erreur                                             | Action recommandée                                                                                                                                                                                                                                                                                                                                                                                                                |
| --------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent_invalid_currency`                         | Spécifiez une devise prise en charge.                                                                                                                                                                                                                                                                                                                                                                                             |
| `missing_required_parameter`                              | Consultez le message d’erreur pour en savoir plus sur le paramètre requis.                                                                                                                                                                                                                                                                                                                                                        |
| `payment_intent_payment_attempt_failed`                   | Ce code peut apparaître dans le champ [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) d’un PaymentIntent. Consultez le message d’erreur pour connaître la raison détaillée de l’échec et obtenir une suggestion de traitement de l’erreur.                                                                                                         |
| `payment_intent_authentication_failure`                   | Ce code peut apparaître dans le champ [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) d’un PaymentIntent. Consultez le message d’erreur pour connaître le motif détaillé de l’échec et obtenir une suggestion sur la gestion de l’erreur. Cette erreur se produit lorsque vous déclenchez manuellement un échec lors du test de votre intégration. |
| `payment_intent_redirect_confirmation_without_return_url` | Précisez une `return_url` lors de la confirmation d’un PaymentIntent.                                                                                                                                                                                                                                                                                                                                                             |


# API directe

> This is a API directe for when payment-ui is direct-api. View the full page at https://docs.stripe.com/payments/accept-stablecoin-payments?payment-ui=direct-api.

Intégrez Pay&nbsp;with&nbsp;Crypto directement via l’{% glossary term="payment-intents&nbsp;» %}API Payment Intents**.

## Configurer Stripe [Côté serveur]

Tout d’abord, [créez un compte Stripe](https://dashboard.stripe.com/register) ou [connectez-vous](https://dashboard.stripe.com/login).

Utilisez nos bibliothèques officielles pour accéder à l’API Stripe depuis votre application&nbsp;:

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

## Créer un PaymentIntent et récupérer la clé secrète du client [Côté serveur]

L’objet [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) représente votre intention de collecter un paiement de la part de votre client et suit le cycle de vie du paiement traité. Créez un PaymentIntent sur votre serveur et indiquez le montant à collecter ainsi qu’une devise prise en charge. Si vous disposez d’une intégration PaymentIntents existante, ajoutez la `crypto` à la liste des [payment_method_types](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types).

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d "payment_method_types[]=crypto"
```

### Récupérer la clé secrète du client

Le PaymentIntent contient une *clé secrète* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) à utiliser côté client pour finaliser le processus de paiement en toute sécurité. Vous pouvez adopter différentes approches pour transmettre cette clé secrète côté client.

#### Application monopage

Récupérez la clé secrète du client à partir d’un endpoint sur votre serveur, à l’aide de la fonction `fetch` du navigateur. Cette approche est recommandée si votre côté client est une application d’une seule page, en particulier si elle repose sur un framework front-end moderne tel que React. Créez l’endpoint de serveur qui gère la clé secrète du client&nbsp;:

#### Ruby

```ruby
get '/secret' do
  intent = # ... Create or retrieve the PaymentIntent
  {client_secret: intent.client_secret}.to_json
end
```

Récupérez ensuite la clé secrète du client à l’aide JavaScript côté client&nbsp;:

```javascript
(async () => {
  const response = await fetch('/secret');
  const {client_secret: clientSecret} = await response.json();
  // Render the form using the clientSecret
})();
```

#### Rendu côté serveur

Transmettez la clé secrète à votre client depuis votre serveur. Cette approche fonctionne mieux si votre application génère du contenu statique sur le serveur avant de l’envoyer sur le navigateur.

Ajoutez le [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) à votre formulaire de paiement. Dans votre code côté serveur, récupérez la clé secrète du client à partir du PaymentIntent&nbsp;:

#### Ruby

```erb
<form id="payment-form" data-secret="<%= @intent.client_secret %>">
  <button id="submit">Submit</button>
</form>
```

```ruby
get '/checkout' do
  @intent = # ... Fetch or create the PaymentIntent
  erb :checkout
end
```

## Redirection vers la page des paiements en stablecoins

Utilisez [Stripe.js](https://docs.stripe.com/js.md) pour envoyer le paiement à Stripe lorsqu’un client choisit **Cryptomonnaie** comme moyen de paiement. Stripe.js est la bibliothèque JavaScript de base pour créer des tunnels de paiement. Il gère automatiquement des situations complexes telles que la redirection décrite ci-dessous et vous permet d’étendre votre intégration à d’autres moyens de paiement. Intégrez le script Stripe.js à votre page de paiement en l’ajoutant entre les balises `<head>` de votre fichier HTML.

```html
<head>
  <title>Checkout</title>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
```

Créez une instance de Stripe.js avec le code JavaScript suivant sur votre page de paiement&nbsp;:

```javascript
// Set your publishable key. Remember to change this to your live publishable key in production!
// See your keys here: https://dashboard.stripe.com/apikeys
const stripe = Stripe('<<YOUR_PUBLISHABLE_KEY>>');
```

Utilisez la [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) du PaymentIntent et appelez `stripe.confirmPayment` pour gérer la redirection vers Pay&nbsp;with&nbsp;Crypto. Ajoutez un `return_url` pour indiquer où Stripe redirige le client une fois qu’il a effectué le paiement.

```javascript
const form = document.getElementById('payment-form');

form.addEventListener('submit', async function(event) {
  event.preventDefault();

  // Set the clientSecret of the PaymentIntent
  const { error } = await stripe.confirmPayment({
    clientSecret: clientSecret,
    confirmParams: {
      payment_method_data: {
        type: 'crypto',
      },
      // Return URL where the customer should be redirected after the authorization
      return_url: `${window.location.href}`,
    },
  });

  if (error) {
    // Inform the customer that there was an error.
    const errorElement = document.getElementById('error-message');
    errorElement.textContent = result.error.message;
  }
});
```

Le `return_url` correspond à une page de votre site Web qui affiche le résultat du paiement. Vous pouvez déterminer ce qu’il faut afficher en [vérifiant l’état](https://docs.stripe.com/payments/payment-intents/verifying-status.md#checking-status) du PaymentIntent. Pour vérifier l’état, la redirection Stripe vers le `return_url` inclut les paramètres de requête d’URL suivants. Vous pouvez également ajouter vos propres paramètres de requête au `return_url`. Ils persistent tout au long du processus de redirection.

|  |
|  |
| `payment_intent`               | L’identifiant unique du `PaymentIntent`.                                                                                                          |
| `payment_intent_client_secret` | La [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) de l’objet `PaymentIntent`. |

## Optional: Gérer les événements post-paiement

Une fois le paiement effectué, Stripe envoie un événement [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded). Utilisez le Dashboard, un [webhook](https://docs.stripe.com/webhooks.md) personnalisé ou une solution partenaire pour recevoir ces événements et exécuter des actions, comme envoyer une confirmation de commande par e-mail à votre client, enregistrer la vente dans une base de données ou lancer un workflow de livraison.

Nous vous conseillons d’écouter ces événements plutôt que d’attendre un rappel de votre client. Côté client, il arrive en effet que l’utilisateur ferme la fenêtre de son navigateur ou quitte l’application avant l’exécution du rappel, et des tentatives de manipulation de la réponse par des clients malintentionnés ne sont par ailleurs pas à exclure. La configuration de votre intégration pour écouter les événements asynchrones peut également vous aider à accepter davantage de moyens de paiement à l’avenir. Pour connaître les différences entre tous les moyens de paiement pris en charge, consultez notre guide sur les [moyens de paiement](https://stripe.com/payments/payment-methods-guide).

### Recevoir des événements et exécuter des actions métier

Plusieurs options s’offrent à vous pour recevoir et exécuter des actions&nbsp;:

- **Manuellement**&nbsp;: utilisez le [Dashboard Stripe](https://dashboard.stripe.com/test/payments) pour afficher tous vos paiements Stripe, envoyer des reçus par e-mail, gérer les virements ou relancer les paiements en échec.

- **Code personnalisé&nbsp;:** [créez un gestionnaire de webhooks](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) pour écouter les événements et construire des tunnels de paiement asynchrones personnalisés. Testez et déboguez votre intégration de webhook localement avec le Stripe CLI.

- **Applications préconfigurées**&nbsp;: intégrez une application partenaire pour gérer les événements courants, comme l’[automatisation](https://stripe.partners/?f_category=automation), le [marketing ou les ventes](https://stripe.partners/?f_category=marketing-and-sales).

### Devises prises en charge

Vous pouvez créer des paiements en cryptomonnaies dans les devises qui correspondent à votre pays. La devise locale par défaut pour la cryptomonnaie est l’USD. Les clients voient également le montant de leurs achats dans cette devise.

## Optional: Gérer la redirection manuellement [Côté serveur]

Le meilleur moyen de gérer les redirections est d’utiliser Stripe.js avec `confirmPayment`. Si vous devez rediriger manuellement vos clients&nbsp;:

1. Indiquez l’URL vers laquelle vos clients seront redirigés une fois leur paiement terminé.

```curl
curl https://api.stripe.com/v1/payment_intents/pi_1DRuHnHgsMRlo4MtwuIAUe6u/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d payment_method=pm_1EnPf7AfTbPYpBIFLxIc8SD9 \
  --data-urlencode "return_url=https://shop.example.com/crtA6B28E1"
```

1. Vérifiez que l’état du `PaymentIntent` est bien `requires_action`. Le type de `next_action` sera `redirect_to_url`.

```json
"next_action": {
  "type": "redirect_to_url",
  "redirect_to_url": {
    "url": "https://hooks.stripe.com/...",
    "return_url": "https://example.com/checkout/complete"
  }
}
```

1. Redirigez le client vers l’URL indiquée dans la propriété `next_action`.

À l’issue du processus de paiement, le client est redirigé vers la destination `return_url`. Les paramètres de requête d’URL `payment_intent` et `payment_intent_client_secret` sont inclus et vous pouvez par ailleurs transmettre vos propres paramètres de requête, comme indiqué plus haut.

## Tester votre intégration

Testez votre intégration de paiement en cryptomonnaie en ouvrant la page de redirection des paiements à l’aide de vos clés API de test. Vous pouvez tester gratuitement un tunnel de paiement réussi à l’aide des [ressources de testnet](https://docs.stripe.com/payments/accept-stablecoin-payments.md#testnet-assets).

1. Dans un *environnement de test* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes), créez une nouvelle transaction avec la méthode d’intégration choisie, puis ouvrez l’URL de redirection.
1. Connectez votre wallet et votre réseau de paiement préférés.
1. Effectuez le paiement et vérifiez que vous pouvez accéder à l’URL attendue.

### Paiements tests avec des actifs testnet

La plupart des cryptomonnaies proposent des actifs testnet, ou des tokens qui n’ont aucune valeur monétaire, que vous pouvez utiliser pour tester les transactions blockchain. Stripe recommande le wallet MetaMask, le testnet Polygon Amoy et le faucet Circle pour les tests, mais vous pouvez utiliser vos propres services préférés.

#### Installez un wallet

1. [Téléchargez l’extension MetaMask](https://metamask.io/download) pour votre navigateur Web.
1. [Créez un wallet](https://support.metamask.io/start/creating-a-new-wallet/) ou [importez un wallet existant](https://support.metamask.io/start/use-an-existing-wallet/).

#### Activer un testnet

1. Dans votre wallet MetaMask, sélectionnez **Réseaux** dans le menu principal.
1. Cliquez sur **Ajouter un réseau personnalisé**.
1. Saisissez les informations suivantes&nbsp;:
   - **Nom du réseau**&nbsp;: `Amoy`
   - **URL RPC par défaut**&nbsp;: `https://rpc-amoy.polygon.technology/`
   - **ID de chaîne**&nbsp;: `80002`
   - **Symbole devise**&nbsp;: `POL`
   - **Bloquer l’URL de l’explorateur**&nbsp;: `https://amoy.polygonscan.com/`
1. Cliquez sur **Enregistrer**.

#### Importez un token

1. Dans votre wallet MetaMask, sous **Tokens**, sélectionnez **Amoy** dans la liste déroulante du réseau.
1. Cliquez sur le menu de débordement (⋯) et sélectionnez **Importer des tokens**.
1. Cliquez sur **Sélectionner un réseau** > **Amoy**.
1. Sous **Adresse du contrat token**, collez l’adresse du contrat testnet Polygon Amoy&nbsp;:
   ```
   0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582
   ```
Le champ **Symbole du token** se met automatiquement à jour avec `USDC` et le champ **Décimales** avec `6`.
1. Cliquez sur **Suivant**.
1. Vérifiez que vous importez le token `USDC`, puis cliquez sur **Importer**.

Votre wallet MetaMask affiche désormais **POL** et **USDC** dans la liste des tokens.

Lors des tests de remboursements, le token envoyé à votre wallet peut avoir un contrat différent de celui utilisé pour le paiement. Nous vous recommandons de vérifier le [transaction_hash](https://docs.stripe.com/api/refunds/object.md?rds=1#refund_object-destination_details-crypto-reference) de votre remboursement sur un explorateur de blocs et d’ajouter le contrat de ce token à votre wallet. Par exemple, vous pourriez voir l’adresse de contrat de token `0x58277ebcabbe2a6694fbca8daf9e23163dbacf3e` pour les remboursements Sepolia ETH USDC.

#### Obtenir des ressources testnet

> Pour utiliser certains faucets de testnet, vous pourriez avoir besoin de détenir une petite quantité de tokens du mainnet.

1. Ouvrir le paramètre [faucet.circle.com](https://faucet.circle.com/)
1. Cliquez sur **USDC**.
1. Sous **Réseau**, sélectionnez **Polygon PDV Amoy**.
1. Sous l’onglet **Envoyer vers**, collez l’adresse de votre wallet.
1. Cliquez sur **Envoyer&nbsp;20&nbsp;USDC**.

En plus de l’USDC pour effectuer des paiements, vous avez besoin de POL pour payer les frais de transaction&nbsp;:

1. Ouvrir [faucet.polygon.technology](https://faucet.polygon.technology/).
1. Sous **Sélectionner la chaîne et le Token**, sélectionnez **Polygon Amoy** et **POL**.
1. Sous **Vérifier votre identité**, cliquez sur la plateforme tierce avec laquelle vous souhaitez vous authentifier, puis suivez la procédure de connexion.
1. Sous **Saisir l’adresse wallet**, collez l’adresse de votre wallet.
1. Cliquez sur **Réclamer**.

La finalisation des transactions Testnet peut prendre quelques minutes. Vérifiez votre wallet pour confirmer que l’USDC et le POL ont bien été transférés.

### Plus de faucets testnet

Consultez ces sites de faucets pour plus d’options de tokens de test&nbsp;:

- [Paxos USDP](https://faucet.paxos.com/)
- [Devnet SOL](https://faucet.solana.com/)
- [Sepolia ETH](https://faucets.chain.link/sepolia)
- [Amoy POL](https://faucet.polygon.technology/)


# iOS

> This is a iOS for when payment-ui is mobile and platform is ios. View the full page at https://docs.stripe.com/payments/accept-stablecoin-payments?payment-ui=mobile&platform=ios.

Nous vous recommandons d’utiliser [Mobile Payment Element](https://docs.stripe.com/payments/accept-a-payment.md?=ios), un formulaire de paiement intégrable, pour ajouter Pay with Crypto et d’autres moyens de paiement à votre intégration le plus facilement possible.

Pay&nbsp;with&nbsp;Crypto est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage) qui nécessite l’[authentification](https://docs.stripe.com/payments/payment-methods.md#customer-actions) du paiement par le client. Les clients sont redirigés depuis votre application, autorisent le paiement avec Stripe Crypto, puis retournent sur votre application. Vous recevez [immédiatement la notification](https://docs.stripe.com/payments/payment-methods.md#payment-notification) de réussite ou d’échec du paiement.

## Configurer Stripe [Côté serveur] [Côté client]

Tout d’abord, il vous faut un compte Stripe. [Inscrivez-vous](https://dashboard.stripe.com/register).

### Côté serveur

Pour cette intégration, votre serveur doit être doté d’endpoints qui communiquent avec l’API Stripe. Utilisez les bibliothèques officielles pour accéder à l’API Stripe depuis votre serveur&nbsp;:

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### Côté client

Le [SDK iOS de Stripe](https://github.com/stripe/stripe-ios) est disponible en open source et [fait l’objet d’une documentation complète](https://stripe.dev/stripe-ios/index.html). Il est également compatible avec les applications prenant en charge iOS 13 et les versions ultérieures.

#### Swift Package Manager

Pour installer le SDK, veuillez suivre les étapes ci-dessous&nbsp;:

1. Dans Xcode, sélectionnez **File** > **Add Package Dependencies…** puis saisissez `https://github.com/stripe/stripe-ios-spm` en tant qu’URL du référentiel.
1. Sélectionnez le dernier numéro de version, visible sur notre [page des versions](https://github.com/stripe/stripe-ios/releases).
1. Ajoutez le produit **StripePaymentsUI** à la [cible de votre application](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app).

#### CocoaPods

1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [CocoaPods](https://guides.cocoapods.org/using/getting-started.html).
1. Si vous n’avez pas de fichier [Podfile](https://guides.cocoapods.org/syntax/podfile.html), exécutez la commande suivante pour en créer un&nbsp;:
   ```bash
   pod init
   ```
1. Ajoutez cette ligne à votre `Podfile`&nbsp;:
   ```podfile
   pod 'StripePaymentsUI'
   ```
1. Exécutez la commande suivante&nbsp;:
   ```bash
   pod install
   ```
1. À partir de maintenant, n’oubliez pas d’utiliser le fichier .xcworkspace au lieu du fichier .xcodeproj pour ouvrir votre projet dans Xcode.
1. Pour mettre à jour ultérieurement le SDK vers la version la plus récente, il vous suffit d’exécuter&nbsp;:
   ```bash
   pod update StripePaymentsUI
   ```

#### Carthage

1. Si vous ne l’avez pas encore fait, installez la version la plus récente de [Carthage](https://github.com/Carthage/Carthage#installing-carthage).
1. Ajoutez cette ligne à votre `Cartfile`&nbsp;:
   ```cartfile
   github "stripe/stripe-ios"
   ```
1. Suivez les [instructions d’installation de Carthage](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Veillez à intégrer tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking).
1. Pour mettre à jour ultérieurement le SDK vers la version la plus récente, exécutez la commande suivante&nbsp;:
   ```bash
   carthage update stripe-ios --platform ios
   ```

#### Cadre manuel

1. Accédez à notre [page des versions GitHub](https://github.com/stripe/stripe-ios/releases/latest), puis téléchargez et décompressez **Stripe.xcframework.zip**.
1. Faites glisser **StripePaymentsUI.xcframework** vers la section **Embedded Binaries (Fichiers binaires incorporés)** des paramètres **General (Général)** de votre projet Xcode. Veillez à sélectionner **Copy items if needed (Copier les éléments si nécessaire)**.
1. Répétez l’étape 2 pour tous les cadres requis listés [ici](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking).
1. À l’avenir, pour mettre à jour vers la version la plus récente de notre SDK, répétez les étapes&nbsp;1 à 3.

> Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des [versions](https://github.com/stripe/stripe-ios/releases) sur GitHub. Pour recevoir une notification lors de la publication d’une nouvelle version, [surveillez les versions](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository) à partir du référentiel.

Configurez le SDK avec votre [clé publiable](https://dashboard.stripe.com/test/apikeys) Stripe au démarrage de votre application. Cela lui permet d’envoyer des requêtes à l’API Stripe.

#### Swift

```swift
import UIKitimportStripePaymentsUI

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<<YOUR_PUBLISHABLE_KEY>>"
        // do any other necessary launch configuration
        return true
    }
}
```

> Utilisez vos [clés de test](https://docs.stripe.com/keys.md#obtain-api-keys) lors de vos activités de test et de développement et vos clés du [mode production](https://docs.stripe.com/keys.md#test-live-modes) pour la publication de votre application.

## Créer un PaymentIntent [Côté serveur] [Côté client]

### Côté serveur

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention de collecter un paiement auprès d’un client et qui suit le cycle de vie du processus de paiement à chaque étape.

#### Gérer les moyens de paiement dans le Dashboard

Vous pouvez gérer les moyens de paiement dans le [Dashboard](https://dashboard.stripe.com/settings/payment_methods). Stripe gère l’affichage des moyens de paiement admissibles en fonction de facteurs tels que le montant de la transaction, la devise et le tunnel de paiement.

Créez un PaymentIntent sur votre serveur avec un montant et une devise. Avant de créer le PaymentIntent, assurez-vous d’activer l’option **Pay&nbsp;with&nbsp;Crypto** dans vos [Paramètres des moyens de paiement](https://dashboard.stripe.com/settings/payment_methods).

> Définissez toujours le montant à débiter côté serveur car il s’agit d’un environnement sécurisé, contrairement à l’environnement client. De cette façon, les clients ne pourront pas fixer leurs propres tarifs.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d "automatic_payment_methods[enabled]=true"
```

#### Répertorier manuellement les moyens de paiement

Si vous ne souhaitez pas utiliser le Dashboard ou si vous souhaitez indiquer manuellement des moyens de paiement, vous pouvez les répertorier à l’aide de l’attribut `payment_method_types`.

Créez un PaymentIntent sur votre serveur avec un montant, une devise et une liste des moyens de paiement.

> Définissez toujours le montant à débiter côté serveur car il s’agit d’un environnement sécurisé, contrairement à l’environnement client. De cette façon, les clients ne pourront pas fixer leurs propres tarifs.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d "payment_method_types[]=crypto"
```

### Côté client

Côté client, demandez un PaymentIntent auprès de votre serveur et stockez la *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)).

#### Swift

```swift
class CheckoutViewController: UIViewController {
    var paymentIntentClientSecret: String?

    // ...continued from previous step

    override func viewDidLoad() {
        // ...continued from previous step
        startCheckout()
    }

    func startCheckout() {
        // Request a PaymentIntent from your server and store its client secret
        // Click View full sample to see a complete implementation
    }
}
```

## Envoyer le paiement à Stripe [Côté client]

Lorsqu’un client présente son compte pour payer avec Pay&nbsp;with&nbsp;Crypto, confirmez le `PaymentIntent` pour finaliser le paiement. Configurez un objet `STPPaymentIntentParams` avec la [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) du `PaymentIntent`.

La clé secrète du client est différente des clés d’API qui authentifient les requêtes d’API Stripe. Manipulez-la avec précaution car elle peut finaliser le paiement. Ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne l’exposez à personne d’autre qu’au client.

### Configurer une URL de redirection

Le SDK iOS présente une vue Web dans votre application qui permet d’effectuer le paiement Pay&nbsp;with&nbsp;Crypto. Si vous souhaitez que la vue Web disparaisse automatiquement une fois l’authentification effectuée sans que votre client ait à la fermer, paramétrez une URL personnalisée ou un lien universel, puis configurer 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
}
```

Transmettez l’URL en tant que `return_url` lorsque vous confirmez le PaymentIntent. Une fois l’authentification effectuée sur la vue Web, Stripe redirige l’utilisateur vers le `return_url`.

### Confirmer le paiement Pay with Crypto

Finalisez le paiement en appelant `STPPaymentHandler.confirmPayment`. Une vue Web s’affiche pour permettre au client d’effectuer le paiement avec Pay&nbsp;with&nbsp;Crypto. Une fois l’opération terminée, Stripe appelle le bloc de finalisation avec le résultat du paiement.

#### Swift

```swift
let paymentIntentParams = STPPaymentIntentParams(clientSecret: paymentIntentClientSecret)

// Pay with Crypto does not require additional parameters so we only need to pass the initialized
// STPPaymentMethodCryptoParams instance to STPPaymentMethodParams
let crypto = STPPaymentMethodCryptoParams()
let paymentMethodParams = STPPaymentMethodParams(crypto: crypto, billingDetails: nil, metadata: nil)

paymentIntentParams.paymentMethodParams = paymentMethodParams
paymentIntentParams.returnURL = "payments-example://stripe-redirect"

STPPaymentHandler.shared().confirmPayment(paymentIntentParams,
                                          with: self)
{ (handlerStatus, paymentIntent, error) in
    switch handlerStatus {
    case .succeeded:
        // Payment succeeded
        // ...

    case .canceled:
        // Payment canceled
        // ...

    case .failed:
        // Payment failed
        // ...

    @unknown default:
        fatalError()
    }
}
```

## Optional: Gérer la redirection manuellement [Côté serveur]

Le meilleur moyen de gérer les redirections est d’utiliser Stripe.js avec `confirmPayment`. Si vous devez rediriger manuellement vos clients&nbsp;:

1. Indiquez l’URL vers laquelle vos clients seront redirigés une fois leur paiement terminé.

```curl
curl https://api.stripe.com/v1/payment_intents/pi_1DRuHnHgsMRlo4MtwuIAUe6u/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d payment_method=pm_1EnPf7AfTbPYpBIFLxIc8SD9 \
  --data-urlencode "return_url=https://shop.example.com/crtA6B28E1"
```

1. Vérifiez que l’état du `PaymentIntent` est bien `requires_action`. Le type de `next_action` sera `redirect_to_url`.

```json
"next_action": {
  "type": "redirect_to_url",
  "redirect_to_url": {
    "url": "https://hooks.stripe.com/...",
    "return_url": "https://example.com/checkout/complete"
  }
}
```

1. Redirigez le client vers l’URL indiquée dans la propriété `next_action`.

À l’issue du processus de paiement, le client est redirigé vers la destination `return_url`. Les paramètres de requête d’URL `payment_intent` et `payment_intent_client_secret` sont inclus et vous pouvez par ailleurs transmettre vos propres paramètres de requête, comme indiqué plus haut.

## Optional: Gérer les événements post-paiement

Stripe envoie un événement [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) à l’issue du paiement. Utilisez le Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personnalisé ou une solution partenaire pour recevoir ces événements et exécuter des actions, comme envoyer une confirmation de commande par e-mail à votre client, enregistrer la vente dans une base de données ou lancer un workflow de livraison.

Plutôt que d’attendre un rappel de votre client, écoutez ces événements. En effet, côté client, l’acheteur pourrait fermer la fenêtre de son navigateur ou quitter l’application avant l’exécution du rappel. Des personnes malveillantes peuvent en profiter pour manipuler la réponse. Si vous configurez votre intégration de manière à écouter les événements asynchrones, cela vous permettra également d’accepter de nouveaux moyens de paiement plus facilement à l’avenir. Apprenez-en davantage sur les [différences entre les différents moyens de paiement pris en charge](https://stripe.com/payments/payment-methods-guide).

- **Gérer les événements manuellement dans le Dashboard**

  Utilisez le Dashboard pour [afficher vos paiements de test dans le Dashboard](https://dashboard.stripe.com/test/payments), envoyer des reçus par e-mail, gérer les virements ou réessayer les paiements échoués.

- **Créer un webhook personnalisé**

  [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the Stripe CLI.

- **Intégrer une application prédéfinie**

  Gérez les événements commerciaux courants, tels que l’[automatisation](https://stripe.partners/?f_category=automation) ou le [marketing et les ventes](https://stripe.partners/?f_category=marketing-and-sales), en intégrant une application partenaire.


# Android

> This is a Android for when payment-ui is mobile and platform is android. View the full page at https://docs.stripe.com/payments/accept-stablecoin-payments?payment-ui=mobile&platform=android.

Nous vous recommandons d’utiliser le composant [Mobile Payment Element](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=mobile&platform=android), un formulaire de paiement intégrable, pour ajouter Paiement en Cryptomonnaie et d’autres moyens de paiement à votre intégration avec un minimum d’effort.

Pay&nbsp;with&nbsp;Crypto est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage) qui nécessite l’[authentification](https://docs.stripe.com/payments/payment-methods.md#customer-actions) du paiement par le client. Les clients sont redirigés depuis votre application, autorisent le paiement avec Stripe, puis retournent sur votre application. Vous recevez [immédiatement la notification](https://docs.stripe.com/payments/payment-methods.md#payment-notification) de réussite ou d’échec du paiement.

## Configurer Stripe [Côté serveur] [Côté client]

Tout d’abord, il vous faut un compte Stripe. [Inscrivez-vous](https://dashboard.stripe.com/register).

### Côté serveur

Pour cette intégration, votre serveur doit être doté d’endpoints qui communiquent avec l’API Stripe. Utilisez les bibliothèques officielles pour accéder à l’API Stripe depuis votre serveur&nbsp;:

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### Côté client

Le [SDK Stripe Android](https://github.com/stripe/stripe-android) est disponible en open source et [fait l’objet d’une documentation complète](https://stripe.dev/stripe-android/).

Pour installer le SDK, ajoutez `stripe-android` au bloc `dependencies` de votre fichier [app/build.gradle](https://developer.android.com/studio/build/dependencies)&nbsp;:

#### Kotlin

```kotlin
plugins {
    id("com.android.application")
}

android { ... }

dependencies {
  // ...

  // Stripe Android SDK
  implementation("com.stripe:stripe-android:23.2.0")
  // Include the financial connections SDK to support US bank account as a payment method
  implementation("com.stripe:financial-connections:23.2.0")
}
```

> Pour obtenir de plus amples informations sur la version la plus récente du SDK et ses versions antérieures, consultez la page des [versions](https://github.com/stripe/stripe-android/releases) sur GitHub. Pour savoir quand une nouvelle version est disponible, [surveillez les versions du référentiel](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository).

Configurez le SDK avec votre [clé publique](https://dashboard.stripe.com/apikeys) Stripe de façon à ce qu’il puisse envoyer des requêtes à l’API Stripe, par exemple à la sous-classe `Application`&nbsp;:

#### Kotlin

```kotlin
import com.stripe.android.PaymentConfiguration

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        PaymentConfiguration.init(
            applicationContext,
            "<<YOUR_PUBLISHABLE_KEY>>"
        )
    }
}
```

> Utilisez vos [clés de test](https://docs.stripe.com/keys.md#obtain-api-keys) lors de vos activités de test et de développement et vos clés du [mode production](https://docs.stripe.com/keys.md#test-live-modes) pour la publication de votre application.

Les échantillons de code de Stripe utilisent également [OkHttp](https://github.com/square/okhttp) et [GSON](https://github.com/google/gson) pour envoyer des requêtes HTTP à un serveur.

## Créer un PaymentIntent [Côté serveur] [Côté client]

### Côté serveur

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention de collecter un paiement auprès d’un client et qui suit le cycle de vie du processus de paiement à chaque étape.

#### Gérer les moyens de paiement dans le Dashboard

Vous pouvez gérer les moyens de paiement dans le [Dashboard](https://dashboard.stripe.com/settings/payment_methods). Stripe gère l’affichage des moyens de paiement admissibles en fonction de facteurs tels que le montant de la transaction, la devise et le tunnel de paiement.

Créez un PaymentIntent sur votre serveur avec un montant et une devise. Avant de créer le PaymentIntent, assurez-vous d’activer l’option **Pay&nbsp;with&nbsp;Crypto** sur la page [Paramètres des moyens de paiement](https://dashboard.stripe.com/settings/payment_methods).

> Définissez toujours le montant à débiter côté serveur car il s’agit d’un environnement sécurisé, contrairement à l’environnement client. De cette façon, les clients ne pourront pas fixer leurs propres tarifs.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d "automatic_payment_methods[enabled]=true"
```

#### Répertorier manuellement les moyens de paiement

Si vous ne souhaitez pas utiliser le Dashboard ou si vous souhaitez indiquer manuellement des moyens de paiement, vous pouvez les répertorier à l’aide de l’attribut `payment_method_types`.

Créez un PaymentIntent sur votre serveur avec un montant, une devise et une liste des moyens de paiement.

> Définissez toujours le montant à débiter côté serveur car il s’agit d’un environnement sécurisé, contrairement à l’environnement client. De cette façon, les clients ne pourront pas fixer leurs propres tarifs.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d "payment_method_types[]=crypto"
```

### Côté client

Côté client, demandez un PaymentIntent auprès de votre serveur et stockez la *clé secrète du client* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)).

#### Kotlin

```kotlin
class CheckoutActivity : AppCompatActivity() {

  private lateinit var paymentIntentClientSecret: String

  override fun onCreate(savedInstanceState: Bundle?) {
      super.onCreate(savedInstanceState)
      // ...
      startCheckout()
  }

  private fun startCheckout() {
      // Request a PaymentIntent from your server and store its client secret in paymentIntentClientSecret
      // Click View full sample to see a complete implementation
  }
}
```

## Envoyer le paiement à Stripe [Côté client]

Lorsqu’un client présente son compte pour payer avec Pay&nbsp;with&nbsp;Crypto, confirmez le `PaymentIntent` pour finaliser le paiement. Configurez un objet `ConfirmPaymentIntentParams` avec la [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) du `PaymentIntent`.

La clé secrète du client est différente des clés d’API qui authentifient les requêtes d’API Stripe. Manipulez-la avec précaution car elle peut finaliser le paiement. Ne l’enregistrez pas, ne l’intégrez pas dans des URL et ne l’exposez à personne d’autre qu’au client.

### Confirmer le paiement Pay&nbsp;with&nbsp;Crypto

Finalisez le paiement en appelant le paramètre [confirmation PaymentLauncher](https://stripe.dev/stripe-android/payments-core/com.stripe.android.payments.paymentlauncher/-payment-launcher/confirm.html). Le client est alors redirigé vers**https://crypto.stripe.com/pay**, où il peut effectuer le paiement avec Pay with Crypto. Une fois le paiement effectué, Stripe appelle le paramètre `PaymentResultCallback` que vous avez défini avec le résultat du paiement.

#### Kotlin

```kotlin
class CheckoutActivity : AppCompatActivity() {

    // ...

    private val paymentLauncher: PaymentLauncher by lazy {
        val paymentConfiguration = PaymentConfiguration.getInstance(applicationContext)
        PaymentLauncher.create(
            activity = this,
            publishableKey = paymentConfiguration.publishableKey,
            stripeAccountId = paymentConfiguration.stripeAccountId,
            callback = ::onPaymentResult,
        )
    }

    // …

    private fun startCheckout() {
        // ...

        val cryptoParams = PaymentMethodCreateParams.createCrypto()

        val confirmParams = ConfirmPaymentIntentParams
            .createWithPaymentMethodCreateParams(
                paymentMethodCreateParams = cryptoParams,
                clientSecret = paymentIntentClientSecret,
            )

        paymentLauncher.confirm(confirmParams)
    }

    private fun onPaymentResult(paymentResult: PaymentResult) {
        // Handle the payment result…
    }
}
```

## Optional: Gérer la redirection manuellement [Côté serveur]

Le meilleur moyen de gérer les redirections est d’utiliser Stripe.js avec `confirmPayment`. Si vous devez rediriger manuellement vos clients&nbsp;:

1. Indiquez l’URL vers laquelle vos clients seront redirigés une fois leur paiement terminé.

```curl
curl https://api.stripe.com/v1/payment_intents/pi_1DRuHnHgsMRlo4MtwuIAUe6u/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d payment_method=pm_1EnPf7AfTbPYpBIFLxIc8SD9 \
  --data-urlencode "return_url=https://shop.example.com/crtA6B28E1"
```

1. Vérifiez que l’état du `PaymentIntent` est bien `requires_action`. Le type de `next_action` sera `redirect_to_url`.

```json
"next_action": {
  "type": "redirect_to_url",
  "redirect_to_url": {
    "url": "https://hooks.stripe.com/...",
    "return_url": "https://example.com/checkout/complete"
  }
}
```

1. Redirigez le client vers l’URL indiquée dans la propriété `next_action`.

À l’issue du processus de paiement, le client est redirigé vers la destination `return_url`. Les paramètres de requête d’URL `payment_intent` et `payment_intent_client_secret` sont inclus et vous pouvez par ailleurs transmettre vos propres paramètres de requête, comme indiqué plus haut.

## Optional: Gérer les événements post-paiement

Stripe envoie un événement [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) à l’issue du paiement. Utilisez le Dashboard, un *webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) personnalisé ou une solution partenaire pour recevoir ces événements et exécuter des actions, comme envoyer une confirmation de commande par e-mail à votre client, enregistrer la vente dans une base de données ou lancer un workflow de livraison.

Plutôt que d’attendre un rappel de votre client, écoutez ces événements. En effet, côté client, l’acheteur pourrait fermer la fenêtre de son navigateur ou quitter l’application avant l’exécution du rappel. Des personnes malveillantes peuvent en profiter pour manipuler la réponse. Si vous configurez votre intégration de manière à écouter les événements asynchrones, cela vous permettra également d’accepter de nouveaux moyens de paiement plus facilement à l’avenir. Apprenez-en davantage sur les [différences entre les différents moyens de paiement pris en charge](https://stripe.com/payments/payment-methods-guide).

- **Gérer les événements manuellement dans le Dashboard**

  Utilisez le Dashboard pour [afficher vos paiements de test dans le Dashboard](https://dashboard.stripe.com/test/payments), envoyer des reçus par e-mail, gérer les virements ou réessayer les paiements échoués.

- **Créer un webhook personnalisé**

  [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the Stripe CLI.

- **Intégrer une application prédéfinie**

  Gérez les événements commerciaux courants, tels que l’[automatisation](https://stripe.partners/?f_category=automation) ou le [marketing et les ventes](https://stripe.partners/?f_category=marketing-and-sales), en intégrant une application partenaire.

### Tester votre intégration

Testez votre intégration de paiement en cryptomonnaie en ouvrant la page de redirection des paiements à l’aide de vos clés API de test. Vous pouvez tester gratuitement un tunnel de paiement réussi à l’aide des [ressources de testnet](https://docs.stripe.com/payments/accept-stablecoin-payments.md#testnet-assets).

1. Dans un *environnement de test* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes), créez une nouvelle transaction avec la méthode d’intégration choisie, puis ouvrez l’URL de redirection.
1. Connectez votre wallet et votre réseau de paiement préférés.
1. Effectuez le paiement et vérifiez que vous pouvez accéder à l’URL attendue.

### Paiements tests avec des actifs testnet

La plupart des cryptomonnaies proposent des actifs testnet, ou des tokens qui n’ont aucune valeur monétaire, que vous pouvez utiliser pour tester les transactions blockchain. Stripe recommande le wallet MetaMask, le testnet Polygon Amoy et le faucet Circle pour les tests, mais vous pouvez utiliser vos propres services préférés.

#### Installez un wallet

1. [Téléchargez l’extension MetaMask](https://metamask.io/download) pour votre navigateur Web.
1. [Créez un wallet](https://support.metamask.io/start/creating-a-new-wallet/) ou [importez un wallet existant](https://support.metamask.io/start/use-an-existing-wallet/).

#### Activer un testnet

1. Dans votre wallet MetaMask, sélectionnez **Réseaux** dans le menu principal.
1. Cliquez sur **Ajouter un réseau personnalisé**.
1. Saisissez les informations suivantes&nbsp;:
   - **Nom du réseau**&nbsp;: `Amoy`
   - **URL RPC par défaut**&nbsp;: `https://rpc-amoy.polygon.technology/`
   - **ID de chaîne**&nbsp;: `80002`
   - **Symbole devise**&nbsp;: `POL`
   - **Bloquer l’URL de l’explorateur**&nbsp;: `https://amoy.polygonscan.com/`
1. Cliquez sur **Enregistrer**.

#### Importez un token

1. Dans votre wallet MetaMask, sous **Tokens**, sélectionnez **Amoy** dans la liste déroulante du réseau.
1. Cliquez sur le menu de débordement (⋯) et sélectionnez **Importer des tokens**.
1. Cliquez sur **Sélectionner un réseau** > **Amoy**.
1. Sous **Adresse du contrat token**, collez l’adresse du contrat testnet Polygon Amoy&nbsp;:
   ```
   0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582
   ```
Le champ **Symbole du token** se met automatiquement à jour avec `USDC` et le champ **Décimales** avec `6`.
1. Cliquez sur **Suivant**.
1. Vérifiez que vous importez le token `USDC`, puis cliquez sur **Importer**.

Votre wallet MetaMask affiche désormais **POL** et **USDC** dans la liste des tokens.

Lors des tests de remboursements, le token envoyé à votre wallet peut avoir un contrat différent de celui utilisé pour le paiement. Nous vous recommandons de vérifier le [transaction_hash](https://docs.stripe.com/api/refunds/object.md?rds=1#refund_object-destination_details-crypto-reference) de votre remboursement sur un explorateur de blocs et d’ajouter le contrat de ce token à votre wallet. Par exemple, vous pourriez voir l’adresse de contrat de token `0x58277ebcabbe2a6694fbca8daf9e23163dbacf3e` pour les remboursements Sepolia ETH USDC.

#### Obtenir des ressources testnet

> Pour utiliser certains faucets de testnet, vous pourriez avoir besoin de détenir une petite quantité de tokens du mainnet.

1. Ouvrir le paramètre [faucet.circle.com](https://faucet.circle.com/)
1. Cliquez sur **USDC**.
1. Sous **Réseau**, sélectionnez **Polygon PDV Amoy**.
1. Sous l’onglet **Envoyer vers**, collez l’adresse de votre wallet.
1. Cliquez sur **Envoyer&nbsp;20&nbsp;USDC**.

En plus de l’USDC pour effectuer des paiements, vous avez besoin de POL pour payer les frais de transaction&nbsp;:

1. Ouvrir [faucet.polygon.technology](https://faucet.polygon.technology/).
1. Sous **Sélectionner la chaîne et le Token**, sélectionnez **Polygon Amoy** et **POL**.
1. Sous **Vérifier votre identité**, cliquez sur la plateforme tierce avec laquelle vous souhaitez vous authentifier, puis suivez la procédure de connexion.
1. Sous **Saisir l’adresse wallet**, collez l’adresse de votre wallet.
1. Cliquez sur **Réclamer**.

La finalisation des transactions Testnet peut prendre quelques minutes. Vérifiez votre wallet pour confirmer que l’USDC et le POL ont bien été transférés.

### Plus de faucets testnet

Consultez ces sites de faucets pour plus d’options de tokens de test&nbsp;:

- [Paxos USDP](https://faucet.paxos.com/)
- [Devnet SOL](https://faucet.solana.com/)
- [Sepolia ETH](https://faucets.chain.link/sepolia)
- [Amoy POL](https://faucet.polygon.technology/)