# Accepter un paiement Alipay

Découvrez comment accepter des paiements par Alipay, un portefeuille électronique très répandu en Chine.

# Paiement

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

> Stripe peut automatiquement proposer les moyens de paiement pertinents à vos clients en évaluant la devise, les restrictions liées aux moyens de paiement et d’autres paramètres.
> 
> - Suivez le guide [Accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted) pour créer une intégration de paiement qui utilise des [moyens de paiement dynamiques](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md).
- Si vous ne souhaitez pas utiliser de moyens de paiement dynamiques, suivez les étapes ci-dessous pour configurer manuellement les moyens de paiement dans votre intégration Checkout.

Alipay 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. Pour effectuer un paiement, les clients sont redirigés depuis votre site Web ou application, autorisent le paiement via Alipay, puis reviennent vers votre site Web ou application. Vous recevez alors une [notification immédiate](https://docs.stripe.com/payments/payment-methods.md#payment-notification) indiquant si le paiement a abouti ou échoué.

## Déterminer la compatibilité

**Région du client** : China

**Devises prises en charge** : `aud, cad, eur, gbp, hkd, jpy, nzd, sgd, usd, myr`

**Devises de règlement** : `aud, cad, cny, eur, gbp, hkd, jpy, nzd, sgd, usd, myr`

**Mode de paiement** : Yes

**Mode de configuration** : No

**Mode d’abonnement** : No

Pour prendre en charge les paiements Alipay, une session Checkout doit remplir toutes les conditions suivantes :

- Pour tous les postes, les *tarifs* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) doivent être exprimés dans la même devise.
  - Si vous avez des postes dans différentes devises, créez une session Checkout par devise.
- Vous ne pouvez utiliser que des postes ponctuels.

Les offres d’*abonnements* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) récurrents ne sont pas prises en charge.

## Accepter un paiement

> Avant d’utiliser ce guide, commencez par créer une intégration permettant d’[accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?integration=checkout) avec Checkout.

Ce guide vous explique comment activer Alipay et montre les différences entre l’acceptation de paiements via des moyens de paiement dynamiques et la configuration manuelle des moyens de paiement.

### Activer le moyen de paiement Alipay

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

1. Ajouter `alipay` à la liste `payment_method_types`.
1. Veiller à ce que tous vos `line_items` utilisent la même devise.

#### Une page hébergée par Stripe

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=hkd" \
  -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" \
  -d mode=payment \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=alipay" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Formulaire intégré

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=hkd" \
  -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" \
  -d mode=payment \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=alipay" \
  --data-urlencode "return_url=https://example.com/return" \
  -d ui_mode=embedded_page
```

### Traiter vos commandes

Maintenant que vous savez accepter des paiements, découvrez comment [traiter les commandes](https://docs.stripe.com/checkout/fulfillment.md).

## Tester votre intégration

Lors du test de votre intégration Checkout, sélectionnez le moyen de paiement Alipay, puis cliquez sur le bouton **Payer**.

## Gérer les litiges et remboursements

Le délai de remboursement applicable aux paiements Alipay est limité à 90&nbsp;jours après le paiement initial.

Alipay ne dispose d’aucun processus de litige, car les clients s’authentifient avec leur compte Alipay.

## See also

- [En savoir plus sur Alipay](https://docs.stripe.com/payments/alipay.md)
- [Exécution Checkout](https://docs.stripe.com/checkout/fulfillment.md)
- [Personnaliser Checkout](https://docs.stripe.com/payments/checkout/customization.md)


# 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/alipay/accept-a-payment?payment-ui=mobile&platform=ios.

Alipay 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. Pour effectuer un paiement, les clients sont redirigés depuis votre site Web ou application, autorisent le paiement via Alipay, puis reviennent vers votre site Web ou application. Vous recevez alors une [notification immédiate](https://docs.stripe.com/payments/payment-methods.md#payment-notification) indiquant si le paiement a abouti ou échoué.

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

Pour commencer, il vous faut un compte Stripe. [Créez votre compte Stripe](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 nos 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]

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention d’encaisser un paiement auprès de votre client et suit le cycle de vie du processus de paiement. Créez un `PaymentIntent` sur votre serveur et précisez le montant à encaisser ainsi qu’une [devise prise en charge](https://docs.stripe.com/payments/alipay.md#supported-currencies). Si vous avez une intégration [Payment Intents](https://docs.stripe.com/payments/payment-intents.md) existante, ajoutez `alipay` à la liste des [types de moyens de paiement](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 "payment_method_types[]=alipay" \
  -d amount=1099 \
  -d currency=hkd
```

