# Accepter un paiement par GrabPay

Découvrez comment accepter les paiements effectués à l'aide de GrabPay, un moyen de paiement très répandu en Asie du Sud-Est.

> À l’heure actuelle, les *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) et l’utilisation de GrabPay pour les paiements ultérieurs ne sont pas pris en charge. Contactez le [service Support de Stripe](https://support.stripe.com/contact) pour toute demande d’assistance portant sur ces fonctionnalités.

# Checkout

> This is a Checkout for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/grabpay/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.

GrabPay est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage). Pour effectuer un paiement avec GrabPay, les clients quittent votre site web, autorisent le paiement, puis reviennent vers votre site web. 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é.

Les ressources comme les logos et les boutons de paiement sont fournis dans la section d’[instructions sur la marque](https://docs.stripe.com/payments/grabpay.md#branding-guidelines).

## Déterminer la compatibilité

Une session Checkout doit remplir toutes les conditions suivantes pour prendre en charge les paiements GrabPay :

- 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 diverses devises, créez des sessions Checkout distinctes pour chaque devise.
- Vous ne pouvez utiliser que des postes ponctuels (les postes récurrents dans le cadre de plans d’*abonnement* (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) ne sont pas pris en charge).
- La devise `sgd` n’est pas prise en charge pour les entreprises basées à Singapour.
- La devise `myr` n’est pas prise en charge pour les entreprises basées en Malaisie.

## Accepter un paiement

> Ce guide s’appuie sur l’intégration de base Checkout permettant d’[accepter un paiement](https://docs.stripe.com/payments/accept-a-payment.md?integration=checkout).

Ce guide vous explique comment activer GrabPay 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 GrabPay

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

1. Ajouter `grabpay` à la liste `payment_method_types`.
1. Assurez-vous que tous vos postes `line_items` utilisent la même devise.

#### 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]=sgd" \
  -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]=grabpay" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Page entièrement intégrée

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=sgd" \
  -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]=grabpay" \
  --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 GrabPay, puis cliquez sur le bouton **Payer**.

## See also

- [Exécution Checkout](https://docs.stripe.com/checkout/fulfillment.md)
- [Personnalisation de 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/grabpay/accept-a-payment?payment-ui=mobile&platform=ios.

GrabPay est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage). Dans le cadre d’un paiement avec GrabPay, le client est redirigé depuis votre application vers GrabPay, il autorise le paiement, puis il revient sur votre application. Vous recevez alors une [notification immédiate](https://docs.stripe.com/payments/payment-methods.md#payment-notification) vous indiquant si le paiement a abouti ou échoué.

> En savoir plus sur l’[activation de GrabPay dans le Dashboard](https://support.stripe.com/questions/grabpay-availability-and-getting-started).

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

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

### Côté serveur

Créez un `PaymentIntent` sur votre serveur et précisez le montant à encaisser dans le champ `amount` et `sgd` ou `myr` en tant que devise. Puisqu’il n’y a pas de montant minimum sur GrabPay, le montant du paiement peut être simplement de 1. Si vous disposez déjà d’une intégration [Payment Intents](https://docs.stripe.com/payments/payment-intents.md), ajoutez `grabpay` à 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[]=grabpay" \
  -d amount=1099 \
  -d currency=sgd
```

### Côté client

Côté client, demandez un PaymentIntent auprès de votre serveur et sauvegardez 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)) qu’il contient.

#### Swift

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

    func startCheckout() {
        // Request a PaymentIntent from your server and store its client secret
    }
}
```

## Rediriger vers le portefeuille GrabPay [Côté client]

Suivez les [consignes relatives à l’utilisation de la marque](https://d37ugbyn3rpeym.cloudfront.net/docs/files/GrabPay_Online_Partners_Brand_Guidelines.pdf) et utilisez les [ressources GrabPay](https://d37ugbyn3rpeym.cloudfront.net/docs/files/GrabPay-Branding-Guidelines-with-Logos-and-Artworks.zip) pour créer votre page de paiement. Le SDK iOS peut présenter une vue Web dans votre application pour effectuer le paiement GrabPay. Une fois l’authentification effectuée, la vue Web peut disparaître automatiquement au lieu que ce soit votre client qui la ferme. Pour cela, [configurez une URL personnalisée](https://developer.apple.com/documentation/xcode/allowing_apps_and_websites_to_link_to_your_content/defining_a_custom_url_scheme_for_your_app) ou [un lien universel](https://developer.apple.com/documentation/xcode/allowing_apps_and_websites_to_link_to_your_content) et configurez votre délégation d’application de façon à transférer l’URL au SDK.

#### 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 choisit de payer avec GrabPay, finalisez le paiement en appelant [STPPaymentHandler confirmPayment](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:@M@StripePayments@objc\(cs\)STPPaymentHandler\(im\)confirmPayment:withAuthenticationContext:completion:). Une page Web s’affiche dans laquelle le client peut finaliser le paiement sur le site GrabPay.

#### Swift

```swift
class CheckoutViewController: UIViewController, STPAuthenticationContext {
    func pay() {
        let clientSecret = ... // The client secret of the PaymentIntent created in step 2
        let grabPayParams = STPPaymentMethodGrabPayParams()
        let paymentMethodParams = STPPaymentMethodParams(grabPay: grabPayParams, billingDetails: nil, metadata: nil)
        let paymentIntentParams = STPPaymentIntentParams(clientSecret: clientSecret)
        paymentIntentParams.paymentMethodParams = paymentMethodParams
        paymentIntentParams.returnURL = "your-app://link"

        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()
            }
        }
    }

    func authenticationPresentingViewController() -> UIViewController {
        return self
    }
}
```

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

- [Créer un webhook personnalisé](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

Les utilisateurs de Stripe en Malaisie et à Singapour peuvent accepter les paiements GrabPay de leurs clients en Malaisie et à Singapour respectivement. Les devises prises en charge et les limites applicables aux transactions GrabPay sont précisées ci-dessous&nbsp;:

| Pays           | Pays du client                                 | Devise prise en charge | Limites de transaction                                                                                                     |
| -------------- | ---------------------------------------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| Singapour (SG) | [Singapour (SG)](https://www.grab.com/sg/pay/) | SGD                    | [GrabPay SG](https://help.grab.com/passenger/en-sg/360023805451)                                                           |
| Malaisie (MY)  | [Malaisie (MY)](https://www.grab.com/my/pay/)  | MYR                    | [GrabPay MY](https://help.grab.com/passenger/en-my/360023805451-What-are-my-GrabPay-Wallet-balance-and-transaction-limits) |


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

GrabPay est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage). Dans le cadre d’un paiement avec GrabPay, le client est redirigé depuis votre application vers GrabPay, il autorise le paiement, puis il revient sur votre application. Vous recevez alors une [notification immédiate](https://docs.stripe.com/payments/payment-methods.md#payment-notification) vous indiquant si le paiement a abouti ou échoué.

> En savoir plus sur l’[activation de GrabPay dans le Dashboard](https://support.stripe.com/questions/grabpay-availability-and-getting-started).

## 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.8.0")
  // Include the financial connections SDK to support US bank account as a payment method
  implementation("com.stripe:financial-connections:23.8.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]

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

### Côté serveur

Créez un `PaymentIntent` sur votre serveur et précisez le montant à encaisser dans le champ `amount` et `sgd` ou `myr` en tant que devise. Puisqu’il n’y a pas de montant minimum sur GrabPay, le montant du paiement peut être simplement de 1. Si vous disposez déjà d’une intégration [Payment Intents](https://docs.stripe.com/payments/payment-intents.md), ajoutez `grabpay` à 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[]=grabpay" \
  -d amount=1099 \
  -d currency=sgd
```

### Côté client

Côté client, demandez un PaymentIntent auprès de votre serveur et sauvegardez la clé secrète du client.

#### Kotlin

```kotlin
class GrabPayActivity : 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
  }
}
```

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

Pour créer votre page de paiement, suivez les [consignes relatives à l’utilisation de la marque](https://d37ugbyn3rpeym.cloudfront.net/docs/files/GrabPay_Online_Partners_Brand_Guidelines.pdf) et utilisez les [ressources GrabPay](https://d37ugbyn3rpeym.cloudfront.net/docs/files/GrabPay-Branding-Guidelines-with-Logos-and-Artworks.zip). Dans votre application, récupérez le nom et le prénom de votre client et créez un objet [PaymentMethodCreateParams](https://stripe.dev/stripe-android/payments-core/com.stripe.android.model/-payment-method-create-params/index.html) avec ces informations.

#### Kotlin

```kotlin
private fun startCheckout() {
    // ...

    val billingDetails = PaymentMethod.BillingDetails(name = "Jenny Rosen")
    val paymentMethodCreateParams = PaymentMethodCreateParams.createGrabPay(billingDetails)
}
```

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

Récupérez la clé secrète du client auprès de la PaymentIntent que vous avez créé et appelez [PaymentLauncher confirm](https://stripe.dev/stripe-android/payments-core/com.stripe.android.payments.paymentlauncher/-payment-launcher/index.html#74063765%2FFunctions%2F-1622557690). Une vue Web s’affiche alors, permettant au client de finaliser le paiement. Ensuite, onPaymentResult est appelé avec le résultat du paiement.

#### Kotlin

```kotlin
class GrabPayPaymentActivity : AppCompatActivity() {
    // ...
    private lateinit var paymentIntentClientSecret: String
    private val paymentLauncher: PaymentLauncher by lazy {
        PaymentLauncher.Companion.create(
            this,
            PaymentConfiguration.getInstance(applicationContext).publishableKey
            PaymentConfiguration.getInstance(applicationContext).stripeAccountId
            ::onPaymentResult
        )
    }

    private fun startCheckout() {
        // ...

        val confirmParams = ConfirmPaymentIntentParams
            .createWithPaymentMethodCreateParams(
                paymentMethodCreateParams = paymentMethodCreateParams,
                clientSecret = paymentIntentClientSecret
            )
        paymentLauncher.confirm(confirmParams)
    }

    private fun onPaymentResult(paymentResult: PaymentResult) {
        val message = when (paymentResult) {
            is PaymentResult.Completed -> {
                "Completed!"
            }
            is PaymentResult.Canceled -> {
                "Canceled!"
            }
            is PaymentResult.Failed -> {
                // This string comes from the PaymentIntent's error message.
                // See here: https://stripe.com/docs/api/payment_intents/object#payment_intent_object-last_payment_error-message
                "Failed: " + paymentResult.throwable.message
            }
            // do something with message
        }
    }
}
```

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

- [Créer un webhook personnalisé](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

Les utilisateurs de Stripe en Malaisie et à Singapour peuvent accepter les paiements GrabPay de leurs clients en Malaisie et à Singapour respectivement. Les devises prises en charge et les limites applicables aux transactions GrabPay sont précisées ci-dessous&nbsp;:

| Pays           | Pays du client                                 | Devise prise en charge | Limites de transaction                                                                                                     |
| -------------- | ---------------------------------------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| Singapour (SG) | [Singapour (SG)](https://www.grab.com/sg/pay/) | SGD                    | [GrabPay SG](https://help.grab.com/passenger/en-sg/360023805451)                                                           |
| Malaisie (MY)  | [Malaisie (MY)](https://www.grab.com/my/pay/)  | MYR                    | [GrabPay MY](https://help.grab.com/passenger/en-my/360023805451-What-are-my-GrabPay-Wallet-balance-and-transaction-limits) |


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

GrabPay est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage). Dans le cadre d’un paiement avec GrabPay, le client est redirigé depuis votre application vers GrabPay, il autorise le paiement, puis il revient sur votre application. Vous recevez alors une [notification immédiate](https://docs.stripe.com/payments/payment-methods.md#payment-notification) vous indiquant si le paiement a abouti ou échoué.

> En savoir plus sur l’[activation de GrabPay dans le Dashboard](https://support.stripe.com/questions/grabpay-availability-and-getting-started).

## 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) représente votre intention d’encaisser un paiement auprès d’un client et suit le cycle de vie du processus de paiement.

### Côté serveur

Créez un `PaymentIntent` sur votre serveur et précisez le montant à encaisser dans le champ `amount` et `sgd` ou `myr` en tant que devise. Puisqu’il n’y a pas de montant minimum sur GrabPay, le montant du paiement peut être simplement de 1. Si vous disposez déjà d’une intégration [Payment Intents](https://docs.stripe.com/payments/payment-intents.md), ajoutez `grabpay` à 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[]=grabpay" \
  -d amount=1099 \
  -d currency=sgd
```

### Côté client

Côté client, demandez un PaymentIntent auprès de votre serveur et sauvegardez la clé secrète du client.

```javascript
const fetchPaymentIntentClientSecret = async () => {
  const response = await fetch(`${API_URL}/create-payment-intent`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
    },
    body: JSON.stringify({
      currency: 'sgd',
      payment_method_types: ['grabpay'],
    }),
  });
  const {clientSecret, error} = await response.json();

  return {clientSecret, error};
};
```

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

Pour créer votre page de paiement, suivez les [consignes relatives à l’utilisation de la marque](https://d37ugbyn3rpeym.cloudfront.net/docs/files/GrabPay_Online_Partners_Brand_Guidelines.pdf) et utilisez les [ressources GrabPay](https://d37ugbyn3rpeym.cloudfront.net/docs/files/GrabPay-Branding-Guidelines-with-Logos-and-Artworks.zip). Dans votre application, récupérez le nom et le prénom de votre client.

```javascript
export default function GrabPayPaymentScreen() {
  const [name, setName] = useState();

  const handlePayPress = async () => {
    // ...
  };

  return (
    <Screen>
      <TextInput
        placeholder="Name"
        onChange={(value) => setName(value.nativeEvent.text)}
      />
    </Screen>
  );
}
```

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

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

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

Récupérez la clé secrète du client dans le PaymentIntent que vous avez créé, puis appelez `confirmPayment`. Une page Web s’affiche dans laquelle le client peut finaliser le paiement sur le site Web ou l’application GrabPay. L’intention de paiement est alors finalisée avec le résultat du paiement.

```javascript
export default function GrabPayPaymentScreen() {
  const [name, setName] = useState();

  const handlePayPress = async () => {
    const billingDetails: PaymentMethodCreateParams.BillingDetails = {
      name,
    };
  };

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

  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="Name"
        onChange={(value) => setName(value.nativeEvent.text)}
      />
    </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.

- [Créer un webhook personnalisé](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

Les utilisateurs de Stripe en Malaisie et à Singapour peuvent accepter les paiements GrabPay de leurs clients en Malaisie et à Singapour respectivement. Les devises prises en charge et les limites applicables aux transactions GrabPay sont précisées ci-dessous&nbsp;:

| Pays           | Pays du client                                 | Devise prise en charge | Limites de transaction                                                                                                     |
| -------------- | ---------------------------------------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| Singapour (SG) | [Singapour (SG)](https://www.grab.com/sg/pay/) | SGD                    | [GrabPay SG](https://help.grab.com/passenger/en-sg/360023805451)                                                           |
| Malaisie (MY)  | [Malaisie (MY)](https://www.grab.com/my/pay/)  | MYR                    | [GrabPay MY](https://help.grab.com/passenger/en-my/360023805451-What-are-my-GrabPay-Wallet-balance-and-transaction-limits) |


# API Direct

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

GrabPay est un moyen de paiement [à usage unique](https://docs.stripe.com/payments/payment-methods.md#usage). Dans le cadre d’un paiement avec GrabPay, le client est redirigé depuis votre application vers GrabPay, il autorise le paiement, puis il revient sur votre application. Vous recevez alors une [notification immédiate](https://docs.stripe.com/payments/payment-methods.md#payment-notification) vous indiquant si le paiement a abouti ou échoué.

> En savoir plus sur l’[activation de GrabPay dans le Dashboard](https://support.stripe.com/questions/grabpay-availability-and-getting-started).

## Configurer Stripe [Côté serveur]

Pour commencer, vous devez créer un compte Stripe. [Inscrivez-vous maintenant](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'
```

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

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

Créez un `PaymentIntent` sur votre serveur et précisez le montant à encaisser dans le champ `amount` et `sgd` ou `myr` en tant que devise. Puisqu’il n’y a pas de montant minimum sur GrabPay, le montant du paiement peut être simplement de 1. Si vous disposez déjà d’une intégration [Payment Intents](https://docs.stripe.com/payments/payment-intents.md), ajoutez `grabpay` à 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[]=grabpay" \
  -d amount=1099 \
  -d currency=sgd
```

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

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

Lorsqu’un client clique pour payer avec GrabPay, 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>>');
```

Pour créer un paiement côté client, ajoutez un [bouton de paiement avec GrabPay](https://docs.stripe.com/payments/grabpay.md#branding-guidelines) et utilisez `stripe.confirmGrabPayPayment` pour gérer la redirection depuis votre page et permettre le paiement.

```html
<button type="button" id="grabpay-button">Pay with GrabPay</button>
<div id="error-message"></div>
```

```javascript
const button = document.getElementById('grabpay-button');

button.addEventListener('click', async function() {
  // By this point, the PaymentIntent should have already been created
  // Pass the clientSecret of the PaymentIntent to confirmGrabPayPayment

  stripe.confirmGrabPayPayment(clientSecret, {
    // Return URL where the customer should be redirected after the authorization
    return_url: 'https://example.com/checkout/complete',
  });
});
```

Transmettez la [clé secrète du client](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) de l’objet `PaymentIntent` que vous avez créé à l’étape&nbsp;2 par `stripe.confirmGrabPayPayment`.

Ajoutez également une URL `return_url` à cette fonction pour indiquer à Stripe vers quelle page rediriger l’utilisateur une fois son paiement effectué sur le site Web de Grab.

Lorsque votre client effectue un paiement, Stripe le redirige vers l’URL `return_url` et inclut les paramètres de requête d’URL suivants. La page de redirection peut utiliser ces paramètres pour récupérer l’état du PaymentIntent et ainsi afficher l’état du paiement pour le client.

Lorsque vous spécifiez une URL `return_url`, vous pouvez également ajouter vos propres paramètres de requête à utiliser sur la page de redirection.

| Paramètre                      | Description                                                                                                                                                                                                                                                                                                                                                       |
| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `payment_intent`               | 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`. Pour les intégrations d’abonnements, le client_secret est également exposé sur l’objet `Invoice` via [`confirmation_secret`](https://docs.stripe.com/api/invoices/object.md#invoice_object-confirmation_secret) |

Lorsque le client est redirigé vers votre site, vous pouvez utiliser le `payment_intent_client_secret` pour interroger le PaymentIntent et communiquer l’état de la transaction à votre client.

```html
<h2>Payment result</h2>
<div class="payment-result">
</div>

<script>
  // Check if we're returning from a redirect.
  const url = new URL(window.location.href);
  const paymentIntentClientSecret = url.searchParams.get(
    "paymentIntentClientSecret"
  );
  if (paymentIntentClientSecret) {
    stripe.retrievePaymentIntent(paymentIntentClientSecret).then(function(result) {
      const paymentIntent = result.paymentIntent;
      document.querySelector(".payment-result").textContent = paymentIntent.status;
    });
  }
</script>
```

## Tester votre intégration

Lors du test, la redirection côté client vous dirige vers une page de paiement de test GrabPay hébergée par Stripe, où vous pouvez autoriser ou refuser le paiement test.

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

- [Créer un webhook personnalisé](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).

## Optional: Gérer la redirection GrabPay manuellement

Nous vous recommandons de recourir à Stripe.js pour gérer les redirections et paiements GrabPay avec `confirmGrabPayPayment`. Toutefois, vous pouvez également rediriger vos clients manuellement&nbsp;:

1. En indiquant l’URL vers laquelle vos clients seront redirigés une fois leur paiement effectué.

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  --data-urlencode "return_url=https://example.com/checkout/complete" \
  -d "payment_method_data[type]=grabpay"
```

1. En vérifiant que l’état du `PaymentIntent` est bien `requires_action` et que le type de `next_action` est `redirect_to_url`.

#### Json

```json
{"next_action": {
    "type": "redirect_to_url",
    "redirect_to_url": {
      "url": "https://hooks.stripe.com/...",
      "return_url": "https://example.com/checkout/complete"
    }
  },
  "payment_method_types": [
    "grabpay"
  ],
  "id": "pi_1G1sgdKi6xqXeNtkldRRE6HT",
  "object": "payment_intent",
  "amount": 1099,
  "confirmation_method": "automatic",
  "created": 1579259303,
  "currency": "sgd",
  "livemode": true
}
```

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

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

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

## Devises prises en charge

Les utilisateurs de Stripe en Malaisie et à Singapour peuvent accepter les paiements GrabPay de leurs clients en Malaisie et à Singapour respectivement. Les devises prises en charge et les limites applicables aux transactions GrabPay sont précisées ci-dessous&nbsp;:

| Pays           | Pays du client                                 | Devise prise en charge | Limites de transaction                                                                                                     |
| -------------- | ---------------------------------------------- | ---------------------- | -------------------------------------------------------------------------------------------------------------------------- |
| Singapour (SG) | [Singapour (SG)](https://www.grab.com/sg/pay/) | SGD                    | [GrabPay SG](https://help.grab.com/passenger/en-sg/360023805451)                                                           |
| Malaisie (MY)  | [Malaisie (MY)](https://www.grab.com/my/pay/)  | MYR                    | [GrabPay MY](https://help.grab.com/passenger/en-my/360023805451-What-are-my-GrabPay-Wallet-balance-and-transaction-limits) |