# PayPal-Zahlungen annehmen Erfahren Sie, wie Sie PayPal-Zahlungen annehmen, einer bei europäischen Unternehmen beliebten Digital Wallet. # Bezahlvorgang > This is a Bezahlvorgang for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/paypal/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. Stripe Checkout zeigt PayPal entweder als Standard-Zahlungsmethode oder als eigenständige Schaltfläche an, je nachdem, welche Option die Konversionsrate wahrscheinlicher erhöht. ## Kompatibilität bestimmen **Unterstützte Unternehmensstandorte**: Europe, GB, EEA **Unterstützte Währungen**: `eur, gbp, usd, chf, czk, dkk, nok, pln, sek, aud, cad, hkd, nzd, sgd` **Transaktionswährungen**: `eur, gbp, usd, chf, czk, dkk, nok, pln, sek, aud, cad, hkd, nzd, sgd` **Zahlungsmodus**: Yes **Einrichtungsmodus**: Yes **Abonnementmodus**: Yes Für die Unterstützung von Zahlungen per PayPal muss eine Checkout-Sitzung 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) sämtlicher Posten müssen in derselben Währung sein. Falls Posten in verschiedenen Währungen vorhanden sind, muss für jede Währung eine separate Checkout-Sitzung erstellt werden. ## Zahlung annehmen > Erstellen Sie zunächst eine Integration, um mit Checkout [Zahlungen anzunehmen](https://docs.stripe.com/payments/accept-a-payment.md?integration=checkout), bevor Sie mit diesem Leitfaden fortfahren. Diese Anleitung zeigt Ihnen, wie Sie PayPal aktivieren und erklärt die Unterschiede zwischen der Annahme von Zahlungen über dynamische Zahlungsmethoden und der manuellen Konfiguration von Zahlungsmethoden. ### PayPal als Zahlungsmethode aktivieren Führen Sie bei der Erstellung einer neuen [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md) folgende Schritte aus: 1. Fügen Sie `paypal` zur Liste der `payment_method_types` hinzu. 1. Stellen Sie sicher, dass alle `line_items` die gleiche Währung verwenden. #### Von Stripe gehostete Seite ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "line_items[0][price_data][currency]=usd" \ -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]=paypal" \ --data-urlencode "success_url=https://example.com/success" ``` #### Vollständig eingebettete Seite ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "line_items[0][price_data][currency]=usd" \ -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]=paypal" \ --data-urlencode "return_url=https://example.com/return" \ -d ui_mode=embedded_page ``` ### Abwicklung Ihrer Bestellungen Informieren Sie sich über die [Ausführung von Bestellungen](https://docs.stripe.com/checkout/fulfillment.md), nachdem Sie eine Zahlung angenommen haben. ## Integration testen Sie müssen Ihr PayPal-Geschäftskonto nicht verbinden, um die Integration zu testen. Achten Sie jedoch darauf, Ihre PayPal- und Stripe-Konten zu verbinden, wenn Sie [Zahlungen im Live-Modus aktivieren möchten](https://docs.stripe.com/payments/paypal/activate.md). Wenn beim Bezahlvorgang die Schaltfläche **PayPal** angezeigt wird, benötigen Sie ein [persönliches PayPal-Sandbox-Konto](https://developer.paypal.com/tools/sandbox/accounts/), um die Testzahlung abzuschließen. Wenn der Bezahlvorgang stattdessen PayPal als Zahlungsmethode aufführt, wählen Sie **PayPal** aus und klicken Sie auf **Bezahlen** – ein PayPal-Sandbox-Konto ist nicht erforderlich. Um die häufigsten Integrations- und Fehlerszenarien für Zahlungen mit PayPal zu simulieren, übergeben Sie `email`-Werte, die den in diesen [Test-Szenarien](https://docs.stripe.com/payments/paypal/accept-a-payment.md?platform=web&ui=stripe-hosted#test-scenarios) beschriebenen Mustern entsprechen. ### Test-Szenarien | E-Mail-Muster | Szenario | Erklärung | | ------------------------------- | ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `.*payee_account_restricted@.*` | Beschränktes Händlerkonto | Die Erfassung oder Autorisierung einer Zahlung schlägt mit dem Fehler `payment_method_unexpected_state` fehl, wenn Ihr Händlerkonto von PayPal eingeschränkt wird. Geben Sie zum Zeitpunkt der Autorisierung eine E-Mail an, die diesem Muster entspricht, damit die Autorisierung fehlschlägt. | | `.*transaction_refused@.*` | Transaktion abgelehnt | Die Erfassung einer Zahlung schlägt mit dem Fehler `payment_method_provider_decline` fehl, wenn die Transaktion von PayPal abgelehnt wird. | | `.*instrument_declined@.*` | Zahlungsmittel abgelehnt | Die Erfassung einer Zahlung schlägt mit dem Fehler `payment_method_provider_decline` fehl, wenn das vorgelegte Zahlungsmittel entweder vom Bearbeiter oder der Bank abgelehnt wurde oder für diese Zahlung nicht verwendet werden kann. | | `.*authorization_expired@.*` | Eine autorisierte manuell erfassen | Die Erfassung einer autorisierten Zahlung schlägt mit dem Fehler `capture_charge_authorization_expired` fehl, wenn die Autorisierung bereits abgelaufen ist. | ## Rückerstattungen und angefochtene Zahlungen handhaben Erfahren Sie mehr über [Zahlungsanfechtungen](https://docs.stripe.com/payments/paypal.md#disputed-payments) und -[Rückerstattungen](https://docs.stripe.com/payments/paypal.md#refunds) bei PayPal. # Direkt-API > This is a Direkt-API for when payment-ui is direct-api. View the full page at https://docs.stripe.com/payments/paypal/accept-a-payment?payment-ui=direct-api. ## 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] Stripe verwendet ein Zahlungsobjekt (als [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) bezeichnet), um sämtliche Status der Zahlung zu dokumentieren und zu verarbeiten, bis sie abgeschlossen ist. Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag und die Währung an. Falls Sie bereits über eine Integration verfügen, die die [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) verwendet, fügen Sie der Liste der [Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren PaymentIntent die Zahlungsmethode `paypal` hinzu. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" ``` Im zurückgegebenen 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 verwendet wird, um Zahlungen sicher abzuschließen, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Senden Sie das Client-Geheimnis zurück an den Client, damit Sie es in späteren Schritten verwenden können. #### Nutzerdefinierte Beschreibung einfügen Standardmäßig wird in den Bestellungsdetails auf der PayPal-Aktivitätsseite der Nutzerin/des Nutzers der Bestellungsbetrag angezeigt. Sie können das ändern, indem Sie eine nutzerdefinierte Beschreibung in der Eigenschaft `description` angeben. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "description=A sample description" \ -d "payment_method_types[]=paypal" ``` #### Bevorzugtes Gebietsschema anpassen Standardmäßig wird die PayPal-Autorisierungsseite basierend auf Variablen wie z. B. dem Land des Unternehmens lokalisiert. Sie können sie mithilfe der Eigenschaft `preferred_locale` an das bevorzugte Gebietsschema Ihrer Kundinnen und Kunden anpassen. Bei dem Wert muss es sich um einen zweistelligen Sprachcode in Kleinbuchstaben handeln, gefolgt von einem Bindestrich (`-`) und einem zweistelligen Ländercode in Großbuchstaben. Beispiel: Der Wert für eine französischsprachige Person in Belgien ist `fr-BE`. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" \ -d "payment_method_options[paypal][preferred_locale]=fr-BE" ``` Sie können die PayPal-Autorisierung über die Eigenschaft [preferred_locale](https://docs.stripe.com/payments/paypal/accept-a-payment.md#customize-the-preferred-locale) auf das bevorzugte Gebietsschema Ihrer Kundin/Ihres Kunden festlegen. Unterstützte Gebietsschemata finden Sie in der folgenden Tabelle: | Wert | Gebietsschema | Land | | ----- | -------------- | ---------------------- | | cs-CZ | Tschechisch | Tschechische Republik | | da-DK | Dänisch | Dänemark | | de-AT | Deutsch | Österreich | | de-DE | Deutsch | Deutschland | | de-LU | Deutsch | Luxemburg | | el-GR | Griechisch | Griechenland | | en-GB | Englisch | Vereinigtes Königreich | | de-DE | Englisch | Vereinigte Staaten | | es-ES | Spanisch | Spanien | | fi-FI | Finnisch | Finnland | | fr-BE | Französisch | Belgien | | fr-FR | Französisch | Frankreich | | fr-LU | Französisch | Luxemburg | | hu-HU | Ungarisch | Ungarn | | it-IT | Italienisch | Italien | | nl-BE | Niederländisch | Belgien | | nl-NL | Niederländisch | Niederlande | | pl-PL | Polnisch | Polen | | pt-PT | Portugiesisch | Portugal | | sk-SK | Slowakisch | Slowakei | | sv-SE | Schwedisch | Schweden | #### Zahlungsbeschreibungen bei PayPal Die Zahlungsbeschreibung auf dem Kontoauszug des Käufers/der Käuferin wird von PayPal festgelegt und lautet standardmäßig `PAYPAL *YOUR_BUSINESS_NAME`. Wenn Sie das Feld `statement_descriptor` beim Erstellen des `PaymentIntent` festlegen, wird sein Wert bis zu 22 Zeichen an den von PayPal festgelegten angehängt. Wenn Ihr Unternehmensname in PayPal beispielsweise `BUSINESS` lautet und Sie `statement_descriptor` auf `order_id_1234` festlegen, sehen die Käufer/innen auf ihrem Kontoauszug die Angabe `PAYPAL *BUSINESS order`. ## Zahlung an Stripe senden [Clientseitig] Wenn Kundinnen/Kunden über das „Click to Pay“-Verfahren mit PayPal 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('<>'); ``` Um eine Zahlung auf dem Client zu erstellen, übergeben Sie das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) des in [Schritt 2](https://docs.stripe.com/payments/paypal/accept-a-payment.md#create-payment-intent) erstellten `PaymentIntent`-Objekts. Das Client-Geheimnis unterscheidet sich von Ihren API-Schlüsseln, die Stripe-API-Anfragen authentifizieren. Achten Sie auf einen vorsichtigen Umgang mit dem Client-Geheimnis, da mit ihm die Zahlung abgeschlossen werden kann. Es darf nicht protokolliert, in URLs eingebettet oder Personen außer der Kundin/dem Kunden selbst zugänglich gemacht werden. ### PayPal-Zahlung bestätigen Rufen Sie [stripe.confirmPayPalPayment](https://docs.stripe.com/js/payment_intents/confirm_paypal_payment) auf, um Ihre Kundinnen/Kunden zum Abschließen der Zahlung an PayPal weiterzuleiten. Sie müssen ein `return_url` hinzufügen, um anzugeben, wohin Stripe Ihre Kundinnen/Kunden weiterleiten sollen, nachdem die Zahlung abgeschlossen ist. Sie können auch die `return_url` für neue PayPal-Zahlungsmethoden hinzufügen. Dies ist jedoch nicht erforderlich, wenn Sie eine zuvor eingerichtete PayPal Zahlungsmethode mit SetupIntent oder eine PaymentIntent verwenden, die `setup_future_usage` enthält. ```javascript // Redirects away from the client const {error} = await stripe.confirmPayPalPayment( '{{PAYMENT_INTENT_CLIENT_SECRET}}', { return_url: 'https://example.com/checkout/complete', } ); if (error) { // Inform the customer that there was an error. } ``` Wenn Sie Ihre PayPal-Mittel mit PayPal begleichen, hat die mit der Zahlung verknüpfte [Saldotransaktion](https://docs.stripe.com/api.md#balance_transaction_object) unabhängig vom Zahlungsbetrag einen Betrag von Null, da die Transaktion eingehendes und ausgehendes Geld Ihres Stripe-Saldos darstellt. Bei PayPal werden die Gelder jedoch Ihrem PayPal-Saldo gutgeschrieben und es wird kein Geld auf Ihren Stripe-Saldo übertragen. Die Saldotransaktion umfasst in diesem Fall auch damit verbundene Gebühren. Erfahren Sie mehr über andere wichtige Details im Zusammenhang mit den [Abrechnungseinstellungen](https://docs.stripe.com/payments/paypal/choose-settlement-preference.md). ### Weiterleitung verarbeiten Die folgenden URL-Abfrageparameter werden angegeben, wenn Stripe Kund/innen an die `return_url` weiterleitet. | Parameter | Beschreibung | | ------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent` | Die eindeutige ID für `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. | Bei Angabe der `return_url` können Sie auch Ihre eigenen Abfrageparameter hinzufügen. Sie bleiben während des gesamten Weiterleitungsvorgangs erhalten. Die `return_url` sollte einer Seite auf Ihrer Website entsprechen, die den Status der Zahlung angibt. Sie sollten den Status des `PaymentIntent` beim Rendern der Rückgabeseite überprüfen. Hierfür können Sie die Funktion `retrievePaymentIntent` von Stripe.js verwenden und im `payment_intent_client_secret` übergeben. ```javascript (async () => { const url = new URL(window.location); const clientSecret = url.searchParams.get('payment_intent_client_secret'); const {paymentIntent, error} = await stripe.retrievePaymentIntent(clientSecret); if (error) { // Handle error } else if (paymentIntent && paymentIntent.status === 'succeeded') { // Handle successful payment } })(); ``` Sie finden den Namen, die E-Mail-Adresse, die Zahler-ID und die Transaktions-ID des des Inhabers/der Inhaberin der Zahlung in der Eigenschaft [payment_method_details](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-paypal). | Feld | Wert | | ---------------- | -------------------------------------------------------------- | | `payer_email` | Die E-Mail-Adresse der zahlenden Person in ihrem PayPal-Konto. | | `payer_name` | Der Name der zahlenden Person in ihrem PayPal-Konto. | | `payer_id` | Eine eindeutige ID des PayPal-Kontos der zahlenden Person. | | `transaction_id` | Eine eindeutige, von PayPal generierte Transaktions-ID. | #### JSON ```json { "charges": { "data": [ {"payment_method_details": { "paypal": { "payer_id": "H54KFE9XXVVYJ", "payer_email": "jenny@example.com", "payer_name": "Jenny Rosen", "transaction_id": "89W40396MK104212M" }, "type": "paypal" }, "id": "src_16xhynE8WzK49JbAs9M21jaR", "object": "source", "amount": 1099, "client_secret": "src_client_secret_UfwvW2WHpZ0s3QEn9g5x7waU", "created": 1445277809, "currency": "eur", "flow": "redirect", "livemode": true, "statement_descriptor": null, "status": "pending", "type": "paypal", "usage": "single_use" } ], "object": "list", "has_more": false, "url": "/v1/charges?payment_intent=pi_1G1sgdKi6xqXeNtkldRRE6HT" }, "payment_method_options": { "paypal": {} }, "payment_method_types": [ "paypal" ], "id": "pi_1G1sgdKi6xqXeNtkldRRE6HT", "object": "payment_intent", "amount": 1099, "client_secret": "pi_1G1sgdKi6xqXeNtkldRRE6HT_secret_h9B56ObhTN72fQiBAuzcVPb2E", "confirmation_method": "automatic", "created": 1579259303, "currency": "eur", "livemode": true, "next_action": null } ``` ## 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). ### Ereignisse empfangen und Geschäftsaktionen ausführen Es gibt mehrere Möglichkeiten, Geschäftsaktionen zu empfangen und auszuführen. #### Manuell Verwenden Sie das Stripe-Dashboard, um alle Stripe-Zahlungen anzuzeigen, Zahlungsbelege per E-Mail zu senden, Auszahlungen abzuwickeln oder fehlgeschlagene Zahlungen erneut durchzuführen. - [Testzahlungen im Dashboard anzeigen](https://dashboard.stripe.com/test/payments) #### Benutzerdefinierter Code Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Zahlungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben. - [Erstellen eines benutzerdefinierten Webhooks](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) #### Vorgefertigte Apps Verarbeiten Sie häufige Geschäftsereignisse, wie [Automatisierung](https://stripe.partners/?f_category=automation) oder [Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales) durch Integration einer Partneranwendung. ## Optional: PayPal-Weiterleitung manuell handhaben Wenn Sie Stripe.js verwenden, können Sie Ihre Integration einfacher um weitere Zahlungsmethoden erweitern. Sie können Ihre Kundinnen und Kunden jedoch auch manuell an Ihren Server weiterleiten. 1. Erstellen und *bestätigen* (Confirming an intent indicates that the customer intends to use the current or provided payment method. Upon confirmation, the intent attempts to initiate the portions of the flow that have real-world side effects) Sie einen PaymentIntent vom Typ `paypal`. Durch Angabe von `payment_method_data` wird eine PaymentMethod erstellt und sofort mit dem PaymentIntent verwendet. Im Feld `return_url` müssen Sie auch die URL angeben, an die Ihre Kund/innen nach Abschluss ihrer Zahlung weitergeleitet werden. Sie können Ihre eigenen Abfrageparameter in dieser URL angeben. Diese Parameter werden nach Abschluss der Weiterleitung in die endgültige URL aufgenommen. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" \ -d "payment_method_data[type]=paypal" \ --data-urlencode "return_url=https://example.com/checkout/complete" \ -d confirm=true ``` 1. Überprüfen Sie, ob der `PaymentIntent` den Status `requires_action` und ob `next_action` den Typ `redirect_to_url` hat. #### JSON ```json {"status": "requires_action", "next_action": { "type": "redirect_to_url", "redirect_to_url": { "url": "https://hooks.stripe.com/...", "return_url": "https://example.com/checkout/complete" } }, "id": "pi_1G1sgdKi6xqXeNtkldRRE6HT", "object": "payment_intent", ... } ``` 1. Leiten Sie die Kundinnen/Kunden an die in der Eigenschaft `next_action.redirect_to_url.url` angegebene URL weiter. Dieses Codebeispiel ist nur eine Annäherung und kann sich vom Weiterleitungsverfahren in Ihrem Web-Framework unterscheiden. #### Ruby ```ruby if payment_intent.status == 'requires_action' && payment_intent.next_action.type == 'redirect_to_url' url = payment_intent.next_action.redirect_to_url.url redirect(url) end ``` Bei Abschluss des Bezahlvorgangs werden Ihre Kundinnen/Kunden zu Ihrer `return_url` weitergeleitet. Die URL-Abfrageparameter `payment_intent` und `payment_intent_client_secret` sind zusammen mit Ihren eigenen Abfrageparametern enthalten. Stripe empfiehlt, einen [Webhook-Endpoint](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) einzurichten, um den Zahlungsstatus programmgesteuert zu bestätigen. ## Optional: Zahlung autorisieren und später erfassen PayPal unterstützt die [separate Autorisierung und Erfassung](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md). Wenn Sie sich für die [Zahlungsabwicklung mit Stripe](https://docs.stripe.com/payments/paypal/choose-settlement-preference.md) entschieden haben, sind Ihre Autorisierungen 10 Tage lang gültig. Stripe autorisiert die Zahlung automatisch erneut, um den Autorisierungszeitraum um weitere 10 Tage zu verlängern. Dies ergibt eine Gesamtdauer von 20 Tagen. Wenn die erneute Autorisierung nicht funktioniert, lässt Stripe die Zahlung nach 10 Tagen ablaufen. Überwachen Sie den Webhook [charge.expired](https://docs.stripe.com/api/events/types.md#event_types-charge.expired), um zu erfahren, wann der Autorisierungszeitraum endet. Wenn Sie sich für die [Zahlungsabwicklung mit PayPal](https://docs.stripe.com/payments/paypal/choose-settlement-preference.md) entschieden haben, bleibt Ihr Autorisierungszeitraum 3 Tage lang gültig. Für einen erweiterten garantierten Autorisierungszeitraum von bis zu 10 Tagen, bei PayPal als *honor period* bezeichnet, kontaktieren Sie den [PayPal-Support](https://www.paypal.com/nu/cshelp/business). ### Stripe anweisen, nur zu autorisieren Um anzugeben, dass Sie Autorisierung und Erfassung trennen möchten, legen Sie [capture_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) beim Erstellen des PaymentIntent auf `manual` fest. Dieser Parameter weist Stripe an, nur den Betrag im PayPal-Konto der Kundin/des Kunden zu autorisieren. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d capture_method=manual \ -d "payment_method_types[]=paypal" \ -d "payment_method_data[type]=paypal" \ -d confirm=true \ --data-urlencode "return_url=http://example.com" ``` Bei erfolgreicher Autorisierung übermittelt Stripe das Ereignis [payment_intent.amount_capturable_updated](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.amount_capturable_updated). Lesen Sie in unserem [Leitfaden zu Ereignissen](https://docs.stripe.com/api/events.md) mehr dazu. ### Die Gelder erfassen Nach erfolgreicher Autorisierung wechselt der [Status](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-status) des PaymentIntent zu `requires_capture`. Um die autorisierten Gelder zu erfassen, führen Sie eine [Erfassungsanfrage](https://docs.stripe.com/api/payment_intents/capture.md) für den PaymentIntent durch. Standardmäßig wird der gesamte autorisierte Betrag erfasst. Sie können keinen höheren, aber einen niedrigeren Betrag erfassen. ```curl curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/capture \ -u "<>:" \ -d amount_to_capture=750 ``` ### (Optional) Autorisierung stornieren Wenn Sie eine Autorisierung stornieren müssen, können Sie den [PaymentIntent](https://docs.stripe.com/refunds.md#cancel-payment) stornieren. ## Optional: Asynchrone Zahlungsmethoden bei PayPal aktivieren Standardmäßig lässt Stripe nur synchrone Zahlungsmethoden per PayPal zu. Dadurch wird garantiert, dass Sie über den Erfolg oder das Fehlschlagen einer Zahlung [umgehend benachrichtigt](https://docs.stripe.com/payments/payment-methods.md#payment-notification) werden. Wenn Sie asynchrone Zahlungsmethoden zulassen, erhalten Sie für einige Zahlungen möglicherweise [verzögerte Benachrichtigungen](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Daher müssen Sie [Webhook-Endpoints](https://docs.stripe.com/payments/payment-methods.md#webhooks) verwenden, um Benachrichtigungen über den Erfolg oder das Fehlschlagen bestimmter Zahlungen zu erhalten. Kontaktieren Sie den [Stripe-Support](https://support.stripe.com/contact), um asynchrone Zahlungen auf PayPal zu aktivieren. ## Optional: Fehlercodes Dies sind die häufigsten Fehlercodes und die dazugehörigen Details bei der Integration mit PayPal. Wenn eine PayPal API-Anfrage den Fehler zurückgegeben hat, enthält sie einen PayPal-Problemcode und die zugehörige Debug-ID für die Anfrage. Sie können die Debug-ID verwenden, wenn Sie sich an den [PayPal-Support](https://www.paypal-support.com/) wenden, um Hilfe bei Ihrem Problem zu erhalten. | Fehlercode | Details | | --------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `country_code_invalid` | Die angegebene Ländercode in der Versandadresse ist ungültig. | | `incorrect_address` | Die angegebene Versandadresse ist ungültig. Dieser Fehler tritt auch auf, wenn das angegebene Land zusätzlich entweder eine Stadt oder eine Postleitzahl erfordert. Für weitere Informationen überprüfen Sie bitte die Fehlermeldung und wenden Sie sich mit der `Debug ID` und dem `PayPal issue` an den [PayPal-Support](https://www.paypal-support.com/) | | `payment_method_not_available` | Die Zahlungsmethode `paypal` ist derzeit nicht verfügbar. Dieser Fehler kann durch eine Zeitüberschreitung oder ein Serverproblem beim Herstellen einer Verbindung zur PayPal API entstehen. | | `payment_method_provider_decline` | Die Transaktion wird von PayPal abgelehnt. Dies erfolgt häufig aufgrund der Einstellungen des Unternehmens zur Betrugsvorbeugung bei PayPal, eines Compliance-Verstoßes oder weil die zahlende Person nicht mit der ausgewählten Finanzierungsmethode bezahlen kann. Für weitere Informationen überprüfen Sie bitte die Fehlermeldung und wenden Sie sich mit der `Debug-ID` und dem `PayPal-Problem` an den [PayPal-Support](https://www.paypal-support.com/). | | `payment_method_provider_timeout` | Die Anfrage ist bei PayPal abgelaufen. In den meisten Fällen handelt es sich um einen vorübergehenden Fehler, und Sie können die Anfrage nach einem kurzen Moment wiederholen. | | `payment_method_unactivated` | Die Zahlungsmethode `paypal` ist für Ihr Stripe-Konto nicht aktiviert. | | `payment_method_unexpected_state` | Die Anfrage bei PayPal ist fehlgeschlagen. Dies kann vorkommen, wenn das Geschäftskonto des Händlers von PayPal gesperrt, eingeschränkt oder geschlossen wird oder wenn das PayPal-Konto der zahlenden Partei eingeschränkt wird. Für weitere Informationen überprüfen Sie bitte die Fehlermeldung und wenden Sie sich mit der `Debug ID` und dem `PayPal issue` an den [PayPal-Support](https://www.paypal-support.com/). | ## Optional: PayPal-Integration testen Um eine erfolgreiche Zahlung in Ihrer PayPal-Integration zu testen, verwenden Sie Ihre [Test-API-Schlüssel](https://docs.stripe.com/keys.md#test-live-modes) und zeigen Sie die Weiterleitungsseite an. Dort sehen Sie die Optionen zum **Autorisieren** oder **Fehlschlagen** der Nutzerauthentifizierung als Test-Szenarien. Wenn Sie **Testzahlung autorisieren** auswählen, geht der PaymentIntent von `requires_action`zu `succeeded` über. Um den Fall zu testen, in dem Nutzer/innen sich nicht authentifizieren können, verwenden Sie Ihre Test-API-Schlüssel und zeigen Sie die Weiterleitungsseite an. Klicken Sie auf der Weiterleitungsseite auf **Fail test payment** (Testzahlung fehlschlagen lassen). Der PaymentIntent wechselt dann von `requires_action` zu `requires_payment_method`. Um die häufigsten Integrations- und Fehlerszenarien für Zahlungen mit PayPal zu simulieren, übergeben Sie bei der Erstellung des PaymentIntent als Teil der [Abrechnungsdetails](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_data-billing_details) `email`-Werte, die den unter [Test-Szenarien](https://docs.stripe.com/payments/paypal/accept-a-payment.md?platform=web#test-scenarios) beschriebenen Mustern entsprechen. Bei der Bestätigung des PaymentIntent auf der Serverseite würde eine Anfrage, die eine von PayPal abgelehnte Zahlung simuliert, zum Beispiel wie folgt aussehen: ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" \ -d "payment_method_data[type]=paypal" \ --data-urlencode "payment_method_data[billing_details][email]=transaction_refused@example.com" ``` ### Test-Szenarien | E-Mail-Muster | Szenario | Erklärung | | ------------------------------- | ---------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `.*payee_account_restricted@.*` | Beschränktes Händlerkonto | Die Erfassung oder Autorisierung einer Zahlung schlägt mit dem Fehler `payment_method_unexpected_state` fehl, wenn Ihr Händlerkonto von PayPal eingeschränkt wird. Geben Sie zum Zeitpunkt der Autorisierung eine E-Mail an, die diesem Muster entspricht, damit die Autorisierung fehlschlägt. | | `.*transaction_refused@.*` | Transaktion abgelehnt | Die Erfassung einer Zahlung schlägt mit dem Fehler `payment_method_provider_decline` fehl, wenn die Transaktion von PayPal abgelehnt wird. | | `.*instrument_declined@.*` | Zahlungsmittel abgelehnt | Die Erfassung einer Zahlung schlägt mit dem Fehler `payment_method_provider_decline` fehl, wenn das vorgelegte Zahlungsmittel entweder vom Bearbeiter oder der Bank abgelehnt wurde oder für diese Zahlung nicht verwendet werden kann. | | `.*authorization_expired@.*` | Eine autorisierte manuell erfassen | Die Erfassung einer autorisierten Zahlung schlägt mit dem Fehler `capture_charge_authorization_expired` fehl, wenn die Autorisierung bereits abgelaufen ist. | # 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/paypal/accept-a-payment?payment-ui=mobile&platform=ios. ## Stripe einrichten [Serverseitig] [Clientseitig] Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register). ### Serverseitig Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie die offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus: #### 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' ``` ### Clientseitig Das [Stripe iOS SDK](https://github.com/stripe/stripe-ios) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-ios/index.html) und kompatibel mit Apps, die iOS 13 oder höher unterstützen. #### Swift Package Manager Führen Sie zur Installation des SDK die folgenden Schritte aus: 1. Wählen Sie in Xcode **Datei** > **Add Package Dependencies** (Paketabhängigkeiten hinzufügen) aus und geben Sie als Repository-URL `https://github.com/stripe/stripe-ios-spm` ein. 1. Wählen auf unserer [Veröffentlichungsseite](https://github.com/stripe/stripe-ios/releases) die neueste Version aus. 1. Fügen Sie das Produkt **StripePaymentsUI** zum [Ziel Ihrer App](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) hinzu. #### CocoaPods 1. Falls noch nicht geschehen, installieren Sie bitte die aktuellste Version von [CocoaPods](https://guides.cocoapods.org/using/getting-started.html). 1. Wenn Sie keine bestehende [Podfile](https://guides.cocoapods.org/syntax/podfile.html) haben, führen Sie folgenden Befehl aus, um eine zu erstellen: ```bash pod init ``` 1. Fügen Sie folgende Zeile in Ihre `Podfile` ein: ```podfile pod 'StripePaymentsUI' ``` 1. Führen Sie folgenden Befehl aus: ```bash pod install ``` 1. Vergessen Sie nicht, ab jetzt in Zukunft anstelle der Datei `.xcodeproj` die Datei `.xcworkspace` zum Öffnen Ihres Projekts in Xcode zu verwenden. 1. Führen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK Folgendes aus: ```bash pod update StripePaymentsUI ``` #### Carthage 1. Falls noch nicht geschehen, installieren Sie bitte die aktuelle Version von [Carthage](https://github.com/Carthage/Carthage#installing-carthage). 1. Fügen Sie folgende Zeile in Ihre `Cartfile` ein: ```cartfile github "stripe/stripe-ios" ``` 1. Befolgen Sie die [Carthage-Installationsanweisungen](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Vergewissern Sie sich, dass Sie alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking) aufgeführten erforderlichen Frameworks einbetten. 1. Führen Sie für zukünftige Updates auf die aktuelle Version unseres SDK einfach folgenden Befehl aus: ```bash carthage update stripe-ios --platform ios ``` #### Manuelles Framework 1. Gehen Sie auf unsere [GitHub-Release-Seite](https://github.com/stripe/stripe-ios/releases/latest), laden Sie **Stripe.xcframework.zip** herunter und entpacken Sie die Datei. 1. Ziehen Sie **StripePaymentsUI.xcframework** in den Abschnitt **Embedded Binaries** (Eingebettete Binärdateien) der Einstellungen unter **General** (Allgemeines) Ihres Xcode-Projekts. Aktivieren Sie dabei die Option **Copy items if needed** (Elemente kopieren, falls nötig). 1. Wiederholen Sie Schritt 2 für alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking) aufgeführten erforderlichen Frameworks. 1. Wiederholen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK die Schritte 1–3. > Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-ios/releases) auf GitHub. Um bei Veröffentlichung einer neuen Version eine Benachrichtigung zu erhalten, [achten Sie auf die Releases zum jeweiligen Repository](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository). Konfigurieren Sie das SDK mit Ihrem [veröffentlichbaren Schlüssel](https://dashboard.stripe.com/test/apikeys) von Stripe, um es beim Start der App auszuführen. Dadurch kann Ihre App Anfragen an die Stripe-API senden. #### Swift ```swift import UIKitimportStripePaymentsUI @main class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<>" // do any other necessary launch configuration return true } } ``` > Verwenden Sie Ihre [Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App. ## Erstellen Sie ein PaymentIntent [Serverseitig] [Clientseitig] ### Serverseitig Stripe verwendet ein Zahlungsobjekt (als [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) bezeichnet), um sämtliche Status der Zahlung zu dokumentieren und zu verarbeiten, bis sie abgeschlossen ist. Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag und die Währung an. Falls Sie bereits über eine Integration verfügen, die die [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) verwendet, fügen Sie der Liste der [Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren PaymentIntent die Zahlungsmethode `paypal` hinzu. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" ``` Im zurückgegebenen 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 verwendet wird, um Zahlungen sicher abzuschließen, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Senden Sie das Client-Geheimnis zurück an den Client, damit Sie es in späteren Schritten verwenden können. #### Nutzerdefinierte Beschreibung einfügen Standardmäßig wird in den Bestellungsdetails auf der PayPal-Aktivitätsseite der Nutzerin/des Nutzers der Bestellungsbetrag angezeigt. Sie können das ändern, indem Sie eine nutzerdefinierte Beschreibung in der Eigenschaft `description` angeben. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "description=A sample description" \ -d "payment_method_types[]=paypal" ``` #### Bevorzugtes Gebietsschema anpassen Standardmäßig wird die PayPal-Autorisierungsseite basierend auf Variablen wie z. B. dem Land des Unternehmens lokalisiert. Sie können sie mithilfe der Eigenschaft `preferred_locale` an das bevorzugte Gebietsschema Ihrer Kundinnen und Kunden anpassen. Bei dem Wert muss es sich um einen zweistelligen Sprachcode in Kleinbuchstaben handeln, gefolgt von einem Bindestrich (`-`) und einem zweistelligen Ländercode in Großbuchstaben. Beispiel: Der Wert für eine französischsprachige Person in Belgien ist `fr-BE`. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" \ -d "payment_method_options[paypal][preferred_locale]=fr-BE" ``` Sie können die PayPal-Autorisierung über die Eigenschaft [preferred_locale](https://docs.stripe.com/payments/paypal/accept-a-payment.md#customize-the-preferred-locale) auf das bevorzugte Gebietsschema Ihrer Kundin/Ihres Kunden festlegen. Unterstützte Gebietsschemata finden Sie in der folgenden Tabelle: | Wert | Gebietsschema | Land | | ----- | -------------- | ---------------------- | | cs-CZ | Tschechisch | Tschechische Republik | | da-DK | Dänisch | Dänemark | | de-AT | Deutsch | Österreich | | de-DE | Deutsch | Deutschland | | de-LU | Deutsch | Luxemburg | | el-GR | Griechisch | Griechenland | | en-GB | Englisch | Vereinigtes Königreich | | de-DE | Englisch | Vereinigte Staaten | | es-ES | Spanisch | Spanien | | fi-FI | Finnisch | Finnland | | fr-BE | Französisch | Belgien | | fr-FR | Französisch | Frankreich | | fr-LU | Französisch | Luxemburg | | hu-HU | Ungarisch | Ungarn | | it-IT | Italienisch | Italien | | nl-BE | Niederländisch | Belgien | | nl-NL | Niederländisch | Niederlande | | pl-PL | Polnisch | Polen | | pt-PT | Portugiesisch | Portugal | | sk-SK | Slowakisch | Slowakei | | sv-SE | Schwedisch | Schweden | #### Zahlungsbeschreibungen bei PayPal Die Zahlungsbeschreibung auf dem Kontoauszug des Käufers/der Käuferin wird von PayPal festgelegt und lautet standardmäßig `PAYPAL *YOUR_BUSINESS_NAME`. Wenn Sie das Feld `statement_descriptor` beim Erstellen des `PaymentIntent` festlegen, wird sein Wert bis zu 22 Zeichen an den von PayPal festgelegten angehängt. Wenn Ihr Unternehmensname in PayPal beispielsweise `BUSINESS` lautet und Sie `statement_descriptor` auf `order_id_1234` festlegen, sehen die Käufer/innen auf ihrem Kontoauszug die Angabe `PAYPAL *BUSINESS order`. ### Clientseitig Fordern Sie auf dem Client einen PaymentIntent von Ihrem Server an und speichern Sie sein *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)). #### Swift ```swift class CheckoutViewController: UIViewController { var paymentIntentClientSecret: String? // ...continued from previous step override func viewDidLoad() { // ...continued from previous step startCheckout() } func startCheckout() { // Request a PaymentIntent from your server and store its client secret // Click View full sample to see a complete implementation } } ``` ## Zahlung an Stripe senden [Clientseitig] Wenn Kundinnen/Kunden die Schaltfläche zum Bezahlen mit PayPal antippen, bestätigen Sie den `PaymentIntent`, um die Zahlung abzuschließen. Konfigurieren Sie ein `STPPaymentIntentParams`-Objekt mit dem [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) des `PaymentIntent`. Das Client-Geheimnis unterscheidet sich von Ihren API-Schlüsseln, die die Stripe API-Anfragen authentifizieren. Achten Sie auf einen vorsichtigen Umgang mit dem Client-Geheimnis, da mit ihm die Zahlung abgeschlossen werden kann. Es darf nicht protokolliert, in URLs eingebettet oder Personen außer der Kundin/dem Kunden selbst zugänglich gemacht werden. ### Rückgabe-URL einrichten Das iOS SDK zeigt zur Durchführung einer Zahlung per PayPal eine Webansicht in Ihrer App an. Wenn die Authentifizierung abgeschlossen ist, muss Ihre Kundin/Ihr Kunde sie nicht schließen, sondern dies geschieht automatisch. Um dieses Verhalten zu aktivieren, konfigurieren Sie ein benutzerdefiniertes URL-Schema oder einen Universal-Link und richten Sie Ihre App so ein, dass die URL an das SDK weitergeleitet wird. #### 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 } // This method handles opening universal link URLs (for example, "https://example.com/stripe_ios_callback") func application(_ application: UIApplication, continue userActivity: NSUserActivity, restorationHandler: @escaping ([UIUserActivityRestoring]?) -> Void) -> Bool { if userActivity.activityType == NSUserActivityTypeBrowsingWeb { if let url = userActivity.webpageURL { 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 } ``` Übergeben Sie die URL als `return_url`, wenn Sie den PaymentIntent bestätigen. Nach Abschluss der webansichtsbasierten Authentifizierung leitet Stripe den/die Nutzer/in an die `return_url` weiter. ### PayPal-Zahlung bestätigen Führen Sie durch Aufrufen von `STPPaymentHandler confirmPayment` die Zahlung durch. Dies entspricht einer Webansicht, über die die Kund/innen die Zahlung per PayPal durchführen können. Danach wird der Completion-Block mit dem Ergebnis der Zahlung aufgerufen. #### Swift ```swift let paymentIntentParams = STPPaymentIntentParams(clientSecret: paymentIntentClientSecret) // PayPal doesn't require additional parameters so we only need to pass the initialized // STPPaymentMethodPayPalParams instance to STPPaymentMethodParams let payPal = STPPaymentMethodPayPalParams() let paymentMethodParams = STPPaymentMethodParams(payPal: payPal, billingDetails: nil, metadata: nil) paymentIntentParams.paymentMethodParams = paymentMethodParams 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() } } ``` Sie finden den Namen, die E-Mail-Adresse, die Zahler-ID und die Transaktions-ID des des Inhabers/der Inhaberin der Zahlung in der Eigenschaft [payment_method_details](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-paypal). | Feld | Wert | | ---------------- | -------------------------------------------------------------- | | `payer_email` | Die E-Mail-Adresse der zahlenden Person in ihrem PayPal-Konto. | | `payer_name` | Der Name der zahlenden Person in ihrem PayPal-Konto. | | `payer_id` | Eine eindeutige ID des PayPal-Kontos der zahlenden Person. | | `transaction_id` | Eine eindeutige, von PayPal generierte Transaktions-ID. | #### JSON ```json { "charges": { "data": [ {"payment_method_details": { "paypal": { "payer_id": "H54KFE9XXVVYJ", "payer_email": "jenny@example.com", "payer_name": "Jenny Rosen", "transaction_id": "89W40396MK104212M" }, "type": "paypal" }, "id": "src_16xhynE8WzK49JbAs9M21jaR", "object": "source", "amount": 1099, "client_secret": "src_client_secret_UfwvW2WHpZ0s3QEn9g5x7waU", "created": 1445277809, "currency": "eur", "flow": "redirect", "livemode": true, "statement_descriptor": null, "status": "pending", "type": "paypal", "usage": "single_use" } ], "object": "list", "has_more": false, "url": "/v1/charges?payment_intent=pi_1G1sgdKi6xqXeNtkldRRE6HT" }, "payment_method_options": { "paypal": {} }, "payment_method_types": [ "paypal" ], "id": "pi_1G1sgdKi6xqXeNtkldRRE6HT", "object": "payment_intent", "amount": 1099, "client_secret": "pi_1G1sgdKi6xqXeNtkldRRE6HT_secret_h9B56ObhTN72fQiBAuzcVPb2E", "confirmation_method": "automatic", "created": 1579259303, "currency": "eur", "livemode": true, "next_action": null } ``` ## 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). ### Ereignisse empfangen und Geschäftsaktionen ausführen Es gibt mehrere Möglichkeiten, Geschäftsaktionen zu empfangen und auszuführen. #### Manuell Verwenden Sie das Stripe-Dashboard, um alle Stripe-Zahlungen anzuzeigen, Zahlungsbelege per E-Mail zu senden, Auszahlungen abzuwickeln oder fehlgeschlagene Zahlungen erneut durchzuführen. - [Testzahlungen im Dashboard anzeigen](https://dashboard.stripe.com/test/payments) #### Benutzerdefinierter Code Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Zahlungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben. - [Erstellen eines benutzerdefinierten Webhooks](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) #### Vorgefertigte Apps Verarbeiten Sie häufige Geschäftsereignisse, wie [Automatisierung](https://stripe.partners/?f_category=automation) oder [Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales) durch Integration einer Partneranwendung. # 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/paypal/accept-a-payment?payment-ui=mobile&platform=android. ## Stripe einrichten [Serverseitig] [Clientseitig] Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register). ### Serverseitig Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie diese offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus: #### 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' ``` ### Clientseitig Das [Stripe Android SDK](https://github.com/stripe/stripe-android) ist Open Source und [vollständig dokumentiert](https://stripe.dev/stripe-android/). Um das SDK zu installieren, fügen Sie `stripe-android` in den Block `dependencies` Ihrer [app/build.gradle](https://developer.android.com/studio/build/dependencies)-Datei ein: #### 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") } ``` > Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-android/releases) auf GitHub. Um bei Veröffentlichung eines neuen Release eine Benachrichtigung zu erhalten, [beobachten Sie Veröffentlichungen für das jeweilige Repository](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository). Konfigurieren Sie das SDK mit Ihrem [veröffentlichbaren Schlüssel](https://dashboard.stripe.com/apikeys) von Stripe so, dass dieser Anfragen an die API stellen kann, wie beispielsweise in Ihrer Unterklasse `Application`: #### Kotlin ```kotlin import com.stripe.android.PaymentConfiguration class MyApp : Application() { override fun onCreate() { super.onCreate() PaymentConfiguration.init( applicationContext, "<>" ) } } ``` > Verwenden Sie Ihre [Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App. Stripe-Beispiele nutzen auch [OkHttp](https://github.com/square/okhttp) und [GSON](https://github.com/google/gson), um HTTP-Anfragen an einen Server zu stellen. ## Erstellen Sie ein PaymentIntent [Serverseitig] [Clientseitig] ### Serverseitig Stripe verwendet ein Zahlungsobjekt (als [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) bezeichnet), um sämtliche Status der Zahlung zu dokumentieren und zu verarbeiten, bis sie abgeschlossen ist. Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag und die Währung an. Falls Sie bereits über eine Integration verfügen, die die [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) verwendet, fügen Sie der Liste der [Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren PaymentIntent die Zahlungsmethode `paypal` hinzu. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" ``` Im zurückgegebenen 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 verwendet wird, um Zahlungen sicher abzuschließen, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Senden Sie das Client-Geheimnis zurück an den Client, damit Sie es in späteren Schritten verwenden können. #### Nutzerdefinierte Beschreibung einfügen Standardmäßig wird in den Bestellungsdetails auf der PayPal-Aktivitätsseite der Nutzerin/des Nutzers der Bestellungsbetrag angezeigt. Sie können das ändern, indem Sie eine nutzerdefinierte Beschreibung in der Eigenschaft `description` angeben. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "description=A sample description" \ -d "payment_method_types[]=paypal" ``` #### Bevorzugtes Gebietsschema anpassen Standardmäßig wird die PayPal-Autorisierungsseite basierend auf Variablen wie z. B. dem Land des Unternehmens lokalisiert. Sie können sie mithilfe der Eigenschaft `preferred_locale` an das bevorzugte Gebietsschema Ihrer Kundinnen und Kunden anpassen. Bei dem Wert muss es sich um einen zweistelligen Sprachcode in Kleinbuchstaben handeln, gefolgt von einem Bindestrich (`-`) und einem zweistelligen Ländercode in Großbuchstaben. Beispiel: Der Wert für eine französischsprachige Person in Belgien ist `fr-BE`. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" \ -d "payment_method_options[paypal][preferred_locale]=fr-BE" ``` Sie können die PayPal-Autorisierung über die Eigenschaft [preferred_locale](https://docs.stripe.com/payments/paypal/accept-a-payment.md#customize-the-preferred-locale) auf das bevorzugte Gebietsschema Ihrer Kundin/Ihres Kunden festlegen. Unterstützte Gebietsschemata finden Sie in der folgenden Tabelle: | Wert | Gebietsschema | Land | | ----- | -------------- | ---------------------- | | cs-CZ | Tschechisch | Tschechische Republik | | da-DK | Dänisch | Dänemark | | de-AT | Deutsch | Österreich | | de-DE | Deutsch | Deutschland | | de-LU | Deutsch | Luxemburg | | el-GR | Griechisch | Griechenland | | en-GB | Englisch | Vereinigtes Königreich | | de-DE | Englisch | Vereinigte Staaten | | es-ES | Spanisch | Spanien | | fi-FI | Finnisch | Finnland | | fr-BE | Französisch | Belgien | | fr-FR | Französisch | Frankreich | | fr-LU | Französisch | Luxemburg | | hu-HU | Ungarisch | Ungarn | | it-IT | Italienisch | Italien | | nl-BE | Niederländisch | Belgien | | nl-NL | Niederländisch | Niederlande | | pl-PL | Polnisch | Polen | | pt-PT | Portugiesisch | Portugal | | sk-SK | Slowakisch | Slowakei | | sv-SE | Schwedisch | Schweden | #### Zahlungsbeschreibungen bei PayPal Die Zahlungsbeschreibung auf dem Kontoauszug des Käufers/der Käuferin wird von PayPal festgelegt und lautet standardmäßig `PAYPAL *YOUR_BUSINESS_NAME`. Wenn Sie das Feld `statement_descriptor` beim Erstellen des `PaymentIntent` festlegen, wird sein Wert bis zu 22 Zeichen an den von PayPal festgelegten angehängt. Wenn Ihr Unternehmensname in PayPal beispielsweise `BUSINESS` lautet und Sie `statement_descriptor` auf `order_id_1234` festlegen, sehen die Käufer/innen auf ihrem Kontoauszug die Angabe `PAYPAL *BUSINESS order`. ### Clientseitig Fordern Sie auf dem Client einen PaymentIntent von Ihrem Server an und speichern Sie sein *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)). #### Kotlin ```kotlin class CheckoutActivity : AppCompatActivity() { private lateinit var paymentIntentClientSecret: String override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // ... startCheckout() } private fun startCheckout() { // Request a PaymentIntent from your server and store its client secret in paymentIntentClientSecret // Click View full sample to see a complete implementation } } ``` ## Zahlung an Stripe senden [Clientseitig] Rufen Sie vom erstellten SetupIntent das Client-Geheimnis ab und rufen Sie [PaymentLauncher bestätigen](https://stripe.dev/stripe-android/payments-core/com.stripe.android.payments.paymentlauncher/-payment-launcher/index.html#74063765%2FFunctions%2F-1622557690) auf. Dies entspricht einer Webansicht, über die die Kund/innen auf der Website der Bank oder über die App die Einrichtung durchführen können. Anschließend wird `onPaymentResult` mit dem Ergebnis der Zahlung aufgerufen. #### Kotlin ```kotlin class CheckoutActivity : 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.createPayPal(), 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 } } } } ``` Sie finden den Namen, die E-Mail-Adresse, die Zahler-ID und die Transaktions-ID des des Inhabers/der Inhaberin der Zahlung in der Eigenschaft [payment_method_details](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-paypal). | Feld | Wert | | ---------------- | -------------------------------------------------------------- | | `payer_email` | Die E-Mail-Adresse der zahlenden Person in ihrem PayPal-Konto. | | `payer_name` | Der Name der zahlenden Person in ihrem PayPal-Konto. | | `payer_id` | Eine eindeutige ID des PayPal-Kontos der zahlenden Person. | | `transaction_id` | Eine eindeutige, von PayPal generierte Transaktions-ID. | #### JSON ```json { "charges": { "data": [ {"payment_method_details": { "paypal": { "payer_id": "H54KFE9XXVVYJ", "payer_email": "jenny@example.com", "payer_name": "Jenny Rosen", "transaction_id": "89W40396MK104212M" }, "type": "paypal" }, "id": "src_16xhynE8WzK49JbAs9M21jaR", "object": "source", "amount": 1099, "client_secret": "src_client_secret_UfwvW2WHpZ0s3QEn9g5x7waU", "created": 1445277809, "currency": "eur", "flow": "redirect", "livemode": true, "statement_descriptor": null, "status": "pending", "type": "paypal", "usage": "single_use" } ], "object": "list", "has_more": false, "url": "/v1/charges?payment_intent=pi_1G1sgdKi6xqXeNtkldRRE6HT" }, "payment_method_options": { "paypal": {} }, "payment_method_types": [ "paypal" ], "id": "pi_1G1sgdKi6xqXeNtkldRRE6HT", "object": "payment_intent", "amount": 1099, "client_secret": "pi_1G1sgdKi6xqXeNtkldRRE6HT_secret_h9B56ObhTN72fQiBAuzcVPb2E", "confirmation_method": "automatic", "created": 1579259303, "currency": "eur", "livemode": true, "next_action": null } ``` ## 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). ### Ereignisse empfangen und Geschäftsaktionen ausführen Es gibt mehrere Möglichkeiten, Geschäftsaktionen zu empfangen und auszuführen. #### Manuell Verwenden Sie das Stripe-Dashboard, um alle Stripe-Zahlungen anzuzeigen, Zahlungsbelege per E-Mail zu senden, Auszahlungen abzuwickeln oder fehlgeschlagene Zahlungen erneut durchzuführen. - [Testzahlungen im Dashboard anzeigen](https://dashboard.stripe.com/test/payments) #### Benutzerdefinierter Code Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Zahlungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben. - [Erstellen eines benutzerdefinierten Webhooks](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook) #### Vorgefertigte Apps Verarbeiten Sie häufige Geschäftsereignisse, wie [Automatisierung](https://stripe.partners/?f_category=automation) oder [Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales) durch Integration einer Partneranwendung. # 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/paypal/accept-a-payment?payment-ui=mobile&platform=react-native. ## Stripe einrichten [Serverseitig] [Clientseitig] ### Serverseitig Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus: #### 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' ``` ### Clientseitig Das [React Native SDK](https://github.com/stripe/stripe-react-native) ist Open Source und vollständig dokumentiert. Intern werden [native iOS](https://github.com/stripe/stripe-ios) und [Android](https://github.com/stripe/stripe-android) SDKs verwendet. Um das React Native SDK von Stripe zu installieren, führen Sie einen der folgenden Befehle im Verzeichnis Ihres Projekts aus (je nachdem, welchen Paket-Manager Sie verwenden): #### yarn ```bash yarn add @stripe/stripe-react-native ``` #### npm ```bash npm install @stripe/stripe-react-native ``` Installieren Sie als Nächstes einige weitere erforderliche Abhängigkeiten: - Für iOS wechseln Sie in das Verzeichnis **ios** und führen Sie `pod install` aus, um sicherzustellen, dass Sie auch die erforderlichen nativen Dependencies installiert haben. - Für Android müssen keine Abhängigkeiten mehr installiert werden. > Wir empfehlen Ihnen, die [offizielle Anleitung zu TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) zu befolgen, um TypeScript zu unterstützen. ### Stripe Initialisierung Um Stripe in Ihrer React Native-App zu initialisieren, umschließen Sie entweder Ihren Zahlungsbildschirm mit der Komponente `StripeProvider` oder verwenden Sie die Initialisierungsmethode `initStripe`. Nur der [veröffentlichbare API-Schlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) in `publishableKey` ist erforderlich. Das folgende Beispiel zeigt, wie Stripe mithilfe der Komponente `StripeProvider` initialisiert wird. ```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 ( {/* Your app code here */} ); } ``` > Verwenden Sie Ihre API-[Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App. ## Erstellen Sie ein PaymentIntent [Serverseitig] [Clientseitig] ### Serverseitig Stripe verwendet ein Zahlungsobjekt (als [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md) bezeichnet), um sämtliche Status der Zahlung zu dokumentieren und zu verarbeiten, bis sie abgeschlossen ist. Erstellen Sie einen `PaymentIntent` auf Ihrem Server und geben Sie den einzuziehenden Betrag und die Währung an. Falls Sie bereits über eine Integration verfügen, die die [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) verwendet, fügen Sie der Liste der [Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren PaymentIntent die Zahlungsmethode `paypal` hinzu. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" ``` Im zurückgegebenen 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 verwendet wird, um Zahlungen sicher abzuschließen, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Senden Sie das Client-Geheimnis zurück an den Client, damit Sie es in späteren Schritten verwenden können. #### Nutzerdefinierte Beschreibung einfügen Standardmäßig wird in den Bestellungsdetails auf der PayPal-Aktivitätsseite der Nutzerin/des Nutzers der Bestellungsbetrag angezeigt. Sie können das ändern, indem Sie eine nutzerdefinierte Beschreibung in der Eigenschaft `description` angeben. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "description=A sample description" \ -d "payment_method_types[]=paypal" ``` #### Bevorzugtes Gebietsschema anpassen Standardmäßig wird die PayPal-Autorisierungsseite basierend auf Variablen wie z. B. dem Land des Unternehmens lokalisiert. Sie können sie mithilfe der Eigenschaft `preferred_locale` an das bevorzugte Gebietsschema Ihrer Kundinnen und Kunden anpassen. Bei dem Wert muss es sich um einen zweistelligen Sprachcode in Kleinbuchstaben handeln, gefolgt von einem Bindestrich (`-`) und einem zweistelligen Ländercode in Großbuchstaben. Beispiel: Der Wert für eine französischsprachige Person in Belgien ist `fr-BE`. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=eur \ -d "payment_method_types[]=paypal" \ -d "payment_method_options[paypal][preferred_locale]=fr-BE" ``` Sie können die PayPal-Autorisierung über die Eigenschaft [preferred_locale](https://docs.stripe.com/payments/paypal/accept-a-payment.md#customize-the-preferred-locale) auf das bevorzugte Gebietsschema Ihrer Kundin/Ihres Kunden festlegen. Unterstützte Gebietsschemata finden Sie in der folgenden Tabelle: | Wert | Gebietsschema | Land | | ----- | -------------- | ---------------------- | | cs-CZ | Tschechisch | Tschechische Republik | | da-DK | Dänisch | Dänemark | | de-AT | Deutsch | Österreich | | de-DE | Deutsch | Deutschland | | de-LU | Deutsch | Luxemburg | | el-GR | Griechisch | Griechenland | | en-GB | Englisch | Vereinigtes Königreich | | de-DE | Englisch | Vereinigte Staaten | | es-ES | Spanisch | Spanien | | fi-FI | Finnisch | Finnland | | fr-BE | Französisch | Belgien | | fr-FR | Französisch | Frankreich | | fr-LU | Französisch | Luxemburg | | hu-HU | Ungarisch | Ungarn | | it-IT | Italienisch | Italien | | nl-BE | Niederländisch | Belgien | | nl-NL | Niederländisch | Niederlande | | pl-PL | Polnisch | Polen | | pt-PT | Portugiesisch | Portugal | | sk-SK | Slowakisch | Slowakei | | sv-SE | Schwedisch | Schweden | #### Zahlungsbeschreibungen bei PayPal Die Zahlungsbeschreibung auf dem Kontoauszug des Käufers/der Käuferin wird von PayPal festgelegt und lautet standardmäßig `PAYPAL *YOUR_BUSINESS_NAME`. Wenn Sie das Feld `statement_descriptor` beim Erstellen des `PaymentIntent` festlegen, wird sein Wert bis zu 22 Zeichen an den von PayPal festgelegten angehängt. Wenn Ihr Unternehmensname in PayPal beispielsweise `BUSINESS` lautet und Sie `statement_descriptor` auf `order_id_1234` festlegen, sehen die Käufer/innen auf ihrem Kontoauszug die Angabe `PAYPAL *BUSINESS order`. ### Clientseitig Fordern Sie auf dem Client einen PaymentIntent von Ihrem Server an und speichern Sie sein *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)): ```javascript function PaymentScreen() { const fetchPaymentIntentClientSecret = async () => { const response = await fetch(`${API_URL}/create-payment-intent`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ currency: 'eur', }), }); const {clientSecret} = await response.json(); return clientSecret; }; const handlePayPress = async () => { // See below }; return (