## Rediriger l'utilisateur vers le portefeuille Alipay [Côté client]

[Définissez un schéma d’URL personnalisé pour votre application](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app) depuis l’onglet Informations des paramètres cibles de votre application.
![Configurer un schéma d'URL personnalisé dans Xcode](https://b.stripecdn.com/docs-statics-srv/assets/ios-custom-url-scheme.e7bbf5f60cbb1a96f157f5cd89410120.png)

L’application Alipay ouvre cette URL pour revenir vers votre application une fois que le client a effectué son paiement. Transférez cette URL au SDK Stripe dans votre `UISceneDelegate` ou votre `UIApplicationDelegate`&nbsp;:

#### SceneDelegate

#### Swift

```swift
// This method handles opening custom URL schemes (for example, "your-app://stripe-redirect")
func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
    guard let url = URLContexts.first?.url else {
        return
    }
    let stripeHandled = StripeAPI.handleURLCallback(with: url)
    if (!stripeHandled) {
        // This was not a Stripe url – handle the URL normally as you would
    }
}

```

#### AppDelegate

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

Lorsque le client appuie sur le bouton permettant de payer avec Alipay, confirmez le PaymentIntent à l’aide de [STPPaymentHandler confirmPayment](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:@M@StripePayments@objc\(cs\)STPPaymentHandler\(im\)confirmPayment:withAuthenticationContext:completion:). Cela déclenchera le lancement de l’application Alipay ou l’affichage d’une vue Web si l’application Alipay n’est pas installée.

#### Swift

```swift
import UIKit
import StripePayments

class CheckoutViewController: UIViewController {
    // ...
    func pay() {
        let clientSecret = ... // The client secret of the PaymentIntent
        let paymentIntentParams = STPPaymentIntentParams(clientSecret: clientSecret)
        paymentIntentParams.paymentMethodParams = STPPaymentMethodParams(alipay: STPPaymentMethodAlipayParams(), billingDetails: nil, metadata: nil)
        paymentIntentParams.paymentMethodOptions = STPConfirmPaymentMethodOptions()
        paymentIntentParams.paymentMethodOptions?.alipayOptions = STPConfirmAlipayOptions()
        paymentIntentParams.returnURL = "{{URL SCHEME}}://safepay/" // Replace {{URL SCHEME}} with your own custom URL scheme.

        STPPaymentHandler.shared().confirmPayment(paymentIntentParams, with: self) { (status, intent, error) in
            switch status {
                case .canceled:
                    // Payment was canceled
                case .failed:
                    // Payment failed
                case .succeeded:
                    // Payment was successful
                @unknown default:
                    fatalError()
            }
        }
    }
}

extension CheckoutViewController: STPAuthenticationContext {
    func authenticationPresentingViewController() -> UIViewController {
        return self
    }
}
```

Alipay ouvre l’URL de redirection avec `safepay/` comme hôte. Par exemple si votre schéma d’URL personnalisé est `myapp`, votre URL de redirection devra être `myapp://safepay/`.

## 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).

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

Plusieurs options s’offrent à vous pour recevoir et exécuter des actions métier.

#### Manuellement

Utilisez le Dashboard pour consulter tous vos paiements Stripe, envoyer des reçus par e-mail, gérer les virements et relancer les paiements ayant échoué.

- [Afficher vos paiements tests dans le Dashboard](https://dashboard.stripe.com/test/payments)

#### Code personnalisé

Créez un gestionnaire de webhooks pour écouter des événements et créer des tunnels de paiement asynchrones personnalisés. Testez et déboguez votre intégration de webhooks en local, grâce à la CLI Stripe.

- [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)

#### Applications préconfigurées

Intégrez une application partenaire pour gérer les événements métier 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

Votre compte doit disposer d’un compte bancaire dans l’une des devises suivantes. Vous pouvez créer des paiements Alipay dans les devises correspondant à votre pays. La devise locale par défaut pour Alipay est `cny` et les clients voient également le montant de leur achat en `cny`.

| Devise | Pays                                                                                                                                                                                                                                                        |
| ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `cny`  | Tous les pays                                                                                                                                                                                                                                               |
| `aud`  | Australie                                                                                                                                                                                                                                                   |
| `cad`  | Canada                                                                                                                                                                                                                                                      |
| `eur`  | Allemagne, Autriche, Belgique, Bulgarie, Chypre, Danemark, Espagne, Estonie, Finlande, France, Grèce, Irlande, Italie, Lettonie, Lituanie, Luxembourg, Malte, Norvège, Pays-Bas, Portugal, République tchèque, Roumanie, Slovaquie, Slovénie, Suède, Suisse |
| `gbp`  | Royaume-Uni                                                                                                                                                                                                                                                 |
| `hkd`  | Hong Kong                                                                                                                                                                                                                                                   |
| `jpy`  | Japon                                                                                                                                                                                                                                                       |
| `myr`  | Malaisie                                                                                                                                                                                                                                                    |
| `nzd`  | Nouvelle-Zélande                                                                                                                                                                                                                                            |
| `sgd`  | Singapour                                                                                                                                                                                                                                                   |
| `usd`  | États-Unis                                                                                                                                                                                                                                                  |

Si vous détenez un compte bancaire dans une autre devise et souhaitez créer un paiement Alipay dans cette devise, veuillez [contacter le service Support](https://support.stripe.com/email). Les devises supplémentaires sont prises en charge au cas par cas.


# 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/alipay/accept-a-payment?payment-ui=mobile&platform=android.

Alipay 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. Pour effectuer un paiement, les clients sont redirigés depuis votre site Web ou application, autorisent le paiement via Alipay, puis reviennent vers votre site Web ou application. Vous recevez alors une [notification immédiate](https://docs.stripe.com/payments/payment-methods.md#payment-notification) indiquant si le paiement a abouti ou échoué.

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

## Intégrer le SDK Alipay [Côté client]

Pour les paiements dans l’application qui utilisent le flux de redirection d’application à application d’Alipay, vous devez intégrer le [SDK Alipay](https://global.alipay.com/docs/ac/app/download). Si vous ne souhaitez pas intégrer le SDK Alipay, le SDK Stripe utilise une vue Web pour rediriger votre client vers Alipay. L’intégration du SDK Alipay permet une expérience plus transparente pour vos clients, mais augmente le poids total de votre application. Pour en savoir plus, consultez la page [Utiliser une vue Web](https://docs.stripe.com/payments/alipay/accept-a-payment.md#android-using-a-webview).

Une fois le fichier d’archive décompressé, ajoutez `alipaySdk-{version}.aar` au répertoire `libs` de votre application. Ajoutez le dossier `libs` à la liste référentielle des dépendances de votre projet&nbsp;:

```groovy
allprojects {
  repositories {
    flatDir {
      dirs 'libs'
    }
  }
}
```

Ajoutez la dépendance à votre application&nbsp;:

```groovy
dependencies {
  // ...

  // Replace {version} with the version number of the Alipay SDK that you downloaded above
  implementation(name:"alipaySdk-{version}", ext:"aar")
}
```

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

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention d’encaisser un paiement auprès de votre client et suit le cycle de vie du processus de paiement. Créez un `PaymentIntent` sur votre serveur et précisez le montant à encaisser ainsi qu’une [devise prise en charge](https://docs.stripe.com/payments/alipay.md#supported-currencies). Si vous avez une intégration [Payment Intents](https://docs.stripe.com/payments/payment-intents.md) existante, ajoutez `alipay` à la liste des [types de moyens de paiement](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 "payment_method_types[]=alipay" \
  -d amount=1099 \
  -d currency=hkd
```

## Rediriger l'utilisateur vers le portefeuille Alipay [Côté client]

Demandez un PaymentIntent depuis votre serveur et stockez sa clé secrète du client.

#### Kotlin

```kotlin
class AlipayActivity : AppCompatActivity() {
  private lateinit var paymentIntentClientSecret: String

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


  private fun fetchPaymentIntent() {
      // Request a PaymentIntent from your server and store its client secret
  }
}
```

Lorsque votre client appuie sur le bouton pour payer via Alipay, confirmez le PaymentIntent à l’aide du `confirmAlipayPayment` de Stripe. Vous devez également fournir un AlipayAuthenticator pour transmettre les données du SDK Stripe au SDK Alipay. L’authentificateur appelle la méthode `payV2` d’Alipay avec la chaîne de données fournie. Le SDK Alipay ouvre l’application Alipay (si elle est installée) ou affiche sa propre interface utilisateur et communique automatiquement le résultat au SDK Stripe.

> Le SDK Android Alipay ne prend pas en charge les paiements de test. Pour tester pleinement cette intégration, utilisez le [mode production](https://docs.stripe.com/keys.md#test-live-modes).

#### Kotlin

```kotlin
import com.alipay.sdk.app.PayTask

class AlipayActivity : AppCompatActivity() {
    // ...
    private lateinit var paymentIntentClientSecret: String
    private val stripe: Stripe by lazy {
        Stripe(
            applicationContext,
            PaymentConfiguration.getInstance(applicationContext).publishableKey
        )
    }

    // Call this function when the customer taps "Pay with Alipay"
    private fun startCheckout() {
        // ...
        lifecycleScope.launch {
            runCatching {
                stripe.confirmAlipayPayment(
                    ConfirmPaymentIntentParams.createAlipay(paymentIntentClientSecret),
                    { data -> PayTask(this@AlipayActivity).payV2(data, true) }
                )
            }.fold(
                onSuccess = { result ->
                    val paymentIntent = result.intent
                    val status = paymentIntent.status
                    when (status) {
                        StripeIntent.Status.Succeeded -> {
                            // Payment succeeded
                        }
                        StripeIntent.Status.RequiresAction -> {
                            // Customer didn't complete the payment
                            // You can try to confirm this Payment Intent again
                        }
                        else -> {
                            // Payment failed/canceled
                        }
                    }
                },
                onFailure = {
                    // Payment failed
                }
            )
        }
    }
}
```

## Optional: Utiliser une vue Web [Côté client]

Si vous ne souhaitez pas intégrer le SDK Alipay, le SDK Stripe peut rediriger votre client vers une vue Web d’Alipay lorsque vous appelez `confirmPayment`. Le site Web d’Alipay ouvre l’application Alipay (si elle est installée) ou permet au client d’effectuer son paiement sur le site.

#### Kotlin

```kotlin
class AlipayActivity : AppCompatActivity() {
    // ...
    private lateinit var paymentIntentClientSecret: String
    private val stripe: Stripe by lazy {
        Stripe(
          applicationContext,
          PaymentConfiguration.getInstance(applicationContext).publishableKey
        )
    }

    // Call this method when the customer taps "Pay with Alipay"
    private fun startCheckout() {
        // ...

        val confirmParams = ConfirmPaymentIntentParams.createAlipay(paymentIntentClientSecret)
        stripe.confirmPayment(this, confirmParams)
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)

        // Handle the result of stripe.confirmPayment
        stripe.onPaymentResult(requestCode, data, object : ApiResultCallback<PaymentIntentResult> {
            override fun onSuccess(result: PaymentIntentResult) {
                val paymentIntent = result.intent
                val status = paymentIntent.status
                when (status) {
                    StripeIntent.Status.Succeeded -> {
                        // Payment succeeded
                    }
                    StripeIntent.Status.RequiresAction -> {
                        // Customer didn't complete the payment
                        // You can try to confirm this Payment Intent again
                    }
                    else -> {
                        // Payment failed/canceled
                    }
                }
            }

            override fun onError(e: Exception) {
                // Payment failed
            }
        })
    }
}
```

## 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).

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

Plusieurs options s’offrent à vous pour recevoir et exécuter des actions métier.

#### Manuellement

Utilisez le Dashboard pour consulter tous vos paiements Stripe, envoyer des reçus par e-mail, gérer les virements et relancer les paiements ayant échoué.

- [Afficher vos paiements tests dans le Dashboard](https://dashboard.stripe.com/test/payments)

#### Code personnalisé

Créez un gestionnaire de webhooks pour écouter des événements et créer des tunnels de paiement asynchrones personnalisés. Testez et déboguez votre intégration de webhooks en local, grâce à la CLI Stripe.

- [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)

#### Applications préconfigurées

Intégrez une application partenaire pour gérer les événements métier 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

Votre compte doit disposer d’un compte bancaire dans l’une des devises suivantes. Vous pouvez créer des paiements Alipay dans les devises correspondant à votre pays. La devise locale par défaut pour Alipay est `cny` et les clients voient également le montant de leur achat en `cny`.

| Devise | Pays                                                                                                                                                                                                                                                        |
| ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `cny`  | Tous les pays                                                                                                                                                                                                                                               |
| `aud`  | Australie                                                                                                                                                                                                                                                   |
| `cad`  | Canada                                                                                                                                                                                                                                                      |
| `eur`  | Allemagne, Autriche, Belgique, Bulgarie, Chypre, Danemark, Espagne, Estonie, Finlande, France, Grèce, Irlande, Italie, Lettonie, Lituanie, Luxembourg, Malte, Norvège, Pays-Bas, Portugal, République tchèque, Roumanie, Slovaquie, Slovénie, Suède, Suisse |
| `gbp`  | Royaume-Uni                                                                                                                                                                                                                                                 |
| `hkd`  | Hong Kong                                                                                                                                                                                                                                                   |
| `jpy`  | Japon                                                                                                                                                                                                                                                       |
| `myr`  | Malaisie                                                                                                                                                                                                                                                    |
| `nzd`  | Nouvelle-Zélande                                                                                                                                                                                                                                            |
| `sgd`  | Singapour                                                                                                                                                                                                                                                   |
| `usd`  | États-Unis                                                                                                                                                                                                                                                  |

Si vous détenez un compte bancaire dans une autre devise et souhaitez créer un paiement Alipay dans cette devise, veuillez [contacter le service Support](https://support.stripe.com/email). Les devises supplémentaires sont prises en charge au cas par cas.


# React Native

> This is a React Native for when payment-ui is mobile and platform is react-native. View the full page at https://docs.stripe.com/payments/alipay/accept-a-payment?payment-ui=mobile&platform=react-native.

Alipay 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. Pour effectuer un paiement, les clients sont redirigés depuis votre site Web ou application, autorisent le paiement via Alipay, puis reviennent vers votre site Web ou application. Vous recevez alors une [notification immédiate](https://docs.stripe.com/payments/payment-methods.md#payment-notification) indiquant si le paiement a abouti ou échoué.

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

### Côté serveur

Pour cette intégration, votre serveur doit être doté d’endpoints qui communiquent avec l’API Stripe. Utilisez nos 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 React Native](https://github.com/stripe/stripe-react-native) est disponible en open source et fait l’objet d’une documentation complète. En interne, il utilise des SDK [Android](https://github.com/stripe/stripe-android) et [iOS natifs](https://github.com/stripe/stripe-ios). Pour installer le SDK React Native de Stripe, exécutez l’une des commandes suivantes dans le répertoire de votre projet (selon le gestionnaire de paquets que vous utilisez)&nbsp;:

#### yarn

```bash
yarn add @stripe/stripe-react-native
```

#### npm

```bash
npm install @stripe/stripe-react-native
```

Ensuite, installez les autres dépendances nécessaires&nbsp;:

- Pour iOS, accédez au directeur **ios** et exécutez `pod install` pour vous assurer que vous installez également les dépendances natives requises.
- Pour Android, il n’y a plus de dépendances à installer.

> Nous vous recommandons de suivre le [guide officiel de TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) pour ajouter la prise en charge de TypeScript.

### Initialisation de Stripe

Pour initialiser Stripe dans votre application React&nbsp;Native, wrappez votre écran de paiement avec le composant `StripeProvider` ou utilisez la méthode d’initialisation `initStripe`. Seule la [clé publiable](https://docs.stripe.com/keys.md#obtain-api-keys) de l’API dans `publishableKey` est nécessaire. L’exemple suivant montre comment initialiser Stripe à l’aide du composant `StripeProvider`.

```jsx
import { useState, useEffect } from 'react';
import { StripeProvider } from '@stripe/stripe-react-native';

function App() {
  const [publishableKey, setPublishableKey] = useState('');

  const fetchPublishableKey = async () => {
    const key = await fetchKey(); // fetch key from your server here
    setPublishableKey(key);
  };

  useEffect(() => {
    fetchPublishableKey();
  }, []);

  return (
    <StripeProvider
      publishableKey={publishableKey}
      merchantIdentifier="merchant.identifier" // required for Apple Pay
      urlScheme="your-url-scheme" // required for 3D Secure and bank redirects
    >
      {/* Your app code here */}
    </StripeProvider>
  );
}
```

> Utilisez vos [clés de test](https://docs.stripe.com/keys.md#obtain-api-keys) d’API 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]

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention d’encaisser un paiement auprès de votre client et suit le cycle de vie du processus de paiement. Créez un `PaymentIntent` sur votre serveur et précisez le montant à encaisser ainsi qu’une [devise prise en charge](https://docs.stripe.com/payments/alipay.md#supported-currencies). Si vous avez une intégration [Payment Intents](https://docs.stripe.com/payments/payment-intents.md) existante, ajoutez `alipay` à la liste des [types de moyens de paiement](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 "payment_method_types[]=alipay" \
  -d amount=1099 \
  -d currency=hkd
```

## Rediriger l'utilisateur vers le portefeuille Alipay [Côté client]

Pour les moyens de paiement par prélèvement bancaire authentifié ou par portefeuille numérique, le SDK React Native de Stripe spécifie `safepay/` comme hôte de l’URL de redirection. Une fois que le client a effectué son paiement par Alipay, il est redirigé vers `myapp://safepay/` où `myapp` correspond à votre schéma d’URL personnalisé.

Lorsqu’un client quitte votre application (par exemple, pour s’authentifier dans Safari ou dans son application bancaire), donnez-lui un moyen de revenir automatiquement dans votre application. De nombreux types de moyens de paiement *nécessitent* une URL de redirection. Si vous n’en fournissez pas, nous ne pourrons pas présenter à vos utilisateurs les moyens de paiement nécessitant une URL de redirection, même si vous les avez activés.

Pour fournir une URL de redirection&nbsp;:

1. [Enregistrez](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app#Register-your-URL-scheme) une URL personnalisée. Les liens universels ne sont pas pris en charge.
1. [Configurez](https://reactnative.dev/docs/linking) votre URL personnalisée.
1. Configurez votre composant racine pour qu’il transfère l’URL au SDK de Stripe, comme illustré ci-dessous.

> Si vous utilisez Expo, [définissez votre schéma](https://docs.expo.io/guides/linking/#in-a-standalone-app) dans le fichier `app.json`.

```jsx
import { useEffect, useCallback } from 'react';
import { Linking } from 'react-native';
import { useStripe } from '@stripe/stripe-react-native';

export default function MyApp() {
  const { handleURLCallback } = useStripe();

  const handleDeepLink = useCallback(
    async (url: string | null) => {
      if (url) {
        const stripeHandled = await handleURLCallback(url);
        if (stripeHandled) {
          // This was a Stripe URL - you can return or add extra handling here as you see fit
        } else {
          // This was NOT a Stripe URL – handle as you normally would
        }
      }
    },
    [handleURLCallback]
  );

  useEffect(() => {
    const getUrlAsync = async () => {
      const initialUrl = await Linking.getInitialURL();
      handleDeepLink(initialUrl);
    };

    getUrlAsync();

    const deepLinkListener = Linking.addEventListener(
      'url',
      (event: { url: string }) => {
        handleDeepLink(event.url);
      }
    );

    return () => deepLinkListener.remove();
  }, [handleDeepLink]);

  return (
    <View>
      <AwesomeAppComponent />
    </View>
  );
}
```

Pour plus d’informations sur les schémas d’URL natifs, consultez la documentation [Android](https://developer.android.com/training/app-links/deep-linking) et [iOS](https://developer.apple.com/documentation/xcode/allowing_apps_and_websites_to_link_to_your_content/defining_a_custom_url_scheme_for_your_app).

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

Lorsque votre client appuie sur le bouton pour payer via Alipay, appelez `confirmPayment` pour afficher une vue Web lui permettant d’effectuer son paiement.

```javascript
export default function AlipayPaymentScreen() {
  const [email, setEmail] = useState('');
  const { confirmPayment, loading } = useConfirmPayment();

  const handlePayPress = async () => {
    const { clientSecret } = await fetchPaymentIntentClientSecret();

    const { error, paymentIntent } = await confirmPayment(clientSecret, {
      paymentMethodType: 'Alipay',
    });

    if (error) {
      Alert.alert(`Error code: ${error.code}`, error.message);
    } else if (paymentIntent) {
      Alert.alert(
        'Success',
        `The payment was confirmed successfully! currency: ${paymentIntent.currency}`
      );
    }
  };

  return (
    <Screen>
      <TextInput
        placeholder="E-mail"
        keyboardType="email-address"
        onChange={(value) => setEmail(value.nativeEvent.text)}
      />
      <Button
        variant="primary"
        onPress={handlePayPress}
        title="Pay"
        loading={loading}
      />
    </Screen>
  );
}
```

## 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).

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

Plusieurs options s’offrent à vous pour recevoir et exécuter des actions métier.

#### Manuellement

Utilisez le Dashboard pour consulter tous vos paiements Stripe, envoyer des reçus par e-mail, gérer les virements et relancer les paiements ayant échoué.

- [Afficher vos paiements tests dans le Dashboard](https://dashboard.stripe.com/test/payments)

#### Code personnalisé

Créez un gestionnaire de webhooks pour écouter des événements et créer des tunnels de paiement asynchrones personnalisés. Testez et déboguez votre intégration de webhooks en local, grâce à la CLI Stripe.

- [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)

#### Applications préconfigurées

Intégrez une application partenaire pour gérer les événements métier 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

Votre compte doit disposer d’un compte bancaire dans l’une des devises suivantes. Vous pouvez créer des paiements Alipay dans les devises correspondant à votre pays. La devise locale par défaut pour Alipay est `cny` et les clients voient également le montant de leur achat en `cny`.

| Devise | Pays                                                                                                                                                                                                                                                        |
| ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `cny`  | Tous les pays                                                                                                                                                                                                                                               |
| `aud`  | Australie                                                                                                                                                                                                                                                   |
| `cad`  | Canada                                                                                                                                                                                                                                                      |
| `eur`  | Allemagne, Autriche, Belgique, Bulgarie, Chypre, Danemark, Espagne, Estonie, Finlande, France, Grèce, Irlande, Italie, Lettonie, Lituanie, Luxembourg, Malte, Norvège, Pays-Bas, Portugal, République tchèque, Roumanie, Slovaquie, Slovénie, Suède, Suisse |
| `gbp`  | Royaume-Uni                                                                                                                                                                                                                                                 |
| `hkd`  | Hong Kong                                                                                                                                                                                                                                                   |
| `jpy`  | Japon                                                                                                                                                                                                                                                       |
| `myr`  | Malaisie                                                                                                                                                                                                                                                    |
| `nzd`  | Nouvelle-Zélande                                                                                                                                                                                                                                            |
| `sgd`  | Singapour                                                                                                                                                                                                                                                   |
| `usd`  | États-Unis                                                                                                                                                                                                                                                  |

Si vous détenez un compte bancaire dans une autre devise et souhaitez créer un paiement Alipay dans cette devise, veuillez [contacter le service Support](https://support.stripe.com/email). Les devises supplémentaires sont prises en charge au cas par cas.


# API Direct

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

Alipay 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. Pour effectuer un paiement, les clients sont redirigés depuis votre site Web ou application, autorisent le paiement via Alipay, puis reviennent vers votre site Web ou application. Vous recevez alors une [notification immédiate](https://docs.stripe.com/payments/payment-methods.md#payment-notification) indiquant si le paiement a abouti ou échoué.

## Configurer Stripe [Côté serveur]

Pour commencer, il vous faut un compte Stripe. [Créez votre compte Stripe](https://dashboard.stripe.com/register).

Utilisez nos bibliothèques officielles pour accéder à l’API Stripe à partir de 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 [Côté serveur]

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention d’encaisser un paiement auprès de votre client et suit le cycle de vie du processus de paiement. Créez un `PaymentIntent` sur votre serveur et précisez le montant à encaisser ainsi qu’une [devise prise en charge](https://docs.stripe.com/payments/alipay.md#supported-currencies). Si vous avez une intégration [Payment Intents](https://docs.stripe.com/payments/payment-intents.md) existante, ajoutez `alipay` à la liste des [types de moyens de paiement](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 "payment_method_types[]=alipay" \
  -d amount=1099 \
  -d currency=hkd
```

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

## Rediriger l'utilisateur vers le portefeuille Alipay [Côté client]

Lorsqu’un client clique pour payer avec Alipay, utilisez Stripe.js pour soumettre le paiement à Stripe. [Stripe.js](https://docs.stripe.com/payments/elements.md) est la bibliothèque JavaScript de base pour créer les tunnels de paiement&nbsp;: elle gère automatiquement les opérations complexes telles que la redirection décrite ci-dessous, et facilite l’extension de votre intégration à d’autres moyens de paiement. Incluez le script Stripe.js sur votre page de paiement en l’ajoutant à la section `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.

```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.confirmAlipayPayment` pour gérer la redirection vers Alipay. Ajoutez une `return_url` vers laquelle Stripe redirigera votre client une fois son paiement effectué.

```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.confirmAlipayPayment(clientSecret, {
    // 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 = error.message;
  }
});
```

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

| Paramètre                      | Description                                                                                                                                       |
| ------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| `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 la redirection manuellement [Côté serveur]

Le meilleur moyen de gérer les redirections est d’utiliser Stripe.js avec `confirmAlipayPayment`. Si vous devez rediriger vos clients manuellement&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 `alipay_handle_redirect`.

```json
"next_action": {
  "type": "alipay_handle_redirect",
  "alipay_handle_redirect": {
    "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).

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

Plusieurs options s’offrent à vous pour recevoir et exécuter des actions métier.

#### Manuellement

Utilisez le Dashboard pour consulter tous vos paiements Stripe, envoyer des reçus par e-mail, gérer les virements et relancer les paiements ayant échoué.

- [Afficher vos paiements tests dans le Dashboard](https://dashboard.stripe.com/test/payments)

#### Code personnalisé

Créez un gestionnaire de webhooks pour écouter des événements et créer des tunnels de paiement asynchrones personnalisés. Testez et déboguez votre intégration de webhooks en local, grâce à la CLI Stripe.

- [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)

#### Applications préconfigurées

Intégrez une application partenaire pour gérer les événements métier 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

Votre compte doit disposer d’un compte bancaire dans l’une des devises suivantes. Vous pouvez créer des paiements Alipay dans les devises correspondant à votre pays. La devise locale par défaut pour Alipay est `cny` et les clients voient également le montant de leur achat en `cny`.

| Devise | Pays                                                                                                                                                                                                                                                        |
| ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `cny`  | Tous les pays                                                                                                                                                                                                                                               |
| `aud`  | Australie                                                                                                                                                                                                                                                   |
| `cad`  | Canada                                                                                                                                                                                                                                                      |
| `eur`  | Allemagne, Autriche, Belgique, Bulgarie, Chypre, Danemark, Espagne, Estonie, Finlande, France, Grèce, Irlande, Italie, Lettonie, Lituanie, Luxembourg, Malte, Norvège, Pays-Bas, Portugal, République tchèque, Roumanie, Slovaquie, Slovénie, Suède, Suisse |
| `gbp`  | Royaume-Uni                                                                                                                                                                                                                                                 |
| `hkd`  | Hong Kong                                                                                                                                                                                                                                                   |
| `jpy`  | Japon                                                                                                                                                                                                                                                       |
| `myr`  | Malaisie                                                                                                                                                                                                                                                    |
| `nzd`  | Nouvelle-Zélande                                                                                                                                                                                                                                            |
| `sgd`  | Singapour                                                                                                                                                                                                                                                   |
| `usd`  | États-Unis                                                                                                                                                                                                                                                  |

Si vous détenez un compte bancaire dans une autre devise et souhaitez créer un paiement Alipay dans cette devise, veuillez [contacter le service Support](https://support.stripe.com/email). Les devises supplémentaires sont prises en charge au cas par cas.