# Eine Zahlung mit PAYCO in Südkorea annehmen # 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 kann Ihren Kundinnen und Kunden automatisch die relevanten Zahlungsmethoden anzeigen, indem Währungen, Einschränkungen der Zahlungsmethode und andere Parameter ausgewertet werden. > > - Befolgen Sie den Leitfaden [Eine Zahlung akzeptieren](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted), um eine Checkout-Integration zu erstellen, die [dynamische Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md) verwendet. - Wenn Sie keine dynamischen Zahlungsmethoden verwenden möchten, befolgen Sie die folgenden Schritte, um die Zahlungsmethoden in Ihrer Checkout-Integration manuell zu konfigurieren. Durch die Integration mit [PAYCO](https://www.payco.com/) können Kundinnen und Kunden in Südkorea mit dieser beliebten lokalen Zahlungsmethode bezahlen. Wenn Kundinnen und Kunden eine Zahlung vornehmen, leiten wir sie an unseren lokalen Abwicklungspartner weiter, um die Zahlung zu authentifizieren und zu autorisieren. Nachdem der Kunde/die Kundin die Zahlung autorisiert hat, leiten wir ihn/sie zurück zu Ihrer Website. ## Kompatibilität bestimmen **Unterstützte Unternehmensstandorte**: 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 **Unterstützte Währungen**: `krw` **Transaktionswährungen**: `krw` **Zahlungsmodus**: Yes **Einrichtungsmodus**: No **Abonnementmodus**: No Für die Unterstützung von Zahlungen mit südkoreanischen Zahlungsmethoden muss eine [Checkout-Sitzung](https://docs.stripe.com/payments/checkout/how-checkout-works.md) alle folgenden Bedingungen erfüllen: - Die *Preise* (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) für alle Posten müssen in koreanischem Won (Währungscode `krw`) angegeben werden. - Der akzeptierte Mindestbetrag beträgt 100 KRW. Es gibt keine Höchstgrenze für Card-Passthrough-Transaktionen, während der Höchstbetrag, den eine Kundin/ein Kunde als gespeichertes Guthaben auf ihr/sein Payco-Konto aufstocken kann, 2.000.000 KRW beträgt. ## Zahlungen per PAYCO annehmen Aktivieren Sie PAYCO, indem Sie die folgenden Aktualisierungen an Ihrer Integration vornehmen. Beim Erstellen einer [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md) müssen Sie Folgendes tun: - Fügen Sie `payco` zur Liste der `payment_method_types` hinzu. - Stellen Sie sicher, dass für alle `line_items` die Währung `krw` verwendet wird. #### Von Stripe gehostete Seite ```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" ``` #### Eingebettetes Formular ```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 ``` ## Ihre Integration mit PAYCO testen Wählen Sie beim Testen Ihrer Checkout-Integration **PAYCO** aus und klicken Sie auf **Bezahlen**. Dadurch werden Sie zu einer von Stripe gehosteten Seite weitergeleitet, auf der Sie die Zahlung autorisieren oder ablehnen können. Wenn Sie die Zahlung autorisieren, wechselt der PaymentIntent von `requires_action` zu `succeeded`. Wenn Sie die Testzahlung fehlschlagen lassen, wechselt der PaymentIntent von `requires_action` zu `requires_payment_method`. Erfahren Sie mehr darüber, wie Sie auf Weiterleitung basierende Zahlungsmethoden [testen](https://docs.stripe.com/testing.md#redirects) können. # Direct API > This is a Direct API 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. Durch die Integration mit [PAYCO](https://www.payco.com/) können Kundinnen und Kunden in Südkorea mit dieser beliebten lokalen Zahlungsmethode bezahlen. Wenn Kundinnen und Kunden eine Zahlung vornehmen, leiten wir sie an unseren lokalen Abwicklungspartner weiter, um die Zahlung zu authentifizieren und zu autorisieren. Nachdem der Kunde/die Kundin die Zahlung autorisiert hat, leiten wir ihn/sie zurück zu Ihrer Website. Mithilfe der [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) können Sie Zahlungen von südkoreanischen Kundinnen/Kunden mit lokalen Karten und lokalen Zahlungsmethoden annehmen. ## Stripe einrichten [Serverseitig] Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register). Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung: #### 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' ``` ## Erstellen Sie ein PaymentIntent [Serverseitig] Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) ist ein Objekt, das Ihre Absicht darstellt, eine Kundenzahlung einzuziehen, und den Zahlungsvorgang dokumentiert. Um einen `PaymentIntent` zu erstellen, der eine Zahlung mit `payco` akzeptiert, geben Sie den einzuziehenden Betrag, `krw` als Währung und `payco` in der [payment_method_types](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types)-Liste an. Wenn Sie eine Liste mit Zahlungsmethodentypen haben, die Sie beim Erstellen eines `PaymentIntent` übergeben, fügen Sie dieser Liste `payco` hinzu. ```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 ``` ### Client-Geheimnis abrufen Im PaymentIntent ist ein *Client-Geheimnis* (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)) enthalten, das auf dem Client verwendet wird, um Zahlungen sicher abzuschließen. Es gibt verschiedene Verfahren zum Übergeben des Client-Geheimnisses an den Client. #### Einseitige Anwendung Rufen Sie das Client-Geheimnis von einem Endpoint auf Ihrem Server ab, indem Sie die Browser-Funktion `fetch` verwenden. Diese Vorgehensweise funktioniert am besten, wenn es sich bei Ihrer Client-Seite um eine einseitige Anwendung handelt, insbesondere wenn sie mit einem modernen Frontend-Framework wie React erstellt wurde. Erstellen Sie den Server-Endpoint, der das Client-Geheimnis bereitstellt: #### Ruby ```ruby get '/secret' do intent = # ... Create or retrieve the PaymentIntent {client_secret: intent.client_secret}.to_json end ``` Und dann rufen Sie das Client-Geheimnis mit JavaScript auf der Client-Seite ab: ```javascript (async () => { const response = await fetch('/secret'); const {client_secret: clientSecret} = await response.json(); // Render the form using the clientSecret })(); ``` #### Serverseitiges Rendering Übergeben Sie das Client-Geheimnis von Ihrem Server an den Client. Diese Vorgehensweise funktioniert am besten, wenn Ihre Anwendung statische Inhalte auf dem Server generiert, bevor sie an den Browser gesendet werden. Fügen Sie das [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) in Ihr Bezahlformular ein. Rufen Sie in Ihrem serverseitigen Code das Client-Geheimnis aus dem PaymentIntent ab: #### Ruby ```erb
``` ```ruby get '/checkout' do @intent = # ... Fetch or create the PaymentIntent erb :checkout end ``` ## Stellen Sie sicher, dass Ihre Kundinnen und Kunden die Nutzungsbedingungen verstehen [Clientseitig] Der Abwicklungspartner von Stripe verlangt, dass die Kundinnen und Kunden über die Identität des Abwicklers und dessen Nutzungsbedingungen informiert werden. Sie müssen die folgende Formulierung und den folgenden Link auf Ihrer Bezahlvorgangsseite angeben: > Nach dem Absenden werden Sie weitergeleitet, sodass Sie die nächsten Schritte durchführen können. Diese Transaktion wird über NICEPAY in Übereinstimmung mit den [Nutzungsbedingungen](https://start.nicepay.co.kr/homepage/terms/bill.do).do von NICEPAY abgewickelt. ## An lokalen Zahlungsabwickler weiterleiten [Clientseitig] Wenn Kundinnen/Kunden über das „Click to Pay“-Verfahren mit PAYCO bezahlen, verwenden Sie Stripe.js, um die Zahlungen an Stripe zu übermitteln. [Stripe.js](https://docs.stripe.com/payments/elements.md) ist die grundlegende JavaScript-Bibliothek für die Erstellung von Zahlungsabläufen. Sie verarbeitet automatisch komplexe Szenarien wie die nachfolgend beschriebene Weiterleitung und ermöglicht die Erweiterung Ihrer Integration durch zusätzliche Zahlungsmethoden. Binden Sie das Stripe.js-Skript in Ihre Bezahlseite ein, indem Sie es im `head` Ihrer HTML-Datei einfügen. ```html Checkout ``` Erstellen Sie auf Ihrer Checkout-Seite mit dem folgenden JavaScript eine Instanz von Stripe.js. ```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('<>'); ``` Verwenden Sie das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) des `PaymentIntent` und rufen Sie `stripe.confirmPayment` auf, um die Weiterleitung an die Bezahlseite des lokalen Zahlungsabwicklers durchzuführen. Auf dieser Seite wählt der Kunde/die Kundin seinen/ihren Aussteller aus und autorisiert die Zahlung. Fügen Sie eine `return_url` hinzu, um festzulegen, wohin Stripe die Kundinnen/Kunden nach Durchführung der Zahlung weiterleitet. ```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; } }); ``` Die `return_url` verweist auf eine Seite auf Ihrer Website, auf der das Ergebnis der Zahlung angezeigt wird. Sie können festlegen, was angezeigt werden soll, indem Sie den Status des `PaymentIntent` [verifizieren](https://docs.stripe.com/payments/payment-intents/verifying-status.md#checking-status). Um den Status zu verifizieren, enthält die Stripe Weiterleitung zum `return_url` die folgenden URL-Abfrageparameter. Sie können auch Ihre eigenen Abfrageparameter an die `return_url` anhängen. Sie bleiben während des gesamten Weiterleitungsvorgangs bestehen. | Parameter | Beschreibung | | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent` | Die eindeutige ID für den `PaymentIntent`. | | `payment_intent_client_secret` | Das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) des `PaymentIntent`-Objekts. | ## Test integration with PAYCO Testen Sie Ihre Integration mit PAYCO mit Ihren Test-API-Schlüsseln, indem Sie die Weiterleitungsseite anzeigen. Sie können die erfolgreiche Zahlung testen, indem Sie die Zahlung auf der Weiterleitungsseite authentifizieren. Der PaymentIntent wechselt von `requires_action` zu `succeeded`. Um einen Fall zu testen, in dem sich Kundinnen/Kunden nicht authentifizieren können, verwenden Sie Ihre Test-API Schlüssel und zeigen Sie die Weiterleitungsseite an. Klicken Sie auf der Weiterleitungsseite auf **Fehlgeschlagene Testzahlung**. Der PaymentIntent wechselt von `requires_action` zu `requires_payment_method`. ## Optional: Ereignisse nach der Zahlung verarbeiten Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs). Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide). - **Manuelles Bearbeiten von Ereignissen im Dashboard** Verwenden Sie das Dashboard, um [Ihre Testzahlungen im Dashboard anzuzeigen](https://dashboard.stripe.com/test/payments), E-Mail-Belege zu senden, Auszahlungen zu bearbeiten oder fehlgeschlagene Zahlungen erneut zu versuchen. - **Erstellen eines benutzerdefinierten Webhooks** [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. - **Integrieren einer vorgefertigten App** Bearbeiten Sie häufige Unternehmensereignisse, wie z. B.[Automatisierung](https://stripe.partners/?f_category=automation) oder[Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales), indem Sie eine Partneranwendung integrieren.