# Accepter des paiements avec PAYCO en Corée du Sud # Checkout > This is a Checkout for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/payco/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. Intégrer [PAYCO](https://www.payco.com/) permet aux clients basés en Corée du Sud de payer en utilisant ce moyen de paiement local très répandu. 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. ## Déterminer la compatibilité **Lieux d’implantation pris en charge** : AT, BE, CY, DE, DK, EE, ES, FI, FR, GB, GR, HK, HR, HU, IE, IT, JP, LT, LU, LV, MT, NL, PT, SE, SG, SI, SK, US **Devises prises en charge** : `krw` **Devises de règlement** : `krw` **Mode de paiement** : Yes **Mode de configuration** : No **Mode d’abonnement** : No Pour prendre en charge les moyens de paiement sud-coréens, [une session Checkout](https://docs.stripe.com/payments/checkout/how-checkout-works.md) doit remplir toutes les conditions suivantes : - Le *tarif* (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) de tous les postes doit être indiqué en won sud-coréen (code de devise `krw`). - Le montant minimum accepté est de 100 KRW. Il n’y a pas de limite maximale pour les transactions par carte, tandis que le montant maximal qu’un client peut recharger sur son compte Payco en tant que valeur sauvegardée est de 2 000 000 KRW. ## Accepter un paiement PAYCO Activez PAYCO en effectuant les mises à jour suivantes dans votre intégration. Lors de la création d’une [session Checkout](https://docs.stripe.com/api/checkout/sessions.md), vous devez procéder comme suit : - Ajouter `payco` à la liste `payment_method_types`. - Veillez à ce que tous les `line_items` utilisent la devise `krw`. #### Une page hébergée par Stripe ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "line_items[0][price_data][currency]"=krw \ -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]"=payco \ --data-urlencode success_url="https://example.com/success" ``` #### Formulaire intégré ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "line_items[0][price_data][currency]"=krw \ -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]"=payco \ --data-urlencode return_url="https://example.com/return" \ -d ui_mode=embedded ``` ## Tester votre intégration avec PAYCO Lorsque vous testez l’intégration Checkout, sélectionnez **PAYCO** et cliquez sur **Payer**. Vous êtes alors redirigé(e) vers une page hébergée par Stripe où vous avez le choix d’autoriser ou non le paiement. Si vous autorisez le paiement, le PaymentIntent passe de `requires_action` à `succeeded`. L’échec du paiement test fait passer le PaymentIntent de `requires_action` à `requires_payment_method` En savoir plus sur la façon de [tester](https://docs.stripe.com/testing.md#redirects) les moyens de paiement basés sur la redirection. # API directe > This is a API directe for when payment-ui is direct-api. View the full page at https://docs.stripe.com/payments/payco/accept-a-payment?payment-ui=direct-api. Intégrer [PAYCO](https://www.payco.com/) permet aux clients basés en Corée du Sud de payer en utilisant ce moyen de paiement local très répandu. 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 d’encaisser le paiement d’un client et qui suit le processus de paiement. Pour créer un `PaymentIntent` qui accepte un paiement à l’aide de `payco`, indiquez le montant à encaisser, `krw` comme devise et `payco` dans la liste [payment_method_types](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types). Si vous conservez une liste des types de moyens de paiement que vous transmettez lors de la création d’un `PaymentIntent`, ajoutez-y `payco`. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=10000 \ -d currency=krw \ -d "payment_method_types[]"=payco \ -d "payment_method_data[type]"=payco ``` ### 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 : #### 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 : ```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 : #### Ruby ```erb
``` ```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 : > 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 PAYCO, 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 : 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 Checkout ``` 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('<>'); ``` 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: 'payco', }, // 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 PAYCO Testez votre intégration avec PAYCO en affichant la page de redirection à l’aide de vos clés API de test. Vous pouvez tester le cas de paiement réussi en authentifiant le paiement sur la page de redirection. Le PaymentIntent passe de `requires_action` à `succeeded`. Pour tester le cas où le client ne parvient pas à s’authentifier, utilisez vos clés API de test et consultez la page de redirection. Sur la page de redirection, cliquez sur **Faire échouer le paiement test**. Le PaymentIntent passe de `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 [afficher vos paiements de test dans le Dashboard](https://dashboard.stripe.com/test/payments), envoyer des reçus par e-mail, gérer les virements ou réessayer les paiements échoués. - **Créer un webhook personnalisé** [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) handler to listen for events and build custom asynchronous payment flows. Test and debug your webhook integration locally with the Stripe CLI. - **Intégrer une application prédéfinie** Gérez les événements commerciaux courants, tels que l’[automatisation](https://stripe.partners/?f_category=automation) ou le [marketing et les ventes](https://stripe.partners/?f_category=marketing-and-sales), en intégrant une application partenaire.