# Accepter un paiement à l'aide de Samsung Pay en Corée du Sud

# API directe


[Samsung Pay](https://www.samsung.com/sec/apps/samsung-wallet/) permet aux clients établis en Corée du Sud de payer en utilisant ce moyen de paiement local.

Lorsqu’un client effectue un paiement, nous le redirigeons vers notre prestataire de services de paiement local pour qu’il l’authentifie et l’autorise. Une fois que le client a autorisé le paiement, nous le redirigeons à nouveau vers votre site.

Utilisez l’[API Payment Intents](https://docs.stripe.com/payments/payment-intents.md) pour accepter les paiements de clients sud-coréens utilisant des cartes et des moyens de paiement locaux.

## Configurer Stripe [Côté serveur]

Pour commencer, vous devez créer un compte Stripe. [S’inscrire](https://dashboard.stripe.com/register).

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

#### Ruby

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

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

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

Un [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) est un objet qui représente votre intention de collecter un paiement auprès d’un client et suit le processus de paiement. Créez un `PaymentIntent` sur votre serveur avec le montant et la devise. [Activez le moyen de paiement](https://dashboard.stripe.com/settings/payment_methods) dans votre Dashboard. Avec les [moyens de paiement dynamiques](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md), Stripe affiche automatiquement les moyens de paiement éligibles aux clients.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=10000 \
  -d currency=krw \
  -d "payment_method_data[type]=samsung_pay"
```

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

## Assurez-vous que vos clients comprennent les conditions d’utilisation [Côté client]

Le sous-traitant de services de paiement partenaire de Stripe exige que les clients soient informés de l’identité du sous-traitant et comprennent ses conditions d’utilisation. Vous devez inclure le texte et le lien suivants dans votre page de paiement&nbsp;:

> Une fois l’opération validée, nous vous redirigeons vers les étapes suivantes. Cette transaction est traitée par NICEPAY, conformément à ses [conditions d’utilisation](https://start.nicepay.co.kr/homepage/terms/bill.do).

## Rediriger vers le sous-traitant local [Côté client]

Lorsqu’un client clique pour payer avec Samsung Pay, 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.confirmPayment` pour gérer la redirection vers la page de paiement du prestataire de services de paiement local. Sur cette page, le client sélectionne son émetteur et autorise le paiement. Ajoutez un `return_url` pour indiquer où Stripe redirige le client une fois qu’il a effectué le paiement.

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

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

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

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

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

## Test integration with Samsung Pay

Testez votre intégration avec Samsung Pay en affichant la page de redirection à l’aide de vos clés API de test. Vous pouvez tester que le paiement fonctionne en l’authentifiant sur la page de redirection. Le PaymentIntent passe alors de l’état `requires_action` à `succeeded`. Pour tester un échec d’authentification, utilisez vos clés API de test et accédez à la page de redirection. Sur cette page, cliquez sur **Faire échouer le paiement test**. Votre PaymentIntent passe de l’état `requires_action` à `requires_payment_method`.

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

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

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

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

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

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

  [Créez un gestionnaire de webhooks personnalisé](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) pour écouter les événements et concevoir des flux de paiement asynchrones sur mesure. Testez et déboguez votre intégration de webhooks en local avec la Stripe CLI.

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

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