# ACH-Lastschriftzahlungen annehmen Erstellen Sie ein nutzerspezifisches Zahlungsformular für die Verwendung mit Stripe Checkout, um Zahlungen per ACH-Lastschrift anzunehmen. # Bezahlvorgang > This is a Bezahlvorgang for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/ach-direct-debit/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-Nutzer/innen in den USA können Checkout im Zahlungsmodus verwenden, um Zahlungen per ACH Direct Debit zu akzeptieren. Eine Checkout-Sitzung repräsentiert die Details der Kaufabsicht Ihres Kunden/Ihrer Kundin. Sie erstellen eine Sitzung, wenn Ihr Kunde/Ihre Kundin für etwas bezahlen möchte. Nachdem Ihre Kundinnen/Kunden zu einer Checkout-Sitzung weitergeleitet wurden, zeigt Stripe ein Zahlungsformular an, von dem aus sie ihren Kauf abschließen können. Nachdem Ihre Kundinnen/Kunden einen Kauf abgeschlossen haben, werden sie wieder auf Ihre Website zurückgeleitet. Mit Checkout können Sie eine Checkout-Sitzung mit `us_bank_account` als Zahlungsmethode erstellen, um alle Zahlungsstatus bis zum Abschluss der Zahlung zu verfolgen und zu verarbeiten. > Beim ACH-Lastschriftverfahren handelt es sich um eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Dies bedeutet, dass Gelder nicht sofort nach der Zahlung verfügbar sind. Eine Zahlung benötigt in der Regel 4 Werktage bis zum Eingang auf Ihrem Konto. ## Kompatibilität bestimmen **Unterstützte Unternehmensstandorte**: US **Unterstützte Währungen**: `usd` **Transaktionswährungen**: `usd` **Zahlungsmodus**: Yes **Einrichtungsmodus**: Yes **Abonnementmodus**: Yes Um ACH Direct Debit-Zahlungen zu unterstützen, stellen Sie sicher, dass Sie 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 in US-Dollar ausdrücken (Währungscode `usd`). ## Kundinnen/Kunden erstellen oder abrufen [Empfohlen] [Serverseitig] > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. #### Accounts v2 Erstellen Sie ein von Kundinnen und Kunden konfiguriertes [Konto](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein bestehendes `Account` ab, das mit diesem/dieser Nutzer/in verknüpft ist. Wenn Sie die ID des `Account`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin oder eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse in das `Account` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl -X POST https://api.stripe.com/v2/core/accounts \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" \ --json '{ "contact_email": "{{CUSTOMER_EMAIL}}" }' ``` #### Customers v1 Erstellen Sie ein *Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein/e bestehende/n `Customer` ab, die/der mit dieser/diesem Nutzer/in verknüpft ist. Wenn Sie die ID des `Customer`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin/eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse für die/den `Customer` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl https://api.stripe.com/v1/customers \ -u "<>:" \ -d email={{CUSTOMER_EMAIL}} ``` ## Zahlung annehmen > Erstellen Sie eine Integration, um [eine Zahlung](https://docs.stripe.com/payments/accept-a-payment.md?integration=checkout) mit Checkout zu akzeptieren, bevor Sie diesen Leitfaden verwenden. Dies führt Sie durch die Aktivierung von ACH Direct Debit und zeigt die Unterschiede zwischen der Annahme von Zahlungen mit dynamischen Zahlungsmethoden und der manuellen Konfiguration von Zahlungsmethoden. ### ACH Direct Debit 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 `us_bank_account` zur Liste der `payment_method_types` hinzu. 1. Stellen Sie sicher, dass alle Ihre `line_items` die Währung `usd` verwenden. #### Von Stripe gehostete Seite #### Accounts v2 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -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]=us_bank_account" \ --data-urlencode "success_url=https://example.com/success" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -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]=us_bank_account" \ --data-urlencode "success_url=https://example.com/success" ``` #### Full embedded page #### Accounts v2 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -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]=us_bank_account" \ --data-urlencode "return_url=https://example.com/return" \ -d ui_mode=embedded_page ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -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]=us_bank_account" \ --data-urlencode "return_url=https://example.com/return" \ -d ui_mode=embedded_page ``` Weitere Informationen zu den Gebühren für Financial Connections finden Sie unter [Preisdetails](https://stripe.com/financial-connections#pricing). Bei der Erfassung von Zahlungsinformationen für Bankkonten wird standardmäßig [Financial Connections](https://docs.stripe.com/financial-connections.md) verwendet, um das Konto Ihres Kunden/Ihrer Kundin sofort zu verifizieren, mit einer Ausweichoption für die manuelle Eingabe der Kontonummer und die Verifizierung von Testeinzahlungen. In der [Financial Connections-Dokumentation](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) erfahren Sie, wie Sie Financial Connections konfigurieren und auf zusätzliche Kontodaten zugreifen, um Ihre ACH-Integration zu optimieren. Beispielsweise können Sie Financial Connections verwenden, um den Kontostand zu prüfen, bevor Sie die ACH-Zahlung veranlassen. > Um den Zugriff auf zusätzliche Daten auszudehnen, nachdem ein/e Kund/in sein/ihr Konto authentifiziert hat, muss er/sie das Konto mit erweiterten Berechtigungen erneut verknüpfen. Wenn der/die Kund/in sich für die Verifizierung der Testeinzahlung statt Financial Connections entscheidet, sendet Stripe automatisch zwei kleine Einzahlungen auf das angegebene Bankkonto. Es kann 1-2 Werktage dauern, bis diese Einzahlungen auf dem Online-Auszug des Kunden/der Kundin erscheinen. Wenn das Eintreffen der Einzahlungen erwartet wird, erhält der/die Kund/in eine E-Mail mit einem Link, um diese Beträge zu bestätigen und das Bankkonto bei Stripe zu verifizieren. Nach abgeschlossener Verifizierung, wird mit der Verarbeitung der Zahlung begonnen. Wir empfehlen, bei der Erstellung einer Zahlungssitzung für ACH-Lastschrift den Parameter [payment_intent_data.setup_future_usage](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-setup_future_usage) mit dem Wert `off_session` anzugeben, damit Sie die [Zahlungsmethoden-Details speichern](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted#save-payment-method-details) können. ### Wickeln Sie Ihre Bestellungen ab Informieren Sie sich über die [Ausführung von Bestellungen](https://docs.stripe.com/checkout/fulfillment.md), nachdem Sie eine Zahlung ausgeführt haben. ## Integration testen Erfahren Sie, wie Sie Szenarien mit sofortigen Verifizierungen mithilfe von [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts) testen können. ### Transaktions-E-Mails in einer Sandbox senden Nachdem Sie die Bankkontodetails erfasst und ein Mandat akzeptiert haben, senden Sie die Mandatsbestätigung und die Verifizierungs-E-Mails mit Testeinzahlungen in einer *Sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes). Wenn Ihre Domain **{domain}** lautet und Ihr Benutzername **{username}** ist, verwenden Sie das folgende E-Mail-Format, um Test-Transaktions-E-Mails zu versenden: **{username}+test\_email@{domain}**. Wenn Ihre Domain beispielsweise **example.com** und Ihr Nutzername **Info** lautet, verwenden Sie zum Testen von ACH Direct Debit-Zahlungen das Format **info+test\_email@example.com**. Dieses Format stellt sicher, dass E-Mails korrekt weitergeleitet werden. Wenn Sie das Suffix **+test\_email** nicht angeben, senden wir die E-Mail nicht. > Sie müssen [Ihr Stripe-Konto einrichten](https://docs.stripe.com/get-started/account/set-up.md), bevor Sie diese E-Mails während Tests auslösen können. ### Testkontonummern Stripe stellt mehrere Testkontonummern und dazugehörige Token zur Verfügung, um sicherzustellen, dass Ihre Integration für Bankkonten mit manueller Eingabe für den Einsatz in einer Produktionsumgebung bereit ist. | Kontonummer | Token | Bankleitzahl | Verhalten | | -------------- | -------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000123456789` | `pm_usBankAccount_success` | `110000000` | Die Zahlung ist erfolgreich. | | `000111111113` | `pm_usBankAccount_accountClosed` | `110000000` | Die Zahlung schlägt fehl, weil das Konto geschlossen ist. | | `000000004954` | `pm_usBankAccount_riskLevelHighest` | `110000000` | Die Zahlung wird von Radar aufgrund eines [hohen Betrugsrisikos](https://docs.stripe.com/radar/risk-evaluation.md#high-risk) blockiert. | | `000111111116` | `pm_usBankAccount_noAccount` | `110000000` | Die Zahlung schlägt fehl, weil kein Konto gefunden wird. | | `000222222227` | `pm_usBankAccount_insufficientFunds` | `110000000` | Die Zahlung schlägt aufgrund unzureichender Deckung fehl. | | `000333333335` | `pm_usBankAccount_debitNotAuthorized` | `110000000` | Die Zahlung schlägt fehl, weil die Lastschriften nicht autorisiert sind. | | `000444444440` | `pm_usBankAccount_invalidCurrency` | `110000000` | Die Zahlung schlägt aufgrund einer ungültigen Währung fehl. | | `000666666661` | `pm_usBankAccount_failMicrodeposits` | `110000000` | Die Zahlung sendet keine Testeinzahlungen. | | `000555555559` | `pm_usBankAccount_dispute` | `110000000` | Die Zahlung löst eine Zahlungsanfechtung aus. | | `000000000009` | `pm_usBankAccount_processing` | `110000000` | Die Zahlung bleibt auf unbestimmte Zeit in Bearbeitung. Nützlich zum Testen [der Stornierung des PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md). | | `000777777771` | `pm_usBankAccount_weeklyLimitExceeded` | `110000000` | Die Zahlung schlägt aufgrund des Zahlungsbetrags fehl, wodurch das Konto sein wöchentliches Zahlungsvolumenlimit überschreitet. | | `000888888885` | | `110000000` | Die Zahlung schlägt aufgrund einer deaktivierten [tokenisierten Kontonummer](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) fehl. | Bevor Testtransaktionen abgeschlossen werden können, müssen Sie alle Testkonten verifizieren, auf denen die Zahlung automatisch erfolgreich war oder fehlschlagen ist. Verwenden Sie dazu die nachstehenden Test-Mikroeinzahlungsbeträge oder Beschreibungscodes. ### Testen von Mikroeinzahlungen und Beschreibungscodes Um verschiedene Szenarien zu imitieren, verwenden Sie diese Mikroeinzahlungsbeträge *oder* 0,01 Beschreibungscodewerte. | Testeinzahlungswerte | 0.01 Beschreibungscodewerte | Szenario | | -------------------- | --------------------------- | ------------------------------------------------------------------------- | | `32` und `45` | SM11AA | Simuliert die Verifizierung des Kontos. | | `10` und `11` | SM33CC | Simuliert das Überschreiten der Anzahl zulässiger Verifizierungsversuche. | | `40` und `41` | SM44DD | Simuliert ein Testeinzahlungs-Timeout. | ### Abwicklungsverhalten testen Testtransaktionen werden sofort abgewickelt und Ihrem verfügbaren Testguthaben hinzugefügt. Dieses Verhalten unterscheidet sich vom Live-Modus, bei dem es [mehrere Tage](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Zusätzliche Überlegungen ### Fehlschlagen der Verifizierung einer Testeinzahlung Wenn die Verifizierung eines Bankkontos mittels Testeinzahlungen noch aussteht, kann die Verifizierung durch die Kundin/den Kunden aus drei Gründen fehlschlagen: - Die Testeinzahlungen haben das Kundenbankkonto nicht erreicht. (Dies weist in der Regel auf ein geschlossenes/nicht verfügbares Bankkonto oder eine falsche Kontonummer hin). - Die Verifizierungsversuche des Kontos durch die Kundin/den Kunden sind 10 mal fehlgeschlagen. Wird diese Grenze überschritten, kann das Bankkonto nicht mehr verifiziert oder erneut verwendet werden. - Die Kundin/der Kunde hat das Bankkonto nicht innerhalb der Frist von 10 Tagen verifiziert. Wenn die Verifizierung des Bankkontos aus einem der genannten Gründe fehlschlägt, können Sie [das Ereignis `checkout.session.async_payment_failed` verarbeiten](https://docs.stripe.com/api/events/types.md?event_types-invoice.payment_succeeded=#event_types-checkout.session.async_payment_failed), um den Kunden/die Kundin zum Aufgeben einer neuen Bestellung aufzufordern. ## Optional: Nur Sofortverifizierung Standardmäßig können Ihre Kund/innen bei Verwendung von ACH-Lastschriftzahlungen die sofortige Bankkontoverifizierung oder Testeinzahlungen nutzen. Optional können Sie die sofortige Verifizierung des Bankkontos nur mit dem Parameter `payment_method_options[us_bank_account][verification_method]` verlangen, wenn Sie die Checkout-Sitzung erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=payment \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ -d "line_items[0][price_data][currency]=usd" \ -d "line_items[0][price_data][unit_amount]=2000" \ -d "line_items[0][price_data][product_data][name]=T-shirt" \ -d "line_items[0][quantity]=1" \ --data-urlencode "success_url=https://example.com/success" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=payment \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ -d "line_items[0][price_data][currency]=usd" \ -d "line_items[0][price_data][unit_amount]=2000" \ -d "line_items[0][price_data][product_data][name]=T-shirt" \ -d "line_items[0][quantity]=1" \ --data-urlencode "success_url=https://example.com/success" ``` ## Optional: Auf Daten für ein Financial Connections-Bankkonto zugreifen Sie können nur dann auf Financial Connections-Daten zugreifen, wenn Sie beim Erstellen Ihres/Ihrer PaymentIntent zusätzliche [Datenberechtigungen](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) anfordern. Nachdem Ihre Kundinnen und Kunden den Bezahlvorgang erfolgreich abgeschlossen haben, enthält die zurückgegebene PaymentMethod `us_bank_account` eine [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account)-ID, die auf ein [Financial Connections-Konto](https://docs.stripe.com/api/financial_connections/accounts.md) verweist. Verwenden Sie diese ID, um auf Kontodaten zuzugreifen. > Bankkonten, die Ihre Kunden/Kundinnen durch manuelle Eingabe verknüpfen, und Testeinzahlungen haben keine `financial_connections_account` auf der Zahlungsmethode. Um die Financial Connections-Konto-ID zu ermitteln, rufen Sie die Checkout-Sitzung ab und erweitern Sie das Attribut `payment_intent.payment_method`: ```curl curl -G https://api.stripe.com/v1/checkout/sessions/{{CHECKOUTSESSION_ID}} \ -u "<>:" \ -d "expand[]=payment_intent.payment_method" ``` ```json { "id": "{{CHECKOUT_SESSION_ID}}", "object": "checkout.session", // ... "payment_intent": { "id": "{{PAYMENT_INTENT_ID}}", "object": "payment_intent", // ... "payment_method": { "id": "{{PAYMENT_METHOD_ID}}", // ... "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}", "fingerprint": "q9qchffggRjlX2tb", "last4": "6789", "routing_number": "110000000" } } // ... } } ``` Erfahren Sie mehr über die Verwendung zusätzlicher Kontodaten zur Optimierung Ihrer ACH-Integration mit [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize). ## Optional: Zahlungsanfechtungen beilegen [Serverseitig] Kundinnen/Kunden [fechten eine ACH-Lastschriftahlung](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#resolving-disputes) im Allgemeinen über ihre Bank an. Dies geschieht in der Regel bis zu 60 Kalendertage nach einer Abbuchung auf einem Privatkonto oder bis zu 2 Werktage bei einem Geschäftskonto. In seltenen Fällen können Kundinnen und Kunden die Lastschriftzahlung auch außerhalb dieser Fristen erfolgreich anfechten. Wenn Kundinnen/Kunden eine Zahlung anfechten, sendet Stripe das Webhook-Ereignis [charge.dispute.closed](https://docs.stripe.com/api/events/types.md#event_types-charge.dispute.closed), und die PaymentMethod-Autorisierung wird widerrufen. In seltenen Fällen erhält Stripe möglicherweise einen ACH-Fehler von der Bank, nachdem ein PaymentIntent in den Status `succeeded` gewechselt ist. In diesem Fall erstellt Stripe eine Zahlungsanfechtung mit folgendem `reason`: - `insufficient_funds` - `incorrect_account_details` - `bank_can't_process` Stripe erhebt in diesem Fall eine Fehlergebühr. Zukünftige Zahlungen, die diese PaymentMethod wiederverwenden, geben den folgenden Fehler zurück: ```javascript { "error": { "message": "This PaymentIntent requires a mandate, but no existing mandate was found. Collect mandate acceptance from the customer and try again, providing acceptance data in the mandate_data parameter.", "payment_intent": { ... } "type": "invalid_request_error" } } ``` Dieser Fehler enthält einen PaymentIntent im Status `requires_confirmation`. Um mit der Zahlung fortzufahren, müssen Sie: 1. Legen Sie die Zahlungsanfechtung mit dem Kunden/der Kundin bei, um sicherzustellen, dass zukünftige Zahlungen nicht angefochten werden. 1. Bestätigen Sie die Autorisierung Ihres Kunden/Ihrer Kundin erneut. Um die Autorisierung der Zahlung zu bestätigen, können Sie [mit Stripe.js online eine Mandatsbestätigung von Ihrem Kunden/Ihrer Kundin einholen](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=web#web-collect-mandate-and-submit) oder die Autorisierung mit Ihrem Kunden/Ihrer Kundin offline über die Stripe API bestätigen. > Wenn ein/e Kund/in mehr als eine Zahlung von demselben Bankkonto anficht, sperrt Stripe sein/ihr Bankkonto. Wenden Sie sich an den [Stripe-Support](https://support.stripe.com/?contact=true), um zusätzliche Hilfe zu erhalten. ```curl curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \ -u "<>:" \ -d "mandate_data[customer_acceptance][type]=offline" ``` ## Optional: Zahlungsreferenz Die Zahlungsreferenznummer ist ein von der Bank generierter Wert, mit dem der/die Kontoinhaber/in Gelder bei seiner/ihrer Bank finden kann. Wenn die Zahlung erfolgreich ist, gibt Stripe die Zahlungsreferenznummer im Dashboard und im [Zahlungsobjekt](https://docs.stripe.com/api/charges/object.md) an. | Status der Abbuchung | Zahlungsreferenzwert | | -------------------- | ---------------------------------------- | | Ausstehend | Nicht verfügbar | | Fehlgeschlagen | Nicht verfügbar | | Erfolgreich | Verfügbar (zum Beispiel 091000015001234) | Wenn Sie den Webhook `charge.succeeded` erhalten, zeigen Sie außerdem den Inhalt von `payment_method_details` an, um die [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference) zu finden. Das folgende Beispielereignis zeigt das Rendern einer erfolgreichen ACH-Zahlung mit einer Zahlungsreferenznummer. #### charge-succeeded ```json { "id": "{{EVENT_ID}}", "object": "event", // omitted some fields in the example "type": "charge.succeeded", "data": { "object": { "id": "{{PAYMENT_ID}}", "object": "charge", //... "paid": true, "payment_intent": "{{PAYMENT_INTENT_ID}}", "payment_method": "{{PAYMENT_METHOD_ID}}", "payment_method_details": { "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK", "fingerprint": "Ih3foEnRvLXShyfB", "last4": "1000","payment_reference": "091000015001234", "routing_number": "110000000" } } // ... } } } ``` Zeigen Sie den Inhalt der `destination_details` an, um die [Rückerstattungsreferenz](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) zu finden, die den erstatteten ACH-Zahlungen zugeordnet ist. Das folgende Beispielereignis zeigt das Rendering einer erfolgreichen ACH-Rückerstattung mit einer Rückerstattungsreferenznummer. Weitere Informationen zu [Rückerstattungen](https://docs.stripe.com/refunds.md). #### charge-refund-updated ```json { "id": "{{EVENT_ID}}", "object": "event", "type": "charge.refund.updated", "data": { "object": { "id": "{{REFUND_ID}}", "object": "refund", //... "payment_intent": "{{PAYMENT_INTENT_ID}}", "destination_details": { "type": "us_bank_transfer", "us_bank_transfer": {"reference": "091000015001111", "reference_status": "available" } } // ... } } } ``` ## Optional: Abbuchungsdatum für Kunde/Kundin konfigurieren [Serverseitig] Mit dem [Zieldatum](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-target_date) können Sie das Datum steuern, an dem Stripe das Bankkonto einer Kundin oder eines Kunden belastet. Das Zieldatum muss mindestens drei Tage in der Zukunft und maximal 15 Tage nach dem aktuellen Datum liegen. Mit dem Zieldatum wird geplant, dass das Geld das Konto der Kundin oder des Kunden am Zieldatum verlässt. Zieldaten, die eines der folgenden Kriterien erfüllen, verzögern die Abbuchung bis zum nächsten verfügbaren Werktag: - Das Zieldatum fällt auf ein Wochenende, einen Feiertag oder einen anderen arbeitsfreien Tag. - Das Zieldatum liegt weniger als drei Werktage in der Zukunft. Dieser Parameter wird auf Best-Effort-Basis ausgeführt. Es kann sein, dass die Bank jedes Kunden/jeder Kundin die Abbuchungen je nach örtlichen Feiertagen oder aus anderen Gründen zu unterschiedlichen Terminen vornimmt. > Sie können die [Verifizierungsmethode](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-verification_method) nicht auf `Mikroeinzahlungen` festlegen, wenn Sie ein [Zieldatum](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-target_date) verwenden, da die Dauer des Verifizierungsprozesses das Zieldatum überschreiten könnte und Zahlungen dann später als erwartet eintreffen könnten. ## See also - [Vorab autorisierte ACH-Lastschriftzahlungen für zukünftige Zahlungen speichern](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md) # Checkout Sessions API > This is a Checkout Sessions API for when payment-ui is elements and api-integration is checkout. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=elements&api-integration=checkout. Informationen dazu, welche API den Anforderungen Ihres Unternehmens entspricht, finden Sie im [Vergleichsleitfaden](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md). Verwenden Sie das [Payment Element](https://docs.stripe.com/payments/payment-element.md), um ein nutzerdefiniertes Stripe-Zahlungsformular in Ihre Website oder Anwendung einzubetten und Kundinnen und Kunden Zahlungsmethoden anzubieten. Erweiterte Konfigurationen und Anpassungen finden Sie im Integrationsleitfaden für die [Zahlungsannahme](https://docs.stripe.com/payments/accept-a-payment.md) Bevor Sie ACH Direct Debit in Ihrer Payment Element-Integration verwenden, beschäftigen Sie sich mit den folgenden Überlegungen zu ACH Direct Debit: - Erfahren Sie mehr über die [Mandatserteilung](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#mandate-collection). - Wählen Sie aus, wie Sie [Bankkonten verifizieren](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#bank-verification). > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. ### Mandatserteilung Wenn Sie ACH-Zahlungen annehmen, müssen Sie Mandate kennen. Sofern Sie keine direkte API-Integration verwenden, übernimmt Stripe die Mandatserfassung und -speicherung für Ihr Unternehmen, um sicherzustellen, dass die gesetzlichen Anforderungen erfüllt werden. Wenn ein Kunde/eine Kundin während des Zahlungsvorgangs das Mandat akzeptiert, speichert Stripe diese Informationen automatisch und sie werden für Sie über Ihr Dashboard verfügbar. ## Server einrichten [Serverseitig] Verwenden Sie die offiziellen Bibliotheken von Stripe, um von Ihrer Anwendung aus auf die API zuzugreifen. #### 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' ``` ## Checkout-Sitzung erstellen [Serverseitig] Fügen Sie einen Endpoint auf Ihrem Server hinzu, der eine [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions/create.md) erstellt und sein [Client-Geheimnis](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-client_secret) an Ihr Frontend zurückgibt. Eine Checkout-Sitzung stellt die Sitzung Ihres Kunden/Ihrer Kundin dar, während er/sie per Checkout für einmalige Käufe oder Abonnements bezahlt. Checkout-Sitzungen laufen 24 Stunden nach Erstellung ab. Wir empfehlen die Verwendung [dynamischer Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md), um allen Kundinnen und Kunden dynamisch die relevantesten infrage kommenden Zahlungsmethoden anzuzeigen und die Konversionsrate zu maximieren. Sie können [Zahlungsmethoden auch manuell auflisten](https://docs.stripe.com/payments/payment-methods/integration-options.md#listing-payment-methods-manually), wodurch dynamische Zahlungsmethoden deaktiviert werden. #### Zahlungsmethoden über das Dashboard verwalten #### TypeScript ```javascript import express, {Express} from 'express'; const app: Express = express(); app.post('/create-checkout-session', async (req: Express.Request, res: Express.Response) => { const session = await stripe.checkout.sessions.create({ line_items: [ { price_data: { currency: 'usd', product_data: { name: 'T-shirt', }, unit_amount: 2000, }, quantity: 1, }, ], mode: 'payment',ui_mode: 'elements', // The URL of your payment completion page return_url: 'https://example.com/return?session_id={CHECKOUT_SESSION_ID}' }); res.json({checkoutSessionClientSecret: session.client_secret}); }); app.listen(3000, () => { console.log('Running on port 3000'); }); ``` #### Zahlungsmethoden manuell auflisten Um eine Zahlung manuell aufzulisten, geben Sie sie in [payment_method_types](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_method_types) an, wenn Sie einen [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md) erstellen. Wenn Sie `line_items` in unterschiedlichen Währungen haben, müssen Sie separate Checkout-Sitzungen erstellen. #### TypeScript ```javascript import express, {Express} from 'express'; const app: Express = express(); app.post('/create-checkout-session', async (req: Express.Request, res: Express.Response) => { const session = await stripe.checkout.sessions.create({ line_items: [ { price_data: { currency: 'usd', product_data: { name: 'T-shirt', }, unit_amount: 1099, }, quantity: 1, }, ], mode: 'payment', ui_mode: 'elements', payment_method_types: ['us_bank_account'], return_url: 'https://example.com/return?session_id={CHECKOUT_SESSION_ID}' }); res.json({checkoutSessionClientSecret: session.client_secret}); }); app.listen(3000, () => { console.log('Running on port 3000'); }); ``` ## Frontend einrichten [Clientseitig] #### HTML + JS Fügen Sie das Stripe.js-Skript auf Ihrer Bezahlseite ein, indem Sie es zum `head` der HTML-Datei hinzufügen. Laden Sie Stripe.js immer direkt von js.stripe.com, um PCI-konform zu bleiben. Fügen Sie das Skript nicht in ein Paket ein und hosten Sie selbst keine Kopie davon. Vergewissern Sie sich, dass Sie die neueste Version von Stripe.js verwenden, indem Sie das folgende Skript-Tag `` einfügen. Erfahren Sie mehr über die [Versionsverwaltung von Stripe.js](https://docs.stripe.com/sdks/stripejs-versioning.md). ```html Checkout ``` > Stripe stellt ein npm-Paket bereit, mit dem Sie Stripe.js als Modul laden können. Siehe das [Projekt auf GitHub](https://github.com/stripe/stripe-js). Version [7.0.0](https://www.npmjs.com/package/%40stripe/stripe-js/v/7.0.0) oder höher ist erforderlich. Initialisieren Sie Stripe.js. ```js // 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( '<>', ); ``` #### React Installieren Sie [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) und den [Stripe.js Loader](https://www.npmjs.com/package/@stripe/stripe-js) aus der öffentlichen npm-Registry. Sie benötigen mindestens Version 5.0.0 für React Stripe.js und Version 8.0.0 für den Stripe.js-Loader. ```bash npm install --save @stripe/react-stripe-js@^5.0.0 @stripe/stripe-js@^8.0.0 ``` Initialisieren Sie eine `stripe`-Instanz auf Ihrem Frontend mit Ihrem veröffentlichbaren Schlüssel. ```javascript import {loadStripe} from '@stripe/stripe-js'; const stripe = loadStripe("<>"); ``` ## Checkout initialisieren [Clientseitig] #### HTML + JS Rufen Sie [initCheckoutElementsSdk](https://docs.stripe.com/js/custom_checkout/init) auf und übergeben Sie `clientSecret`. `initCheckoutElementsSdk` gibt ein [Checkout](https://docs.stripe.com/js/custom_checkout)-Objekt zurück, das Daten aus der Checkout-Session und Methoden zur Aktualisierung enthält. Lesen Sie `total` und `lineItems` aus [actions.getSession()](https://docs.stripe.com/js/custom_checkout/session) und zeigen Sie sie in Ihrer Benutzeroberfläche an. So können Sie neue Funktionen mit minimalen Codeänderungen aktivieren. Zum Beispiel erfordert das Hinzufügen [manueller Währungspreise](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) keine UI-Änderungen, wenn `total` angezeigt wird. ```html
``` ```javascript const clientSecret = fetch('/create-checkout-session', {method: 'POST'}) .then((response) => response.json()) .then((json) => json.client_secret); const checkout = stripe.initCheckoutElementsSdk({clientSecret}); const loadActionsResult = await checkout.loadActions(); if (loadActionsResult.type === 'success') { const session = loadActionsResult.actions.getSession(); const checkoutContainer = document.getElementById('checkout-container'); checkoutContainer.append(JSON.stringify(session.lineItems, null, 2)); checkoutContainer.append(document.createElement('br')); checkoutContainer.append(`Total: ${session.total.total.amount}`); } ``` #### React Umhüllen Sie Ihre Anwendung mit der Komponente [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider) und übergeben Sie dabei `clientSecret` und die `Stripe`-Instanz. ```jsx import React from 'react'; import {CheckoutElementsProvider} from '@stripe/react-stripe-js/checkout'; import CheckoutForm from './CheckoutForm'; const clientSecret = fetch('/create-checkout-session', {method: 'POST'}) .then((response) => response.json()) .then((json) => json.client_secret); const App = () => { return ( ); }; export default App; ``` Greifen Sie auf das [Checkout](https://docs.stripe.com/js/custom_checkout)-Objekt in Ihrer Checkout-Formularkomponente, indem Sie den `useCheckoutElements()`-Hook verwenden. Das `Checkout`-Objekt enthält Daten aus der Checkout-Sitzung und Methoden zu ihrer Aktualisierung. Lesen Sie `total` und `lineItems` aus dem `Checkout`-Objekt und zeigen Sie sie in Ihrer Benutzeroberfläche an. So können Sie Funktionen mit minimalen Codeänderungen aktivieren. Zum Beispiel erfordert das Hinzufügen [manueller Währungspreise](https://docs.stripe.com/payments/custom/localize-prices/manual-currency-prices.md) keine UI-Änderungen, wenn `total` angezeigt wird. ```jsx import React from 'react'; import {useCheckoutElements} from '@stripe/react-stripe-js/checkout'; const CheckoutForm = () => {const checkoutState = useCheckoutElements(); if (checkoutState.type === 'loading') { return (
Loading...
); } if (checkoutState.type === 'error') { return (
Error: {checkoutState.error.message}
); } return (
{JSON.stringify(checkoutState.checkout.lineItems, null, 2)} {/* A formatted total amount */} Total: {checkoutState.checkout.total.total.amount}
); }; ``` ## E-Mail-Adressen von Kundinnen/Kunden erfassen [Clientseitig] #### HTML + JS Bitte geben Sie beim Abschluss einer Checkout-Sitzung eine gültige E-Mail-Adresse an. Diese Anweisungen erstellen eine E-Mail-Eingabe und verwenden [updateEmail](https://docs.stripe.com/js/custom_checkout/update_email) aus dem Objekt `Checkout`. Alternativ können Sie: - Übergeben Sie die Werte [Kunde_E-Mail](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email), [Kunden_Konto](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_account) (für Kundinnen und Kunden, die als kundenkonfigurierte `Account`-Objekte dargestellt werden), oder [Kundin/Kunde](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) (für Kundinnen und Kunden, die `Customer`-Objekte dargestellt werden), wenn Sie die Checkout-Session erstellen. Stripe validiert E-Mail-Adressen, die in dieser Weise bereitgestellt werden. - Geben Sie eine E-Mail-Adresse ein, die Sie bereits bei [checkout.confirm](https://docs.stripe.com/js/custom_checkout/confirm) validiert haben. ```html
``` ```javascript const checkout = stripe.initCheckoutElementsSdk({clientSecret}); const loadActionsResult = await checkout.loadActions(); if (loadActionsResult.type === 'success') { const {actions} = loadActionsResult; const emailInput = document.getElementById('email'); const emailErrors = document.getElementById('email-errors'); emailInput.addEventListener('input', () => { // Clear any validation errors emailErrors.textContent = ''; }); emailInput.addEventListener('blur', () => { const newEmail = emailInput.value;actions.updateEmail(newEmail).then((result) => { if (result.error) { emailErrors.textContent = result.error.message; } }); }); } ``` #### React Bitte geben Sie beim Abschluss einer Checkout-Sitzung eine gültige E-Mail-Adresse an. Diese Anweisungen erstellen eine E-Mail-Eingabe und verwenden [updateEmail](https://docs.stripe.com/js/react_stripe_js/checkout/update_email) aus dem Objekt `Checkout`. Alternativ können Sie: - Übergeben Sie die Werte [Kunde_E-Mail](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_email), [Kunden_Konto](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_account) (für Kundinnen und Kunden, die als kundenkonfigurierte `Account`-Objekte dargestellt werden), oder [Kundin/Kunde](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer) (für Kundinnen und Kunden, die `Customer`-Objekte dargestellt werden), wenn Sie die Checkout-Session erstellen. Stripe validiert E-Mail-Adressen, die in dieser Weise bereitgestellt werden. - Geben Sie eine E-Mail-Adresse ein, die Sie bereits auf [confirm](https://docs.stripe.com/js/react_stripe_js/checkout/confirm) validiert haben. ```jsx import React from 'react'; import {useCheckoutElements} from '@stripe/react-stripe-js/checkout'; const EmailInput = () => { const checkoutState = useCheckoutElements(); const [email, setEmail] = React.useState(''); const [error, setError] = React.useState(null); if (checkoutState.type === 'loading') { return (
Loading...
); } else if (checkoutState.type === 'error') { return (
Error: {checkoutState.error.message}
); } const handleBlur = () => {checkoutState.checkout.updateEmail(email).then((result) => { if (result.type === 'error') { setError(result.error); } }) }; const handleChange = (e) => { setError(null); setEmail(e.target.value); }; return (
{error &&
{error.message}
}
); }; export default EmailInput; ``` ## Zahlungsdaten erfassen [Clientseitig] Erfassen Sie Zahlungsdetails auf dem Client mit dem [Payment Element](https://docs.stripe.com/payments/payment-element.md). Das Payment Element ist eine vorgefertigte Komponente der Nutzeroberfläche, das die Erfassung von Zahlungsdaten für verschiedene Zahlungsmethoden vereinfacht. Das Payment Element enthält einen iFrame, der Zahlungsinformationen über eine sichere HTTPS-Verbindung an Stripe sendet. Vermeiden Sie es, das Payment Element in einem anderen iFrame zu platzieren, da einige Zahlungsmethoden die Weiterleitung an eine andere Seite zur Zahlungsbestätigung voraussetzen. Wenn Sie sich für die Verwendung eines Iframes entscheiden und Apple Pay oder Google Pay akzeptieren möchten, muss das Attribut [Zulassen](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-allowpaymentrequest) des Iframes auf `"payment*"` gesetzt sein. Die Adresse der Bezahlseite muss mit `https://` beginnen, nicht mit `http://`, damit Ihre Integration funktioniert. Sie können Ihre Integration ohne HTTPS testen. Denken Sie jedoch daran, dieses zu [aktivieren](https://docs.stripe.com/security/guide.md#tls), wenn Sie bereit sind, Live-Zahlungen zu akzeptieren. #### HTML + JS Erstellen Sie zunächst ein Container-DOM-Element, um das [Payment Element](https://docs.stripe.com/payments/payment-element.md) zu verbinden. Erstellen Sie dann eine Instanz des `Payment Element` mit [checkout.createPaymentElement](https://docs.stripe.com/js/custom_checkout/create_payment_element) und verbinden Sie es durch Aufrufen von [element.mount](https://docs.stripe.com/js/element/mount), wobei Sie entweder einen CSS-Selektor oder das Container-DOM-Element angeben. ```html
``` ```javascript const paymentElement = checkout.createPaymentElement(); paymentElement.mount('#payment-element'); ``` Die unterstützten Optionen finden Sie in der [Stripe.js-Dokumentation](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options). Sie können das [Erscheinungsbild](https://docs.stripe.com/payments/checkout/customization/appearance.md) aller Elements anpassen, indem Sie [elementsOptions.appearance](https://docs.stripe.com/js/custom_checkout/init#custom_checkout_init-options-elementsOptions-appearance) übergeben, wenn Sie Checkout im Frontend initialisieren. #### React Integrieren Sie die Komponente [Payment Element](https://docs.stripe.com/payments/payment-element.md) in den [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider). ```jsx import React from 'react';import {PaymentElement, useCheckoutElements} from '@stripe/react-stripe-js/checkout'; const CheckoutForm = () => { const checkoutState = useCheckoutElements(); if (checkoutState.type === 'loading') { return (
Loading...
); } if (checkoutState.type === 'error') { return (
Error: {checkoutState.error.message}
); } return (
{JSON.stringify(checkoutState.checkout.lineItems, null, 2)} {/* A formatted total amount */} Total: {checkoutState.checkout.total.total.amount} ); }; export default CheckoutForm; ``` Die unterstützten Optionen finden Sie in der [Stripe.js-Dokumentation](https://docs.stripe.com/js/custom_checkout/create_payment_element#custom_checkout_create_payment_element-options). Sie können das [Erscheinungsbild aller Elemente anpassen](https://docs.stripe.com/payments/checkout/customization/appearance.md), indem Sie [elementsOptions.appearance](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider#react_checkout_provider-options-elementsOptions-appearance) an den [CheckoutElementsProvider](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider) übergeben. ## Bankkonten verifizieren #### Item 1 Informationen zu Gebühren für Financial Connections finden Sie unter [Preisübersicht](https://stripe.com/financial-connections#pricing). Bei der Bankkontoverifizierung werden standardmäßig Zahlungsinformationen über [Financial Connections](https://docs.stripe.com/financial-connections.md) automatisch verifiziert. Es sind keine Änderungen erforderlich, um sie zu verwenden. Sie können Ihre Verifizierungsmethode ändern, indem Sie `payment_method_options[us_bank_account][verification_method]` beim Erstellen der Checkout-Sitzung auf `instant` setzen, damit alle Nutzer/innen ihre Bankkonten mit Financial Connections verifizieren. Informationen dazu, wie Sie Financial Connections konfigurieren und auf zusätzliche Kontodaten zugreifen, um beispielsweise vor dem Initiieren einer Zahlung den Kontostand zu prüfen, finden Sie unter [Financial Connections](https://docs.stripe.com/financial-connections.md). #### Automatisch (Standardeinstellung) Bei der Erfassung von Zahlungsinformationen für Bankkonten wird standardmäßig [Financial Connections](https://docs.stripe.com/financial-connections.md) verwendet, um das Konto Ihres Kunden/Ihrer Kundin sofort zu verifizieren. Wenn eine sofortige Verifizierung nicht möglich ist, wird auf die manuelle Eingabe der Kontonummer und die Verifizierung von Testeinzahlungen zurückgegriffen. > Um den Zugriff auf zusätzliche Daten auszudehnen, nachdem ein Kunde/eine Kundin sein/ihr Konto authentifiziert hat, muss der Kunde/die Kundin sein/ihr Konto mit erweiterten Berechtigungen erneut verknüpfen. Diese Authentifizierung erfolgt einmal pro Kunde/Kundin, und die dadurch gewährte Berechtigung kann wiederverwendet werden. **Verifizierung von Testeinzahlungen**: Nicht alle Kundinnen/Kunden können ihr Bankkonto sofort verifizieren. Dieser Abschnitt gilt nur, wenn Ihre Kundin/Ihr Kunde die sofortige Verifizierung im vorherigen Schritt deaktiviert hat. In diesen Fällen sendet Stripe stattdessen 1 bis 2 Testeinzahlungen zur Verifizierung an das Bankkonto eines Kunden/einer Kundin. Es dauert 1 bis 2 Werktage, bis Einzahlungen auf der Online-Abrechnung des Kunden/der Kundin erscheinen. Es gibt zwei Arten von Testeinzahlungen: - **Beschreibungscode** (Standard): Stripe sendet eine Testeinzahlung in Höhe von 0,01 USD mit einem eindeutigen 6-stelligen `descriptor_code`, der mit SM beginnt, auf das Bankkonto des Kunden/der Kundin. Ihre Kundinnen/Kunden verwenden diesen Code, um ihr Bankkonto zu verifizieren. - **Betrag**: Stripe sendet zwei nicht eindeutige Testeinzahlungen mit `ACCTVERIFY` als Zahlungsbeschreibung in der Abrechnung an das Bankkonto des Kunden/der Kundin Ihr Kunde/Ihre Kundin verwendet die Einzahlungsbeträge, um sein/ihr Bankkonto zu verifizieren. **Verifizierung von Testeinzahlungen fehlgeschlagen**: Wenn die Verifizierung eines Bankkontos mittels Testeinzahlungen noch aussteht, kann die Verifizierung aus verschiedenen Gründen fehlschlagen: - Die Testeinzahlungen gehen nicht auf dem Bankkonto der Kundin/des Kunden ein (dies weist in der Regel auf ein geschlossenes/nicht verfügbares Bankkonto oder eine falsche Bankkontonummer hin). - Der Kunde/die Kundin überschreitet das Limit der Verifizierungsversuche für das Konto. Wird dieses Limit überschritten, kann das Bankkonto nicht mehr verifiziert oder erneut verwendet werden. - Der Kunde/die Kundin hat die Verifizierung nicht innerhalb von 10 Tagen abgeschlossen. #### Sofort Mithilfe der sofortigen Verifzierung können Sie durchsetzen, dass alle Ihre Kundinnen und Kunden ihre Bankkonten mit Financial Connections verifizieren. Um die sofortige Verifizierung zu verwenden, legen Sie den Parameter `payment_method_options[us_bank_account][verification_method]` auf `instant` fest, wenn Sie eine Checkout-Sitzung erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -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 ui_mode=elements \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ --data-urlencode "return_url=https://example.com/return?session_id={CHECKOUT_SESSION_ID}" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -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 ui_mode=elements \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ --data-urlencode "return_url=https://example.com/return?session_id={CHECKOUT_SESSION_ID}" ``` Auf Client-Seite verwendet das durch `checkout.createPaymentElement()` erstellte Payment Element automatisch die in der Checkout-Sitzung konfigurierte Verifizierungsmethode. Es ist keine zusätzliche Konfiguration erforderlich. #### Item 2 Informationen zu Gebühren für Financial Connections finden Sie unter [Preisübersicht](https://stripe.com/financial-connections#pricing). Bei der Bankkontoverifizierung werden standardmäßig Zahlungsinformationen über [Financial Connections](https://docs.stripe.com/financial-connections.md) automatisch verifiziert. Es sind keine Änderungen erforderlich, um sie zu verwenden. Sie können Ihre Verifizierungsmethode ändern, indem Sie `payment_method_options[us_bank_account][verification_method]` beim Erstellen der Checkout-Sitzung auf `instant` setzen, damit alle Nutzer/innen ihre Bankkonten mit Financial Connections verifizieren. Informationen dazu, wie Sie Financial Connections konfigurieren und auf zusätzliche Kontodaten zugreifen, um beispielsweise vor dem Initiieren einer Zahlung den Kontostand zu prüfen, finden Sie unter [Financial Connections](https://docs.stripe.com/financial-connections.md). #### Automatisch (Standardeinstellung) Bei der Erfassung von Zahlungsinformationen für Bankkonten wird standardmäßig [Financial Connections](https://docs.stripe.com/financial-connections.md) verwendet, um das Konto Ihres Kunden/Ihrer Kundin sofort zu verifizieren. Wenn eine sofortige Verifizierung nicht möglich ist, wird auf die manuelle Eingabe der Kontonummer und die Verifizierung von Testeinzahlungen zurückgegriffen. > Um den Zugriff auf zusätzliche Daten auszudehnen, nachdem ein Kunde/eine Kundin sein/ihr Konto authentifiziert hat, muss der Kunde/die Kundin sein/ihr Konto mit erweiterten Berechtigungen erneut verknüpfen. Diese Authentifizierung erfolgt einmal pro Kunde/Kundin, und die dadurch gewährte Berechtigung kann wiederverwendet werden. **Verifizierung von Testeinzahlungen**: Nicht alle Kundinnen/Kunden können ihr Bankkonto sofort verifizieren. Dieser Abschnitt gilt nur, wenn Ihre Kundin/Ihr Kunde die sofortige Verifizierung im vorherigen Schritt deaktiviert hat. In diesen Fällen sendet Stripe stattdessen 1 bis 2 Testeinzahlungen zur Verifizierung an das Bankkonto eines Kunden/einer Kundin. Es dauert 1 bis 2 Werktage, bis Einzahlungen auf der Online-Abrechnung des Kunden/der Kundin erscheinen. Es gibt zwei Arten von Testeinzahlungen: - **Beschreibungscode** (Standard): Stripe sendet eine Testeinzahlung in Höhe von 0,01 USD mit einem eindeutigen 6-stelligen `descriptor_code`, der mit SM beginnt, auf das Bankkonto des Kunden/der Kundin. Ihre Kundinnen/Kunden verwenden diesen Code, um ihr Bankkonto zu verifizieren. - **Betrag**: Stripe sendet zwei nicht eindeutige Testeinzahlungen mit `ACCTVERIFY` als Zahlungsbeschreibung in der Abrechnung an das Bankkonto des Kunden/der Kundin Ihr Kunde/Ihre Kundin verwendet die Einzahlungsbeträge, um sein/ihr Bankkonto zu verifizieren. **Verifizierung von Testeinzahlungen fehlgeschlagen**: Wenn die Verifizierung eines Bankkontos mittels Testeinzahlungen noch aussteht, kann die Verifizierung aus verschiedenen Gründen fehlschlagen: - Die Testeinzahlungen gehen nicht auf dem Bankkonto der Kundin/des Kunden ein (dies weist in der Regel auf ein geschlossenes/nicht verfügbares Bankkonto oder eine falsche Bankkontonummer hin). - Der Kunde/die Kundin überschreitet das Limit der Verifizierungsversuche für das Konto. Wird dieses Limit überschritten, kann das Bankkonto nicht mehr verifiziert oder erneut verwendet werden. - Der Kunde/die Kundin hat die Verifizierung nicht innerhalb von 10 Tagen abgeschlossen. #### Sofort Mithilfe der sofortigen Verifzierung können Sie durchsetzen, dass alle Ihre Kundinnen und Kunden ihre Bankkonten mit Financial Connections verifizieren. Um die sofortige Verifizierung zu verwenden, legen Sie den Parameter `payment_method_options[us_bank_account][verification_method]` auf `instant` fest, wenn Sie eine Checkout-Sitzung erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -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 ui_mode=elements \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ --data-urlencode "return_url=https://example.com/return?session_id={CHECKOUT_SESSION_ID}" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -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 ui_mode=elements \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ --data-urlencode "return_url=https://example.com/return?session_id={CHECKOUT_SESSION_ID}" ``` Auf Client-Seite verwendet das durch `checkout.createPaymentElement()` erstellte Payment Element automatisch die in der Checkout-Sitzung konfigurierte Verifizierungsmethode. Es ist keine zusätzliche Konfiguration erforderlich. ## Zahlung übermitteln [Clientseitig] #### HTML + JS Zeigen Sie eine Schaltfläche **Bezahlen** an, die [confirm](https://docs.stripe.com/js/custom_checkout/confirm) von der `Checkout`-Instanz aufruft, um die Zahlung zu übermitteln. ```html
``` ```js const checkout = stripe.initCheckoutElementsSdk({clientSecret}); checkout.on('change', (session) => { document.getElementById('pay-button').disabled = !session.canConfirm; }); const loadActionsResult = await checkout.loadActions(); if (loadActionsResult.type === 'success') { const {actions} = loadActionsResult; const button = document.getElementById('pay-button'); const errors = document.getElementById('confirm-errors'); button.addEventListener('click', () => { // Clear any validation errors errors.textContent = ''; actions.confirm().then((result) => { if (result.type === 'error') { errors.textContent = result.error.message; } }); }); } ``` #### React Zeigen Sie eine Schaltfläche **Bezahlen** an, die zur [Bestätigung](https://docs.stripe.com/js/custom_checkout/confirm) von [useCheckoutElements](https://docs.stripe.com/js/react_stripe_js/checkout/use_checkout_elements) aufruft, um die Zahlung zu übermitteln. ```jsx import React from 'react'; import {useCheckoutElements} from '@stripe/react-stripe-js/checkout'; const PayButton = () => { const checkoutState = useCheckoutElements(); const [loading, setLoading] = React.useState(false); const [error, setError] = React.useState(null); if (checkoutState.type !== "success") { return null; } const handleClick = () => { setLoading(true);checkoutState.checkout.confirm().then((result) => { if (result.type === 'error') { setError(result.error) } setLoading(false); }) }; return (
{error &&
{error.message}
}
) }; export default PayButton; ``` ## Ereignisse nach der Zahlung verarbeiten Stripe übermittelt ein [checkout.session.async_payment_succeeded](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen benutzerdefinierten *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 wie das Versenden einer Bestellbestätigung per E-Mail an Kundinnen und Kunden, das Erfassen des Verkaufs in einer Datenbank oder das Einleiten des Versandablaufs auszuführen. Ü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** Erstellen Sie einen [benutzerdefinierten Webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)-Handler, um auf Ereignisse zu hören und eigene asynchrone Zahlungsabläufe zu implementieren. Testen und debuggen Sie Ihre Webhook-Integration lokal mit der 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. ## Integration testen Erfahren Sie, wie Sie Szenarien mit sofortigen Verifizierungen mithilfe von [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts) testen können. ### Transaktions-E-Mails in einer Sandbox senden Nachdem Sie die Bankkontodetails erfasst und ein Mandat akzeptiert haben, senden Sie die Mandatsbestätigung und die Verifizierungs-E-Mails mit Testeinzahlungen in einer *Sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes). Wenn Ihre Domain **{domain}** lautet und Ihr Benutzername **{username}** ist, verwenden Sie das folgende E-Mail-Format, um Test-Transaktions-E-Mails zu versenden: **{username}+test\_email@{domain}**. Wenn Ihre Domain beispielsweise **example.com** und Ihr Nutzername **Info** lautet, verwenden Sie zum Testen von ACH Direct Debit-Zahlungen das Format **info+test\_email@example.com**. Dieses Format stellt sicher, dass E-Mails korrekt weitergeleitet werden. Wenn Sie das Suffix **+test\_email** nicht angeben, senden wir die E-Mail nicht. > Sie müssen [Ihr Stripe-Konto einrichten](https://docs.stripe.com/get-started/account/set-up.md), bevor Sie diese E-Mails während Tests auslösen können. ### Testkontonummern Stripe stellt mehrere Testkontonummern und dazugehörige Token zur Verfügung, um sicherzustellen, dass Ihre Integration für Bankkonten mit manueller Eingabe für den Einsatz in einer Produktionsumgebung bereit ist. | Kontonummer | Token | Bankleitzahl | Verhalten | | -------------- | -------------------------------------- | ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000123456789` | `pm_usBankAccount_success` | `110000000` | Die Zahlung ist erfolgreich. | | `000111111113` | `pm_usBankAccount_accountClosed` | `110000000` | Die Zahlung schlägt fehl, weil das Konto geschlossen ist. | | `000000004954` | `pm_usBankAccount_riskLevelHighest` | `110000000` | Die Zahlung wird von Radar aufgrund eines [hohen Betrugsrisikos](https://docs.stripe.com/radar/risk-evaluation.md#high-risk) blockiert. | | `000111111116` | `pm_usBankAccount_noAccount` | `110000000` | Die Zahlung schlägt fehl, weil kein Konto gefunden wird. | | `000222222227` | `pm_usBankAccount_insufficientFunds` | `110000000` | Die Zahlung schlägt aufgrund unzureichender Deckung fehl. | | `000333333335` | `pm_usBankAccount_debitNotAuthorized` | `110000000` | Die Zahlung schlägt fehl, weil die Lastschriften nicht autorisiert sind. | | `000444444440` | `pm_usBankAccount_invalidCurrency` | `110000000` | Die Zahlung schlägt aufgrund einer ungültigen Währung fehl. | | `000666666661` | `pm_usBankAccount_failMicrodeposits` | `110000000` | Die Zahlung sendet keine Testeinzahlungen. | | `000555555559` | `pm_usBankAccount_dispute` | `110000000` | Die Zahlung löst eine Zahlungsanfechtung aus. | | `000000000009` | `pm_usBankAccount_processing` | `110000000` | Die Zahlung bleibt auf unbestimmte Zeit in Bearbeitung. Nützlich zum Testen [des Ablaufens der Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions/expire.md). | | `000777777771` | `pm_usBankAccount_weeklyLimitExceeded` | `110000000` | Die Zahlung schlägt aufgrund des Zahlungsbetrags fehl, wodurch das Konto sein wöchentliches Zahlungsvolumenlimit überschreitet. | | `000888888885` | | `110000000` | Die Zahlung schlägt aufgrund einer deaktivierten [tokenisierten Kontonummer](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) fehl. | Bevor Testtransaktionen abgeschlossen werden können, müssen Sie alle Testkonten verifizieren, auf denen die Zahlung automatisch erfolgreich war oder fehlschlagen ist. Verwenden Sie dazu die nachstehenden Test-Mikroeinzahlungsbeträge oder Beschreibungscodes. ### Testen von Mikroeinzahlungen und Beschreibungscodes Um verschiedene Szenarien zu imitieren, verwenden Sie diese Mikroeinzahlungsbeträge *oder* 0,01 Beschreibungscodewerte. | Testeinzahlungswerte | 0.01 Beschreibungscodewerte | Szenario | | -------------------- | --------------------------- | ------------------------------------------------------------------------- | | `32` und `45` | SM11AA | Simuliert die Verifizierung des Kontos. | | `10` und `11` | SM33CC | Simuliert das Überschreiten der Anzahl zulässiger Verifizierungsversuche. | | `40` und `41` | SM44DD | Simuliert ein Testeinzahlungs-Timeout. | ### Abwicklungsverhalten testen Testtransaktionen werden sofort abgewickelt und Ihrem verfügbaren Testguthaben hinzugefügt. Dieses Verhalten unterscheidet sich vom Live-Modus, bei dem es [mehrere Tage](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Optional: Auf Daten für ein Financial Connections-Bankkonto zugreifen Sie können nur dann auf Financial Connections-Daten zugreifen, wenn Sie beim Erstellen Ihres/Ihrer PaymentIntent zusätzliche [Datenberechtigungen](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) anfordern. Nachdem Ihre Kundinnen und Kunden den Bezahlvorgang erfolgreich abgeschlossen haben, enthält die zurückgegebene PaymentMethod `us_bank_account` eine [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account)-ID, die auf ein [Financial Connections-Konto](https://docs.stripe.com/api/financial_connections/accounts.md) verweist. Verwenden Sie diese ID, um auf Kontodaten zuzugreifen. > Bankkonten, die Ihre Kunden/Kundinnen durch manuelle Eingabe verknüpfen, und Testeinzahlungen haben keine `financial_connections_account` auf der Zahlungsmethode. Um die Financial Connections-Konto-ID zu ermitteln, rufen Sie die Checkout-Sitzung ab und erweitern Sie das Attribut `payment_intent.payment_method`: ```curl curl -G https://api.stripe.com/v1/checkout/sessions/{{CHECKOUTSESSION_ID}} \ -u "<>:" \ -d "expand[]=payment_intent.payment_method" ``` ```json { "id": "{{CHECKOUT_SESSION_ID}}", "object": "checkout.session", // ... "payment_intent": { "id": "{{PAYMENT_INTENT_ID}}", "object": "payment_intent", // ... "payment_method": { "id": "{{PAYMENT_METHOD_ID}}", // ... "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}", "fingerprint": "q9qchffggRjlX2tb", "last4": "6789", "routing_number": "110000000" } } // ... } } ``` Erfahren Sie mehr über die Verwendung zusätzlicher Kontodaten zur Optimierung Ihrer ACH-Integration mit [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize). ## Optional: Zahlungsanfechtungen beilegen [Serverseitig] Kundinnen/Kunden [fechten eine ACH-Lastschriftahlung](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#resolving-disputes) im Allgemeinen über ihre Bank an. Dies geschieht in der Regel bis zu 60 Kalendertage nach einer Abbuchung auf einem Privatkonto oder bis zu 2 Werktage bei einem Geschäftskonto. In seltenen Fällen können Kundinnen und Kunden die Lastschriftzahlung auch außerhalb dieser Fristen erfolgreich anfechten. Wenn Kundinnen/Kunden eine Zahlung anfechten, sendet Stripe das Webhook-Ereignis [charge.dispute.closed](https://docs.stripe.com/api/events/types.md#event_types-charge.dispute.closed), und die PaymentMethod-Autorisierung wird widerrufen. In seltenen Fällen erhält Stripe möglicherweise einen ACH-Fehler von der Bank, nachdem ein PaymentIntent in den Status `succeeded` gewechselt ist. In diesem Fall erstellt Stripe eine Zahlungsanfechtung mit folgendem `reason`: - `insufficient_funds` - `incorrect_account_details` - `bank_can't_process` Stripe erhebt in diesem Fall eine Fehlergebühr. Zukünftige Zahlungen, die diese PaymentMethod wiederverwenden, geben den folgenden Fehler zurück: ```javascript { "error": { "message": "This PaymentIntent requires a mandate, but no existing mandate was found. Collect mandate acceptance from the customer and try again, providing acceptance data in the mandate_data parameter.", "payment_intent": { ... } "type": "invalid_request_error" } } ``` Dieser Fehler enthält einen PaymentIntent im Status `requires_confirmation`. Um mit der Zahlung fortzufahren, müssen Sie: 1. Legen Sie die Zahlungsanfechtung mit dem Kunden/der Kundin bei, um sicherzustellen, dass zukünftige Zahlungen nicht angefochten werden. 1. Bestätigen Sie die Autorisierung Ihres Kunden/Ihrer Kundin erneut. Um die Autorisierung der Zahlung zu bestätigen, können Sie [mit Stripe.js online eine Mandatsbestätigung von Ihrem Kunden/Ihrer Kundin einholen](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=web#web-collect-mandate-and-submit) oder die Autorisierung mit Ihrem Kunden/Ihrer Kundin offline über die Stripe API bestätigen. > Wenn ein/e Kund/in mehr als eine Zahlung von demselben Bankkonto anficht, sperrt Stripe sein/ihr Bankkonto. Wenden Sie sich an den [Stripe-Support](https://support.stripe.com/?contact=true), um zusätzliche Hilfe zu erhalten. ```curl curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \ -u "<>:" \ -d "mandate_data[customer_acceptance][type]=offline" ``` ## Optional: Zahlungsreferenz Die Zahlungsreferenznummer ist ein von der Bank generierter Wert, mit dem der/die Kontoinhaber/in Gelder bei seiner/ihrer Bank finden kann. Wenn die Zahlung erfolgreich ist, gibt Stripe die Zahlungsreferenznummer im Dashboard und im [Zahlungsobjekt](https://docs.stripe.com/api/charges/object.md) an. | Status der Abbuchung | Zahlungsreferenzwert | | -------------------- | ---------------------------------------- | | Ausstehend | Nicht verfügbar | | Fehlgeschlagen | Nicht verfügbar | | Erfolgreich | Verfügbar (zum Beispiel 091000015001234) | Wenn Sie den Webhook `charge.succeeded` erhalten, zeigen Sie außerdem den Inhalt von `payment_method_details` an, um die [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference) zu finden. Das folgende Beispielereignis zeigt das Rendern einer erfolgreichen ACH-Zahlung mit einer Zahlungsreferenznummer. #### charge-succeeded ```json { "id": "{{EVENT_ID}}", "object": "event", // omitted some fields in the example "type": "charge.succeeded", "data": { "object": { "id": "{{PAYMENT_ID}}", "object": "charge", //... "paid": true, "payment_intent": "{{PAYMENT_INTENT_ID}}", "payment_method": "{{PAYMENT_METHOD_ID}}", "payment_method_details": { "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK", "fingerprint": "Ih3foEnRvLXShyfB", "last4": "1000","payment_reference": "091000015001234", "routing_number": "110000000" } } // ... } } } ``` Zeigen Sie den Inhalt der `destination_details` an, um die [Rückerstattungsreferenz](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) zu finden, die den erstatteten ACH-Zahlungen zugeordnet ist. Das folgende Beispielereignis zeigt das Rendering einer erfolgreichen ACH-Rückerstattung mit einer Rückerstattungsreferenznummer. Weitere Informationen zu [Rückerstattungen](https://docs.stripe.com/refunds.md). #### charge-refund-updated ```json { "id": "{{EVENT_ID}}", "object": "event", "type": "charge.refund.updated", "data": { "object": { "id": "{{REFUND_ID}}", "object": "refund", //... "payment_intent": "{{PAYMENT_INTENT_ID}}", "destination_details": { "type": "us_bank_transfer", "us_bank_transfer": {"reference": "091000015001111", "reference_status": "available" } } // ... } } } ``` ## Optional: Abbuchungsdatum für Kunde/Kundin konfigurieren [Serverseitig] Mit dem [Zieldatum](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-target_date) können Sie das Datum steuern, an dem Stripe das Bankkonto einer Kundin oder eines Kunden belastet. Das Zieldatum muss mindestens drei Tage in der Zukunft und maximal 15 Tage nach dem aktuellen Datum liegen. Mit dem Zieldatum wird geplant, dass das Geld das Konto der Kundin oder des Kunden am Zieldatum verlässt. Zieldaten, die eines der folgenden Kriterien erfüllen, verzögern die Abbuchung bis zum nächsten verfügbaren Werktag: - Das Zieldatum fällt auf ein Wochenende, einen Feiertag oder einen anderen arbeitsfreien Tag. - Das Zieldatum liegt weniger als drei Werktage in der Zukunft. Dieser Parameter wird auf Best-Effort-Basis ausgeführt. Es kann sein, dass die Bank jedes Kunden/jeder Kundin die Abbuchungen je nach örtlichen Feiertagen oder aus anderen Gründen zu unterschiedlichen Terminen vornimmt. > Sie können die [Verifizierungsmethode](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-verification_method) nicht auf `Mikroeinzahlungen` festlegen, wenn Sie ein [Zieldatum](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-us_bank_account-target_date) verwenden, da die Dauer des Verifizierungsprozesses das Zieldatum überschreiten könnte und Zahlungen dann später als erwartet eintreffen könnten. # Payment Intents API > This is a Payment Intents API for when payment-ui is elements and api-integration is paymentintents. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=elements&api-integration=paymentintents. Informationen dazu, welche API den Anforderungen Ihres Unternehmens entspricht, finden Sie im [Vergleichsleitfaden](https://docs.stripe.com/payments/checkout-sessions-and-payment-intents-comparison.md). Verwenden Sie das [Payment Element](https://docs.stripe.com/payments/payment-element.md), um ein nutzerdefiniertes Stripe-Zahlungsformular in Ihre Website oder Anwendung einzubetten und Kundinnen und Kunden Zahlungsmethoden anzubieten. Erweiterte Konfigurationen und Anpassungen finden Sie im Integrationsleitfaden für die [Zahlungsannahme](https://docs.stripe.com/payments/accept-a-payment.md) Bevor Sie das ACH-Lastschriftverfahren in Ihrer Payment Element-Integration verwenden, informieren Sie sich über die folgenden Aspekte des ACH-Lastschriftverfahrens: - Erfahren Sie mehr über die [Mandatserteilung](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#mandate-collection). - Wählen Sie aus, wie Sie [Bankkonten verifizieren](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#bank-verification). ### Mandatserteilung Wenn Sie ACH-Zahlungen annehmen, müssen Sie Mandate kennen. Sofern Sie keine direkte API-Integration verwenden, übernimmt Stripe die Mandatserfassung und -speicherung für Ihr Unternehmen, um sicherzustellen, dass die gesetzlichen Anforderungen erfüllt werden. Wenn ein Kunde/eine Kundin während des Zahlungsvorgangs das Mandat akzeptiert, speichert Stripe diese Informationen automatisch und sie werden für Sie über Ihr Dashboard verfügbar. ## Stripe einrichten [Serverseitig] [Erstellen Sie ein Stripe-Konto](https://dashboard.stripe.com/register), um zu beginnen. 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' ``` ## Zahlungsdaten erfassen [Clientseitig] Verwenden Sie das Payment Element, um Zahlungsdetails auf dem Client zu erfassen. Das Payment Element ist eine vorgefertigte Komponente der Nutzeroberfläche, die die Erfassung von Zahlungsdetails für verschiedene Zahlungsmethoden vereinfacht. Das Payment Element enthält einen iFrame, der Zahlungsinformationen sicher über eine HTTPS-Verbindung an Stripe sendet. Vermeiden Sie es, das Payment Element in einem anderen iFrame zu platzieren, da bei einigen Zahlungsmethoden die Weiterleitung an eine andere Seite zur Zahlungsbestätigung erforderlich ist. Die Adresse der Bezahlseite muss mit `https://` und nicht `http://` beginnen, damit Ihre Integration funktioniert. Sie können Ihre Integration ohne HTTPS testen. Denken Sie jedoch daran, es es [aktivieren](https://docs.stripe.com/security/guide.md#tls), wenn Sie bereit sind, Live-Zahlungen zu akzeptieren. #### HTML + JS ### Stripe.js einrichten Das Payment Element ist automatisch als Funktion von Stripe.js verfügbar. Fügen Sie das Stripe.js-Skript auf Ihrer Bezahlseite ein, indem Sie es zum `head` der HTML-Datei hinzufügen. Laden Sie Stripe.js immer direkt von js.stripe.com, um PCI-konform zu bleiben. Fügen Sie das Skript nicht in ein Paket ein und hosten Sie selbst keine Kopie davon. ```html Checkout ``` Erstellen Sie auf Ihrer Zahlungsseite eine Instanz von Stripe mit dem folgenden JavaScript: ```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('<>'); ``` ### Payment Element zu Ihrer Checkout-Seite hinzufügen Um das Payment Element zu Ihrer Bezahlseite hinzuzufügen, erstellen Sie einen leeren DOM-Knoten (Container) mit einer eindeutigen ID in Ihrem Zahlungsformular: ```html
``` Sie können Zahlungsmethoden vom Dashboard aus verwalten oder die Zahlungsmethoden, die verfügbar sein sollen, manuell auflisten, wenn Sie das [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent) erstellen. #### Zahlungsmethoden über das Dashboard verwalten ```javascript const options = {mode: 'payment', amount: 1099, currency: 'usd', // Fully customizable with appearance API. appearance: {/*...*/}, }; // Set up Stripe.js and Elements to use in checkout formconst elements = stripe.elements(options); // Create and mount the Payment Element const paymentElementOptions = { layout: 'accordion'}; const paymentElement = elements.create('payment', paymentElementOptions); paymentElement.mount('#payment-element'); ``` #### Zahlungsmethoden manuell auflisten Um Zahlungsmethoden manuell aufzulisten, fügen Sie jede einzelne dem Attribut `PaymentMethodTypes` attribute in `options` hinzu, wenn Sie das [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent) erstellen. ```javascript const options = {mode: 'payment', amount: 1099, currency: 'usd', paymentMethodTypes: ['us_bank_account'], // Fully customizable with appearance API. appearance: {/*...*/}, }; // Set up Stripe.js and Elements to use in checkout formconst elements = stripe.elements(options); // Create and mount the Payment Element const paymentElementOptions = { layout: 'accordion'}; const paymentElement = elements.create('payment', paymentElementOptions); paymentElement.mount('#payment-element'); ``` #### React ### Stripe.js einrichten Installieren Sie React Stripe.js und den Stripe.js-Loader aus dem [öffentlichen npm-Register](https://www.npmjs.com/package/@stripe/react-stripe-js). ```bash npm install --save @stripe/react-stripe-js @stripe/stripe-js ``` ### Den Elements-Anbieter zu Ihrer Checkout-Seite hinzufügen und konfigurieren Um die Payment Element-Komponente zu verwenden, schließen Sie die Komponente Ihrer Bezahlseite in einen [Elements-Anbieter](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider) ein. Rufen Sie `loadStripe` mit Ihrem veröffentlichbaren Schlüssel auf und übergeben Sie das zurückgegebene `Promise` an den `Elements`-Anbieter. Sie können Zahlungsmethoden vom Dashboard aus verwalten oder die Zahlungsmethoden, die verfügbar sein sollen, manuell auflisten, wenn Sie das [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent) erstellen. #### Zahlungsmethoden über das Dashboard verwalten ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import CheckoutForm from './CheckoutForm'; // Make sure to call `loadStripe` outside of a component’s render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('<>'); function App() { const options = {mode: 'payment', amount: 1099, currency: 'usd', // Fully customizable with appearance API. appearance: {/*...*/}, }; return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` #### Zahlungsmethoden manuell auflisten Um Zahlungsmethoden manuell aufzulisten, fügen Sie jede einzelne dem Attribut `payment_method_types` hinzu, wenn Sie das [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent) erstellen. ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import CheckoutForm from './CheckoutForm'; // Make sure to call `loadStripe` outside of a component’s render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('<>'); function App() { const options = {mode: 'payment', amount: 1099, currency: 'usd', paymentMethodTypes: ['us_bank_account'], // Fully customizable with appearance API. appearance: {/*...*/}, }; return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` ### Payment Element hinzufügen Verwenden Sie die Komponente `PaymentElement`, um Ihr Formular zu erstellen. ```jsx import React from 'react'; import {PaymentElement} from '@stripe/react-stripe-js'; const CheckoutForm = () => { return (
); }; export default CheckoutForm; ``` Sie können das Payment Element an das Design Ihrer Website anpassen, indem Sie beim Erstellen des `Elements`-Anbieters das [Erscheinungsbild-Objekt](https://docs.stripe.com/elements/appearance-api.md) an `options` übergeben. ### Adressen einholen Standardmäßig erfasst das Payment Element nur die erforderlichen Angaben zur Rechnungsadresse. Einige Verhaltensweisen, wie z. B. die [Berechnung der Steuer](https://docs.stripe.com/api/tax/calculations/create.md) oder die Eingabe der Versanddaten, erfordern die vollständige Adresse Ihrer Kundin/Ihres Kunden. Sie können Folgendes tun: - Verwenden Sie das [Address Element](https://docs.stripe.com/elements/address-element.md), um die Vorteile der Funktionen der automatischen Vervollständigung und Lokalisierung zu nutzen, um die vollständige Adresse Ihrer Kundin oder Ihres Kunden zu erfassen. Dies trägt dazu bei, eine möglichst genaue Steuerberechnung zu gewährleisten. - Erfassen Sie Adressdaten mit Ihrem eigenen benutzerdefinierten Formular. ## Bankkonten verifizieren #### Item 1 Informationen zu Gebühren für Financial Connections finden Sie unter [Preisübersicht](https://stripe.com/financial-connections#pricing). Bei der Bankkontoverifizierung werden standardmäßig Zahlungsinformationen über [Financial Connections](https://docs.stripe.com/financial-connections.md) automatisch verifiziert. Es sind keine Änderungen erforderlich, um sie zu verwenden. Sie können Ihre [verification_method](https://docs.stripe.com/js/elements_object/create_without_intent#stripe_elements_no_intent-options-paymentMethodOptions-us_bank_account-verification_method) auf `instant` ändern, damit alle Nutzer/innen ihre Bankkonten mit Financial Connections verifizieren. Informationen dazu, wie Sie Financial Connections konfigurieren und auf zusätzliche Kontodaten zugreifen, um beispielsweise vor dem Initiieren einer Zahlung den Kontostand zu prüfen, finden Sie unter [Financial Connections](https://docs.stripe.com/financial-connections.md). #### Automatisch (Standardeinstellung) Bei der Erfassung von Zahlungsinformationen für Bankkonten wird standardmäßig [Financial Connections](https://docs.stripe.com/financial-connections.md) verwendet, um das Konto Ihres Kunden/Ihrer Kundin sofort zu verifizieren. Wenn eine sofortige Verifizierung nicht möglich ist, wird auf die manuelle Eingabe der Kontonummer und die Verifizierung von Testeinzahlungen zurückgegriffen. > Um den Zugriff auf zusätzliche Daten auszudehnen, nachdem ein Kunde/eine Kundin sein/ihr Konto authentifiziert hat, muss der Kunde/die Kundin sein/ihr Konto mit erweiterten Berechtigungen erneut verknüpfen. Diese Authentifizierung erfolgt einmal pro Kunde/Kundin, und die dadurch gewährte Berechtigung kann wiederverwendet werden. **Verifizierung von Testeinzahlungen**: Nicht alle Kundinnen/Kunden können ihr Bankkonto sofort verifizieren. Dieser Abschnitt gilt nur, wenn Ihre Kundin/Ihr Kunde die sofortige Verifizierung im vorherigen Schritt deaktiviert hat. In diesen Fällen sendet Stripe stattdessen 1 bis 2 Testeinzahlungen zur Verifizierung an das Bankkonto eines Kunden/einer Kundin. Es dauert 1 bis 2 Werktage, bis Einzahlungen auf der Online-Abrechnung des Kunden/der Kundin erscheinen. Es gibt zwei Arten von Testeinzahlungen: - **Beschreibungscode** (Standard): Stripe sendet eine Testeinzahlung in Höhe von 0,01 USD mit einem eindeutigen 6-stelligen `descriptor_code`, der mit SM beginnt, auf das Bankkonto des Kunden/der Kundin. Ihre Kundinnen/Kunden verwenden diesen Code, um ihr Bankkonto zu verifizieren. - **Betrag**: Stripe sendet zwei nicht eindeutige Testeinzahlungen mit `ACCTVERIFY` als Zahlungsbeschreibung in der Abrechnung an das Bankkonto des Kunden/der Kundin Ihr Kunde/Ihre Kundin verwendet die Einzahlungsbeträge, um sein/ihr Bankkonto zu verifizieren. **Verifizierung von Testeinzahlungen fehlgeschlagen**: Wenn die Verifizierung eines Bankkontos mittels Testeinzahlungen noch aussteht, kann die Verifizierung aus verschiedenen Gründen fehlschlagen: - Die Testeinzahlungen gehen nicht auf dem Bankkonto der Kundin/des Kunden ein (dies weist in der Regel auf ein geschlossenes/nicht verfügbares Bankkonto oder eine falsche Bankkontonummer hin). - Der Kunde/die Kundin überschreitet das Limit der Verifizierungsversuche für das Konto. Wird dieses Limit überschritten, kann das Bankkonto nicht mehr verifiziert oder erneut verwendet werden. - Der Kunde/die Kundin hat die Verifizierung nicht innerhalb von 10 Tagen abgeschlossen. #### Sofort Mithilfe der sofortigen Verifzierung können Sie durchsetzen, dass alle Ihre Kundinnen und Kunden ihre Bankkonten mit Financial Connections verifizieren. Um die sofortige Verifizierung zu verwenden, legen Sie den Parameter [verification_method](https://docs.stripe.com/js/elements_object/create_without_intent#stripe_elements_no_intent-options-paymentMethodOptions-us_bank_account-verification_method) auf `instant` fest, wenn Sie ein [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent) erstellen. #### HTML + JS ```js const options = { mode: 'payment', amount: 1099, currency: 'usd',paymentMethodOptions: { us_bank_account: { verification_method: "instant" } } appearance: {/*...*/}, }; // Set up Stripe.js and Elements to use in checkout form const elements = stripe.elements(options); // Create and mount the Payment Element const paymentElement = elements.create('payment'); paymentElement.mount('#payment-element'); ``` #### React ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import CheckoutForm from './CheckoutForm'; // Make sure to call `loadStripe` outside of a component’s render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('<>'); function App() { const options = { mode: 'payment', amount: 1099, currency: 'usd',paymentMethodOptions: { us_bank_account: { verification_method: "instant" } } // Fully customizable with appearance API. appearance: {/*...*/}, }; return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` ### Payment Element hinzufügen Verwenden Sie die Komponente `PaymentElement`, um Ihr Formular zu erstellen. ```jsx import React from 'react'; import {PaymentElement} from '@stripe/react-stripe-js'; const CheckoutForm = () => { return (
); }; export default CheckoutForm; ``` #### Item 2 Informationen zu Gebühren für Financial Connections finden Sie unter [Preisübersicht](https://stripe.com/financial-connections#pricing). Bei der Bankkontoverifizierung werden standardmäßig Zahlungsinformationen über [Financial Connections](https://docs.stripe.com/financial-connections.md) automatisch verifiziert. Es sind keine Änderungen erforderlich, um sie zu verwenden. Sie können Ihre [verification_method](https://docs.stripe.com/js/elements_object/create_without_intent#stripe_elements_no_intent-options-paymentMethodOptions-us_bank_account-verification_method) auf `instant` ändern, damit alle Nutzer/innen ihre Bankkonten mit Financial Connections verifizieren. Informationen dazu, wie Sie Financial Connections konfigurieren und auf zusätzliche Kontodaten zugreifen, um beispielsweise vor dem Initiieren einer Zahlung den Kontostand zu prüfen, finden Sie unter [Financial Connections](https://docs.stripe.com/financial-connections.md). #### Automatisch (Standardeinstellung) Bei der Erfassung von Zahlungsinformationen für Bankkonten wird standardmäßig [Financial Connections](https://docs.stripe.com/financial-connections.md) verwendet, um das Konto Ihres Kunden/Ihrer Kundin sofort zu verifizieren. Wenn eine sofortige Verifizierung nicht möglich ist, wird auf die manuelle Eingabe der Kontonummer und die Verifizierung von Testeinzahlungen zurückgegriffen. > Um den Zugriff auf zusätzliche Daten auszudehnen, nachdem ein Kunde/eine Kundin sein/ihr Konto authentifiziert hat, muss der Kunde/die Kundin sein/ihr Konto mit erweiterten Berechtigungen erneut verknüpfen. Diese Authentifizierung erfolgt einmal pro Kunde/Kundin, und die dadurch gewährte Berechtigung kann wiederverwendet werden. **Verifizierung von Testeinzahlungen**: Nicht alle Kundinnen/Kunden können ihr Bankkonto sofort verifizieren. Dieser Abschnitt gilt nur, wenn Ihre Kundin/Ihr Kunde die sofortige Verifizierung im vorherigen Schritt deaktiviert hat. In diesen Fällen sendet Stripe stattdessen 1 bis 2 Testeinzahlungen zur Verifizierung an das Bankkonto eines Kunden/einer Kundin. Es dauert 1 bis 2 Werktage, bis Einzahlungen auf der Online-Abrechnung des Kunden/der Kundin erscheinen. Es gibt zwei Arten von Testeinzahlungen: - **Beschreibungscode** (Standard): Stripe sendet eine Testeinzahlung in Höhe von 0,01 USD mit einem eindeutigen 6-stelligen `descriptor_code`, der mit SM beginnt, auf das Bankkonto des Kunden/der Kundin. Ihre Kundinnen/Kunden verwenden diesen Code, um ihr Bankkonto zu verifizieren. - **Betrag**: Stripe sendet zwei nicht eindeutige Testeinzahlungen mit `ACCTVERIFY` als Zahlungsbeschreibung in der Abrechnung an das Bankkonto des Kunden/der Kundin Ihr Kunde/Ihre Kundin verwendet die Einzahlungsbeträge, um sein/ihr Bankkonto zu verifizieren. **Verifizierung von Testeinzahlungen fehlgeschlagen**: Wenn die Verifizierung eines Bankkontos mittels Testeinzahlungen noch aussteht, kann die Verifizierung aus verschiedenen Gründen fehlschlagen: - Die Testeinzahlungen gehen nicht auf dem Bankkonto der Kundin/des Kunden ein (dies weist in der Regel auf ein geschlossenes/nicht verfügbares Bankkonto oder eine falsche Bankkontonummer hin). - Der Kunde/die Kundin überschreitet das Limit der Verifizierungsversuche für das Konto. Wird dieses Limit überschritten, kann das Bankkonto nicht mehr verifiziert oder erneut verwendet werden. - Der Kunde/die Kundin hat die Verifizierung nicht innerhalb von 10 Tagen abgeschlossen. #### Sofort Mithilfe der sofortigen Verifzierung können Sie durchsetzen, dass alle Ihre Kundinnen und Kunden ihre Bankkonten mit Financial Connections verifizieren. Um die sofortige Verifizierung zu verwenden, legen Sie den Parameter [verification_method](https://docs.stripe.com/js/elements_object/create_without_intent#stripe_elements_no_intent-options-paymentMethodOptions-us_bank_account-verification_method) auf `instant` fest, wenn Sie ein [Payment Element](https://docs.stripe.com/js/elements_object/create_without_intent) erstellen. #### HTML + JS ```js const options = { mode: 'payment', amount: 1099, payment_method_types: ["card", "us_bank_account"], currency: 'usd',paymentMethodOptions: { us_bank_account: { verification_method: "instant" } } appearance: {/*...*/}, }; // Set up Stripe.js and Elements to use in checkout form const elements = stripe.elements(options); // Create and mount the Payment Element const paymentElement = elements.create('payment'); paymentElement.mount('#payment-element'); ``` #### React ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import CheckoutForm from './CheckoutForm'; // Make sure to call `loadStripe` outside of a component’s render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('<>'); function App() { const options = { mode: 'payment', amount: 1099, currency: 'usd', payment_method_types: `us_bank_account`,paymentMethodOptions: { us_bank_account: { verification_method: "instant" } } // Fully customizable with appearance API. appearance: {/*...*/}, }; return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` ### Payment Element hinzufügen Verwenden Sie die Komponente `PaymentElement`, um Ihr Formular zu erstellen. ```jsx import React from 'react'; import {PaymentElement} from '@stripe/react-stripe-js'; const CheckoutForm = () => { return (
); }; export default CheckoutForm; ``` ## Einen PaymentIntent erstellen [Serverseitig] > #### Benutzerdefinierte Geschäftslogik unmittelbar vor der Zahlungsbestätigung ausführen > > Navigieren Sie zu [Schritt 5](https://docs.stripe.com/payments/finalize-payments-on-the-server.md?platform=web&type=payment#submit-payment) im Leitfaden zum Abschließen von Zahlungen, um Ihre nutzerdefinierte Geschäftslogik unmittelbar vor der Zahlungsbestätigung auszuführen. Führen Sie andernfalls die folgenden Schritte für eine einfachere Integration aus, die `stripe.confirmPayment` auf dem Client verwendet, um die Zahlung zu bestätigen und alle nächsten Aktionen abzuwickeln. #### Zahlungsmethoden über das Dashboard steuern Wenn der Kunde/die Kundin Ihr Zahlungsformular absendet, verwenden Sie einen *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods), um den Bestätigungs- und Zahlungsvorgang zu vereinfachen. Erstellen Sie einen PaymentIntent auf Ihrem Server mit einem `amount` und einer `currency`. Um zu verhindern, dass böswillige Kundinnen/Kunden ihre eigenen Preise wählen, entscheiden Sie, wie viel Sie berechnen möchten, immer auf der Serverseite (einer vertrauenswürdigen Umgebung) und nicht auf dem Client. Zu einem `PaymentIntent` gehört 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)). Geben Sie diesen Wert an Ihren Client zurück, damit Stripe.js den Zahlungsvorgang sicher abschließen kann. #### Accounts v2 #### Ruby ```ruby require 'stripe' # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. client = Stripe::StripeClient.new('<>') post '/create-intent' do intent = client.v1.payment_intents.create({ # To allow saving and retrieving payment methods, provide the customer's Account ID. customer_account: "{{CUSTOMER_ACCOUNT_ID}}", amount: 1099, currency: 'usd', }) {client_secret: intent.client_secret}.to_json end ``` #### Customers v1 #### Ruby ```ruby require 'stripe' # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. client = Stripe::StripeClient.new('<>') post '/create-intent' do intent = client.v1.payment_intents.create({ # To allow saving and retrieving payment methods, provide the Customer ID. customer: customer.id, amount: 1099, currency: 'usd', }) {client_secret: intent.client_secret}.to_json end ``` #### Zahlungsmethoden manuell auflisten Wenn der Kunde/die Kundin Ihr Zahlungsformular absendet, verwenden Sie einen *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods), um den Bestätigungs- und Zahlungsvorgang zu vereinfachen. Erstellen Sie einen PaymentIntent auf Ihrem Server mit einem `amount`, einer `currency` und einer oder mehreren Zahlungsmethoden mithilfe von `payment_method_types`. Um zu verhindern, dass böswillige Kundinnen und Kunden ihre eigenen Preise wählen, sollten Sie den Preis immer auf der Serverseite (einer vertrauenswürdigen Umgebung) festlegen und nicht auf dem Client. Zu einem PaymentIntent gehört 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)). Geben Sie diesen Wert an Ihren Client zurück, damit Stripe.js den Zahlungsvorgang sicher abschließen kann. #### Accounts v2 #### Ruby ```ruby require 'stripe' # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. client = Stripe::StripeClient.new('<>') post '/create-intent' do intent = client.v1.payment_intents.create({ # To allow saving and retrieving payment methods, provide the customer's Account ID. customer_account: customer_account.id, amount: 1099, currency: 'usd', payment_method_types: ['us_bank_account'], }) {client_secret: intent.client_secret}.to_json end ``` #### Customers v1 #### Ruby ```ruby require 'stripe' # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. client = Stripe::StripeClient.new('<>') post '/create-intent' do intent = client.v1.payment_intents.create({ # To allow saving and retrieving payment methods, provide the Customer ID. customer: customer.id, amount: 1099, currency: 'usd', payment_method_types: ['us_bank_account'], }) {client_secret: intent.client_secret}.to_json end ``` ## Zahlung an Stripe senden [Clientseitig] Verwenden Sie [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment), um die Zahlung mit den Angaben aus dem Payment Element abzuschließen. Geben Sie eine [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) für diese Funktion an, um anzugeben, wohin Stripe den/die Nutzer/in nach Abschluss der Zahlung weiterleitet. Ihre Nutzer/innen werden möglicherweise zunächst an eine Zwischenwebsite, z. B. eine Bankautorisierungsseite, weitergeleitet, bevor sie zur `return_url` weitergeleitet werden. Bei Kartenzahlungen erfolgt die Weiterleitung zur `return_url` sofort, wenn eine Zahlung erfolgreich ist. Wenn Sie bei Kartenzahlungen nach Abschluss der Zahlung keine Weiterleitung wünschen, können Sie [redirect](https://docs.stripe.com/js/payment_intents/confirm_payment#confirm_payment_intent-options-redirect) auf `if_required` festlegen. Dadurch werden nur Kundinnen/Kunden weitergeleitet, die mit auf Weiterleitung basierenden Zahlungsmethoden bezahlen. #### HTML + JS ```javascript const form = document.getElementById('payment-form'); const submitBtn = document.getElementById('submit'); const handleError = (error) => { const messageContainer = document.querySelector('#error-message'); messageContainer.textContent = error.message; submitBtn.disabled = false; } form.addEventListener('submit', async (event) => { // We don't want to let default form submission happen here, // which would refresh the page. event.preventDefault(); // Prevent multiple form submissions if (submitBtn.disabled) { return; } // Disable form submission while loading submitBtn.disabled = true; // Trigger form validation and wallet collection const {error: submitError} = await elements.submit(); if (submitError) { handleError(submitError); return; } // Create the PaymentIntent and obtain clientSecret const res = await fetch("/create-intent", { method: "POST", }); const {client_secret: clientSecret} = await res.json(); // Confirm the PaymentIntent using the details collected by the Payment Element const {error} = await stripe.confirmPayment({ elements, clientSecret, confirmParams: { return_url: 'https://example.com/order/123/complete', }, }); if (error) { // This point is only reached if there's an immediate error when // confirming the payment. Show the error to your customer (for example, payment details incomplete) handleError(error); } else { // Your customer is redirected to your `return_url`. For some payment // methods like iDEAL, your customer is redirected to an intermediate // site first to authorize the payment, then redirected to the `return_url`. } }); ``` #### React ```jsx import React, {useState} from 'react'; import {useStripe, useElements, PaymentElement} from '@stripe/react-stripe-js'; export default function CheckoutForm() { const stripe = useStripe(); const elements = useElements(); const [errorMessage, setErrorMessage] = useState(); const [loading, setLoading] = useState(false); const handleError = (error) => { setLoading(false); setErrorMessage(error.message); } const handleSubmit = async (event) => { // We don't want to let default form submission happen here, // which would refresh the page. event.preventDefault(); if (!stripe) { // Stripe.js hasn't yet loaded. // Make sure to disable form submission until Stripe.js has loaded. return; } setLoading(true); // Trigger form validation and wallet collection const {error: submitError} = await elements.submit(); if (submitError) { handleError(submitError); return; } // Create the PaymentIntent and obtain clientSecret const res = await fetch("/create-intent", { method: "POST", }); const {client_secret: clientSecret} = await res.json(); // Confirm the PaymentIntent using the details collected by the Payment Element const {error} = await stripe.confirmPayment({ elements, clientSecret, confirmParams: { return_url: 'https://example.com/order/123/complete', }, }); if (error) { // This point is only reached if there's an immediate error when // confirming the payment. Show the error to your customer (for example, payment details incomplete) handleError(error); } else { // Your customer is redirected to your `return_url`. For some payment // methods like iDEAL, your customer is redirected to an intermediate // site first to authorize the payment, then redirected to the `return_url`. } }; return (
{errorMessage &&
{errorMessage}
} ); } ``` ## Optional: Ereignisse nach 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. ## Integration testen Erfahren Sie, wie Sie Szenarien mit sofortigen Verifizierungen mithilfe von [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts) testen können. ### Transaktions-E-Mails in einer Sandbox senden Nachdem Sie die Bankkontodetails erfasst und ein Mandat akzeptiert haben, senden Sie die Mandatsbestätigung und die Verifizierungs-E-Mails mit Testeinzahlungen in einer *Sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes). Wenn Ihre Domain **{domain}** lautet und Ihr Benutzername **{username}** ist, verwenden Sie das folgende E-Mail-Format, um Test-Transaktions-E-Mails zu versenden: **{username}+test\_email@{domain}**. Wenn Ihre Domain beispielsweise **example.com** und Ihr Nutzername **Info** lautet, verwenden Sie zum Testen von ACH Direct Debit-Zahlungen das Format **info+test\_email@example.com**. Dieses Format stellt sicher, dass E-Mails korrekt weitergeleitet werden. Wenn Sie das Suffix **+test\_email** nicht angeben, senden wir die E-Mail nicht. > Sie müssen [Ihr Stripe-Konto einrichten](https://docs.stripe.com/get-started/account/set-up.md), bevor Sie diese E-Mails während Tests auslösen können. ### Testkontonummern Stripe stellt mehrere Testkontonummern und dazugehörige Token zur Verfügung, um sicherzustellen, dass Ihre Integration für Bankkonten mit manueller Eingabe für den Einsatz in einer Produktionsumgebung bereit ist. | Kontonummer | Token | Bankleitzahl | Verhalten | | -------------- | -------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000123456789` | `pm_usBankAccount_success` | `110000000` | Die Zahlung ist erfolgreich. | | `000111111113` | `pm_usBankAccount_accountClosed` | `110000000` | Die Zahlung schlägt fehl, weil das Konto geschlossen ist. | | `000000004954` | `pm_usBankAccount_riskLevelHighest` | `110000000` | Die Zahlung wird von Radar aufgrund eines [hohen Betrugsrisikos](https://docs.stripe.com/radar/risk-evaluation.md#high-risk) blockiert. | | `000111111116` | `pm_usBankAccount_noAccount` | `110000000` | Die Zahlung schlägt fehl, weil kein Konto gefunden wird. | | `000222222227` | `pm_usBankAccount_insufficientFunds` | `110000000` | Die Zahlung schlägt aufgrund unzureichender Deckung fehl. | | `000333333335` | `pm_usBankAccount_debitNotAuthorized` | `110000000` | Die Zahlung schlägt fehl, weil die Lastschriften nicht autorisiert sind. | | `000444444440` | `pm_usBankAccount_invalidCurrency` | `110000000` | Die Zahlung schlägt aufgrund einer ungültigen Währung fehl. | | `000666666661` | `pm_usBankAccount_failMicrodeposits` | `110000000` | Die Zahlung sendet keine Testeinzahlungen. | | `000555555559` | `pm_usBankAccount_dispute` | `110000000` | Die Zahlung löst eine Zahlungsanfechtung aus. | | `000000000009` | `pm_usBankAccount_processing` | `110000000` | Die Zahlung bleibt auf unbestimmte Zeit in Bearbeitung. Nützlich zum Testen [der Stornierung des PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md). | | `000777777771` | `pm_usBankAccount_weeklyLimitExceeded` | `110000000` | Die Zahlung schlägt aufgrund des Zahlungsbetrags fehl, wodurch das Konto sein wöchentliches Zahlungsvolumenlimit überschreitet. | | `000888888885` | | `110000000` | Die Zahlung schlägt aufgrund einer deaktivierten [tokenisierten Kontonummer](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) fehl. | Bevor Testtransaktionen abgeschlossen werden können, müssen Sie alle Testkonten verifizieren, auf denen die Zahlung automatisch erfolgreich war oder fehlschlagen ist. Verwenden Sie dazu die nachstehenden Test-Mikroeinzahlungsbeträge oder Beschreibungscodes. ### Testen von Mikroeinzahlungen und Beschreibungscodes Um verschiedene Szenarien zu imitieren, verwenden Sie diese Mikroeinzahlungsbeträge *oder* 0,01 Beschreibungscodewerte. | Testeinzahlungswerte | 0.01 Beschreibungscodewerte | Szenario | | -------------------- | --------------------------- | ------------------------------------------------------------------------- | | `32` und `45` | SM11AA | Simuliert die Verifizierung des Kontos. | | `10` und `11` | SM33CC | Simuliert das Überschreiten der Anzahl zulässiger Verifizierungsversuche. | | `40` und `41` | SM44DD | Simuliert ein Testeinzahlungs-Timeout. | ### Abwicklungsverhalten testen Testtransaktionen werden sofort abgewickelt und Ihrem verfügbaren Testguthaben hinzugefügt. Dieses Verhalten unterscheidet sich vom Live-Modus, bei dem es [mehrere Tage](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Fehlercodes In der folgenden Tabelle finden Sie häufige Fehlercodes und die empfohlenen Maßnahmen: | Fehlercode | Empfohlene Maßnahme | | --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent_invalid_currency` | Geben Sie eine unterstützte Währung ein. | | `missing_required_parameter` | In der Fehlermeldung erhalten Sie weitere Informationen zum erforderlichen Parameter. | | `payment_intent_payment_attempt_failed` | Dieser Code kann im Feld [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) eines PaymentIntent angezeigt werden. Eine genauere Fehlerursache und Vorschläge zur Fehlerbehebung finden Sie in der Fehlermeldung. | | `payment_intent_authentication_failure` | Dieser Code kann im Feld [last_payment_error.code](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-last_payment_error-code) eines PaymentIntent erscheinen. Prüfen Sie die Fehlermeldung für einen detaillierten Grund des Fehlers und Hinweise zur Fehlerbehandlung. Dieser Fehler tritt auf, wenn Sie während des Testens Ihrer Integration manuell einen Fehler auslösen. | | `payment_intent_redirect_confirmation_without_return_url` | Geben Sie eine `return_url` an, wenn Sie einen PaymentIntent bestätigen. | ## Optional: Auf Daten für ein Financial Connections-Bankkonto zugreifen Weitere Informationen zu den Gebühren für Financial Connections finden Sie unter [Preisdetails](https://stripe.com/financial-connections#pricing). Sie können nur auf [Financial Connections](https://docs.stripe.com/financial-connections.md)-Daten zugreifen, wenn Sie beim Erstellen Ihres Payment Intent zusätzliche [Datenberechtigungen](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) anfordern. Nachdem Ihre Kundinnen/Kunden den [Authentifizierungsvorgang von Stripe Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) erfolgreich abgeschlossen haben, enthält die zurückgegebene PaymentMethod `us_bank_account` eine [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account)-ID, die auf ein [Financial Connections-Konto](https://docs.stripe.com/api/financial_connections/accounts.md) verweist. Verwenden Sie diese ID, um auf Kontodaten zuzugreifen. > Bankkonten, mit denen Ihre Kunden/Kundinnen durch manuelle Eingabe und Testeinzahlungen verknüpft werden, haben keine `financial_connections_account`-ID für die Zahlungsmethode. Um die Financial Connections-Konto-ID zu ermitteln, rufen Sie den Payment Intent ab und erweitern Sie das Attribut `payment_intent.payment_method`: ```curl curl -G https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}} \ -u "<>:" \ -d "expand[]=payment_method" ``` ```json { "payment_intent": { "id": "{{PAYMENT_INTENT_ID}}", "object": "payment_intent", // ... "payment_method": { "id": "{{PAYMENT_METHOD_ID}}", // ... "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}", "fingerprint": "q9qchffggRjlX2tb", "last4": "6789", "routing_number": "110000000" } } // ... } } ``` ## Optional: Zahlungsanfechtungen beilegen [Serverseitig] Kundinnen/Kunden [fechten eine ACH-Lastschriftahlung](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#resolving-disputes) im Allgemeinen über ihre Bank an. Dies geschieht in der Regel bis zu 60 Kalendertage nach einer Abbuchung auf einem Privatkonto oder bis zu 2 Werktage bei einem Geschäftskonto. In seltenen Fällen können Kundinnen und Kunden die Lastschriftzahlung auch außerhalb dieser Fristen erfolgreich anfechten. Wenn Kundinnen/Kunden eine Zahlung anfechten, sendet Stripe das Webhook-Ereignis [charge.dispute.closed](https://docs.stripe.com/api/events/types.md#event_types-charge.dispute.closed), und die PaymentMethod-Autorisierung wird widerrufen. In seltenen Fällen erhält Stripe möglicherweise einen ACH-Fehler von der Bank, nachdem ein PaymentIntent in den Status `succeeded` gewechselt ist. In diesem Fall erstellt Stripe eine Zahlungsanfechtung mit folgendem `reason`: - `insufficient_funds` - `incorrect_account_details` - `bank_can't_process` Stripe erhebt in diesem Fall eine Fehlergebühr. Zukünftige Zahlungen, die diese PaymentMethod wiederverwenden, geben den folgenden Fehler zurück: ```javascript { "error": { "message": "This PaymentIntent requires a mandate, but no existing mandate was found. Collect mandate acceptance from the customer and try again, providing acceptance data in the mandate_data parameter.", "payment_intent": { ... } "type": "invalid_request_error" } } ``` Dieser Fehler enthält einen PaymentIntent im Status `requires_confirmation`. Um mit der Zahlung fortzufahren, müssen Sie: 1. Legen Sie die Zahlungsanfechtung mit dem Kunden/der Kundin bei, um sicherzustellen, dass zukünftige Zahlungen nicht angefochten werden. 1. Bestätigen Sie die Autorisierung Ihres Kunden/Ihrer Kundin erneut. Um die Autorisierung der Zahlung zu bestätigen, können Sie [mit Stripe.js online eine Mandatsbestätigung von Ihrem Kunden/Ihrer Kundin einholen](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=web#web-collect-mandate-and-submit) oder die Autorisierung mit Ihrem Kunden/Ihrer Kundin offline über die Stripe API bestätigen. > Wenn ein/e Kund/in mehr als eine Zahlung von demselben Bankkonto anficht, sperrt Stripe sein/ihr Bankkonto. Wenden Sie sich an den [Stripe-Support](https://support.stripe.com/?contact=true), um zusätzliche Hilfe zu erhalten. ```curl curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \ -u "<>:" \ -d "mandate_data[customer_acceptance][type]=offline" ``` ## Optional: Zahlungsreferenz Die Zahlungsreferenznummer ist ein von der Bank generierter Wert, mit dem der/die Kontoinhaber/in Gelder bei seiner/ihrer Bank finden kann. Wenn die Zahlung erfolgreich ist, gibt Stripe die Zahlungsreferenznummer im Dashboard und im [Zahlungsobjekt](https://docs.stripe.com/api/charges/object.md) an. | Status der Abbuchung | Zahlungsreferenzwert | | -------------------- | ---------------------------------------- | | Ausstehend | Nicht verfügbar | | Fehlgeschlagen | Nicht verfügbar | | Erfolgreich | Verfügbar (zum Beispiel 091000015001234) | Wenn Sie den Webhook `charge.succeeded` erhalten, zeigen Sie außerdem den Inhalt von `payment_method_details` an, um die [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference) zu finden. Das folgende Beispielereignis zeigt das Rendern einer erfolgreichen ACH-Zahlung mit einer Zahlungsreferenznummer. #### charge-succeeded ```json { "id": "{{EVENT_ID}}", "object": "event", // omitted some fields in the example "type": "charge.succeeded", "data": { "object": { "id": "{{PAYMENT_ID}}", "object": "charge", //... "paid": true, "payment_intent": "{{PAYMENT_INTENT_ID}}", "payment_method": "{{PAYMENT_METHOD_ID}}", "payment_method_details": { "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK", "fingerprint": "Ih3foEnRvLXShyfB", "last4": "1000","payment_reference": "091000015001234", "routing_number": "110000000" } } // ... } } } ``` Zeigen Sie den Inhalt der `destination_details` an, um die [Rückerstattungsreferenz](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) zu finden, die den erstatteten ACH-Zahlungen zugeordnet ist. Das folgende Beispielereignis zeigt das Rendering einer erfolgreichen ACH-Rückerstattung mit einer Rückerstattungsreferenznummer. Weitere Informationen zu [Rückerstattungen](https://docs.stripe.com/refunds.md). #### charge-refund-updated ```json { "id": "{{EVENT_ID}}", "object": "event", "type": "charge.refund.updated", "data": { "object": { "id": "{{REFUND_ID}}", "object": "refund", //... "payment_intent": "{{PAYMENT_INTENT_ID}}", "destination_details": { "type": "us_bank_transfer", "us_bank_transfer": {"reference": "091000015001111", "reference_status": "available" } } // ... } } } ``` ## Optional: Abbuchungsdatum für Kunde/Kundin konfigurieren [Serverseitig] Das Datum, an dem Stripe das Bankkonto eines Kunden/einer Kundin belastet, können Sie über das [Zieldatum](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-us_bank_account-target_date) steuern. Das Zieldatum muss mindestens drei Tage in der Zukunft und nicht mehr als 15 Tage ab dem aktuellen Datum liegen. Mit dem Zieldatum wird geplant, dass das Geld das Konto des Kunden/der Kundin zum Zieldatum verlässt. Sie können einen [PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md), der mit einem Zieldatum erstellt wurde, bis zu drei Werktage vor dem konfigurierten Datum stornieren. Wenn das Zieldatum eines der folgenden Kriterien erfüllt, wird die Abbuchung am nächsten verfügbaren Werktag durchgeführt: - Das Zieldatum fällt auf ein Wochenende, einen Feiertag oder einen anderen arbeitsfreien Tag. - Das Zieldatum liegt weniger als drei Werktage in der Zukunft. Dieser Parameter wird auf Best-Effort-Basis ausgeführt. Es kann sein, dass die Bank jedes Kunden/jeder Kundin die Abbuchungen je nach örtlichen Feiertagen oder aus anderen Gründen zu unterschiedlichen Terminen vornimmt. > Sie können die [Verifizierungsmethode](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-us_bank_account-verification_method) nicht auf `microdeposits` festlegen, wenn Sie ein [Zieldatum](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-us_bank_account-target_date) verwenden, da der Verifizierungsvorgang längern dauern könnte als vorgesehen (Zieldatum), sodass die Zahlungen später als erwartet eintreffen. # Direkt-API > This is a Direkt-API for when payment-ui is direct-api. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=direct-api. Die Annahme von ACH-Lastschriftzahlungen auf Ihrer Website umfasst Folgendes: - Objekt zur Zahlungsverfolgung erstellen - Erfassen von Zahlungsmethodeninformationen mit sofortiger Verifizierung, die durch [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md) ermöglicht wird - Zahlung zur weiteren Verarbeitung an Stripe übermitteln - Bankkonto Ihres Kunden/Ihrer Kundin verifizieren Bei ACH Direct Debit handelt es sich um eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Dies bedeutet, dass Gelder nicht sofort nach der Zahlung verfügbar sind. Eine Zahlung benötigt in der Regel 4 Werktage bis zum Eingang auf Ihrem Konto. Stripe verwendet das Zahlungsobjekt, den [Payment Intent](https://docs.stripe.com/payments/payment-intents.md), zur Dokumentation und Verarbeitung aller Zahlungsstatus bis zum Zahlungsabschluss. > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. ## Stripe einrichten [Serverseitig] Zunächst benötigen Sie ein Stripe-Konto. [Jetzt registrieren](https://dashboard.stripe.com/register). Verwenden 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' ``` ## Kundinnen/Kunden erstellen oder abrufen [Empfohlen] [Serverseitig] > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. #### Accounts v2 Erstellen Sie ein von Kundinnen und Kunden konfiguriertes [Konto](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein bestehendes `Account` ab, das mit diesem/dieser Nutzer/in verknüpft ist. Wenn Sie die ID des `Account`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin oder eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse in das `Account` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl -X POST https://api.stripe.com/v2/core/accounts \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" \ --json '{ "contact_email": "{{CUSTOMER_EMAIL}}" }' ``` #### Customers v1 Erstellen Sie ein *Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein/e bestehende/n `Customer` ab, die/der mit dieser/diesem Nutzer/in verknüpft ist. Wenn Sie die ID des `Customer`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin/eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse für die/den `Customer` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl https://api.stripe.com/v1/customers \ -u "<>:" \ -d email={{CUSTOMER_EMAIL}} ``` ## PaymentIntent erstellen [Serverseitig] Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) ist ein Objekt, das Ihre Absicht darstellt, eine Zahlung von einer Kundin/einem Kunden einzuziehen, und das den Lebenszyklus des Zahlungsprozesses in jeder Phase verfolgt. Erstellen Sie einen PaymentIntent auf Ihrem Server und geben Sie den einzuziehenden Betrag und die Währung `usd` an. Wenn Sie bereits eine Integration mit der Payment Intents API haben, fügen Sie `us_bank_account` zur Liste der [Zahlungsmethodentypen](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) für Ihren PaymentIntent hinzu. Geben Sie die ID des Kunden/der Kundin an. Falls Sie die Zahlungsmethode künftig wiederverwenden möchten, geben Sie den Parameter [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) mit dem Wert `off_session` an. Weitere Informationen zu den Gebühren für Financial Connections finden Sie unter [Preisdetails](https://stripe.com/financial-connections#pricing). Bei der Erfassung von Zahlungsinformationen für Bankkonten wird standardmäßig [Financial Connections](https://docs.stripe.com/financial-connections.md) verwendet, um das Konto Ihres Kunden/Ihrer Kundin sofort zu verifizieren, mit einer Ausweichoption für die manuelle Eingabe der Kontonummer und die Verifizierung von Testeinzahlungen. In der [Financial Connections-Dokumentation](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) erfahren Sie, wie Sie Financial Connections konfigurieren und auf zusätzliche Kontodaten zugreifen, um Ihre ACH-Integration zu optimieren. Beispielsweise können Sie Financial Connections verwenden, um den Kontostand zu prüfen, bevor Sie die ACH-Zahlung veranlassen. > Um den Zugriff auf zusätzliche Daten auszudehnen, nachdem ein/e Kund/in sein/ihr Konto authentifiziert hat, muss er/sie das Konto mit erweiterten Berechtigungen erneut verknüpfen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" ``` ### 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 ``` ## Angaben zur Zahlungsmethode erfassen [Clientseitig] Wenn Kundinnen/Kunden über das „Click to Pay“-Verfahren mit ACH Direct Debit zahlen, empfehlen wir Ihnen, Stripe.js zu verwenden, um die Zahlung an Stripe zu übermitteln. [Stripe.js](https://docs.stripe.com/payments/elements.md) ist unsere grundlegende JavaScript-Bibliothek für die Erstellung von Zahlungsabläufen. Sie übernimmt automatisch komplexe Integrationsaufgaben und ermöglicht es Ihnen, Ihre Integration in Zukunft unkompliziert um andere Zahlungsmethoden zu erweitern. Binden Sie das Stripe.js-Skript in Ihre Zahlungsseite ein, indem Sie es im `head` Ihrer HTML-Datei einfügen. ```html Checkout ``` Erstellen Sie auf Ihrer Bezahlseite eine Instanz von Stripe.js mit dem folgenden JavaScript. ```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('<>'); ``` Anstatt das gesamte PaymentIntent-Objekt an den Client zu übermitteln, verwenden Sie dessen *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)) aus dem vorherigen Schritt. Dieses unterscheidet sich von Ihren API-Schlüsseln, mit denen Anfragen der Stripe API authentifiziert werden. Gehen Sie vorsichtig mit dem Client-Geheimnis um, da es die Zahlung abschließen kann. Protokollieren Sie es nicht, betten Sie es nicht in URLs ein und machen Sie es nur dem Kunden/der Kundin zugänglich. Verwenden Sie [stripe.collectBankAccountForPayment](https://docs.stripe.com/js/payment_intents/collect_bank_account_for_payment) , um Bankkontodaten mit [Financial Connections](https://docs.stripe.com/financial-connections.md) zu erfassen, eine *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) zu erstellen und diese PaymentMethod an den PaymentIntent anzuhängen. Der Parameter `billing_details` muss den Namen des Kontoinhabers/der Kontoinhaberin enthalten, um eine PaymentMethod für ein ACH-Lastschriftkonto zu erstellen. ```javascript // Use the form that already exists on the web page. const paymentMethodForm = document.getElementById('payment-method-form'); const confirmationForm = document.getElementById('confirmation-form'); paymentMethodForm.addEventListener('submit', (ev) => { ev.preventDefault(); const accountHolderNameField = document.getElementById('account-holder-name-field'); const emailField = document.getElementById('email-field'); // Calling this method will open the instant verification dialog. stripe.collectBankAccountForPayment({ clientSecret: clientSecret, params: { payment_method_type: 'us_bank_account', payment_method_data: { billing_details: { name: accountHolderNameField.value, email: emailField.value, }, }, }, expand: ['payment_method'], }) .then(({paymentIntent, error}) => { if (error) { console.error(error.message); // PaymentMethod collection failed for some reason. } else if (paymentIntent.status === 'requires_payment_method') { // Customer canceled the hosted verification modal. Present them with other // payment method type options. } else if (paymentIntent.status === 'requires_confirmation') { // We collected an account - possibly instantly verified, but possibly // manually-entered. Display payment method details and mandate text // to the customer and confirm the intent once they accept // the mandate. confirmationForm.show(); } }); }); ``` Der [Stripe Financial Connections-Authentifizierungsvogang](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) verarbeitet die Erfassung und Überprüfung von Bankkontodaten automatisch. Wenn Ihr Kunde/Ihre Kundin den Authentifizierungsvorgang abschließt, wird die *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) automatisch an den PaymentIntent angehängt und ein [Financial Connections Account](https://docs.stripe.com/api/financial_connections/accounts.md) wird erstellt. > Bankkonten, die Ihre Kundinnen/Kunden durch manuelle Eingabe und Testeinzahlungen verknüpfen, haben keinen Zugriff auf zusätzliche Bankkontodaten wie Salden, Kontoinhaberschaft und Transaktionen. Um die beste Nutzererfahrung auf allen Geräten zu bieten, setzen Sie die `minimum-scale` des Darstellungsfelds für Ihre Seite mithilfe des `meta`-Tags des Darstellungsfelds auf 1. ```html ``` ## Optional: Auf Daten für ein Financial Connections-Bankkonto zugreifen [Serverseitig] Sie können nur dann auf Financial Connections-Daten zugreifen, wenn Sie beim Erstellen Ihres/Ihrer PaymentIntent zusätzliche [Datenberechtigungen](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) anfordern. Nachdem Ihre Kundinnen und Kunden den [Authentifizierungsvorgang von Stripe Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) erfolgreich abgeschlossen haben, enthält die zurückgegebene PaymentMethod `us_bank_account` eine [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account)-ID, die auf ein [Financial Connections-Konto](https://docs.stripe.com/api/financial_connections/accounts.md) verweist. Verwenden Sie diese ID, um auf Kontodaten zuzugreifen. > Bankkonten, die Ihre Kunden/Kundinnen durch manuelle Eingabe verknüpfen, und Testeinzahlungen haben keine `financial_connections_account` auf der Zahlungsmethode. Um die Financial Connections-Konto-ID zu ermitteln, rufen Sie den PaymentIntent ab und erweitern Sie das Attribut `payment_method`: ```curl curl -G https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}} \ -u "<>:" \ -d "expand[]=payment_method" ``` ```json { "id": "{{PAYMENT_INTENT_ID}}", "object": "payment_intent", // ... "payment_method": { "id": "{{PAYMENT_METHOD_ID}}", // ... "type": "us_bank_account" "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}", "fingerprint": "q9qchffggRjlX2tb", "last4": "6789", "routing_number": "110000000" } } // ... } ``` Wenn Sie sich für die `balances`-Berechtigung entschieden haben, empfehlen wir Ihnen, Salden zu diesem Zeitpunkt zu überprüfen, um eine ausreichende Deckung zu gewährleisten, bevor Sie eine Zahlung bestätigen. Erfahren Sie mehr über die Verwendung zusätzlicher Kontodaten zur Optimierung Ihrer ACH-Integration mit [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize). ## Mandatsbestätigung einziehen und die Zahlung übermitteln [Clientseitig] Bevor Sie die Zahlung veranlassen können, müssen Sie eine Zahlungsautorisierung von Ihrem/Ihrer Kund/in einholen, indem Sie Mandatsbedingungen anzeigen, denen er/sie zustimmen muss. Um die Nacha-Regeln einzuhalten, müssen Sie eine Autorisierung von Ihrem Kunden/Ihrer Kundin einholen, bevor Sie die Zahlung veranlassen können. Dies tun Sie durch Anzeigen von Mandatskonditionen, denen der Kunde/die Kundin zustimmen muss. Weitere Informationen finden Sie unter [Mandate]](/payments/ach-direct-debit#mandates). Wenn der Kunde/die Kundin den Mandatskonditionen zustimmt, müssen Sie den PaymentIntent bestätigen. Verwenden Sie [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment), um die Zahlung abzuschließen, wenn der Kunde/die Kundin das Formular absendet. ```javascript confirmationForm.addEventListener('submit', (ev) => { ev.preventDefault(); stripe.confirmUsBankAccountPayment(clientSecret) .then(({paymentIntent, error}) => { if (error) { console.error(error.message); // The payment failed for some reason. } else if (paymentIntent.status === "requires_payment_method") { // Confirmation failed. Attempt again with a different payment method. } else if (paymentIntent.status === "processing") { // Confirmation succeeded! The account will be debited. // Display a message to customer. } else if (paymentIntent.next_action?.type === "verify_with_microdeposits") { // The account needs to be verified through microdeposits. // Display a message to consumer with next steps (consumer waits for // microdeposits, then enters a statement descriptor code on a page sent to them through email). } }); }); ``` > Die Ausführung von [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) kann einige Sekunden dauern. Während dieser Zeit sollten Sie Ihr Formular deaktivieren, damit keine erneute Übermittlung erfolgen kann. Lassen Sie stattdessen ein Wartesymbol einblenden, wie beispielsweise eine Sanduhr. Tritt ein Fehler auf, lassen Sie eine Fehlermeldung für die Kundin/den Kunden anzeigen, aktivieren Sie das Formular erneut und blenden Sie das Wartesymbol aus. Bei erfolgreicher Ausführung gibt Stripe ein PaymentIntent-Objekt mit einem der folgenden möglichen Status zurück: | Status | Beschreibung | Ausblick | | ----------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `requires_action` | Weitere Schritte sind erforderlich, um die Bankkontoverifizierung abzuschließen. | Schritt 6: [Bankkonten mit Testeinzahlungen verifizieren](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#web-verify-with-microdeposits) | | `processing` | Das Bankkonto wurde sofort verifiziert oder eine Verifizierung war nicht notwendig. | Schritt 7: [Erfolgreichen PaymentIntent bestätigen](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#web-confirm-paymentintent-succeeded) | Nach erfolgreicher Bestätigung des PaymentIntent muss eine E-Mail-Bestätigung des Mandats und der erfassten Bankkontodaten an Ihren Kunden/Ihre Kundin gesendet werden. Stripe kümmert sich standardmäßig darum, aber Sie können auch [nutzerdefinierte Benachrichtigungen senden](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails), wenn Sie dies vorziehen. ## Bankkonto mit Testeinzahlungen verifizieren [Clientseitig] Nicht alle Kund/innen können das Bankkonto sofort verifizieren. Dieser Schritt wird nur ausgeführt, wenn Ihr/e Kund/in die Sofortverifizierung im vorherigen Schritt deaktiviert hat. In diesen Fällen sendet Stripe eine `descriptor_code`-Testeinzahlung und greift möglicherweise auf eine `amount`-Testeinzahlung zurück, falls weitere Probleme bei der Verifizierung des Bankkontos auftreten. Es dauert 1–2 Werktage, bis diese Einzahlungen auf der Online-Abrechnung des Kunden/der Kundin erscheinen - **Code der Zahlungsbeschreibung**. Stripe sendet eine einzelne Mikroeinzahlung über 0,01 USD an das Bankkonto des/der Kund/in mit einem einmaligen, 6-stelligen `descriptor_code`, der mit SM beginnt. Ihr/e Kund/in verwendet diese Zeichenfolge, um sein/ihr Bankkonto zu verifizieren. - **Betrag**: Stripe sendet zwei nicht eindeutige Testeinzahlungen an das Kundenbankkonto, wobei `ACCTVERIFY` als Zahlungsbeschreibung in der Abrechnung angegeben ist. Ihre Kundin/Ihr Kunde verwendet die Einzahlungsbeträge zur Verifizierung des Bankkontos. Das Ergebnis des Aufrufs der Methode [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) im vorhergehenden Schritt ist ein PaymentIntent mit dem Status `requires_action`. Der PaymentIntent enthält das Feld `next_action`, das einige nützliche Informationen zum Abschließen der Verifizierung enthält. ```javascript next_action: { type: "verify_with_microdeposits", verify_with_microdeposits: { arrival_date: 1647586800, hosted_verification_url: "https://payments.stripe.com/…", microdeposit_type: "descriptor_code" } } ``` Wenn Sie eine [E-Mail-Adresse für die Rechnungsstellung](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email) angegeben haben, benachrichtigt Stripe Ihre Kundinnen und Kunden über diese E-Mail-Adresse, wann die Einzahlungen voraussichtlich eingehen werden. Die E-Mail enthält einen Link zu einer von Stripe gehosteten Verifizierungsseite, auf der sie die Beträge der Einzahlungen bestätigen und die Verifizierung abschließen können. > Verifizierungsversuche dürfen für beschreibungsbasierte Testeinzahlungen bis zu 10 mal und für betragsbasierte bis zu 3 mal fehlschlagen. Wenn Sie dieses Limit überschreiten, können wir das Bankkonto nicht mehr verifizieren. Darüber hinaus gilt für Verifizierungen von Testeinzahlungen eine Zeitüberschreitung von 10 Tagen. Werden Testeinzahlungen nicht innerhalb dieser Zeit verifiziert, fordert der PaymentIntent wieder neue Angaben zur Zahlungsmethode an. Wenn Sie Ihren Kund/innen genau erläutern, was Testeinzahlungen sind und wie sie verwendet werden, können Sie Probleme bei der Verifizierung vermeiden. ### Optional: Nutzerdefinierte E-Mails-Benachrichtigungen senden Optional können Sie [personalisierte E-Mail-Benachrichtigungen](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) an Ihren Kunden/Ihre Kundin senden. Nachdem Sie die nutzerspezifischen E-Mails eingerichtet haben, müssen Sie angeben, wie der Kunde/die Kundin auf die Verifizierungs-E-Mail antwortet. Wählen Sie dazu *eine* der folgenden Optionen aus: - Verwenden Sie die von Stripe gehostete Verifizierungsseite. Verwenden Sie dazu die URL `verify_with_microdeposits[hosted_verification_url]` im [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url)-Objekt, um Ihre Kundinnen/Kunden zum Abschluss des Verifizierungsvorgangs zu leiten. - Wenn Sie die von Stripe gehostete Verifizierungsseite nicht verwenden möchten, können Sie auf Ihrer Website ein Formular für Ihre Kundinnen/Kunden zur Weiterleitung von Testeinzahlungen an Sie erstellen und das Bankkonto mit [Stripe.js](https://docs.stripe.com/js/payment_intents/verify_microdeposits_for_payment) verifizieren. - Richten Sie das Formular mindestens so ein, dass es den Parameter `descriptor code` verarbeitet, bei dem es sich um eine 6-stellige Zeichenfolge zu Verifizierungszwecken handelt. - Stripe empfiehlt außerdem, dass Sie Ihr Formular so konfigurieren, dass der Parameter `beträge` verarbeitet wird, da einige der von Ihren Kund/innen verwenden Banken dies möglicherweise verlangen. Integrationen übergeben nur den `descriptor_code` *oder* `amounts`. Um festzustellen, welches Ihre Integration verwendet, prüfen Sie den Wert für `verify_with_microdeposits[microdeposit_type]` im `next_action`-Objekt. ```javascript stripe.verifyMicrodepositsForPayment(clientSecret, { // Provide either a descriptor_code OR amounts, not both descriptor_code: 'SMT86W', amounts: [32, 45], }); ``` Wenn das Bankkonto erfolgreich verifiziert wurde, gibt Stripe das PaymentIntent-Objekt mit dem `status` `processing` zurück und übermittelt das *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests)-Ereignis [payment_intent.processing`](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.processing). Die Verifizierung kann aus unterschiedlichen Gründen fehlschlagen. Der Fehler kann synchron als direkte Fehlermeldung oder asynchron über das Webhook-Ereignis [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.failed) auftreten (wie in den folgenden Beispielen dargestellt). #### Synchroner Fehler ```json { "error": { "code": "payment_method_microdeposit_verification_amounts_mismatch", "message": "The amounts provided do not match the amounts that were sent to the bank account. You have {attempts_remaining} verification attempts remaining.", "type": "invalid_request_error" } } ``` #### Webhook-Ereignis ```javascript { "object": { "id": "pi_1234", "object": "payment_intent", "customer": "cus_0246", ... "last_payment_error": { "code": "payment_method_microdeposit_verification_attempts_exceeded", "message": "You have exceeded the number of allowed verification attempts.", }, ... "status": "requires_payment_method" } } ``` | Fehlercode | Synchron oder asynchron | Meldungen | Änderung des Status | | ------------------------------------------------------------ | ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | | `payment_method_microdeposit_failed` | Synchron oder asynchron über ein Webhook-Ereignis | Die Testeinzahlungen sind fehlgeschlagen. Bitte überprüfen Sie die Kontonummer, die Finanzinstitutsnummer und die bereitgestellte Transitnummer. | `status` ist `requires_payment_method` und `last_payment_error` ist festgelegt. | | `payment_method_microdeposit_verification_amounts_mismatch` | Synchron | Die angegebenen Beträge stimmen nicht mit den Beträgen überein, die an das Bankkonto gesendet wurden. Sie haben noch {attempts_remaining} Verifizierungsversuche. | Unverändert | | `payment_method_microdeposit_verification_attempts_exceeded` | Synchron oder asynchron über ein Webhook-Ereignis | Anzahl zulässiger Verifizierungsversuche wurde überschritten | `status` ist `requires_payment_method` und `last_payment_error` ist festgelegt. | | `payment_method_microdeposit_verification_timeout` | Asynchron über ein Webhook-Ereignis | Zeitüberschreitung bei der Testeinzahlung. Die Kundin/der Kunde hat das Bankkonto nicht innerhalb der Frist von 10 Tagen verifiziert. | `status` ist `requires_payment_method` und `last_payment_error` ist festgelegt. | ## Erfolgreichen PaymentIntent bestätigen [Serverseitig] Bei ACH Direct Debit handelt es sich um eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Das bedeutet, dass es bis zu vier Werktage dauern kann, bis Sie nach Initiierung einer Lastschrift für das Kundenkonto eine Mitteilung über die erfolgreiche oder fehlgeschlagene Zahlung erhalten. Der von Ihnen erstellte PaymentIntent hat zunächst den Status `processing`. Wenn die Zahlung erfolgreich war, wird der PaymentIntent-Status von `processing` in `succeeded` geändert. Wir empfehlen die Verwendung von [Webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks), um die erfolgreiche Zahlung zu *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) und die Kundinnen/Kunden zu informieren, dass die Zahlung abgeschlossen ist. Sie können sich Ereignisse auch im [Stripe-Dashboard](https://dashboard.stripe.com/events) anzeigen lassen. #### PaymentIntent-Ereignisse Die folgenden Ereignisse werden übermittelt, wenn der PaymentIntent-Status aktualisiert wird: | Ereignis | Beschreibung | Nächster Schritt | | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent.processing` | Die Zahlung der Kundin/des Kunden wurde erfolgreich an Stripe übermittelt. | Warten Sie, bis die initiierte Zahlung erfolgt oder fehlschlägt. | | `payment_intent.succeeded` | Die Kundenzahlung war erfolgreich. | Führen Sie die Bestellung der gekauften Waren oder Dienstleistungen aus. | | `payment_intent.payment_failed` | Die Zahlung der Kundin/des Kunden wurde abgelehnt. Dies kann auch bei einer fehlgeschlagenen Verifizierung der Testeinzahlung zutreffen. | Kontaktieren Sie Ihre/n Kund/in per E-Mail oder Push-Benachrichtigung und fordern Sie eine andere Zahlungsmethode an. Wenn der Webhook aufgrund einer fehlgeschlagenen Verifizierung der Testeinzahlung übermittelt wurde, müssen die Nutzer/innen ihre Bankkontodaten erneut eingeben. Danach werden neue Testeinzahlungen durchgeführt. | #### Zahlungsereignisse Sie können auch zusätzliche Charge-Webhooks verwenden, um den Status der Zahlung zu verfolgen. Sobald Sie den Webhook `charge.updated` empfangen haben, kann die Zahlung nicht mehr storniert werden. Die folgenden Ereignisse werden gesendet, wenn der Status der Zahlung aktualisiert wird: | Ereignis | Beschreibung | Nächster Schritt | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | | `charge.pending` | Die Zahlung wurde erfolgreich erstellt. | Warten Sie, bis die initiierte Zahlung verarbeitet wird. | | `charge.updated` | Die Kundenzahlung wurde aktualisiert. Sie kann gesendet werden, wenn eine neue Saldo-Transaktion erstellt wurde und eine Zahlungsbeschreibung bzw. die Metadaten aktualisiert wurden. | Warten Sie, bis die initiierte Zahlung erfolgt oder fehlschlägt. | | `charge.succeeded` | Die Kundenzahlung war erfolgreich und das Geld ist in Ihrem Saldo verfügbar. | Führen Sie die Bestellung der gekauften Waren oder Dienstleistungen aus. | | `charge.failed` | Kundenzahlung ist fehlgeschlagen. | Überprüfen Sie den failure_code und die failure_message der Zahlung, um weitere Maßnahmen festzulegen. | ## Integration testen Erfahren Sie, wie Sie Szenarien mit sofortigen Verifizierungen mithilfe von [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts) testen können. ### Transaktions-E-Mails in einer Sandbox senden Nachdem Sie die Bankkontodetails erfasst und ein Mandat akzeptiert haben, senden Sie die Mandatsbestätigung und die Verifizierungs-E-Mails mit Testeinzahlungen in einer *Sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes). Wenn Ihre Domain **{domain}** lautet und Ihr Benutzername **{username}** ist, verwenden Sie das folgende E-Mail-Format, um Test-Transaktions-E-Mails zu versenden: **{username}+test\_email@{domain}**. Wenn Ihre Domain beispielsweise **example.com** und Ihr Nutzername **Info** lautet, verwenden Sie zum Testen von ACH Direct Debit-Zahlungen das Format **info+test\_email@example.com**. Dieses Format stellt sicher, dass E-Mails korrekt weitergeleitet werden. Wenn Sie das Suffix **+test\_email** nicht angeben, senden wir die E-Mail nicht. > Sie müssen [Ihr Stripe-Konto einrichten](https://docs.stripe.com/get-started/account/set-up.md), bevor Sie diese E-Mails während Tests auslösen können. ### Testkontonummern Stripe stellt mehrere Testkontonummern und dazugehörige Token zur Verfügung, um sicherzustellen, dass Ihre Integration für Bankkonten mit manueller Eingabe für den Einsatz in einer Produktionsumgebung bereit ist. | Kontonummer | Token | Bankleitzahl | Verhalten | | -------------- | -------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000123456789` | `pm_usBankAccount_success` | `110000000` | Die Zahlung ist erfolgreich. | | `000111111113` | `pm_usBankAccount_accountClosed` | `110000000` | Die Zahlung schlägt fehl, weil das Konto geschlossen ist. | | `000000004954` | `pm_usBankAccount_riskLevelHighest` | `110000000` | Die Zahlung wird von Radar aufgrund eines [hohen Betrugsrisikos](https://docs.stripe.com/radar/risk-evaluation.md#high-risk) blockiert. | | `000111111116` | `pm_usBankAccount_noAccount` | `110000000` | Die Zahlung schlägt fehl, weil kein Konto gefunden wird. | | `000222222227` | `pm_usBankAccount_insufficientFunds` | `110000000` | Die Zahlung schlägt aufgrund unzureichender Deckung fehl. | | `000333333335` | `pm_usBankAccount_debitNotAuthorized` | `110000000` | Die Zahlung schlägt fehl, weil die Lastschriften nicht autorisiert sind. | | `000444444440` | `pm_usBankAccount_invalidCurrency` | `110000000` | Die Zahlung schlägt aufgrund einer ungültigen Währung fehl. | | `000666666661` | `pm_usBankAccount_failMicrodeposits` | `110000000` | Die Zahlung sendet keine Testeinzahlungen. | | `000555555559` | `pm_usBankAccount_dispute` | `110000000` | Die Zahlung löst eine Zahlungsanfechtung aus. | | `000000000009` | `pm_usBankAccount_processing` | `110000000` | Die Zahlung bleibt auf unbestimmte Zeit in Bearbeitung. Nützlich zum Testen [der Stornierung des PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md). | | `000777777771` | `pm_usBankAccount_weeklyLimitExceeded` | `110000000` | Die Zahlung schlägt aufgrund des Zahlungsbetrags fehl, wodurch das Konto sein wöchentliches Zahlungsvolumenlimit überschreitet. | | `000888888885` | | `110000000` | Die Zahlung schlägt aufgrund einer deaktivierten [tokenisierten Kontonummer](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) fehl. | Bevor Testtransaktionen abgeschlossen werden können, müssen Sie alle Testkonten verifizieren, auf denen die Zahlung automatisch erfolgreich war oder fehlschlagen ist. Verwenden Sie dazu die nachstehenden Test-Mikroeinzahlungsbeträge oder Beschreibungscodes. ### Testen von Mikroeinzahlungen und Beschreibungscodes Um verschiedene Szenarien zu imitieren, verwenden Sie diese Mikroeinzahlungsbeträge *oder* 0,01 Beschreibungscodewerte. | Testeinzahlungswerte | 0.01 Beschreibungscodewerte | Szenario | | -------------------- | --------------------------- | ------------------------------------------------------------------------- | | `32` und `45` | SM11AA | Simuliert die Verifizierung des Kontos. | | `10` und `11` | SM33CC | Simuliert das Überschreiten der Anzahl zulässiger Verifizierungsversuche. | | `40` und `41` | SM44DD | Simuliert ein Testeinzahlungs-Timeout. | ### Abwicklungsverhalten testen Testtransaktionen werden sofort abgewickelt und Ihrem verfügbaren Testguthaben hinzugefügt. Dieses Verhalten unterscheidet sich vom Live-Modus, bei dem es [mehrere Tage](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Optional: Nur Sofortverifizierung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die Zahlungen per US-Bankkonto tätigen, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional auch nur eine sofortige Verifizierung des Bankkontos verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den PaymentIntent erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` Dadurch wird sichergestellt, dass Sie keine Verifizierung von Testeinzahlungen durchführen müssen. Wenn die sofortige Verifizierung jedoch fehlschlägt, lautet der Status des PaymentIntent `requires_payment_method`. Dies weist darauf hin, dass die sofortige Verifizierung eines Kundenbankkontos fehlgeschlagen ist. ## Optional: Verifizierung ausschließlich durch Testeinzahlung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die Zahlungen per US-Bankkonto tätigen, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional auch nur Testeinzahlungen verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den PaymentIntent erstellen. > Wenn Sie ein individuelles Zahlungsformular verwenden, müssen Sie Ihre eigene Nutzeroberfläche erstellen, um Bankkontodaten zu erfassen. Wenn Sie Stripe-E-Mails mit Testeinzahlungen deaktivieren, müssen Sie Ihre eigene Nutzeroberfläche für Ihre Kundin/Ihren Kunden erstellen, um den Testeinzahlungscode bzw. -betrag zu bestätigen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=microdeposits" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=microdeposits" ``` Sie müssen dann das Bankkonto Ihrer Kundin/Ihres Kunden mit Ihrem eigenen Formular erfassen und [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) mit diesen Angaben aufrufen, um den PaymentIntent abzuschließen. ```javascript var form = document.getElementById('payment-form'); var accountholderName = document.getElementById('accountholder-name'); var email = document.getElementById('email'); var accountNumber = document.getElementById('account-number'); var routingNumber = document.getElementById('routing-number'); var accountHolderType= document.getElementById('account-holder-type'); var submitButton = document.getElementById('submit-button'); var clientSecret = submitButton.dataset.secret; form.addEventListener('submit', function(event) { event.preventDefault(); stripe.confirmUsBankAccountPayment(clientSecret, { payment_method: { billing_details: { name: accountholderName.value, email: email.value, }, us_bank_account: { account_number: accountNumber.value, routing_number: routingNumber.value, account_holder_type: accountHolderType.value, // 'individual' or 'company' }, }, }) .then(({paymentIntent, error}) => { if (error) { // Inform the customer that there was an error. console.log(error.message); } else { // Handle next step based on the intent's status. console.log("PaymentIntent ID: " + paymentIntent.id); console.log("PaymentIntent status: " + paymentIntent.status); } }); }); ``` ## Optional: Zahlungsanfechtungen beheben [Serverseitig] Kundinnen/Kunden [fechten eine ACH-Lastschriftahlung](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#resolving-disputes) im Allgemeinen über ihre Bank an. Dies geschieht in der Regel bis zu 60 Kalendertage nach einer Abbuchung auf einem Privatkonto oder bis zu 2 Werktage bei einem Geschäftskonto. In seltenen Fällen können Kundinnen und Kunden die Lastschriftzahlung auch außerhalb dieser Fristen erfolgreich anfechten. Wenn Kundinnen/Kunden eine Zahlung anfechten, sendet Stripe das Webhook-Ereignis [charge.dispute.closed](https://docs.stripe.com/api/events/types.md#event_types-charge.dispute.closed), und die PaymentMethod-Autorisierung wird widerrufen. In seltenen Fällen erhält Stripe möglicherweise einen ACH-Fehler von der Bank, nachdem ein PaymentIntent in den Status `succeeded` gewechselt ist. In diesem Fall erstellt Stripe eine Zahlungsanfechtung mit folgendem `reason`: - `insufficient_funds` - `incorrect_account_details` - `bank_can't_process` Stripe erhebt in diesem Fall eine Fehlergebühr. Zukünftige Zahlungen, die diese PaymentMethod wiederverwenden, geben den folgenden Fehler zurück: ```javascript { "error": { "message": "This PaymentIntent requires a mandate, but no existing mandate was found. Collect mandate acceptance from the customer and try again, providing acceptance data in the mandate_data parameter.", "payment_intent": { ... } "type": "invalid_request_error" } } ``` Dieser Fehler enthält einen PaymentIntent im Status `requires_confirmation`. Um mit der Zahlung fortzufahren, müssen Sie: 1. Legen Sie die Zahlungsanfechtung mit dem Kunden/der Kundin bei, um sicherzustellen, dass zukünftige Zahlungen nicht angefochten werden. 1. Bestätigen Sie die Autorisierung Ihres Kunden/Ihrer Kundin erneut. Um die Autorisierung der Zahlung zu bestätigen, können Sie [mit Stripe.js online eine Mandatsbestätigung von Ihrem Kunden/Ihrer Kundin einholen](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md?platform=web#web-collect-mandate-and-submit) oder die Autorisierung mit Ihrem Kunden/Ihrer Kundin offline über die Stripe API bestätigen. > Wenn ein/e Kund/in mehr als eine Zahlung von demselben Bankkonto anficht, sperrt Stripe sein/ihr Bankkonto. Wenden Sie sich an den [Stripe-Support](https://support.stripe.com/?contact=true), um zusätzliche Hilfe zu erhalten. ```curl curl https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/confirm \ -u "<>:" \ -d "mandate_data[customer_acceptance][type]=offline" ``` ## Optional: Zahlungsreferenz Die Zahlungsreferenznummer ist ein von der Bank generierter Wert, mit dem der/die Kontoinhaber/in Gelder bei seiner/ihrer Bank finden kann. Wenn die Zahlung erfolgreich ist, gibt Stripe die Zahlungsreferenznummer im Dashboard und im [Zahlungsobjekt](https://docs.stripe.com/api/charges/object.md) an. | Status der Abbuchung | Zahlungsreferenzwert | | -------------------- | ---------------------------------------- | | Ausstehend | Nicht verfügbar | | Fehlgeschlagen | Nicht verfügbar | | Erfolgreich | Verfügbar (zum Beispiel 091000015001234) | Wenn Sie den Webhook `charge.succeeded` erhalten, zeigen Sie außerdem den Inhalt von `payment_method_details` an, um die [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference) zu finden. Das folgende Beispielereignis zeigt das Rendern einer erfolgreichen ACH-Zahlung mit einer Zahlungsreferenznummer. #### charge-succeeded ```json { "id": "{{EVENT_ID}}", "object": "event", // omitted some fields in the example "type": "charge.succeeded", "data": { "object": { "id": "{{PAYMENT_ID}}", "object": "charge", //... "paid": true, "payment_intent": "{{PAYMENT_INTENT_ID}}", "payment_method": "{{PAYMENT_METHOD_ID}}", "payment_method_details": { "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK", "fingerprint": "Ih3foEnRvLXShyfB", "last4": "1000","payment_reference": "091000015001234", "routing_number": "110000000" } } // ... } } } ``` Zeigen Sie den Inhalt der `destination_details` an, um die [Rückerstattungsreferenz](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) zu finden, die den erstatteten ACH-Zahlungen zugeordnet ist. Das folgende Beispielereignis zeigt das Rendering einer erfolgreichen ACH-Rückerstattung mit einer Rückerstattungsreferenznummer. Weitere Informationen zu [Rückerstattungen](https://docs.stripe.com/refunds.md). #### charge-refund-updated ```json { "id": "{{EVENT_ID}}", "object": "event", "type": "charge.refund.updated", "data": { "object": { "id": "{{REFUND_ID}}", "object": "refund", //... "payment_intent": "{{PAYMENT_INTENT_ID}}", "destination_details": { "type": "us_bank_transfer", "us_bank_transfer": {"reference": "091000015001111", "reference_status": "available" } } // ... } } } ``` ## Optional: Abbuchungsdatum für Kunde/Kundin konfigurieren [Serverseitig] Das Datum, an dem Stripe das Bankkonto eines Kunden/einer Kundin belastet, können Sie über das [Zieldatum](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-us_bank_account-target_date) steuern. Das Zieldatum muss mindestens drei Tage in der Zukunft und nicht mehr als 15 Tage ab dem aktuellen Datum liegen. Mit dem Zieldatum wird geplant, dass das Geld das Konto des Kunden/der Kundin zum Zieldatum verlässt. Sie können einen [PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md), der mit einem Zieldatum erstellt wurde, bis zu drei Werktage vor dem konfigurierten Datum stornieren. Wenn das Zieldatum eines der folgenden Kriterien erfüllt, wird die Abbuchung am nächsten verfügbaren Werktag durchgeführt: - Das Zieldatum fällt auf ein Wochenende, einen Feiertag oder einen anderen arbeitsfreien Tag. - Das Zieldatum liegt weniger als drei Werktage in der Zukunft. Dieser Parameter wird auf Best-Effort-Basis ausgeführt. Es kann sein, dass die Bank jedes Kunden/jeder Kundin die Abbuchungen je nach örtlichen Feiertagen oder aus anderen Gründen zu unterschiedlichen Terminen vornimmt. ## See also - [Vorab autorisierte ACH-Lastschriftzahlungen für zukünftige Zahlungen speichern](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md) # iOS > This is a iOS for when payment-ui is mobile and platform is ios. View the full page at https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment?payment-ui=mobile&platform=ios. > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. Die Annahme von ACH-Lastschriftzahlungen mit Ihrer Anwendung umfasst Folgendes: - Objekt zur Zahlungsverfolgung erstellen - Erfassen von Zahlungsmethodeninformationen mit sofortiger Verifizierung, die durch [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md) ermöglicht wird - Zahlung zur weiteren Verarbeitung an Stripe übermitteln - Bankkonto Ihres Kunden/Ihrer Kundin verifizieren > Bei ACH Direct Debit handelt es sich um eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Dies bedeutet, dass Gelder nicht sofort nach der Zahlung verfügbar sind. Eine Zahlung benötigt in der Regel 4 Werktage bis zum Eingang auf Ihrem Konto. Stripe verwendet das Zahlungsobjekt, den [Payment Intent](https://docs.stripe.com/payments/payment-intents.md), zur Dokumentation und Verarbeitung aller Zahlungsstatus bis zum Zahlungsabschluss. Das [iOS SDK](https://github.com/stripe/stripe-ios) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-ios/index.html) und mit allen Apps kompatibel, die iOS 13 oder höher unterstützen. #### Swift Package Manager SDK installieren: 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 dem [Ziel Ihrer App](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) die Produkte **StripePayments** und **StripeFinancialConnections** 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 'Stripe' pod 'StripeFinancialConnections' ``` 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 Stripe pod update StripeFinancialConnections ``` #### 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#releases) aufgeführten erforderlichen Frameworks einbetten. 1. Zusätzlich zu den erforderlichen Frameworks im oben stehenden Link muss auch das Framework **StripeFinancialConnections** enthalten sein. 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 **Stripe.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 **StripeFinancialConnections.xcframework** 1. Wiederholen Sie Schritt 2 für alle [hier](https://github.com/stripe/stripe-ios#releases) 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 aktuellsten SDK-Version und vorigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-ios/releases) auf GitHub. Um bei Veröffentlichung eines neuen Release eine Benachrichtigung zu erhalten, [beobachten Sie Veröffentlichungen für das jeweilige 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 UIKitimportStripeFinancialConnections @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. Mit Stripe können Sie das Bankkonto eines Kunden/einer Kundin sofort verifizieren. Wenn Sie zusätzliche Daten zu einem Konto abrufen möchten, [registrieren Sie sich für den Datenzugriff](https://dashboard.stripe.com/financial-connections/application) mit [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md). Mit Stripe Financial Connections können Ihre Kund/innen ihre Finanzdaten sicher teilen, indem sie ihre Finanzkonten mit Ihrem Unternehmen verknüpfen. Verwenden Sie Financial Connections, um auf von Kund/innen autorisierte Finanzdaten zuzugreifen, wie zum Beispiel tokenisierte Konto- und Routingnummern, Saldodaten, Eigentumsdaten und Transaktionsdaten. Der Zugriff auf diese Daten hilft Ihnen, Aktionen wie das Überprüfen von Salden durchzuführen, bevor Sie eine Zahlung veranlassen. Dies verringert die Wahrscheinlichkeit einer fehlgeschlagenen Zahlung aufgrund unzureichender Deckung. Mit Financial Connections können Ihre Nutzer/innen ihre Konten in wenigen Schritten mit Link verknüpfen. So können sie ihre Bankkontodaten bei Stripe-Unternehmen speichern und wiederverwenden. ## Kundinnen/Kunden erstellen oder abrufen [Empfohlen] [Serverseitig] > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. #### Accounts v2 Erstellen Sie ein von Kundinnen und Kunden konfiguriertes [Konto](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein bestehendes `Account` ab, das mit diesem/dieser Nutzer/in verknüpft ist. Wenn Sie die ID des `Account`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin oder eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse in das `Account` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl -X POST https://api.stripe.com/v2/core/accounts \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" \ --json '{ "contact_email": "{{CUSTOMER_EMAIL}}" }' ``` #### Customers v1 Erstellen Sie ein *Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein/e bestehende/n `Customer` ab, die/der mit dieser/diesem Nutzer/in verknüpft ist. Wenn Sie die ID des `Customer`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin/eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse für die/den `Customer` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl https://api.stripe.com/v1/customers \ -u "<>:" \ -d email={{CUSTOMER_EMAIL}} ``` ## PaymentIntent erstellen [Serverseitig] [Clientseitig] Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) ist ein Objekt, das Ihre Absicht darstellt, eine Zahlung von einer Kundin/einem Kunden einzuziehen, und das den Lebenszyklus des Zahlungsprozesses in jeder Phase verfolgt. ### Serverseitig Erstellen Sie zunächst einen PaymentIntent auf Ihrem Server und geben Sie den einzuziehenden Betrag und die Währung `usd` an. Falls Sie bereits über eine Integration verfügen, die die Payment Intents API 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 `us_bank_account` hinzu. Geben Sie optional die [ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) der Kundin/des Kunden an. Falls Sie die Zahlungsmethode künftig wiederverwenden möchten, geben Sie den Parameter [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) mit dem Wert `off_session` an. Weitere Informationen zu den Gebühren für Financial Connections finden Sie unter [Preisdetails](https://stripe.com/financial-connections#pricing). Bei der Erfassung von Zahlungsinformationen für Bankkonten wird standardmäßig [Financial Connections](https://docs.stripe.com/financial-connections.md) verwendet, um das Konto Ihres Kunden/Ihrer Kundin sofort zu verifizieren, mit einer Ausweichoption für die manuelle Eingabe der Kontonummer und die Verifizierung von Testeinzahlungen. In der [Financial Connections-Dokumentation](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) erfahren Sie, wie Sie Financial Connections konfigurieren und auf zusätzliche Kontodaten zugreifen, um Ihre ACH-Integration zu optimieren. Beispielsweise können Sie Financial Connections verwenden, um den Kontostand zu prüfen, bevor Sie die ACH-Zahlung veranlassen. > Um den Zugriff auf zusätzliche Daten auszudehnen, nachdem ein/e Kund/in sein/ihr Konto authentifiziert hat, muss er/sie das Konto mit erweiterten Berechtigungen erneut verknüpfen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" ``` ### Clientseitig 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, mit dem der Client den Zahlungsvorgang sicher abschließen kann, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Fordern Sie auf dem Client einen PaymentIntent von Ihrem Server an und speichern Sie dessen Client-Geheimnis. #### Swift ```swift import UIKit import StripePayments class CheckoutViewController: UIViewController { var paymentIntentClientSecret: String? func startCheckout() { // Request a PaymentIntent from your server and store its client secret } } ``` ## Rückgabe-URL einrichten [Clientseitig] Der Kunde/Die Kundin verlässt ggf. Ihre App, um sich zu authentifizieren (z. B. in Safari oder einer Banking-App). Damit sie nach der Authentifizierung automatisch zu Ihrer App zurückkehren können, [konfigurieren Sie ein benutzerdefiniertes URL-Schema](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app) und richten Sie Ihren App-Delegate so ein, dass die URL an das SDK weitergeleitet wird. Stripe unterstützt keine [universellen Links](https://developer.apple.com/documentation/xcode/allowing-apps-and-websites-to-link-to-your-content). > Stripe fügt möglicherweise zusätzliche Parameter an die angegebene Rückgabe-URL an. Stellen Sie sicher, dass Rückgabe-URLs mit zusätzlichen Parametern nicht von Ihrem Code zurückgewiesen werden. #### SceneDelegate #### Swift ```swift // This method handles opening custom URL schemes (for example, "your-app://stripe-redirect") func scene(_ scene: UIScene, openURLContexts URLContexts: Set) { guard let url = URLContexts.first?.url else { return } let stripeHandled = StripeAPI.handleURLCallback(with: url) if (!stripeHandled) { // This was not a Stripe url – handle the URL normally as you would } } ``` #### AppDelegate #### Swift ```swift // This method handles opening custom URL schemes (for example, "your-app://stripe-redirect") func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool { let stripeHandled = StripeAPI.handleURLCallback(with: url) if (stripeHandled) { return true } else { // This was not a Stripe url – handle the URL normally as you would } return false } ``` #### SwiftUI #### Swift ```swift @main struct MyApp: App { var body: some Scene { WindowGroup { Text("Hello, world!").onOpenURL { incomingURL in let stripeHandled = StripeAPI.handleURLCallback(with: incomingURL) if (!stripeHandled) { // This was not a Stripe url – handle the URL normally as you would } } } } } ``` ## Angaben zur Zahlungsmethode erfassen [Clientseitig] Damit die Zahlung erfolgreich ist, erfordert das ACH Direct Debit einen Kundennamen und (optional) eine E-Mail-Adresse. Erfassen Sie in Ihrer App die notwendigen Abrechnungsdaten von den Kund/innen: - Den vollständigen Namen (Vor- und Nachname) der Kundin/des Kunden - E-Mail-Adresse Verwenden Sie die Klassenfunktion `collectUSBankAccountParams` in `STPCollectBankAccountParams`, um Ihre Parameter zu erstellen, die zum Aufrufen von `collectBankAccountForPayment` erforderlich sind. Um die PaymentMethod „ACH Direct Debit“ zu erstellen, muss der Name des Kontoinhabers/der Kontoinhaberin im Parameter `billing_details` enthalten sein. Erstellen Sie eine Instanz von `STPBankAccountCollector`, um `collectBankAccountForPayment` aufzurufen und Bankkontodetails zu erfassen, eine *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) zu erstellen und diese PaymentMethod an den PaymentIntent anzuhängen. #### Swift ```swift // Build params let collectParams = STPCollectBankAccountParams.collectUSBankAccountParams(with: name, email: email) // (optional) Configure the style let style: STPBankAccountCollectorUserInterfaceStyle = .alwaysLight let bankAccountCollector = STPBankAccountCollector(style: style) // Calling this method will display a modal for collecting bank account information bankAccountCollector.collectBankAccountForPayment(clientSecret: clientSecret, returnURL: "https://your-app-domain.com/stripe-redirect", params: collectParams, from: self) { intent, error in guard let intent = intent else { // handle error return } if case .requiresPaymentMethod = intent.status { // Customer canceled the Financial Connections modal. Present them with other // payment method type options. } else if case .requiresConfirmation = intent.status { // We collected an account - possibly instantly verified, but possibly // manually-entered. Display payment method details and mandate text // to the customer and confirm the intent once they accept // the mandate. } } ``` Dadurch wird eine Modal-Nutzeroberfläche geladen, um die Erfassung und Überprüfung der Bankkontodaten abzuwickeln. Wenn dies abgeschlossen ist, wird die *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) automatisch an den PaymentIntent angehängt. ## Optional: Auf Daten für ein Financial Connections-Bankkonto zugreifen [Serverseitig] Sie können nur dann auf Financial Connections-Daten zugreifen, wenn Sie beim Erstellen Ihres/Ihrer PaymentIntent zusätzliche [Datenberechtigungen](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) anfordern. Nachdem Ihre Kundinnen und Kunden den [Authentifizierungsvorgang von Stripe Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) erfolgreich abgeschlossen haben, enthält die zurückgegebene PaymentMethod `us_bank_account` eine [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account)-ID, die auf ein [Financial Connections-Konto](https://docs.stripe.com/api/financial_connections/accounts.md) verweist. Verwenden Sie diese ID, um auf Kontodaten zuzugreifen. > Bankkonten, die Ihre Kunden/Kundinnen durch manuelle Eingabe verknüpfen, und Testeinzahlungen haben keine `financial_connections_account` auf der Zahlungsmethode. Um die Financial Connections-Konto-ID zu ermitteln, rufen Sie den PaymentIntent ab und erweitern Sie das Attribut `payment_method`: ```curl curl -G https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}} \ -u "<>:" \ -d "expand[]=payment_method" ``` ```json { "id": "{{PAYMENT_INTENT_ID}}", "object": "payment_intent", // ... "payment_method": { "id": "{{PAYMENT_METHOD_ID}}", // ... "type": "us_bank_account" "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}", "fingerprint": "q9qchffggRjlX2tb", "last4": "6789", "routing_number": "110000000" } } // ... } ``` Wenn Sie sich für die `balances`-Berechtigung entschieden haben, empfehlen wir Ihnen, Salden zu diesem Zeitpunkt zu überprüfen, um eine ausreichende Deckung zu gewährleisten, bevor Sie eine Zahlung bestätigen. Erfahren Sie mehr über die Verwendung zusätzlicher Kontodaten zur Optimierung Ihrer ACH-Integration mit [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize). ## Mandatsbestätigung einziehen und die Zahlung übermitteln [Clientseitig] Bevor Sie die Zahlung veranlassen können, müssen Sie eine Zahlungsautorisierung von Ihrem/Ihrer Kund/in einholen, indem Sie Mandatsbedingungen anzeigen, denen er/sie zustimmen muss. Um die *Nacha* (Nacha is the governing body that oversees the ACH network)-Regeln einzuhalten, müssen Sie eine Autorisierung von Ihrem Kunden/Ihrer Kundin einholen, bevor Sie die Zahlung veranlassen können. Dies erfolgt durch Anzeigen von Mandatsbedingungen, denen der Kunde/die Kundin zustimmen muss. Weitere Informationen finden Sie unter [Mandate]](/payments/ach-direct-debit#mandates). Wenn der/die Kund/in den Mandatskonditionen zustimmt, müssen Sie den PaymentIntent bestätigen. Verwenden Sie `confirmPayment`, um die Zahlung abzuschließen, wenn der/die Kund/in das Formular absendet. #### Swift ```swift let paymentIntentParams = STPPaymentIntentParams(clientSecret: clientSecret, paymentMethodType: .USBankAccount) STPPaymentHandler.shared().confirmPayment( paymentIntentParams, with: self ) { (status, intent, error) in switch status { case .failed: // Payment failed case .canceled: // Payment was canceled case .succeeded: // Payment succeeded @unknown default: fatalError() } } ``` > Die Ausführung von `confirmPayment` kann einige Sekunden dauern. Während dieser Zeit sollten Sie Ihr Formular deaktivieren, damit keine erneute Übermittlung erfolgen kann. Lassen Sie stattdessen ein Wartesymbol einblenden, wie beispielsweise eine Sanduhr. Tritt ein Fehler auf, lassen Sie eine Fehlermeldung für die Kundin/den Kunden anzeigen, aktivieren Sie das Formular erneut und blenden Sie das Wartesymbol aus. Bei erfolgreicher Ausführung gibt Stripe ein PaymentIntent-Objekt mit einem der folgenden möglichen Status zurück: | Status | Beschreibung | Nächste Schritte | | ----------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `requires_action` | Weitere Schritte sind erforderlich, um die Bankkontoverifizierung abzuschließen. | Schritt 6: [Bankkonten mit Testeinzahlungen verifizieren](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#ios-verify-with-microdeposits) | | `processing` | Das Bankkonto wurde sofort verifiziert oder eine Verifizierung war nicht notwendig. | Schritt 7: [Erfolgreichen PaymentIntent bestätigen](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#ios-confirm-paymentintent-succeeded) | Nach erfolgreicher Bestätigung des PaymentIntent muss eine E-Mail-Bestätigung des Mandats und der erfassten Bankkontodaten an Ihren Kunden/Ihre Kundin gesendet werden. Stripe kümmert sich standardmäßig darum, aber Sie können auch [nutzerdefinierte Benachrichtigungen senden](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails), wenn Sie dies vorziehen. ## Bankkonto mit Testeinzahlungen verifizieren [Clientseitig] Nicht alle Kund/innen können das Bankkonto sofort verifizieren. Dieser Schritt wird nur ausgeführt, wenn Ihre Kundin/Ihr Kunde die Sofortverifizierung im vorherigen Schritt deaktiviert hat. In diesen Fällen sendet Stripe eine `descriptor_code`-Testeinzahlung und greift möglicherweise auf eine `amount`-Testeinzahlung zurück, falls weitere Probleme bei der Verifizierung des Bankkontos auftreten. Es dauert 1–2 Werktage, bis diese Einzahlungen auf der Online-Abrechnung des Kunden/der Kundin erscheinen - **Code der Zahlungsbeschreibung**. Stripe sendet eine einzelne Mikroeinzahlung über 0,01 USD an das Bankkonto des/der Kund/in mit einem einmaligen, 6-stelligen `descriptor_code`, der mit SM beginnt. Ihr/e Kund/in verwendet diese Zeichenfolge, um sein/ihr Bankkonto zu verifizieren. - **Betrag**: Stripe sendet zwei nicht eindeutige Testeinzahlungen an das Kundenbankkonto, wobei `ACCTVERIFY` als Zahlungsbeschreibung in der Abrechnung angegeben ist. Ihre Kundin/Ihr Kunde verwendet die Einzahlungsbeträge zur Verifizierung des Bankkontos. Das Ergebnis des Aufrufs der Methode `confirmPayment` im vorhergehenden Schritt ist ein PaymentIntent mit dem Status `requires_action`. Der PaymentIntent enthält ein [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits)-Feld, das einige nützliche Informationen zum Abschließen der Verifizierung enthält. Wenn Sie eine [E-Mail-Adresse für die Rechnungsstellung](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email) angegeben haben, benachrichtigt Stripe Ihre Kundinnen und Kunden über diese E-Mail-Adresse, wann die Einzahlungen voraussichtlich eingehen werden. Die E-Mail enthält einen Link zu einer von Stripe gehosteten Verifizierungsseite, auf der sie die Beträge der Einzahlungen bestätigen und die Verifizierung abschließen können. > Verifizierungsversuche dürfen für beschreibungsbasierte Testeinzahlungen bis zu 10 mal und für betragsbasierte bis zu 3 mal fehlschlagen. Wenn Sie dieses Limit überschreiten, können wir das Bankkonto nicht mehr verifizieren. Darüber hinaus gilt für Verifizierungen von Testeinzahlungen eine Zeitüberschreitung von 10 Tagen. Werden Testeinzahlungen nicht innerhalb dieser Zeit verifiziert, fordert der PaymentIntent wieder neue Angaben zur Zahlungsmethode an. Wenn Sie Ihren Kund/innen genau erläutern, was Testeinzahlungen sind und wie sie verwendet werden, können Sie Probleme bei der Verifizierung vermeiden. ### Optional: Nutzerdefinierte E-Mails-Benachrichtigungen senden Sie können auch [personalisierte E-Mail-Benachrichtigungen](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) an Ihren Kunden/Ihre Kundin senden. Nachdem Sie die nutzerspezifischen E-Mails eingerichtet haben, müssen Sie angeben, wie der Kunde/die Kundin auf die Verifizierungs-E-Mail antwortet. Wählen Sie dazu *eine* der folgenden Optionen aus: - Verwenden Sie die von Stripe gehostete Verifizierungsseite. Verwenden Sie dazu die URL `verify_with_microdeposits[hosted_verification_url]` im [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url)-Objekt, um Ihre Kundinnen/Kunden zum Abschluss des Verifizierungsvorgangs zu leiten. - Wenn die von Stripe gehostete Verifizierungsseite nicht verwenden möchten, können Sie in Ihrer App ein Formular für Ihre Kund/innen zur Weiterleitung von Mikroeinzahlungen an Sie erstellen und das Bankkonto mit dem iOS-SDK verifizieren. - Richten Sie das Formular mindestens so ein, dass es den Parameter `descriptor code` verarbeitet, bei dem es sich um eine 6-stellige Zeichenfolge zu Verifizierungszwecken handelt. - Stripe empfiehlt außerdem, dass Sie Ihr Formular so konfigurieren, dass der Parameter `Beträge` berücksichtigt wird, da einige der von Ihren Kundinnen und Kunden verwendeten Banken dies möglicherweise verlangen. Integrationen übergeben nur den `descriptor_code` *oder* `amounts`. Um festzustellen, welches Ihre Integration verwendet, prüfen Sie den Wert für `verify_with_microdeposits[microdeposit_type]` im `next_action`-Objekt. #### Swift ```swift // Use if you are using a descriptor code, do not use if you are using amounts STPAPIClient.shared.verifyPaymentIntentWithMicrodeposits(clientSecret: clientSecret, descriptorCode: descriptorCode, completion: { intent, error in }) // Use if you are using amounts, do not use if you are using descriptor code STPAPIClient.shared.verifyPaymentIntentWithMicrodeposits(clientSecret: clientSecret, firstAmount: firstAmount, secondAmount: secondAmount, completion: { intent, error in }) ``` Wenn das Bankkonto erfolgreich verifiziert wurde, gibt Stripe das PaymentIntent-Objekt mit dem `status` `processing` zurück. Die Verifizierung kann aus unterschiedlichen Gründen fehlschlagen. Der Fehler tritt synchron als direkte Fehlermeldung auf. ```json { "error": { "code": "payment_method_microdeposit_verification_amounts_mismatch", "message": "The amounts provided do not match the amounts that were sent to the bank account. You have {attempts_remaining} verification attempts remaining.", "type": "invalid_request_error" } } ``` | Fehlercode | Nachricht | Änderung des Status | | ------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | | `payment_method_microdeposit_failed` | Die Testeinzahlungen sind fehlgeschlagen. Bitte überprüfen Sie die Kontonummer, die Finanzinstitutsnummer und die bereitgestellte Transitnummer. | `status` ist `requires_payment_method` und `last_payment_error` ist festgelegt. | | `payment_method_microdeposit_verification_amounts_mismatch` | Die angegebenen Beträge stimmen nicht mit den Beträgen überein, die an das Bankkonto gesendet wurden. Sie haben noch {attempts_remaining} Verifizierungsversuche. | Unverändert | | `payment_method_microdeposit_verification_attempts_exceeded` | Anzahl zulässiger Verifizierungsversuche wurde überschritten | `status` ist `requires_payment_method` und `last_payment_error` ist festgelegt. | ## Erfolgreichen PaymentIntent bestätigen [Serverseitig] Bei ACH Direct Debit handelt es sich um eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Das bedeutet, dass es bis zu vier Werktage dauern kann, bis Sie nach Initiierung einer Lastschrift für das Kundenkonto eine Mitteilung über die erfolgreiche oder fehlgeschlagene Zahlung erhalten. Der von Ihnen erstellte PaymentIntent hat zunächst den Status `processing`. Wenn die Zahlung erfolgreich war, wird der PaymentIntent-Status von `processing` in `succeeded` geändert. Wir empfehlen die Verwendung von [Webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks), um die erfolgreiche Zahlung zu *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) und die Kundinnen/Kunden zu informieren, dass die Zahlung abgeschlossen ist. Sie können sich Ereignisse auch im [Stripe-Dashboard](https://dashboard.stripe.com/events) anzeigen lassen. #### PaymentIntent-Ereignisse Die folgenden Ereignisse werden übermittelt, wenn der PaymentIntent-Status aktualisiert wird: | Ereignis | Beschreibung | Nächster Schritt | | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent.processing` | Die Zahlung der Kundin/des Kunden wurde erfolgreich an Stripe übermittelt. | Warten Sie, bis die initiierte Zahlung erfolgt oder fehlschlägt. | | `payment_intent.succeeded` | Die Kundenzahlung war erfolgreich. | Führen Sie die Bestellung der gekauften Waren oder Dienstleistungen aus. | | `payment_intent.payment_failed` | Die Zahlung der Kundin/des Kunden wurde abgelehnt. Dies kann auch bei einer fehlgeschlagenen Verifizierung der Testeinzahlung zutreffen. | Kontaktieren Sie Ihre/n Kund/in per E-Mail oder Push-Benachrichtigung und fordern Sie eine andere Zahlungsmethode an. Wenn der Webhook aufgrund einer fehlgeschlagenen Verifizierung der Testeinzahlung übermittelt wurde, müssen die Nutzer/innen ihre Bankkontodaten erneut eingeben. Danach werden neue Testeinzahlungen durchgeführt. | #### Zahlungsereignisse Sie können auch zusätzliche Charge-Webhooks verwenden, um den Status der Zahlung zu verfolgen. Sobald Sie den Webhook `charge.updated` empfangen haben, kann die Zahlung nicht mehr storniert werden. Die folgenden Ereignisse werden gesendet, wenn der Status der Zahlung aktualisiert wird: | Ereignis | Beschreibung | Nächster Schritt | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | | `charge.pending` | Die Zahlung wurde erfolgreich erstellt. | Warten Sie, bis die initiierte Zahlung verarbeitet wird. | | `charge.updated` | Die Kundenzahlung wurde aktualisiert. Sie kann gesendet werden, wenn eine neue Saldo-Transaktion erstellt wurde und eine Zahlungsbeschreibung bzw. die Metadaten aktualisiert wurden. | Warten Sie, bis die initiierte Zahlung erfolgt oder fehlschlägt. | | `charge.succeeded` | Die Kundenzahlung war erfolgreich und das Geld ist in Ihrem Saldo verfügbar. | Führen Sie die Bestellung der gekauften Waren oder Dienstleistungen aus. | | `charge.failed` | Kundenzahlung ist fehlgeschlagen. | Überprüfen Sie den failure_code und die failure_message der Zahlung, um weitere Maßnahmen festzulegen. | ## Integration testen Erfahren Sie, wie Sie Szenarien mit sofortigen Verifizierungen mithilfe von [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts) testen können. ### Transaktions-E-Mails in einer Sandbox senden Nachdem Sie die Bankkontodetails erfasst und ein Mandat akzeptiert haben, senden Sie die Mandatsbestätigung und die Verifizierungs-E-Mails mit Testeinzahlungen in einer *Sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes). Wenn Ihre Domain **{domain}** lautet und Ihr Benutzername **{username}** ist, verwenden Sie das folgende E-Mail-Format, um Test-Transaktions-E-Mails zu versenden: **{username}+test\_email@{domain}**. Wenn Ihre Domain beispielsweise **example.com** und Ihr Nutzername **Info** lautet, verwenden Sie zum Testen von ACH Direct Debit-Zahlungen das Format **info+test\_email@example.com**. Dieses Format stellt sicher, dass E-Mails korrekt weitergeleitet werden. Wenn Sie das Suffix **+test\_email** nicht angeben, senden wir die E-Mail nicht. > Sie müssen [Ihr Stripe-Konto einrichten](https://docs.stripe.com/get-started/account/set-up.md), bevor Sie diese E-Mails während Tests auslösen können. ### Testkontonummern Stripe stellt mehrere Testkontonummern und dazugehörige Token zur Verfügung, um sicherzustellen, dass Ihre Integration für Bankkonten mit manueller Eingabe für den Einsatz in einer Produktionsumgebung bereit ist. | Kontonummer | Token | Bankleitzahl | Verhalten | | -------------- | -------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000123456789` | `pm_usBankAccount_success` | `110000000` | Die Zahlung ist erfolgreich. | | `000111111113` | `pm_usBankAccount_accountClosed` | `110000000` | Die Zahlung schlägt fehl, weil das Konto geschlossen ist. | | `000000004954` | `pm_usBankAccount_riskLevelHighest` | `110000000` | Die Zahlung wird von Radar aufgrund eines [hohen Betrugsrisikos](https://docs.stripe.com/radar/risk-evaluation.md#high-risk) blockiert. | | `000111111116` | `pm_usBankAccount_noAccount` | `110000000` | Die Zahlung schlägt fehl, weil kein Konto gefunden wird. | | `000222222227` | `pm_usBankAccount_insufficientFunds` | `110000000` | Die Zahlung schlägt aufgrund unzureichender Deckung fehl. | | `000333333335` | `pm_usBankAccount_debitNotAuthorized` | `110000000` | Die Zahlung schlägt fehl, weil die Lastschriften nicht autorisiert sind. | | `000444444440` | `pm_usBankAccount_invalidCurrency` | `110000000` | Die Zahlung schlägt aufgrund einer ungültigen Währung fehl. | | `000666666661` | `pm_usBankAccount_failMicrodeposits` | `110000000` | Die Zahlung sendet keine Testeinzahlungen. | | `000555555559` | `pm_usBankAccount_dispute` | `110000000` | Die Zahlung löst eine Zahlungsanfechtung aus. | | `000000000009` | `pm_usBankAccount_processing` | `110000000` | Die Zahlung bleibt auf unbestimmte Zeit in Bearbeitung. Nützlich zum Testen [der Stornierung des PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md). | | `000777777771` | `pm_usBankAccount_weeklyLimitExceeded` | `110000000` | Die Zahlung schlägt aufgrund des Zahlungsbetrags fehl, wodurch das Konto sein wöchentliches Zahlungsvolumenlimit überschreitet. | | `000888888885` | | `110000000` | Die Zahlung schlägt aufgrund einer deaktivierten [tokenisierten Kontonummer](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) fehl. | Bevor Testtransaktionen abgeschlossen werden können, müssen Sie alle Testkonten verifizieren, auf denen die Zahlung automatisch erfolgreich war oder fehlschlagen ist. Verwenden Sie dazu die nachstehenden Test-Mikroeinzahlungsbeträge oder Beschreibungscodes. ### Testen von Mikroeinzahlungen und Beschreibungscodes Um verschiedene Szenarien zu imitieren, verwenden Sie diese Mikroeinzahlungsbeträge *oder* 0,01 Beschreibungscodewerte. | Testeinzahlungswerte | 0.01 Beschreibungscodewerte | Szenario | | -------------------- | --------------------------- | ------------------------------------------------------------------------- | | `32` und `45` | SM11AA | Simuliert die Verifizierung des Kontos. | | `10` und `11` | SM33CC | Simuliert das Überschreiten der Anzahl zulässiger Verifizierungsversuche. | | `40` und `41` | SM44DD | Simuliert ein Testeinzahlungs-Timeout. | ### Abwicklungsverhalten testen Testtransaktionen werden sofort abgewickelt und Ihrem verfügbaren Testguthaben hinzugefügt. Dieses Verhalten unterscheidet sich vom Live-Modus, bei dem es [mehrere Tage](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Optional: Nur Sofortverifizierung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die Zahlungen per US-Bankkonto tätigen, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional auch nur eine sofortige Verifizierung des Bankkontos verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den PaymentIntent erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` Dadurch wird sichergestellt, dass Sie keine Verifizierung von Testeinzahlungen durchführen müssen. Wenn die sofortige Verifizierung jedoch fehlschlägt, lautet der Status des PaymentIntent `requires_payment_method`. Dies weist darauf hin, dass die sofortige Verifizierung eines Kundenbankkontos fehlgeschlagen ist. ## Optional: Verifizierung ausschließlich durch Testeinzahlung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die Zahlungen per US-Bankkonto tätigen, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional auch nur Testeinzahlungen verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den PaymentIntent erstellen. > Wenn Sie ein individuelles Zahlungsformular verwenden, müssen Sie Ihre eigene Nutzeroberfläche erstellen, um Bankkontodaten zu erfassen. Wenn Sie Stripe-E-Mails mit Testeinzahlungen deaktivieren, müssen Sie Ihre eigene Nutzeroberfläche für Ihre Kundin/Ihren Kunden erstellen, um den Testeinzahlungscode bzw. -betrag zu bestätigen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=microdeposits" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=microdeposits" ``` Sie müssen dann das Bankkonto Ihrer Kundin/Ihres Kunden mit Ihrem eigenen Formular erfassen und [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) mit diesen Angaben aufrufen, um den PaymentIntent abzuschließen. ```javascript var form = document.getElementById('payment-form'); var accountholderName = document.getElementById('accountholder-name'); var email = document.getElementById('email'); var accountNumber = document.getElementById('account-number'); var routingNumber = document.getElementById('routing-number'); var accountHolderType= document.getElementById('account-holder-type'); var submitButton = document.getElementById('submit-button'); var clientSecret = submitButton.dataset.secret; form.addEventListener('submit', function(event) { event.preventDefault(); stripe.confirmUsBankAccountPayment(clientSecret, { payment_method: { billing_details: { name: accountholderName.value, email: email.value, }, us_bank_account: { account_number: accountNumber.value, routing_number: routingNumber.value, account_holder_type: accountHolderType.value, // 'individual' or 'company' }, }, }) .then(({paymentIntent, error}) => { if (error) { // Inform the customer that there was an error. console.log(error.message); } else { // Handle next step based on the intent's status. console.log("PaymentIntent ID: " + paymentIntent.id); console.log("PaymentIntent status: " + paymentIntent.status); } }); }); ``` ## Optional: Zahlungsreferenz Die Zahlungsreferenznummer ist ein von der Bank generierter Wert, mit dem der/die Kontoinhaber/in Gelder bei seiner/ihrer Bank finden kann. Wenn die Zahlung erfolgreich ist, gibt Stripe die Zahlungsreferenznummer im Dashboard und im [Zahlungsobjekt](https://docs.stripe.com/api/charges/object.md) an. | Status der Abbuchung | Zahlungsreferenzwert | | -------------------- | ---------------------------------------- | | Ausstehend | Nicht verfügbar | | Fehlgeschlagen | Nicht verfügbar | | Erfolgreich | Verfügbar (zum Beispiel 091000015001234) | Wenn Sie den Webhook `charge.succeeded` erhalten, zeigen Sie außerdem den Inhalt von `payment_method_details` an, um die [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference) zu finden. Das folgende Beispielereignis zeigt das Rendern einer erfolgreichen ACH-Zahlung mit einer Zahlungsreferenznummer. #### charge-succeeded ```json { "id": "{{EVENT_ID}}", "object": "event", // omitted some fields in the example "type": "charge.succeeded", "data": { "object": { "id": "{{PAYMENT_ID}}", "object": "charge", //... "paid": true, "payment_intent": "{{PAYMENT_INTENT_ID}}", "payment_method": "{{PAYMENT_METHOD_ID}}", "payment_method_details": { "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK", "fingerprint": "Ih3foEnRvLXShyfB", "last4": "1000","payment_reference": "091000015001234", "routing_number": "110000000" } } // ... } } } ``` Zeigen Sie den Inhalt der `destination_details` an, um die [Rückerstattungsreferenz](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) zu finden, die den erstatteten ACH-Zahlungen zugeordnet ist. Das folgende Beispielereignis zeigt das Rendering einer erfolgreichen ACH-Rückerstattung mit einer Rückerstattungsreferenznummer. Weitere Informationen zu [Rückerstattungen](https://docs.stripe.com/refunds.md). #### charge-refund-updated ```json { "id": "{{EVENT_ID}}", "object": "event", "type": "charge.refund.updated", "data": { "object": { "id": "{{REFUND_ID}}", "object": "refund", //... "payment_intent": "{{PAYMENT_INTENT_ID}}", "destination_details": { "type": "us_bank_transfer", "us_bank_transfer": {"reference": "091000015001111", "reference_status": "available" } } // ... } } } ``` ## See also - [Vorab autorisierte ACH-Lastschriftzahlungen für zukünftige Zahlungen speichern](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md) # 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/ach-direct-debit/accept-a-payment?payment-ui=mobile&platform=android. > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. Die Annahme von ACH-Lastschriftzahlungen mit Ihrer Anwendung umfasst Folgendes: - Objekt zur Zahlungsverfolgung erstellen - Erfassen von Zahlungsmethodeninformationen mit sofortiger Verifizierung, die durch [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md) ermöglicht wird - Zahlung zur weiteren Verarbeitung an Stripe übermitteln - Bankkonto Ihres/Ihrer Kund/in verifizieren > Bei ACH Direct Debit handelt es sich um eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Dies bedeutet, dass Gelder nicht sofort nach der Zahlung verfügbar sind. Eine Zahlung benötigt in der Regel 4 Werktage bis zum Eingang auf Ihrem Konto. Stripe verwendet das Zahlungsobjekt, den [Payment Intent](https://docs.stripe.com/payments/payment-intents.md), zur Dokumentation und Verarbeitung aller Zahlungsstatus bis zum Zahlungsabschluss. 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` und `financial-connections` to the `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.5.0") // Include the financial connections SDK to support US bank account as a payment method implementation("com.stripe:financial-connections:23.5.0") // Financial Connections SDK implementation("com.stripe:financial-connections:23.5.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. ## Kundinnen/Kunden erstellen oder abrufen [Empfohlen] [Serverseitig] > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. #### Accounts v2 Erstellen Sie ein von Kundinnen und Kunden konfiguriertes [Konto](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein bestehendes `Account` ab, das mit diesem/dieser Nutzer/in verknüpft ist. Wenn Sie die ID des `Account`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin oder eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse in das `Account` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl -X POST https://api.stripe.com/v2/core/accounts \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" \ --json '{ "contact_email": "{{CUSTOMER_EMAIL}}" }' ``` #### Customers v1 Erstellen Sie ein *Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein/e bestehende/n `Customer` ab, die/der mit dieser/diesem Nutzer/in verknüpft ist. Wenn Sie die ID des `Customer`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin/eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse für die/den `Customer` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl https://api.stripe.com/v1/customers \ -u "<>:" \ -d email={{CUSTOMER_EMAIL}} ``` ## PaymentIntent erstellen [Serverseitig] [Clientseitig] Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) ist ein Objekt, das Ihre Absicht darstellt, eine Zahlung von einer Kundin/einem Kunden einzuziehen, und das den Lebenszyklus des Zahlungsprozesses in jeder Phase verfolgt. ### Serverseitig Erstellen Sie zunächst einen PaymentIntent auf Ihrem Server und geben Sie den einzuziehenden Betrag und die Währung `usd` an. Falls Sie bereits über eine Integration verfügen, die die Payment Intents API 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 `us_bank_account` hinzu. Geben Sie optional die [ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) der Kundin/des Kunden an. Falls Sie die Zahlungsmethode künftig wiederverwenden möchten, geben Sie den Parameter [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) mit dem Wert `off_session` an. Weitere Informationen zu den Gebühren für Financial Connections finden Sie unter [Preisdetails](https://stripe.com/financial-connections#pricing). Bei der Erfassung von Zahlungsinformationen für Bankkonten wird standardmäßig [Financial Connections](https://docs.stripe.com/financial-connections.md) verwendet, um das Konto Ihres Kunden/Ihrer Kundin sofort zu verifizieren, mit einer Ausweichoption für die manuelle Eingabe der Kontonummer und die Verifizierung von Testeinzahlungen. In der [Financial Connections-Dokumentation](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) erfahren Sie, wie Sie Financial Connections konfigurieren und auf zusätzliche Kontodaten zugreifen, um Ihre ACH-Integration zu optimieren. Beispielsweise können Sie Financial Connections verwenden, um den Kontostand zu prüfen, bevor Sie die ACH-Zahlung veranlassen. > Um den Zugriff auf zusätzliche Daten auszudehnen, nachdem ein/e Kund/in sein/ihr Konto authentifiziert hat, muss er/sie das Konto mit erweiterten Berechtigungen erneut verknüpfen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" ``` ### Clientseitig 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, mit dem der Client den Zahlungsvorgang sicher abschließen kann, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Fordern Sie auf dem Client einen PaymentIntent von Ihrem Server an und verwenden Sie das Client-Geheimnis für nachfolgende API-Aufrufe. #### Kotlin ```kotlin import androidx.appcompat.app.AppCompatActivity class CheckoutActivity : AppCompatActivity() { private lateinit var paymentIntentClientSecret: String fun startCheckout() { // Request a PaymentIntent from your server and store its client secret } } ``` ## Angaben zur Zahlungsmethode erfassen [Clientseitig] Damit die Zahlung erfolgreich ist, ist bei ACH Direct Debit ein Kundenname und (optional) eine E-Mail-Adresse erforderlich. Erfassen Sie in Ihrer App die notwendigen Abrechnungsdaten von den Kund/innen: - Den vollständigen Namen (Vor- und Nachname) des/der Kund/in - E-Mail-Adresse Verwenden Sie `CollectBankAccountConfiguration.USBankAccount`, um die Parameter zu erstellen, die für den Aufruf von `presentWithPaymentIntent` erforderlich sind. Initialisieren Sie eine `CollectBankAccountLauncher`-Instanz innerhalb von OnCreate Ihrer Checkout-Aktivität und übergeben Sie eine Methode zur Verarbeitung des Ergebnisses. Rufen Sie dann `presentWithPaymentIntent` auf, um Bankkontodaten zu erfassen, eine *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) zu erstellen und diese PaymentMethod an den PaymentIntent anzuhängen. #### Kotlin ```kotlin import androidx.appcompat.app.AppCompatActivity class CheckoutActivity : AppCompatActivity() { private lateinit var paymentIntentClientSecret: String private lateinit var collectBankAccountLauncher CollectBankAccountLauncher override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Create collector collectBankAccountLauncher = CollectBankAccountLauncher.create( this ) { result: CollectBankAccountResult -> when (result) { is CollectBankAccountResult.Completed -> { val intent = result.response.intent if (intent.status === StripeIntent.Status.RequiresPaymentMethod) { // Customer canceled the Financial Connections modal. Present them with other // payment method type options. } else if (intent.status === StripeIntent.Status.RequiresConfirmation) { // We collected an account - possibly instantly verified, but possibly // manually-entered. Display payment method details and mandate text // to the customer and confirm the intent once they accept // the mandate. } } is CollectBankAccountResult.Cancelled -> { // handle cancellation } is CollectBankAccountResult.Failed -> { // handle error print("Error: ${result.error}") } } } } fun startCheckout() { // ... // Build params val configuration: CollectBankAccountConfiguration = CollectBankAccountConfiguration.USBankAccount( name, email ) // Calling this method will trigger the Financial Connections modal to be displayed collectBankAccountLauncher.presentWithPaymentIntent( publishableKey, paymentIntentClientSecret, collectParams ) } } ``` Dadurch wird eine Modal-Nutzeroberfläche geladen, um die Erfassung und Überprüfung der Bankkontodaten abzuwickeln. Wenn dies abgeschlossen ist, wird die *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) automatisch an den PaymentIntent angehängt. ## Optional: Formular anpassen [Clientseitig] ### Dunkelmodus Standardmäßig passt sich `CollectBankAccountLauncher` automatisch an die systemweiten Einstellungen für das Erscheinungsbild des Nutzers/der Nutzerin an (heller und dunkler Modus). Sie können dies ändern, indem Sie in Ihrer App den Hell- oder Dunkelmodus einrichten: #### Kotlin ```kotlin // force dark AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES) // force light AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO) ``` ## Optional: Auf Daten für ein Financial Connections-Bankkonto zugreifen [Serverseitig] Sie können nur dann auf Financial Connections-Daten zugreifen, wenn Sie beim Erstellen Ihres/Ihrer PaymentIntent zusätzliche [Datenberechtigungen](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) anfordern. Nachdem Ihre Kundinnen und Kunden den [Authentifizierungsvorgang von Stripe Financial Connections](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) erfolgreich abgeschlossen haben, enthält die zurückgegebene PaymentMethod `us_bank_account` eine [financial_connections_account](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-us_bank_account-financial_connections_account)-ID, die auf ein [Financial Connections-Konto](https://docs.stripe.com/api/financial_connections/accounts.md) verweist. Verwenden Sie diese ID, um auf Kontodaten zuzugreifen. > Bankkonten, die Ihre Kunden/Kundinnen durch manuelle Eingabe verknüpfen, und Testeinzahlungen haben keine `financial_connections_account` auf der Zahlungsmethode. Um die Financial Connections-Konto-ID zu ermitteln, rufen Sie den PaymentIntent ab und erweitern Sie das Attribut `payment_method`: ```curl curl -G https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}} \ -u "<>:" \ -d "expand[]=payment_method" ``` ```json { "id": "{{PAYMENT_INTENT_ID}}", "object": "payment_intent", // ... "payment_method": { "id": "{{PAYMENT_METHOD_ID}}", // ... "type": "us_bank_account" "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK","financial_connections_account": "{{FINANCIAL_CONNECTIONS_ACCOUNT_ID}}", "fingerprint": "q9qchffggRjlX2tb", "last4": "6789", "routing_number": "110000000" } } // ... } ``` Wenn Sie sich für die `balances`-Berechtigung entschieden haben, empfehlen wir Ihnen, Salden zu diesem Zeitpunkt zu überprüfen, um eine ausreichende Deckung zu gewährleisten, bevor Sie eine Zahlung bestätigen. Erfahren Sie mehr über die Verwendung zusätzlicher Kontodaten zur Optimierung Ihrer ACH-Integration mit [Financial Connections](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md#optimize). ## Mandatsbestätigung erfassen und die Zahlung übermitteln [Clientseitig] Bevor Sie die Zahlung veranlassen können, müssen Sie eine Zahlungsautorisierung von Ihrem/Ihrer Kund/in einholen, indem Sie Mandatsbedingungen anzeigen, denen er/sie zustimmen muss. Um die *Nacha* (Nacha is the governing body that oversees the ACH network)-Regeln einzuhalten, müssen Sie eine Autorisierung von Ihrem Kunden/Ihrer Kundin einholen, bevor Sie die Zahlung veranlassen können. Dies erfolgt durch Anzeigen von Mandatsbedingungen, denen der Kunde/die Kundin zustimmen muss. Weitere Informationen finden Sie unter [Mandate](https://docs.stripe.com/payments/ach-direct-debit.md#mandates). Wenn der/die Kund/in den Mandatsbedingungen zustimmt, müssen Sie den Payment bestätigen. Verwenden Sie `confirm`, um die Zahlung abzuschließen, wenn der/die Kund/in das Formular einreicht. #### Kotlin ```kotlin class CheckoutActivity : AppCompatActivity() { // ... private lateinit var paymentIntentClientSecret: String private val paymentLauncher: PaymentLauncher by lazy { val paymentConfiguration = PaymentConfiguration.getInstance(applicationContext) PaymentLauncher.Companion.create( this, paymentConfiguration.publishableKey, paymentConfiguration.stripeAccountId, ::onPaymentResult ) } private fun startCheckout() { // ... val confirmParams = ConfirmPaymentIntentParams.create( clientSecret = paymentIntentClientSecret, paymentMethodType = PaymentMethod.Type.USBankAccount ) paymentLauncher.confirm(confirmParams) } private fun onPaymentResult(paymentResult: PaymentResult) { when (paymentResult) { is PaymentResult.Completed -> { // show success UI } is PaymentResult.Canceled -> { // handle cancel flow } is PaymentResult.Failed -> { // handle failures // (for example, the customer might need to choose a new payment // method) } } } } ``` > Die Ausführung von `bestätigen` kann einige Sekunden dauern. Während dieser Zeit sollten Sie Ihr Formular deaktivieren, damit keine erneute Übermittlung erfolgen kann. Lassen Sie stattdessen ein Wartesymbol einblenden, wie beispielsweise eine Sanduhr. Tritt ein Fehler auf, lassen Sie eine Fehlermeldung für den Kunden/die Kundin anzeigen, aktivieren Sie das Formular erneut und blenden Sie das Wartesymbol aus. Bei erfolgreicher Ausführung gibt Stripe ein PaymentIntent-Objekt mit einem der folgenden möglichen Status zurück: | Status | Beschreibung | Nächste Schritte | | ----------------- | ------------------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `requires_action` | Weitere Schritte sind erforderlich, um die Bankkontoverifizierung abzuschließen. | Schritt 5: [Bankkonten mit Testeinzahlungen verifizieren](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#android-verify-with-microdeposits) | | `processing` | Das Bankkonto wurde sofort verifiziert, oder eine Verifizierung war nicht notwendig. | Schritt 6: [Erfolgreichen PaymentIntent bestätigen](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#android-confirm-paymentintent-succeeded) | Nach erfolgreicher Bestätigung des Payment muss eine Bestätigung des Mandats und der erfassten Bankkontodaten per E-Mail an Ihre Kundinnen/Kunden gesendet werden. Stripe kümmert sich standardmäßig darum, aber Sie können auch [nutzerdefinierte Benachrichtigungen senden](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails), wenn Sie dies vorziehen. ## Bankkonto mit Testeinzahlungen verifizieren [Clientseitig] Nicht alle Kund/innen können das Bankkonto sofort verifizieren. Dieser Schritt wird nur ausgeführt, wenn Ihr/e Kund/in die Sofortverifizierung im vorherigen Schritt deaktiviert hat. In diesen Fällen sendet Stripe eine `descriptor_code`-Testeinzahlung und greift möglicherweise auf eine `amount`-Testeinzahlung zurück, falls weitere Probleme bei der Verifizierung des Bankkontos auftreten. Es dauert 1–2 Werktage, bis diese Einzahlungen auf der Online-Abrechnung des/der Kund/in angezeigt werden. - **Code der Zahlungsbeschreibung**: Stripe sendet eine einzelne Testeinzahlung über 0,01 USD an das Bankkonto des/der Kund/in mit einem einmaligen, 6-stelligen `descriptor_code`, der mit SM beginnt. Ihr/e Kund/in verwendet diese Zeichenfolge, um sein/ihr Bankkonto zu verifizieren. - **Betrag**: Stripe sendet zwei nicht eindeutige Testeinzahlungen an das Kundenbankkonto, wobei `ACCTVERIFY` als Zahlungsbeschreibung in der Abrechnung angegeben ist. Ihre Kundin/Ihr Kunde verwendet die Einzahlungsbeträge zur Verifizierung des Bankkontos. Das Ergebnis des Aufrufs der Methode `confirmPayment` im vorhergehenden Schritt ist ein PaymentIntent mit dem Status `requires_action`. Der PaymentIntent enthält ein [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits)-Feld, das einige nützliche Informationen zum Abschließen der Verifizierung enthält. Wenn Sie eine [E-Mail-Adresse für die Rechnungsstellung](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email) angegeben haben, benachrichtigt Stripe Ihre Kundinnen und Kunden über diese E-Mail-Adresse, wann die Einzahlungen voraussichtlich eingehen werden. Die E-Mail enthält einen Link zu einer von Stripe gehosteten Verifizierungsseite, auf der sie die Beträge der Einzahlungen bestätigen und die Verifizierung abschließen können. > Verifizierungsversuche dürfen für beschreibungsbasierte Testeinzahlungen bis zu 10 mal und für betragsbasierte bis zu 3 mal fehlschlagen. Wenn Sie dieses Limit überschreiten, können wir das Bankkonto nicht mehr verifizieren. Darüber hinaus gilt für Verifizierungen von Testeinzahlungen eine Zeitüberschreitung von 10 Tagen. Werden Testeinzahlungen nicht innerhalb dieser Zeit verifiziert, fordert der PaymentIntent wieder neue Angaben zur Zahlungsmethode an. Wenn Sie Ihren Kund/innen genau erläutern, was Testeinzahlungen sind und wie sie verwendet werden, können Sie Probleme bei der Verifizierung vermeiden. ### Optional: Nutzerdefinierte E-Mail-Benachrichtigungen senden Sie können auch [personalisierte E-Mail-Benachrichtigungen](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) an Ihren Kunden/Ihre Kundin senden. Nachdem Sie die nutzerspezifischen E-Mails eingerichtet haben, müssen Sie angeben, wie der Kunde/die Kundin auf die Verifizierungs-E-Mail antwortet. Wählen Sie dazu *eine* der folgenden Optionen aus: - Verwenden Sie die von Stripe gehostete Verifizierungsseite. Verwenden Sie dazu die URL `verify_with_microdeposits[hosted_verification_url]` im [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url)-Objekt, um Ihre Kundinnen/Kunden zum Abschluss des Verifizierungsvorgangs zu leiten. - Wenn die von Stripe gehostete Verifizierungsseite nicht verwenden möchten, können Sie in Ihrer App ein Formular für Ihre Kund/innen zur Weiterleitung von Mikroeinzahlungen an Sie erstellen und das Bankkonto mit dem Android SDK verifizieren. - Richten Sie das Formular mindestens so ein, dass es den Parameter `descriptor code` verarbeitet, bei dem es sich um eine 6-stellige Zeichenfolge zu Verifizierungszwecken handelt. - Stripe empfiehlt außerdem, dass Sie Ihr Formular so konfigurieren, dass der Parameter `Beträge` berücksichtigt wird, da einige der von Ihren Kundinnen und Kunden verwendeten Banken dies möglicherweise verlangen. Integrationen übergeben nur den `descriptor_code` *oder* `amounts`. Um festzustellen, welchen Parameter Ihre Integration verwendet, prüfen Sie den Wert für `verify_with_microdeposits[microdeposit_type]` im `next_action`-Objekt. #### Kotlin ```kotlin // Use if you are using a descriptor code, do not use if you are using amounts fun verifyPaymentIntentWithMicrodeposits( clientSecret: String, descriptorCode: String, callback: ApiResultCallback ) // Use if you are using amounts, do not use if you are using descriptor code fun verifyPaymentIntentWithMicrodeposits( clientSecret: String, firstAmount: Int, secondAmount: Int, callback: ApiResultCallback ) ``` Wenn das Bankkonto erfolgreich verifiziert wurde, gibt Stripe das PaymentIntent-Objekt mit dem `status` `processing` zurück. Die Verifizierung kann aus unterschiedlichen Gründen fehlschlagen. Der Fehler tritt synchron als direkte Fehlermeldung auf. ```json { "error": { "code": "payment_method_microdeposit_verification_amounts_mismatch", "message": "The amounts provided do not match the amounts that were sent to the bank account. You have {attempts_remaining} verification attempts remaining.", "type": "invalid_request_error" } } ``` | Fehlercode | Nachricht | Änderung des Status | | ------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------- | | `payment_method_microdeposit_failed` | Die Testeinzahlungen sind fehlgeschlagen. Bitte überprüfen Sie die Kontonummer, die Finanzinstitutsnummer und die bereitgestellte Transitnummer. | `status` ist `requires_payment_method`, und `last_payment_error` ist festgelegt. | | `payment_method_microdeposit_verification_amounts_mismatch` | Die angegebenen Beträge stimmen nicht mit den Beträgen überein, die an das Bankkonto gesendet wurden. Sie haben noch {attempts_remaining} Verifizierungsversuche. | Unverändert | | `payment_method_microdeposit_verification_attempts_exceeded` | Anzahl zulässiger Verifizierungsversuche wurde überschritten | `status` ist `requires_payment_method`, und `last_payment_error` ist festgelegt. | ## Erfolgreichen PaymentIntent bestätigen [Serverseitig] Bei ACH Direct Debit handelt es sich um eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Das bedeutet, dass es bis zu vier Werktage dauern kann, bis Sie nach Initiierung einer Lastschrift für das Kundenkonto eine Mitteilung über die erfolgreiche oder fehlgeschlagene Zahlung erhalten. Der von Ihnen erstellte PaymentIntent hat zunächst den Status `processing`. Wenn die Zahlung erfolgreich war, wird der PaymentIntent-Status von `processing` in `succeeded` geändert. Wir empfehlen die Verwendung von [Webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks), um die erfolgreiche Zahlung zu *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) und die Kundinnen/Kunden zu informieren, dass die Zahlung abgeschlossen ist. Sie können sich Ereignisse auch im [Stripe-Dashboard](https://dashboard.stripe.com/events) anzeigen lassen. #### PaymentIntent-Ereignisse Die folgenden Ereignisse werden übermittelt, wenn der PaymentIntent-Status aktualisiert wird: | Ereignis | Beschreibung | Nächster Schritt | | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent.processing` | Die Zahlung der Kundin/des Kunden wurde erfolgreich an Stripe übermittelt. | Warten Sie, bis die initiierte Zahlung erfolgt oder fehlschlägt. | | `payment_intent.succeeded` | Die Kundenzahlung war erfolgreich. | Führen Sie die Bestellung der gekauften Waren oder Dienstleistungen aus. | | `payment_intent.payment_failed` | Die Zahlung der Kundin/des Kunden wurde abgelehnt. Dies kann auch bei einer fehlgeschlagenen Verifizierung der Testeinzahlung zutreffen. | Kontaktieren Sie Ihre/n Kund/in per E-Mail oder Push-Benachrichtigung und fordern Sie eine andere Zahlungsmethode an. Wenn der Webhook aufgrund einer fehlgeschlagenen Verifizierung der Testeinzahlung übermittelt wurde, müssen die Nutzer/innen ihre Bankkontodaten erneut eingeben. Danach werden neue Testeinzahlungen durchgeführt. | #### Zahlungsereignisse Sie können auch zusätzliche Charge-Webhooks verwenden, um den Status der Zahlung zu verfolgen. Sobald Sie den Webhook `charge.updated` empfangen haben, kann die Zahlung nicht mehr storniert werden. Die folgenden Ereignisse werden gesendet, wenn der Status der Zahlung aktualisiert wird: | Ereignis | Beschreibung | Nächster Schritt | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | | `charge.pending` | Die Zahlung wurde erfolgreich erstellt. | Warten Sie, bis die initiierte Zahlung verarbeitet wird. | | `charge.updated` | Die Kundenzahlung wurde aktualisiert. Sie kann gesendet werden, wenn eine neue Saldo-Transaktion erstellt wurde und eine Zahlungsbeschreibung bzw. die Metadaten aktualisiert wurden. | Warten Sie, bis die initiierte Zahlung erfolgt oder fehlschlägt. | | `charge.succeeded` | Die Kundenzahlung war erfolgreich und das Geld ist in Ihrem Saldo verfügbar. | Führen Sie die Bestellung der gekauften Waren oder Dienstleistungen aus. | | `charge.failed` | Kundenzahlung ist fehlgeschlagen. | Überprüfen Sie den failure_code und die failure_message der Zahlung, um weitere Maßnahmen festzulegen. | ## Integration testen Erfahren Sie, wie Sie Szenarien mit sofortigen Verifizierungen mithilfe von [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts) testen können. ### Transaktions-E-Mails in einer Sandbox senden Nachdem Sie die Bankkontodetails erfasst und ein Mandat akzeptiert haben, senden Sie die Mandatsbestätigung und die Verifizierungs-E-Mails mit Testeinzahlungen in einer *Sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes). Wenn Ihre Domain **{domain}** lautet und Ihr Benutzername **{username}** ist, verwenden Sie das folgende E-Mail-Format, um Test-Transaktions-E-Mails zu versenden: **{username}+test\_email@{domain}**. Wenn Ihre Domain beispielsweise **example.com** und Ihr Nutzername **Info** lautet, verwenden Sie zum Testen von ACH Direct Debit-Zahlungen das Format **info+test\_email@example.com**. Dieses Format stellt sicher, dass E-Mails korrekt weitergeleitet werden. Wenn Sie das Suffix **+test\_email** nicht angeben, senden wir die E-Mail nicht. > Sie müssen [Ihr Stripe-Konto einrichten](https://docs.stripe.com/get-started/account/set-up.md), bevor Sie diese E-Mails während Tests auslösen können. ### Testkontonummern Stripe stellt mehrere Testkontonummern und dazugehörige Token zur Verfügung, um sicherzustellen, dass Ihre Integration für Bankkonten mit manueller Eingabe für den Einsatz in einer Produktionsumgebung bereit ist. | Kontonummer | Token | Bankleitzahl | Verhalten | | -------------- | -------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000123456789` | `pm_usBankAccount_success` | `110000000` | Die Zahlung ist erfolgreich. | | `000111111113` | `pm_usBankAccount_accountClosed` | `110000000` | Die Zahlung schlägt fehl, weil das Konto geschlossen ist. | | `000000004954` | `pm_usBankAccount_riskLevelHighest` | `110000000` | Die Zahlung wird von Radar aufgrund eines [hohen Betrugsrisikos](https://docs.stripe.com/radar/risk-evaluation.md#high-risk) blockiert. | | `000111111116` | `pm_usBankAccount_noAccount` | `110000000` | Die Zahlung schlägt fehl, weil kein Konto gefunden wird. | | `000222222227` | `pm_usBankAccount_insufficientFunds` | `110000000` | Die Zahlung schlägt aufgrund unzureichender Deckung fehl. | | `000333333335` | `pm_usBankAccount_debitNotAuthorized` | `110000000` | Die Zahlung schlägt fehl, weil die Lastschriften nicht autorisiert sind. | | `000444444440` | `pm_usBankAccount_invalidCurrency` | `110000000` | Die Zahlung schlägt aufgrund einer ungültigen Währung fehl. | | `000666666661` | `pm_usBankAccount_failMicrodeposits` | `110000000` | Die Zahlung sendet keine Testeinzahlungen. | | `000555555559` | `pm_usBankAccount_dispute` | `110000000` | Die Zahlung löst eine Zahlungsanfechtung aus. | | `000000000009` | `pm_usBankAccount_processing` | `110000000` | Die Zahlung bleibt auf unbestimmte Zeit in Bearbeitung. Nützlich zum Testen [der Stornierung des PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md). | | `000777777771` | `pm_usBankAccount_weeklyLimitExceeded` | `110000000` | Die Zahlung schlägt aufgrund des Zahlungsbetrags fehl, wodurch das Konto sein wöchentliches Zahlungsvolumenlimit überschreitet. | | `000888888885` | | `110000000` | Die Zahlung schlägt aufgrund einer deaktivierten [tokenisierten Kontonummer](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) fehl. | Bevor Testtransaktionen abgeschlossen werden können, müssen Sie alle Testkonten verifizieren, auf denen die Zahlung automatisch erfolgreich war oder fehlschlagen ist. Verwenden Sie dazu die nachstehenden Test-Mikroeinzahlungsbeträge oder Beschreibungscodes. ### Testen von Mikroeinzahlungen und Beschreibungscodes Um verschiedene Szenarien zu imitieren, verwenden Sie diese Mikroeinzahlungsbeträge *oder* 0,01 Beschreibungscodewerte. | Testeinzahlungswerte | 0.01 Beschreibungscodewerte | Szenario | | -------------------- | --------------------------- | ------------------------------------------------------------------------- | | `32` und `45` | SM11AA | Simuliert die Verifizierung des Kontos. | | `10` und `11` | SM33CC | Simuliert das Überschreiten der Anzahl zulässiger Verifizierungsversuche. | | `40` und `41` | SM44DD | Simuliert ein Testeinzahlungs-Timeout. | ### Abwicklungsverhalten testen Testtransaktionen werden sofort abgewickelt und Ihrem verfügbaren Testguthaben hinzugefügt. Dieses Verhalten unterscheidet sich vom Live-Modus, bei dem es [mehrere Tage](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Optional: Nur Sofortverifizierung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die Zahlungen per US-Bankkonto tätigen, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional auch nur eine sofortige Verifizierung des Bankkontos verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den PaymentIntent erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` Dadurch wird sichergestellt, dass Sie keine Verifizierung von Testeinzahlungen durchführen müssen. Wenn die sofortige Verifizierung jedoch fehlschlägt, lautet der Status des PaymentIntent `requires_payment_method`. Dies weist darauf hin, dass die sofortige Verifizierung eines Kundenbankkontos fehlgeschlagen ist. ## Optional: Verifizierung ausschließlich durch Testeinzahlung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die Zahlungen per US-Bankkonto tätigen, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional auch nur Testeinzahlungen verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den PaymentIntent erstellen. > Wenn Sie ein individuelles Zahlungsformular verwenden, müssen Sie Ihre eigene Nutzeroberfläche erstellen, um Bankkontodaten zu erfassen. Wenn Sie Stripe-E-Mails mit Testeinzahlungen deaktivieren, müssen Sie Ihre eigene Nutzeroberfläche für Ihre Kundin/Ihren Kunden erstellen, um den Testeinzahlungscode bzw. -betrag zu bestätigen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=microdeposits" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=microdeposits" ``` Sie müssen dann das Bankkonto Ihrer Kundin/Ihres Kunden mit Ihrem eigenen Formular erfassen und [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) mit diesen Angaben aufrufen, um den PaymentIntent abzuschließen. ```javascript var form = document.getElementById('payment-form'); var accountholderName = document.getElementById('accountholder-name'); var email = document.getElementById('email'); var accountNumber = document.getElementById('account-number'); var routingNumber = document.getElementById('routing-number'); var accountHolderType= document.getElementById('account-holder-type'); var submitButton = document.getElementById('submit-button'); var clientSecret = submitButton.dataset.secret; form.addEventListener('submit', function(event) { event.preventDefault(); stripe.confirmUsBankAccountPayment(clientSecret, { payment_method: { billing_details: { name: accountholderName.value, email: email.value, }, us_bank_account: { account_number: accountNumber.value, routing_number: routingNumber.value, account_holder_type: accountHolderType.value, // 'individual' or 'company' }, }, }) .then(({paymentIntent, error}) => { if (error) { // Inform the customer that there was an error. console.log(error.message); } else { // Handle next step based on the intent's status. console.log("PaymentIntent ID: " + paymentIntent.id); console.log("PaymentIntent status: " + paymentIntent.status); } }); }); ``` ## Optional: Zahlungsreferenz Die Zahlungsreferenznummer ist ein von der Bank generierter Wert, mit dem der/die Kontoinhaber/in Gelder bei seiner/ihrer Bank finden kann. Wenn die Zahlung erfolgreich ist, gibt Stripe die Zahlungsreferenznummer im Dashboard und im [Zahlungsobjekt](https://docs.stripe.com/api/charges/object.md) an. | Status der Abbuchung | Zahlungsreferenzwert | | -------------------- | ---------------------------------------- | | Ausstehend | Nicht verfügbar | | Fehlgeschlagen | Nicht verfügbar | | Erfolgreich | Verfügbar (zum Beispiel 091000015001234) | Wenn Sie den Webhook `charge.succeeded` erhalten, zeigen Sie außerdem den Inhalt von `payment_method_details` an, um die [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference) zu finden. Das folgende Beispielereignis zeigt das Rendern einer erfolgreichen ACH-Zahlung mit einer Zahlungsreferenznummer. #### charge-succeeded ```json { "id": "{{EVENT_ID}}", "object": "event", // omitted some fields in the example "type": "charge.succeeded", "data": { "object": { "id": "{{PAYMENT_ID}}", "object": "charge", //... "paid": true, "payment_intent": "{{PAYMENT_INTENT_ID}}", "payment_method": "{{PAYMENT_METHOD_ID}}", "payment_method_details": { "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK", "fingerprint": "Ih3foEnRvLXShyfB", "last4": "1000","payment_reference": "091000015001234", "routing_number": "110000000" } } // ... } } } ``` Zeigen Sie den Inhalt der `destination_details` an, um die [Rückerstattungsreferenz](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) zu finden, die den erstatteten ACH-Zahlungen zugeordnet ist. Das folgende Beispielereignis zeigt das Rendering einer erfolgreichen ACH-Rückerstattung mit einer Rückerstattungsreferenznummer. Weitere Informationen zu [Rückerstattungen](https://docs.stripe.com/refunds.md). #### charge-refund-updated ```json { "id": "{{EVENT_ID}}", "object": "event", "type": "charge.refund.updated", "data": { "object": { "id": "{{REFUND_ID}}", "object": "refund", //... "payment_intent": "{{PAYMENT_INTENT_ID}}", "destination_details": { "type": "us_bank_transfer", "us_bank_transfer": {"reference": "091000015001111", "reference_status": "available" } } // ... } } } ``` ## See also - [Vorab autorisierte ACH-Lastschriftzahlungen für zukünftige Zahlungen speichern](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md) # 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/ach-direct-debit/accept-a-payment?payment-ui=mobile&platform=react-native. > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. Die Annahme von ACH-Lastschriftzahlungen mit Ihrer Anwendung umfasst Folgendes: - Objekt zur Zahlungsverfolgung erstellen - Informationen zur Zahlungsmethode erfassen - Zahlung zur weiteren Verarbeitung an Stripe übermitteln - Bankkonto Ihres/Ihrer Kund/in verifizieren Stripe verwendet einen [Payment Intent](https://docs.stripe.com/payments/payment-intents.md), um alle Status der Zahlung bis zu ihrem Abschluss zu verfolgen und zu verarbeiten. > Bei ACH Direct Debit handelt es sich um eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Dies bedeutet, dass Gelder nicht sofort nach der Zahlung verfügbar sind. Eine Zahlung benötigt in der Regel 4 Werktage bis zum Eingang auf Ihrem Konto. ## 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. Mit Stripe können Sie das Bankkonto eines Kunden/einer Kundin sofort verifizieren. Wenn Sie zusätzliche Daten zu einem Konto abrufen möchten, [registrieren Sie sich für den Datenzugriff](https://dashboard.stripe.com/financial-connections/application) mit [Stripe Financial Connections](https://docs.stripe.com/financial-connections.md). Mit Stripe Financial Connections können Ihre Kund/innen ihre Finanzdaten sicher teilen, indem sie ihre Finanzkonten mit Ihrem Unternehmen verknüpfen. Verwenden Sie Financial Connections, um auf von Kund/innen autorisierte Finanzdaten zuzugreifen, wie zum Beispiel tokenisierte Konto- und Routingnummern, Saldodaten, Eigentumsdaten und Transaktionsdaten. Der Zugriff auf diese Daten hilft Ihnen, Aktionen wie das Überprüfen von Salden durchzuführen, bevor Sie eine Zahlung veranlassen. Dies verringert die Wahrscheinlichkeit einer fehlgeschlagenen Zahlung aufgrund unzureichender Deckung. Mit Financial Connections können Ihre Nutzer/innen ihre Konten in wenigen Schritten mit Link verknüpfen. So können sie ihre Bankkontodaten bei Stripe-Unternehmen speichern und wiederverwenden. ## Kundinnen/Kunden erstellen oder abrufen [Empfohlen] [Serverseitig] > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. #### Accounts v2 Erstellen Sie ein von Kundinnen und Kunden konfiguriertes [Konto](https://docs.stripe.com/api/v2/core/accounts/object.md#v2_account_object-configuration-customer)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein bestehendes `Account` ab, das mit diesem/dieser Nutzer/in verknüpft ist. Wenn Sie die ID des `Account`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin oder eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse in das `Account` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl -X POST https://api.stripe.com/v2/core/accounts \ -H "Authorization: Bearer <>" \ -H "Stripe-Version: 2026-04-22.preview" \ --json '{ "contact_email": "{{CUSTOMER_EMAIL}}" }' ``` #### Customers v1 Erstellen Sie ein *Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments)-Objekt, wenn Ihr/e Nutzer/in ein Konto bei Ihrem Unternehmen anlegt, oder rufen Sie ein/e bestehende/n `Customer` ab, die/der mit dieser/diesem Nutzer/in verknüpft ist. Wenn Sie die ID des `Customer`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin/eines Kunden verknüpfen, können Sie die gespeicherten Zahlungsmethodendetails später abrufen und verwenden. Fügen Sie eine E-Mail-Adresse für die/den `Customer` ein, um die [Optimierung wiederkehrender Nutzer/innen](https://docs.stripe.com/financial-connections/fundamentals.md#return-user-optimization) von Financial Connections zu aktivieren. ```curl curl https://api.stripe.com/v1/customers \ -u "<>:" \ -d email={{CUSTOMER_EMAIL}} ``` ## PaymentIntent erstellen [Serverseitig] Ein [PaymentIntent](https://docs.stripe.com/api/payment_intents.md) ist ein Objekt, das Ihre Absicht darstellt, eine Zahlung von einer Kundin/einem Kunden einzuziehen, und das den Lebenszyklus des Zahlungsprozesses in jeder Phase verfolgt. ### Serverseitig Erstellen Sie zunächst einen PaymentIntent auf Ihrem Server und geben Sie den einzuziehenden Betrag und `usd` als Währung an. Falls Sie bereits über eine Integration verfügen, die die Payment Intents API 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 `us_bank_account` hinzu. Geben Sie die [ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) der Kundin/des Kunden an. Falls Sie die Zahlungsmethode künftig wiederverwenden möchten, geben Sie den Parameter [setup_future_usage](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) mit dem Wert `off_session` an. Weitere Informationen zu den Gebühren für Financial Connections finden Sie unter [Preisdetails](https://stripe.com/financial-connections#pricing). Bei der Erfassung von Zahlungsinformationen für Bankkonten wird standardmäßig [Financial Connections](https://docs.stripe.com/financial-connections.md) verwendet, um das Konto Ihres Kunden/Ihrer Kundin sofort zu verifizieren, mit einer Ausweichoption für die manuelle Eingabe der Kontonummer und die Verifizierung von Testeinzahlungen. In der [Financial Connections-Dokumentation](https://docs.stripe.com/financial-connections/ach-direct-debit-payments.md) erfahren Sie, wie Sie Financial Connections konfigurieren und auf zusätzliche Kontodaten zugreifen, um Ihre ACH-Integration zu optimieren. Beispielsweise können Sie Financial Connections verwenden, um den Kontostand zu prüfen, bevor Sie die ACH-Zahlung veranlassen. > Um den Zugriff auf zusätzliche Daten auszudehnen, nachdem ein/e Kund/in sein/ihr Konto authentifiziert hat, muss er/sie das Konto mit erweiterten Berechtigungen erneut verknüpfen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" ``` ### Clientseitig Ein PaymentIntent enthält 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)). Sie können das Client-Geheimnis in Ihrer React Native-App verwenden, um den Zahlungsvorgang sicher abzuschließen, anstatt das gesamte PaymentIntent-Objekt zurückzugeben. Fordern Sie in Ihrer App einen PaymentIntent von Ihrem Server an und speichern Sie dessen Client-Geheimnis. ```javascript function PaymentScreen() { // ... const fetchIntentClientSecret = async () => { const response = await fetch(`${API_URL}/create-intent`, { method: 'POST', headers: { 'Content-Type': 'application/json', }, body: JSON.stringify({ // This is an example request body, the parameters you pass are up to you customer: '', product: '', }), }); const {clientSecret} = await response.json(); return clientSecret; }; return ...; } ``` ## Angaben zur Zahlungsmethode erfassen [Clientseitig] Anstatt das gesamte PaymentIntent-Objekt an den Client zu übermitteln, verwenden Sie dessen *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)) aus dem vorherigen Schritt. Dieses unterscheidet sich von Ihren API-Schlüsseln, mit denen Anfragen der Stripe API authentifiziert werden. Gehen Sie sorgfältig mit dem Client-Geheimnis um, denn es kann die Zahlung abschließen. Protokollieren Sie es nicht, betten Sie es nicht in URLs ein und geben Sie es nur dem/der Kund/in preis. Verwenden Sie [collectBankAccountForPayment](https://docs.stripe.com/js/payment_intents/collect_bank_account_for_payment), um Bankkontodaten zu erfassen, eine *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) zu erstellen und diese PaymentMethod dem PaymentIntent hinzuzufügen. Sie müssen den Namen des Kontoinhabers/der Kontoinhaberin im Parameter `billingDetails` angeben, um eine PaymentMethod vom Typ ACH Direct Debit zu erstellen. ```javascript import {collectBankAccountForPayment} from '@stripe/stripe-react-native'; export default function MyPaymentScreen() { const [name, setName] = useState(''); const handleCollectBankAccountPress = async () => { // Fetch the intent client secret from the backend. // See `fetchIntentClientSecret()`'s implementation above. const {clientSecret} = await fetchIntentClientSecret(); const {paymentIntent, error} = await collectBankAccountForPayment( clientSecret, { paymentMethodType: 'USBankAccount', paymentMethodData: { billingDetails: { name: "John Doe", }, }, }, ); if (error) { Alert.alert(`Error code: ${error.code}`, error.message); } else if (paymentIntent) { Alert.alert('Payment status:', paymentIntent.status); if (paymentIntent.status === PaymentIntents.Status.RequiresConfirmation) { // The next step is to call `confirmPayment` } else if ( paymentIntent.status === PaymentIntents.Status.RequiresAction ) { // The next step is to call `verifyMicrodepositsForPayment` } } }; return ( setName(value.nativeEvent.text)} /> ``` ```ruby get '/checkout' do @intent = # ... Fetch or create the PaymentIntent erb :checkout end ``` ## Angaben zur Zahlungsmethode erfassen [Clientseitig] Wenn Kundinnen/Kunden über das „Click to Pay“-Verfahren mit ACH Direct Debit zahlen, empfehlen wir Ihnen, Stripe.js zu verwenden, um die Zahlung an Stripe zu übermitteln. [Stripe.js](https://docs.stripe.com/payments/elements.md) ist unsere grundlegende JavaScript-Bibliothek für die Erstellung von Zahlungsabläufen. Sie übernimmt automatisch komplexe Integrationsaufgaben und ermöglicht es Ihnen, Ihre Integration in Zukunft unkompliziert um andere Zahlungsmethoden zu erweitern. Binden Sie das Stripe.js-Skript in Ihre Zahlungsseite ein, indem Sie es im `head` Ihrer HTML-Datei einfügen. ```html Checkout ``` Erstellen Sie auf Ihrer Bezahlseite eine Instanz von Stripe.js mit dem folgenden JavaScript. ```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('<>'); ``` Anstatt das gesamte PaymentIntent-Objekt an den Client zu übermitteln, verwenden Sie dessen *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)) aus dem vorherigen Schritt. Dieses unterscheidet sich von Ihren API-Schlüsseln, mit denen Anfragen der Stripe API authentifiziert werden. Gehen Sie vorsichtig mit dem Client-Geheimnis um, da es die Zahlung abschließen kann. Protokollieren Sie es nicht, betten Sie es nicht in URLs ein und machen Sie es nur dem Kunden/der Kundin zugänglich. Verwenden Sie [stripe.collectBankAccountForPayment](https://docs.stripe.com/js/payment_intents/collect_bank_account_for_payment) , um Bankkontodaten mit [Financial Connections](https://docs.stripe.com/financial-connections.md) zu erfassen, eine *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) zu erstellen und diese PaymentMethod an den PaymentIntent anzuhängen. Der Parameter `billing_details` muss den Namen des Kontoinhabers/der Kontoinhaberin enthalten, um eine PaymentMethod für ein ACH-Lastschriftkonto zu erstellen. ```javascript // Use the form that already exists on the web page. const paymentMethodForm = document.getElementById('payment-method-form'); const confirmationForm = document.getElementById('confirmation-form'); paymentMethodForm.addEventListener('submit', (ev) => { ev.preventDefault(); const accountHolderNameField = document.getElementById('account-holder-name-field'); const emailField = document.getElementById('email-field'); // Calling this method will open the instant verification dialog. stripe.collectBankAccountForPayment({ clientSecret: clientSecret, params: { payment_method_type: 'us_bank_account', payment_method_data: { billing_details: { name: accountHolderNameField.value, email: emailField.value, }, }, }, expand: ['payment_method'], }) .then(({paymentIntent, error}) => { if (error) { console.error(error.message); // PaymentMethod collection failed for some reason. } else if (paymentIntent.status === 'requires_payment_method') { // Customer canceled the hosted verification modal. Present them with other // payment method type options. } else if (paymentIntent.status === 'requires_confirmation') { // We collected an account - possibly instantly verified, but possibly // manually-entered. Display payment method details and mandate text // to the customer and confirm the intent once they accept // the mandate. confirmationForm.show(); } }); }); ``` Der [Stripe Financial Connections-Authentifizierungsvogang](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) verarbeitet die Erfassung und Überprüfung von Bankkontodaten automatisch. Wenn Ihr Kunde/Ihre Kundin den Authentifizierungsvorgang abschließt, wird die *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) automatisch an den PaymentIntent angehängt und ein [Financial Connections Account](https://docs.stripe.com/api/financial_connections/accounts.md) wird erstellt. > Bankkonten, die Ihre Kundinnen/Kunden durch manuelle Eingabe und Testeinzahlungen verknüpfen, haben keinen Zugriff auf zusätzliche Bankkontodaten wie Salden, Kontoinhaberschaft und Transaktionen. Um die beste Nutzererfahrung auf allen Geräten zu bieten, setzen Sie die `minimum-scale` des Darstellungsfelds für Ihre Seite mithilfe des `meta`-Tags des Darstellungsfelds auf 1. ```html ``` ### OAuth-Weiterleitungen über Ihre Mobil-App verarbeiten Zusätzlich zur Aufnahme von Stripe.js auf Ihrer in der Webansicht eingebetteten Seite muss Ihre App möglicherweise die Weiterleitung Ihrer Kundinnen/Kunden zu ihrem nativen mobilen Browser für die OAuth-Anmeldung übernehmen. > Beginning January 1, 2024, all webview-based integrations need to properly handle secure institution authentication and app redirects, or it will impact your Financial Connections authorization flow. Refer to the iOS or Android instructions above. #### Android Unter Android muss Ihre App einen [Intent-Filter](https://developer.android.com/guide/components/intents-filters) für die zuvor festgelegte `return_url` in Ihrem Manifest registrieren. Erfahren Sie mehr über die [Verwendung von Links unter Android](https://developer.android.com/training/app-links). ```xml ``` Registrieren Sie einen [WebViewClient](https://developer.android.com/reference/android/webkit/WebViewClient) in Ihrer Webansicht. Sie können `shouldOverrideUrlLoading` überschreiben, um die OAuth-Anmeldeseiten auf einer benutzerdefinierten Registerkarte bzw. einem sicheren Browserfenster zu öffnen: ```kotlin val webViewClient = object : WebViewClient() { override fun shouldOverrideUrlLoading( view: WebView, webResourceRequest: WebResourceRequest ): Boolean { val url = webResourceRequest.url.toString() CustomTabsIntent.Builder().build().launchUrl(view.context, Uri.parse(url)) return true } } // ... // register the web view client on your WebView myWebView.webViewClient = webViewClient ``` #### iOS Unter iOS muss Ihre App in der Lage sein, den Versuch der Webansicht zu verarbeiten, ein OAuth-Fenster zu öffnen. Bei diesem Vorgang wird versucht, die URL in einer Bank-App oder, falls dies nicht unterstützt wird, in einer sicheren Browserinstanz zu öffnen. Wenn `WKWebView` eine neue Fensteranforderung abfängt, versuchen Sie zunächst, die URL als universellen Link zu öffnen. Universelle Links ermöglichen es Banking-Apps, die auf dem Gerät des Nutzers/der Nutzerin installiert sind, die zugehörigen URLs direkt zu verarbeiten, um den Authentifizierungsprozess zu vereinfachen. Diese Methode verbessert die Sicherheit und den Komfort der Nutzer/innen, indem sie die vorhandenen, vertrauenswürdigen Apps nutzt, die sich bereits auf dem Gerät befinden. Wenn die URL nicht erfolgreich als universeller Link geöffnet werden kann – entweder weil keine unterstützende Bank-App installiert ist oder der Link nicht erkannt wird – muss die App auf die Verwendung von `ASWebAuthenticationSession` zurückgreifen. Diese Sitzung ermöglicht den Authentifizierungsvorgang in einem sicheren In-App-Browser, der den sicheren Umgang mit sensiblen Informationen gewährleistet. `ASWebAuthenticationSession` imitiert den nativen Browser und ermöglicht es Nutzern/Nutzerinnen, sich zu authentifizieren, ohne die App zu verlassen. ```swift class ViewController: UIViewController { private var webAuthenticationSession: ASWebAuthenticationSession? override func viewDidLoad() { super.viewDidLoad() // Initialize and configure your WKWebView let webView = WKWebView(frame: .zero, configuration: WKWebViewConfiguration()) // Load your website URL webView.load(URLRequest(url: URL(string: "https://yourwebsite.com")!)) // Add the web view to the view view.addSubview(webView) // Important: Assign a `uiDelegate` to handle redirects webView.uiDelegate = self } } extension ViewController: WKUIDelegate { func webView( _ webView: WKWebView, createWebViewWith configuration: WKWebViewConfiguration, for navigationAction: WKNavigationAction, windowFeatures: WKWindowFeatures ) -> WKWebView? { // Check if the link is attempting to open in a new window. // This is typically the case for a banking partner's authentication flow. let isAttemptingToOpenLinkInNewWindow = navigationAction.targetFrame?.isMainFrame != true if isAttemptingToOpenLinkInNewWindow, let url = navigationAction.request.url { // Attempt to open the URL as a universal link. // Universal links allow apps on the device to handle specific URLs directly. UIApplication.shared.open( url, options: [.universalLinksOnly: true], completionHandler: { [weak self] success in guard let self else { return } if success { // App-to-app flow: // The URL was successfully opened in a banking application that supports universal links. print("Successfully opened the authentication URL in a bank app: \(url)") } else { // Fallback for when no compatible bank app is found: // Create an `ASWebAuthenticationSession` to handle the authentication in a secure in-app browser self.launchInSecureBrowser(url: url) } }) } return nil } private func launchInSecureBrowser(url: URL) { let redirectURL = URL(string: "https://yourwebsite.com")! let webAuthenticationSession = ASWebAuthenticationSession( url: url, callbackURLScheme: redirectURL.scheme, completionHandler: { redirectURL, error in if let error { if (error as NSError).domain == ASWebAuthenticationSessionErrorDomain, (error as NSError).code == ASWebAuthenticationSessionError.canceledLogin.rawValue { print("User manually closed the browser by pressing 'Cancel' at the top-left corner.") } else { print("Received an error from ASWebAuthenticationSession: \(error)") } } else { // IMPORTANT NOTE: // The browser will automatically close when // the `callbackURLScheme` is called. print("Received a redirect URL: \(redirectURL?.absoluteString ?? "null")") } } ) // Store the session reference to prevent premature deallocation self.webAuthenticationSession = webAuthenticationSession // Set the presentation context provider to handle the browser's UI presentation webAuthenticationSession.presentationContextProvider = self // Use an ephemeral session to enhance privacy // This also disables the initial Apple alert about signing in to another app webAuthenticationSession.prefersEphemeralWebBrowserSession = true // Initiate the authentication session webAuthenticationSession.start() } } ``` Nachdem Ihre Kundinnen/Kunden sich bei ihrer Institution angemeldet und den Zugriff auf ihre Konten autorisiert haben, leitet Stripe auf die `return_url` um, um zu Ihrer App zurückzukehren. Anschließend können Ihre Kundinnen/Kunden den Erfassungsvorgang der Bankkontodetails fortsetzen und abschließen. ## Mandatsbestätigung erfassen und die Zahlung übermitteln [Clientseitig] Bevor Sie die Zahlung veranlassen können, müssen Sie eine Zahlungsautorisierung von Ihrem/Ihrer Kund/in einholen, indem Sie Mandatsbedingungen anzeigen, denen er/sie zustimmen muss. Um die Nacha-Regeln einzuhalten, müssen Sie eine Autorisierung von Ihrem Kunden/Ihrer Kundin einholen, bevor Sie die Zahlung veranlassen können. Dies tun Sie durch Anzeigen von Mandatskonditionen, denen der Kunde/die Kundin zustimmen muss. Weitere Informationen finden Sie unter [Mandate]](/payments/ach-direct-debit#mandates). Wenn der Kunde/die Kundin den Mandatskonditionen zustimmt, müssen Sie den PaymentIntent bestätigen. Verwenden Sie [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment), um die Zahlung abzuschließen, wenn der Kunde/die Kundin das Formular absendet. ```javascript confirmationForm.addEventListener('submit', (ev) => { ev.preventDefault(); stripe.confirmUsBankAccountPayment(clientSecret) .then(({paymentIntent, error}) => { if (error) { console.error(error.message); // The payment failed for some reason. } else if (paymentIntent.status === "requires_payment_method") { // Confirmation failed. Attempt again with a different payment method. } else if (paymentIntent.status === "processing") { // Confirmation succeeded! The account will be debited. // Display a message to customer. } else if (paymentIntent.next_action?.type === "verify_with_microdeposits") { // The account needs to be verified through microdeposits. // Display a message to consumer with next steps (consumer waits for // microdeposits, then enters a statement descriptor code on a page sent to them through email). } }); }); ``` > Die Ausführung von [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) kann einige Sekunden dauern. Während dieser Zeit sollten Sie Ihr Formular deaktivieren, damit keine erneute Übermittlung erfolgen kann. Lassen Sie stattdessen ein Wartesymbol einblenden, wie beispielsweise eine Sanduhr. Tritt ein Fehler auf, lassen Sie eine Fehlermeldung für die Kundin/den Kunden anzeigen, aktivieren Sie das Formular erneut und blenden Sie das Wartesymbol aus. Bei erfolgreicher Ausführung gibt Stripe ein PaymentIntent-Objekt mit einem der folgenden möglichen Status zurück: | Status | Beschreibung | Ausblick | | ----------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `requires_action` | Weitere Schritte sind erforderlich, um die Bankkontoverifizierung abzuschließen. | Schritt 6: [Bankkonten mit Testeinzahlungen verifizieren](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#web-verify-with-microdeposits) | | `processing` | Das Bankkonto wurde sofort verifiziert oder eine Verifizierung war nicht notwendig. | Schritt 7: [Erfolgreichen PaymentIntent bestätigen](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#web-confirm-paymentintent-succeeded) | Nach erfolgreicher Bestätigung des PaymentIntent muss eine E-Mail-Bestätigung des Mandats und der erfassten Bankkontodaten an Ihren Kunden/Ihre Kundin gesendet werden. Stripe kümmert sich standardmäßig darum, aber Sie können auch [nutzerdefinierte Benachrichtigungen senden](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails), wenn Sie dies vorziehen. ## Bankkonto mit Testeinzahlungen verifizieren [Clientseitig] Nicht alle Kund/innen können das Bankkonto sofort verifizieren. Dieser Schritt wird nur ausgeführt, wenn Ihr/e Kund/in die Sofortverifizierung im vorherigen Schritt deaktiviert hat. In diesen Fällen sendet Stripe eine `descriptor_code`-Testeinzahlung und greift möglicherweise auf eine `amount`-Testeinzahlung zurück, falls weitere Probleme bei der Verifizierung des Bankkontos auftreten. Es dauert 1–2 Werktage, bis diese Einzahlungen auf der Online-Abrechnung des Kunden/der Kundin erscheinen - **Code der Zahlungsbeschreibung**. Stripe sendet eine einzelne Mikroeinzahlung über 0,01 USD an das Bankkonto des/der Kund/in mit einem einmaligen, 6-stelligen `descriptor_code`, der mit SM beginnt. Ihr/e Kund/in verwendet diese Zeichenfolge, um sein/ihr Bankkonto zu verifizieren. - **Betrag**: Stripe sendet zwei nicht eindeutige Testeinzahlungen an das Kundenbankkonto, wobei `ACCTVERIFY` als Zahlungsbeschreibung in der Abrechnung angegeben ist. Ihre Kundin/Ihr Kunde verwendet die Einzahlungsbeträge zur Verifizierung des Bankkontos. Das Ergebnis des Aufrufs der Methode [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) im vorhergehenden Schritt ist ein PaymentIntent mit dem Status `requires_action`. Der PaymentIntent enthält das Feld `next_action`, das einige nützliche Informationen zum Abschließen der Verifizierung enthält. ```javascript next_action: { type: "verify_with_microdeposits", verify_with_microdeposits: { arrival_date: 1647586800, hosted_verification_url: "https://payments.stripe.com/…", microdeposit_type: "descriptor_code" } } ``` Wenn Sie eine [E-Mail-Adresse für die Rechnungsstellung](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email) angegeben haben, benachrichtigt Stripe Ihre Kundinnen und Kunden über diese E-Mail-Adresse, wann die Einzahlungen voraussichtlich eingehen werden. Die E-Mail enthält einen Link zu einer von Stripe gehosteten Verifizierungsseite, auf der sie die Beträge der Einzahlungen bestätigen und die Verifizierung abschließen können. > Verifizierungsversuche dürfen für beschreibungsbasierte Testeinzahlungen bis zu 10 mal und für betragsbasierte bis zu 3 mal fehlschlagen. Wenn Sie dieses Limit überschreiten, können wir das Bankkonto nicht mehr verifizieren. Darüber hinaus gilt für Verifizierungen von Testeinzahlungen eine Zeitüberschreitung von 10 Tagen. Werden Testeinzahlungen nicht innerhalb dieser Zeit verifiziert, fordert der PaymentIntent wieder neue Angaben zur Zahlungsmethode an. Wenn Sie Ihren Kund/innen genau erläutern, was Testeinzahlungen sind und wie sie verwendet werden, können Sie Probleme bei der Verifizierung vermeiden. ### Optional: Nutzerdefinierte E-Mails-Benachrichtigungen senden Optional können Sie [personalisierte E-Mail-Benachrichtigungen](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) an Ihren Kunden/Ihre Kundin senden. Nachdem Sie die nutzerspezifischen E-Mails eingerichtet haben, müssen Sie angeben, wie der Kunde/die Kundin auf die Verifizierungs-E-Mail antwortet. Wählen Sie dazu *eine* der folgenden Optionen aus: - Verwenden Sie die von Stripe gehostete Verifizierungsseite. Verwenden Sie dazu die URL `verify_with_microdeposits[hosted_verification_url]` im [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url)-Objekt, um Ihre Kundinnen/Kunden zum Abschluss des Verifizierungsvorgangs zu leiten. - Wenn Sie die von Stripe gehostete Verifizierungsseite nicht verwenden möchten, können Sie auf Ihrer Website ein Formular für Ihre Kundinnen/Kunden zur Weiterleitung von Testeinzahlungen an Sie erstellen und das Bankkonto mit [Stripe.js](https://docs.stripe.com/js/payment_intents/verify_microdeposits_for_payment) verifizieren. - Richten Sie das Formular mindestens so ein, dass es den Parameter `descriptor code` verarbeitet, bei dem es sich um eine 6-stellige Zeichenfolge zu Verifizierungszwecken handelt. - Stripe empfiehlt außerdem, dass Sie Ihr Formular so konfigurieren, dass der Parameter `beträge` verarbeitet wird, da einige der von Ihren Kund/innen verwenden Banken dies möglicherweise verlangen. Integrationen übergeben nur den `descriptor_code` *oder* `amounts`. Um festzustellen, welches Ihre Integration verwendet, prüfen Sie den Wert für `verify_with_microdeposits[microdeposit_type]` im `next_action`-Objekt. ```javascript stripe.verifyMicrodepositsForPayment(clientSecret, { // Provide either a descriptor_code OR amounts, not both descriptor_code: 'SMT86W', amounts: [32, 45], }); ``` Wenn das Bankkonto erfolgreich verifiziert wurde, gibt Stripe das PaymentIntent-Objekt mit dem `status` `processing` zurück und übermittelt das *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests)-Ereignis [payment_intent.processing`](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.processing). Die Verifizierung kann aus unterschiedlichen Gründen fehlschlagen. Der Fehler kann synchron als direkte Fehlermeldung oder asynchron über das Webhook-Ereignis [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.failed) auftreten (wie in den folgenden Beispielen dargestellt). #### Synchroner Fehler ```json { "error": { "code": "payment_method_microdeposit_verification_amounts_mismatch", "message": "The amounts provided do not match the amounts that were sent to the bank account. You have {attempts_remaining} verification attempts remaining.", "type": "invalid_request_error" } } ``` #### Webhook-Ereignis ```javascript { "object": { "id": "pi_1234", "object": "payment_intent", "customer": "cus_0246", ... "last_payment_error": { "code": "payment_method_microdeposit_verification_attempts_exceeded", "message": "You have exceeded the number of allowed verification attempts.", }, ... "status": "requires_payment_method" } } ``` | Fehlercode | Synchron oder asynchron | Meldungen | Änderung des Status | | ------------------------------------------------------------ | ------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------- | | `payment_method_microdeposit_failed` | Synchron oder asynchron über ein Webhook-Ereignis | Die Testeinzahlungen sind fehlgeschlagen. Bitte überprüfen Sie die Kontonummer, die Finanzinstitutsnummer und die bereitgestellte Transitnummer. | `status` ist `requires_payment_method` und `last_payment_error` ist festgelegt. | | `payment_method_microdeposit_verification_amounts_mismatch` | Synchron | Die angegebenen Beträge stimmen nicht mit den Beträgen überein, die an das Bankkonto gesendet wurden. Sie haben noch {attempts_remaining} Verifizierungsversuche. | Unverändert | | `payment_method_microdeposit_verification_attempts_exceeded` | Synchron oder asynchron über ein Webhook-Ereignis | Anzahl zulässiger Verifizierungsversuche wurde überschritten | `status` ist `requires_payment_method` und `last_payment_error` ist festgelegt. | | `payment_method_microdeposit_verification_timeout` | Asynchron über ein Webhook-Ereignis | Zeitüberschreitung bei der Testeinzahlung. Die Kundin/der Kunde hat das Bankkonto nicht innerhalb der Frist von 10 Tagen verifiziert. | `status` ist `requires_payment_method` und `last_payment_error` ist festgelegt. | ## Erfolgreichen PaymentIntent bestätigen [Serverseitig] Bei ACH Direct Debit handelt es sich um eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). Das bedeutet, dass es bis zu vier Werktage dauern kann, bis Sie nach Initiierung einer Lastschrift für das Kundenkonto eine Mitteilung über die erfolgreiche oder fehlgeschlagene Zahlung erhalten. Der von Ihnen erstellte PaymentIntent hat zunächst den Status `processing`. Wenn die Zahlung erfolgreich war, wird der PaymentIntent-Status von `processing` in `succeeded` geändert. Wir empfehlen die Verwendung von [Webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks), um die erfolgreiche Zahlung zu *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) und die Kundinnen/Kunden zu informieren, dass die Zahlung abgeschlossen ist. Sie können sich Ereignisse auch im [Stripe-Dashboard](https://dashboard.stripe.com/events) anzeigen lassen. #### PaymentIntent-Ereignisse Die folgenden Ereignisse werden übermittelt, wenn der PaymentIntent-Status aktualisiert wird: | Ereignis | Beschreibung | Nächster Schritt | | ------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `payment_intent.processing` | Die Zahlung der Kundin/des Kunden wurde erfolgreich an Stripe übermittelt. | Warten Sie, bis die initiierte Zahlung erfolgt oder fehlschlägt. | | `payment_intent.succeeded` | Die Kundenzahlung war erfolgreich. | Führen Sie die Bestellung der gekauften Waren oder Dienstleistungen aus. | | `payment_intent.payment_failed` | Die Zahlung der Kundin/des Kunden wurde abgelehnt. Dies kann auch bei einer fehlgeschlagenen Verifizierung der Testeinzahlung zutreffen. | Kontaktieren Sie Ihre/n Kund/in per E-Mail oder Push-Benachrichtigung und fordern Sie eine andere Zahlungsmethode an. Wenn der Webhook aufgrund einer fehlgeschlagenen Verifizierung der Testeinzahlung übermittelt wurde, müssen die Nutzer/innen ihre Bankkontodaten erneut eingeben. Danach werden neue Testeinzahlungen durchgeführt. | #### Zahlungsereignisse Sie können auch zusätzliche Charge-Webhooks verwenden, um den Status der Zahlung zu verfolgen. Sobald Sie den Webhook `charge.updated` empfangen haben, kann die Zahlung nicht mehr storniert werden. Die folgenden Ereignisse werden gesendet, wenn der Status der Zahlung aktualisiert wird: | Ereignis | Beschreibung | Nächster Schritt | | ------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ | | `charge.pending` | Die Zahlung wurde erfolgreich erstellt. | Warten Sie, bis die initiierte Zahlung verarbeitet wird. | | `charge.updated` | Die Kundenzahlung wurde aktualisiert. Sie kann gesendet werden, wenn eine neue Saldo-Transaktion erstellt wurde und eine Zahlungsbeschreibung bzw. die Metadaten aktualisiert wurden. | Warten Sie, bis die initiierte Zahlung erfolgt oder fehlschlägt. | | `charge.succeeded` | Die Kundenzahlung war erfolgreich und das Geld ist in Ihrem Saldo verfügbar. | Führen Sie die Bestellung der gekauften Waren oder Dienstleistungen aus. | | `charge.failed` | Kundenzahlung ist fehlgeschlagen. | Überprüfen Sie den failure_code und die failure_message der Zahlung, um weitere Maßnahmen festzulegen. | ## Integration testen Erfahren Sie, wie Sie Szenarien mit sofortigen Verifizierungen mithilfe von [Financial Connections](https://docs.stripe.com/financial-connections/testing.md#web-how-to-use-test-accounts) testen können. ### Transaktions-E-Mails in einer Sandbox senden Nachdem Sie die Bankkontodetails erfasst und ein Mandat akzeptiert haben, senden Sie die Mandatsbestätigung und die Verifizierungs-E-Mails mit Testeinzahlungen in einer *Sandbox* (A sandbox is an isolated test environment that allows you to test Stripe functionality in your account without affecting your live integration. Use sandboxes to safely experiment with new features and changes). Wenn Ihre Domain **{domain}** lautet und Ihr Benutzername **{username}** ist, verwenden Sie das folgende E-Mail-Format, um Test-Transaktions-E-Mails zu versenden: **{username}+test\_email@{domain}**. Wenn Ihre Domain beispielsweise **example.com** und Ihr Nutzername **Info** lautet, verwenden Sie zum Testen von ACH Direct Debit-Zahlungen das Format **info+test\_email@example.com**. Dieses Format stellt sicher, dass E-Mails korrekt weitergeleitet werden. Wenn Sie das Suffix **+test\_email** nicht angeben, senden wir die E-Mail nicht. > Sie müssen [Ihr Stripe-Konto einrichten](https://docs.stripe.com/get-started/account/set-up.md), bevor Sie diese E-Mails während Tests auslösen können. ### Testkontonummern Stripe stellt mehrere Testkontonummern und dazugehörige Token zur Verfügung, um sicherzustellen, dass Ihre Integration für Bankkonten mit manueller Eingabe für den Einsatz in einer Produktionsumgebung bereit ist. | Kontonummer | Token | Bankleitzahl | Verhalten | | -------------- | -------------------------------------- | ------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000123456789` | `pm_usBankAccount_success` | `110000000` | Die Zahlung ist erfolgreich. | | `000111111113` | `pm_usBankAccount_accountClosed` | `110000000` | Die Zahlung schlägt fehl, weil das Konto geschlossen ist. | | `000000004954` | `pm_usBankAccount_riskLevelHighest` | `110000000` | Die Zahlung wird von Radar aufgrund eines [hohen Betrugsrisikos](https://docs.stripe.com/radar/risk-evaluation.md#high-risk) blockiert. | | `000111111116` | `pm_usBankAccount_noAccount` | `110000000` | Die Zahlung schlägt fehl, weil kein Konto gefunden wird. | | `000222222227` | `pm_usBankAccount_insufficientFunds` | `110000000` | Die Zahlung schlägt aufgrund unzureichender Deckung fehl. | | `000333333335` | `pm_usBankAccount_debitNotAuthorized` | `110000000` | Die Zahlung schlägt fehl, weil die Lastschriften nicht autorisiert sind. | | `000444444440` | `pm_usBankAccount_invalidCurrency` | `110000000` | Die Zahlung schlägt aufgrund einer ungültigen Währung fehl. | | `000666666661` | `pm_usBankAccount_failMicrodeposits` | `110000000` | Die Zahlung sendet keine Testeinzahlungen. | | `000555555559` | `pm_usBankAccount_dispute` | `110000000` | Die Zahlung löst eine Zahlungsanfechtung aus. | | `000000000009` | `pm_usBankAccount_processing` | `110000000` | Die Zahlung bleibt auf unbestimmte Zeit in Bearbeitung. Nützlich zum Testen [der Stornierung des PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md). | | `000777777771` | `pm_usBankAccount_weeklyLimitExceeded` | `110000000` | Die Zahlung schlägt aufgrund des Zahlungsbetrags fehl, wodurch das Konto sein wöchentliches Zahlungsvolumenlimit überschreitet. | | `000888888885` | | `110000000` | Die Zahlung schlägt aufgrund einer deaktivierten [tokenisierten Kontonummer](https://docs.stripe.com/financial-connections/tokenized-account-numbers.md) fehl. | Bevor Testtransaktionen abgeschlossen werden können, müssen Sie alle Testkonten verifizieren, auf denen die Zahlung automatisch erfolgreich war oder fehlschlagen ist. Verwenden Sie dazu die nachstehenden Test-Mikroeinzahlungsbeträge oder Beschreibungscodes. ### Testen von Mikroeinzahlungen und Beschreibungscodes Um verschiedene Szenarien zu imitieren, verwenden Sie diese Mikroeinzahlungsbeträge *oder* 0,01 Beschreibungscodewerte. | Testeinzahlungswerte | 0.01 Beschreibungscodewerte | Szenario | | -------------------- | --------------------------- | ------------------------------------------------------------------------- | | `32` und `45` | SM11AA | Simuliert die Verifizierung des Kontos. | | `10` und `11` | SM33CC | Simuliert das Überschreiten der Anzahl zulässiger Verifizierungsversuche. | | `40` und `41` | SM44DD | Simuliert ein Testeinzahlungs-Timeout. | ### Abwicklungsverhalten testen Testtransaktionen werden sofort abgewickelt und Ihrem verfügbaren Testguthaben hinzugefügt. Dieses Verhalten unterscheidet sich vom Live-Modus, bei dem es [mehrere Tage](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Optional: Nur Sofortverifizierung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die Zahlungen per US-Bankkonto tätigen, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional auch nur eine sofortige Verifizierung des Bankkontos verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den PaymentIntent erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` Dadurch wird sichergestellt, dass Sie keine Verifizierung von Testeinzahlungen durchführen müssen. Wenn die sofortige Verifizierung jedoch fehlschlägt, lautet der Status des PaymentIntent `requires_payment_method`. Dies weist darauf hin, dass die sofortige Verifizierung eines Kundenbankkontos fehlgeschlagen ist. ## Optional: Verifizierung ausschließlich durch Testeinzahlung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die Zahlungen per US-Bankkonto tätigen, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional auch nur Testeinzahlungen verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den PaymentIntent erstellen. > Wenn Sie ein individuelles Zahlungsformular verwenden, müssen Sie Ihre eigene Nutzeroberfläche erstellen, um Bankkontodaten zu erfassen. Wenn Sie Stripe-E-Mails mit Testeinzahlungen deaktivieren, müssen Sie Ihre eigene Nutzeroberfläche für Ihre Kundin/Ihren Kunden erstellen, um den Testeinzahlungscode bzw. -betrag zu bestätigen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=microdeposits" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d setup_future_usage=off_session \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=microdeposits" ``` Sie müssen dann das Bankkonto Ihrer Kundin/Ihres Kunden mit Ihrem eigenen Formular erfassen und [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) mit diesen Angaben aufrufen, um den PaymentIntent abzuschließen. ```javascript var form = document.getElementById('payment-form'); var accountholderName = document.getElementById('accountholder-name'); var email = document.getElementById('email'); var accountNumber = document.getElementById('account-number'); var routingNumber = document.getElementById('routing-number'); var accountHolderType= document.getElementById('account-holder-type'); var submitButton = document.getElementById('submit-button'); var clientSecret = submitButton.dataset.secret; form.addEventListener('submit', function(event) { event.preventDefault(); stripe.confirmUsBankAccountPayment(clientSecret, { payment_method: { billing_details: { name: accountholderName.value, email: email.value, }, us_bank_account: { account_number: accountNumber.value, routing_number: routingNumber.value, account_holder_type: accountHolderType.value, // 'individual' or 'company' }, }, }) .then(({paymentIntent, error}) => { if (error) { // Inform the customer that there was an error. console.log(error.message); } else { // Handle next step based on the intent's status. console.log("PaymentIntent ID: " + paymentIntent.id); console.log("PaymentIntent status: " + paymentIntent.status); } }); }); ``` ## Optional: Informationen zum Saldo für ein Financial Connections-Bankkonto abrufen Um Zahlungsausfälle aufgrund unzureichender Mittel zu vermeiden, empfehlen wir Ihnen, das Guthaben eines Kunden/einer Kundin zu überprüfen, bevor Sie eine Zahlung veranlassen. Mit der Erlaubnis Ihrer Nutzerin/Ihres Nutzers können Sie über Financial Connections auf [Kontostände zugreifen](https://docs.stripe.com/financial-connections/balances.md). ## Optional: Zahlungsreferenz Die Zahlungsreferenznummer ist ein von der Bank generierter Wert, mit dem der/die Kontoinhaber/in Gelder bei seiner/ihrer Bank finden kann. Wenn die Zahlung erfolgreich ist, gibt Stripe die Zahlungsreferenznummer im Dashboard und im [Zahlungsobjekt](https://docs.stripe.com/api/charges/object.md) an. | Status der Abbuchung | Zahlungsreferenzwert | | -------------------- | ---------------------------------------- | | Ausstehend | Nicht verfügbar | | Fehlgeschlagen | Nicht verfügbar | | Erfolgreich | Verfügbar (zum Beispiel 091000015001234) | Wenn Sie den Webhook `charge.succeeded` erhalten, zeigen Sie außerdem den Inhalt von `payment_method_details` an, um die [payment_reference](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details-us_bank_account-payment_reference) zu finden. Das folgende Beispielereignis zeigt das Rendern einer erfolgreichen ACH-Zahlung mit einer Zahlungsreferenznummer. #### charge-succeeded ```json { "id": "{{EVENT_ID}}", "object": "event", // omitted some fields in the example "type": "charge.succeeded", "data": { "object": { "id": "{{PAYMENT_ID}}", "object": "charge", //... "paid": true, "payment_intent": "{{PAYMENT_INTENT_ID}}", "payment_method": "{{PAYMENT_METHOD_ID}}", "payment_method_details": { "type": "us_bank_account", "us_bank_account": { "account_holder_type": "individual", "account_type": "checking", "bank_name": "TEST BANK", "fingerprint": "Ih3foEnRvLXShyfB", "last4": "1000","payment_reference": "091000015001234", "routing_number": "110000000" } } // ... } } } ``` Zeigen Sie den Inhalt der `destination_details` an, um die [Rückerstattungsreferenz](https://docs.stripe.com/api/refunds/object.md#refund_object-destination_details-us_bank_transfer-reference) zu finden, die den erstatteten ACH-Zahlungen zugeordnet ist. Das folgende Beispielereignis zeigt das Rendering einer erfolgreichen ACH-Rückerstattung mit einer Rückerstattungsreferenznummer. Weitere Informationen zu [Rückerstattungen](https://docs.stripe.com/refunds.md). #### charge-refund-updated ```json { "id": "{{EVENT_ID}}", "object": "event", "type": "charge.refund.updated", "data": { "object": { "id": "{{REFUND_ID}}", "object": "refund", //... "payment_intent": "{{PAYMENT_INTENT_ID}}", "destination_details": { "type": "us_bank_transfer", "us_bank_transfer": {"reference": "091000015001111", "reference_status": "available" } } // ... } } } ``` ## See also - [Vorab autorisierte ACH-Lastschriftzahlungen für zukünftige Zahlungen speichern](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md)