# Details für zukünftige Zahlungen per ACH-Lastschrift speichern So speichern Sie die Angaben zur Zahlungsmethode für zukünftige SEPA-Lastschriftzahlungen. # Bezahlvorgang > This is a Bezahlvorgang for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/ach-direct-debit/set-up-payment?payment-ui=checkout. Sie können Checkout im [Einrichtungsmodus](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-mode) verwenden, um die Details der Zahlungsmethode im Voraus zu erfassen, wobei der endgültige Betrag oder das Zahlungsdatum später festgelegt wird. Dies ist nützlich für Folgendes: - Speichern von Zahlungsmethoden in einer Wallet, um zukünftige Einkäufe zu optimieren - Einziehen von Zuschlägen nach Abwicklung einer Dienstleistung - Kostenlosen Testzeitraum für ein *Abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) starten > 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. ## Before you begin In diesem Leitfaden erfahren Sie, wie Sie die grundlegende Checkout-Integration für die [Einrichtung zukünftiger Zahlungen](https://docs.stripe.com/payments/save-and-reuse.md?platform=web&ui=stripe-hosted) erweitern, um Unterstützung für ACH-Lastschriftzahlungen hinzuzufügen. ## 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}} ``` ## ACH-Lastschriftverfahren 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. Legen Sie den Parameter `permissions` so fest, dass er eine `payment_method` enthält. #### Von Stripe gehostete Seite #### Accounts v2 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d mode=setup \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_types[]=card" \ -d "payment_method_types[]=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 mode=setup \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_types[]=card" \ -d "payment_method_types[]=us_bank_account" \ --data-urlencode "success_url=https://example.com/success" ``` #### Vollständige eingebettete Seite #### Accounts v2 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d mode=setup \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_types[]=card" \ -d "payment_method_types[]=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 mode=setup \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_types[]=card" \ -d "payment_method_types[]=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. Während der Checkout-Sitzung sieht der/die Kund/in einen Dialog mit der Option, die sofortige Verifizierung zu verwenden oder Bankkontodaten für die Verifizierung der Testeinzahlungen anzugeben. Wenn der Kunde/die Kundin sich für die Verifizierung der Testeinzahlung entscheidet, sendet Stripe automatisch zwei kleine Einzahlungen auf das angegebene Bankkonto. Es kann 1 bis 2 Werktage dauern, bis diese Einzahlungen auf dem Online-Auszug des Kunden/der Kundin erscheinen. Wenn die Einzahlungen eingehen, erhält die Kundin/der Kunde 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. ## 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/set-up-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Zahlungsmethode verwenden Nach Abschluss der Checkout-Sitzung können Sie die [PaymentMethod](https://docs.stripe.com/api/payment_methods.md)-ID [erfassen](https://docs.stripe.com/payments/checkout/save-and-reuse.md?payment-ui=stripe-hosted#retrieve-checkout-session). Mit diesen PaymentMethod-IDs können künftige Zahlungen eingeleitet werden, ohne dass der Kunde/die Kundin das Bankkonto erneut angeben muss. Geben Sie beim [Erstellen eines PaymentIntent](https://docs.stripe.com/api/payment_intents/create.md) die `payment_method` und Kunden-IDs an, um Ihren Kunden/Ihre Kundin mit seinen/ihren gespeicherten Bankkontoinformationen zu belasten. ## 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=setup \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=card" \ -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" \ --data-urlencode "success_url=https://example.com/success" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=setup \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[]=card" \ -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" \ --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 SetupIntent 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 SetupIntent ab und erweitern Sie das Attribut `payment_method`: ```curl curl -G https://api.stripe.com/v1/setup_intents/{{SETUPINTENT_ID}} \ -u "<>:" \ -d "expand[]=payment_method" ``` ```json { "id": "{{SETUP_INTENT_ID}}", "object": "setup_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 Zugriff auf Saldodaten haben, empfehlen wir Ihnen, die [Salden zu prüfen](https://docs.stripe.com/financial-connections/balances.md#initiate-balance-refresh), bevor Sie Zahlungen mit der erfassten Zahlungsmethode veranlassen. 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: Standard-Zahlungsmethode aktualisieren Nachdem der `SetupIntent` den Status `succeeded` erreicht hat, können Sie die `default_payment_method` Ihres Kunden/Ihrer Kundin aktualisieren. #### Ruby ```ruby # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. # Find your keys at https://dashboard.stripe.com/apikeys. client = Stripe::StripeClient.new('<>') if event.type == 'setup_intent.succeeded' setup_intent = event.data.object customer_id = setup_intent['customer'] payment_method_id = setup_intent['payment_method'] # Set the default payment method client.v1.customers.update( customer_id, { invoice_settings: { default_payment_method: payment_method_id } } ) end ``` # Elements > This is a Elements for when payment-ui is elements. View the full page at https://docs.stripe.com/payments/ach-direct-debit/set-up-payment?payment-ui=elements. Sie können der [Setup Intents API](https://docs.stripe.com/payments/setup-intents.md) verwenden, um die Details der Zahlungsmethode im Voraus zu erfassen, wobei der endgültige Betrag oder das Zahlungsdatum später festgelegt wird. Dies ist nützlich für Folgendes: - Speichern von Zahlungsmethoden in einer Wallet, um zukünftige Einkäufe zu optimieren - Einziehen von Zuschlägen nach Abwicklung einer Dienstleistung - Kostenlosen Testzeitraum für ein *Abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) starten > 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. ## 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}} ``` ## SetupIntent erstellen [Serverseitig] Ein [SetupIntent](https://docs.stripe.com/api/setup_intents.md) ist ein Objekt, mit dem Sie eine Zahlungsmethode eines Kunden/einer Kundin für zukünftige Zahlungen einrichten können. Der `SetupIntent` verfolgt die Schritte dieses Einrichtungsvorgangs. Erstellen Sie einen SetupIntent auf Ihrem Server, wobei [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types) auf us_bank_account gesetzt ist, und geben Sie die [id](https://docs.stripe.com/api/customers/object.md#customer_object-id) der Kundin/des Kunden 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/setup_intents \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -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/setup_intents \ -u "<>:" \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` ### Client-Geheimnis abrufen Im SetupIntent 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 SetupIntent {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/setup_intents/object.md#setup_intent_object-client_secret) in Ihr Bezahlformular ein. Rufen Sie in Ihrem serverseitigen Code das Client-Geheimnis aus dem SetupIntent ab: #### Ruby ```erb
``` ```ruby get '/checkout' do @intent = # ... Fetch or create the SetupIntent 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 SetupIntent-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 den Einrichtungsvorgang für die Zahlungsmethode 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.collectBankAccountForSetup](https://docs.stripe.com/js/setup_intents/collect_bank_account_for_setup) , 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 SetupIntent 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.collectBankAccountForSetup({ clientSecret: clientSecret, params: { payment_method_type: 'us_bank_account', payment_method_data: { billing_details: { name: accountHolderNameField.value, email: emailField.value, }, }, }, expand: ['payment_method'], }) .then(({setupIntent, error}) => { if (error) { console.error(error.message); // PaymentMethod collection failed for some reason. } else if (setupIntent.status === 'requires_payment_method') { // Customer canceled the hosted verification modal. Present them with other // payment method type options. } else if (setupIntent.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 SetupIntent 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 SetupIntent 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 SetupIntent ab und erweitern Sie das Attribut `payment_method`: ```curl curl -G https://api.stripe.com/v1/setup_intents/{{SETUPINTENT_ID}} \ -u "<>:" \ -d "expand[]=payment_method" ``` ```json { "id": "{{SETUP_INTENT_ID}}", "object": "setup_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 Zugriff auf Saldodaten haben, empfehlen wir Ihnen, die [Salden zu prüfen](https://docs.stripe.com/financial-connections/balances.md#initiate-balance-refresh), bevor Sie Zahlungen mit der erfassten Zahlungsmethode veranlassen. 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 übermitteln [Clientseitig] Bevor Sie den SetupIntent abschließen und die Zahlungsmethodendetails für den/die Kund/in speichern können, müssen Sie eine Zahlungsautorisierung 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 SetupIntent bestätigen. Verwenden Sie [stripe.confirmUsBankAccountSetup](https://docs.stripe.com/js/setup_intents/confirm_us_bank_account_setup), um die Zahlung abzuschließen, wenn der Kunde/die Kundin das Formular absendet. ```javascript confirmationForm.addEventListener('submit', (ev) => { ev.preventDefault(); stripe.confirmUsBankAccountSetup(clientSecret) .then(({setupIntent, error}) => { if (error) { console.error(error.message); // The payment failed for some reason. } else if (setupIntent.status === "requires_payment_method") { // Confirmation failed. Attempt again with a different payment method. } else if (setupIntent.status === "succeeded") { // Confirmation succeeded! The account is now saved. // Display a message to customer. } else if (setupIntent.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.confirmUsBankAccountSetup](https://docs.stripe.com/js/setup_intents/confirm_us_bank_account_setup) 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 SetupIntent-Objekt mit einem der folgenden möglichen Status zurück: | Status | Beschreibung | Ausblick | | ----------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `succeeded` | Das Bankkonto wurde sofort verifiziert oder eine Verifizierung war nicht notwendig. | Kein Handlungsbedarf | | `requires_action` | Weitere Schritte 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) | Nach erfolgreicher Bestätigung des SetupIntent 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.confirmUsBankAccountSetup](https://docs.stripe.com/js/setup_intents/confirm_us_bank_account_setup) im vorhergehenden Schritt ist ein SetupIntent mit dem Status `requires_action`. Der SetupIntent 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 SetupIntent 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.verifyMicrodepositsForSetup(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 SetupIntent-Objekt mit dem `status` `succeeded` 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 [setup_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.succeeded). Die Verifizierung kann aus unterschiedlichen Gründen fehlschlagen. Der Fehler kann synchron als direkte Fehlermeldung oder asynchron über das Webhook-Ereignis [setup_intent.setup_failed](https://docs.stripe.com/api/events/types.md#event_types-setup_intent.setup_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": "seti_1234", "object": "setup_intent", "customer": "cus_0246", ... "last_setup_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_setup_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_setup_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_setup_error` ist festgelegt. | ## 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/set-up-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Künftige Zahlungen annehmen [Serverseitig] Wenn der `SetupIntent` erfolgreich ist, wird eine neue *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) erstellt, die an ein Objekt angehängt wird, das einen Endkunden bzw. eine Endkundin repräsentiert – entweder ein kundenkonfiguriertes `Account` oder ein `Customer`. Diese können verwendet werden, um zukünftige Zahlungen zu initiieren, ohne den Endkunden bzw. die Endkundin erneut nach seinen/ihren Bankkontodaten fragen zu müssen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method={{PAYMENTMETHOD_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d confirm=true ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method={{PAYMENTMETHOD_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d confirm=true ``` ## Optional: Nur Sofortverifizierung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die die Zahlungsmethode per US-Bankkonto einrichten, 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/setup_intents/object.md#setup_intent_object-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den SetupIntent erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -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/setup_intents \ -u "<>:" \ -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 SetupIntent `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 die Zahlungsmethode per US-Bankkonto einrichten, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional eine Verifizierung per Testeinzahlung verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-payment_method_options-us_bank_account-verification_method) verwenden, wenn Sie den SetupIntent 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. ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -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/setup_intents/confirm_us_bank_account_setup) mit diesen Angaben aufrufen, um den SetupIntent 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.confirmUsBankAccountSetup(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({setupIntent, 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("SetupIntent ID: " + setupIntent.id); console.log("SetupIntent status: " + setupIntent.status); } }); }); ``` ## Optional: Standard-Zahlungsmethode aktualisieren [Serverseitig] Nachdem der `SetupIntent` den Status `succeeded` erreicht hat, können Sie die `default_payment_method` Ihres/Ihrer Kund/in aktualisieren. #### Ruby ```ruby # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. # Find your keys at https://dashboard.stripe.com/apikeys. client = Stripe::StripeClient.new('<>') if event.type == 'setup_intent.succeeded' setup_intent = event.data.object customer_id = setup_intent['customer'] payment_method_id = setup_intent['payment_method'] # Set the default payment method client.v1.customers.update( customer_id, { invoice_settings: { default_payment_method: payment_method_id } } ) end ``` # 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/set-up-payment?payment-ui=mobile&platform=ios. Sie können der [Setup Intents API](https://docs.stripe.com/payments/setup-intents.md) verwenden, um die Details der Zahlungsmethode im Voraus zu erfassen, wobei der endgültige Betrag oder das Zahlungsdatum später festgelegt wird. Dies ist nützlich für Folgendes: - Speichern von Zahlungsmethoden in einer Wallet, um zukünftige Einkäufe zu optimieren - Einziehen von Zuschlägen nach Abwicklung einer Dienstleistung - Kostenlosen Testzeitraum für ein *Abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) starten > 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. 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. ## 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}} ``` ## SetupIntent erstellen [Serverseitig] [Clientseitig] Ein [SetupIntent](https://docs.stripe.com/api/setup_intents.md) ist ein Objekt, mit dem Sie eine Zahlungsmethode eines Kunden/einer Kundin für zukünftige Zahlungen einrichten können. Der `SetupIntent` verfolgt die Schritte dieses Einrichtungsvorgangs. ### Serverseitig Erstellen Sie einen SetupIntent auf Ihrem Server, wobei [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types) auf us_bank_account gesetzt ist, und geben Sie die [id](https://docs.stripe.com/api/customers/object.md#customer_object-id) der Kundin/des Kunden 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/setup_intents \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -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/setup_intents \ -u "<>:" \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` ### Clientseitig In dem zurückgegebenen SetupIntent 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 die Client-Seite verwendet, um die Einrichtung sicher abzuschließen, ohne das gesamte SetupIntent-Objekt übergeben zu müssen. Es gibt verschiedene Möglichkeiten, das Client-Geheimnis an den Client zu übergeben. #### Swift ```swift import UIKit import StripePayments class CheckoutViewController: UIViewController { var setupIntentClientSecret: String? func startCheckout() { // Request a SetupIntent 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 der SetupIntent erfolgreich ist, erfordert das ACH-Lastschriftverfahren 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 `collectBankAccountForSetup` erforderlich sind. Erstellen Sie eine Instanz von `BankAccountCollector`, um `collectBankAccountForSetup` 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 SetupIntent anzuhängen. Der Parameter `billing_details` muss den Namen des/der Kontoinhaber/in enthalten, um eine PaymentMethod vom Typ ACH Direct Debit zu erstellen. #### Swift ```swift // Build params let collectParams = STPCollectBankAccountParams.collectUSBankAccountParams(with: name, email: email) // Calling this method will display a modal for collecting bank account information let bankAccountCollector = STPBankAccountCollector() bankAccountCollector.collectBankAccountForSetup(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 SetupIntent 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 SetupIntent 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 SetupIntent ab und erweitern Sie das Attribut `payment_method`: ```curl curl -G https://api.stripe.com/v1/setup_intents/{{SETUPINTENT_ID}} \ -u "<>:" \ -d "expand[]=payment_method" ``` ```json { "id": "{{SETUP_INTENT_ID}}", "object": "setup_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 Zugriff auf Saldodaten haben, empfehlen wir Ihnen, die [Salden zu prüfen](https://docs.stripe.com/financial-connections/balances.md#initiate-balance-refresh), bevor Sie Zahlungen mit der erfassten Zahlungsmethode veranlassen. 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 übermitteln [Clientseitig] Bevor Sie den SetupIntent abschließen und die Zahlungsmethodendetails für den/die Kund/in speichern können, müssen Sie eine Zahlungsautorisierung 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 SetupIntent bestätigen. Verwenden Sie `confirmSetupIntent`, um die Zahlung abzuschließen, wenn der/die Kund/in das Formular absendet. #### Swift ```swift let setupIntentParams = STPSetupIntentConfirmParams(clientSecret: clientSecret, paymentMethodType: .USBankAccount) STPPaymentHandler.shared().confirmSetupIntent( setupIntentParams, 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 `confirmSetupIntent` 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 SetupIntent-Objekt mit einem der folgenden möglichen Status zurück: | Status | Beschreibung | Nächste Schritte | | ----------------- | ----------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `succeeded` | Das Bankkonto wurde sofort verifiziert oder eine Verifizierung war nicht notwendig. | Keine Aktion erforderlich | | `requires_action` | Weitere Schritte 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) | Nach erfolgreicher Bestätigung des SetupIntent 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 `confirmSetupIntent` im vorhergehenden Schritt ist ein SetupIntent mit dem Status `requires_action`. Der SetupIntent enthält ein [next_action](https://docs.stripe.com/api/setup_intents/object.md#setup_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.verifySetupIntentWithMicrodeposits(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.verifySetupIntentWithMicrodeposits(clientSecret: clientSecret, firstAmount: firstAmount, secondAmount: secondAmount, completion: { intent, error in }) ``` Wenn das Bankkonto erfolgreich verifiziert wurde, gibt Stripe das SetupIntent-Objekt mit dem `status` `succeeded` 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_setup_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_setup_error` ist festgelegt. | ## 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/set-up-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Künftige Zahlungen annehmen [Serverseitig] Ist der SetupIntent erfolgreich, wird eine neue *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) erstellt, die an ein [Kundenobjekt](https://docs.stripe.com/api/customers.md) angehängt ist. Damit können künftige Zahlungen eingeleitet werden, ohne dass der Kunde/die Kundin das Bankkonto erneut angeben muss. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method={{PAYMENTMETHOD_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d confirm=true ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method={{PAYMENTMETHOD_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d confirm=true ``` ## Optional: Nur Sofortverifizierung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die die Zahlungsmethode per US-Bankkonto einrichten, 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/setup_intents/object.md#setup_intent_object-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den SetupIntent erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -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/setup_intents \ -u "<>:" \ -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 SetupIntent `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 die Zahlungsmethode per US-Bankkonto einrichten, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional eine Verifizierung per Testeinzahlung verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-payment_method_options-us_bank_account-verification_method) verwenden, wenn Sie den SetupIntent erstellen. > Wenn Sie ein individuelles Zahlungsformular verwenden, müssen Sie Ihre eigene Benutzeroberfläche erstellen, um Bankkontodaten zu erfassen. Wenn Sie Stripe-E-Mails mit Testeinzahlungen deaktivieren, müssen Sie Ihre eigene Benutzeroberfläche für Ihre Kundinnen/Kunden erstellen, um den Testeinzahlungscode oder -betrag zu bestätigen. ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -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 Ihrer eigenen Nutzeroberfläche erfassen und [STPPaymentHandler.confirmSetupIntent](https://stripe.dev/stripe-ios/stripepayments/documentation/stripepayments/stppaymenthandler/confirmsetupintent\(_:with:completion:\)) mit diesen Angaben aufrufen, um den SetupIntent abzuschließen. #### Swift ```swift // Use your own UI to collect your customer's input let accountholderName = // … let email = // … let accountNumber = // … let routingNumber = // … let accountType = // … let accountHolderType = // … let usBankAccountParams = STPPaymentMethodUSBankAccountParams() usBankAccountParams.accountNumber = accountNumber usBankAccountParams.routingNumber = routingNumber usBankAccountParams.accountType = accountType usBankAccountParams.accountHolderType = accountHolderType let billingDetails = STPPaymentMethodBillingDetails() billingDetails.name = accountholderName billingDetails.email = email let paymentMethodParams = STPPaymentMethodParams(usBankAccount: usBankAccountParams, billingDetails: billingDetails, metadata: nil) let setupIntentParams = STPSetupIntentConfirmParams(clientSecret: clientSecret) setupIntentParams.paymentMethodParams = paymentMethodParams setupIntentParams.returnURL = "https://your-app-domain.com/stripe-redirect" STPPaymentHandler.shared().confirmSetupIntent( setupIntentParams, with: self ) { (status, intent, error) in // Handle the result } ``` ## Optional: Standard-Zahlungsmethode aktualisieren [Serverseitig] Nachdem der `SetupIntent` den Status `succeeded` erreicht hat, können Sie die `default_payment_method` Ihres/Ihrer Kund/in aktualisieren. #### Ruby ```ruby # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. # Find your keys at https://dashboard.stripe.com/apikeys. client = Stripe::StripeClient.new('<>') if event.type == 'setup_intent.succeeded' setup_intent = event.data.object customer_id = setup_intent['customer'] payment_method_id = setup_intent['payment_method'] # Set the default payment method client.v1.customers.update( customer_id, { invoice_settings: { default_payment_method: payment_method_id } } ) end ``` # 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/set-up-payment?payment-ui=mobile&platform=android. Sie können der [Setup Intents API](https://docs.stripe.com/payments/setup-intents.md) verwenden, um die Details der Zahlungsmethode im Voraus zu erfassen, wobei der endgültige Betrag oder das Zahlungsdatum später festgelegt wird. Dies ist nützlich für Folgendes: - Speichern von Zahlungsmethoden in einer Wallet, um zukünftige Einkäufe zu optimieren - Einziehen von Zuschlägen nach Abwicklung einer Dienstleistung - Kostenlosen Testzeitraum für ein *Abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) starten > 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. 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.9.1") // Include the financial connections SDK to support US bank account as a payment method implementation("com.stripe:financial-connections:23.9.1") // Financial Connections SDK implementation("com.stripe:financial-connections:23.9.1") } ``` > 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}} ``` ## SetupIntent erstellen [Serverseitig] [Clientseitig] Ein [SetupIntent](https://docs.stripe.com/api/setup_intents.md) ist ein Objekt, das Ihre Absicht darstellt, die Zahlungsmethode eines Endkunden/einer Endkundin für zukünftige Zahlungen einzurichten. Der `SetupIntent` verfolgt die Schritte dieses Einrichtungsprozesses. ### Serverseitig Erstellen Sie einen `SetupIntent` auf Ihrem Server und fügen Sie `us_bank_account` zum [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types)-Array hinzu. Geben Sie die ID des `Customer` oder des kundenkonfigurierten `Account` 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/setup_intents \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -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/setup_intents \ -u "<>:" \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` ### Clientseitig Der zurückgegebene `SetupIntent` 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)), das clientseitig verwendet wird, um die Einrichtung sicher abzuschließen, ohne dass das `SetupIntent`-Objekt benötigt wird. Sie können verschiedene Ansätze verwenden, um das Client-Geheimnis an die Client-Seite weiterzugeben. #### Kotlin ```kotlin import androidx.appcompat.app.AppCompatActivity class CheckoutActivity : AppCompatActivity() { lateinit var setupIntentClientSecret: String fun startCheckout() { // Request a SetupIntent 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 `presentWithSetupIntent` 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 `presentWithSetupIntent` 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 SetupIntent anzuhängen. #### Kotlin ```kotlin import androidx.appcompat.app.AppCompatActivity class CheckoutActivity : AppCompatActivity() { private lateinit var setupIntentClientSecret: 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 collectParams: CollectBankAccountConfiguration = CollectBankAccountConfiguration.USBankAccount( name, email ) // Calling this method will trigger the Financial Connections modal to be displayed collectBankAccountLauncher.presentWithSetupIntent( publishableKey, setupIntentClientSecret, 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 SetupIntent 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 SetupIntent 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 SetupIntent ab und erweitern Sie das Attribut `payment_method`: ```curl curl -G https://api.stripe.com/v1/setup_intents/{{SETUPINTENT_ID}} \ -u "<>:" \ -d "expand[]=payment_method" ``` ```json { "id": "{{SETUP_INTENT_ID}}", "object": "setup_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 Zugriff auf Saldodaten haben, empfehlen wir Ihnen, die [Salden zu prüfen](https://docs.stripe.com/financial-connections/balances.md#initiate-balance-refresh), bevor Sie Zahlungen mit der erfassten Zahlungsmethode veranlassen. 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 übermitteln [Clientseitig] Bevor Sie den SetupIntent abschließen und die Zahlungsmethodendetails für den/die Kund/in speichern können, müssen Sie eine Zahlungsautorisierung 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 Setup 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 setupIntentClientSecret: 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 = ConfirmSetupIntentParams.create( clientSecret = setupIntentClientSecret, 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 SetupIntent-Objekt mit einem der folgenden möglichen Status zurück: | Status | Beschreibung | Nächste Schritte | | ----------------- | ----------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `succeeded` | Das Bankkonto wurde sofort verifiziert oder eine Verifizierung war nicht notwendig. | Keine Aktion erforderlich | | `requires_action` | Weitere Schritte erforderlich, um die Bankkontoverifizierung abzuschließen. | Schritt 6: [Bankkonten mit Testeinzahlungen verifizieren](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#android-verify-with-microdeposits) | Nach erfolgreicher Bestätigung des Setup 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 `confirmSetupIntent` im vorhergehenden Schritt ist ein SetupIntent mit dem Status `requires_action`. Der SetupIntent enthält ein [next_action](https://docs.stripe.com/api/setup_intents/object.md#setup_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 verifySetupIntentWithMicrodeposits( clientSecret: String, descriptorCode: String, callback: ApiResultCallback ) // Use if you are using amounts, do not use if you are using descriptor code fun verifySetupIntentWithMicrodeposits( clientSecret: String, firstAmount: Int, secondAmount: Int, callback: ApiResultCallback ) ``` Wenn das Bankkonto erfolgreich verifiziert wurde, gibt Stripe das SetupIntent-Objekt mit dem `status` `succeeded` 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_setup_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_setup_error` ist festgelegt. | ## 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/set-up-payment.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Künftige Zahlungen annehmen [Serverseitig] Ist der SetupIntent erfolgreich, wird eine neue *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) erstellt, die an ein [Kundenobjekt](https://docs.stripe.com/api/customers.md) angehängt ist. Damit können künftige Zahlungen eingeleitet werden, ohne dass der Kunde/die Kundin das Bankkonto erneut angeben muss. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method={{PAYMENTMETHOD_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d confirm=true ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method={{PAYMENTMETHOD_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -d confirm=true ``` ## Optional: Nur Sofortverifizierung [Serverseitig] Standardmäßig können Ihre Kundinnen/Kunden, die die Zahlungsmethode per US-Bankkonto einrichten, 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/setup_intents/object.md#setup_intent_object-payment_method_options-us_bank_account-verification_method) nutzen, wenn Sie den SetupIntent erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -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/setup_intents \ -u "<>:" \ -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 SetupIntent `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 die Zahlungsmethode per US-Bankkonto einrichten, die sofortige Bankkonto-Verifizierung oder Testeinzahlungen nutzen. Sie können optional eine Verifizierung per Testeinzahlung verlangen, indem Sie den Parameter [verification_method](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-payment_method_options-us_bank_account-verification_method) verwenden, wenn Sie den SetupIntent erstellen. > Wenn Sie ein individuelles Zahlungsformular verwenden, müssen Sie Ihre eigene Benutzeroberfläche erstellen, um Bankkontodaten zu erfassen. Wenn Sie Stripe-E-Mails mit Testeinzahlungen deaktivieren, müssen Sie Ihre eigene Benutzeroberfläche für Ihre Kundinnen/Kunden erstellen, um den Testeinzahlungscode oder -betrag zu bestätigen. ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -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 Ihrer eigenen Nutzeroberfläche erfassen und [PaymentLauncher.confirm](https://stripe.dev/stripe-android/payments-core/com.stripe.android.payments.paymentlauncher/-payment-launcher/confirm.html) mit diesen Angaben aufrufen, um den SetupIntent abzuschließen. #### Kotlin ```kotlin class CheckoutActivity : AppCompatActivity() { private lateinit var setupIntentClientSecret: String private val paymentLauncher: PaymentLauncher = // … private fun confirmSetupIntent() { // Use your own UI to collect your customer's input val accountholderName: String = // … val email: String = // … val accountNumber: String = // … val routingNumber: String = // … val accountType: PaymentMethod.USBankAccount.USBankAccountType = // … val accountHolderType: PaymentMethod.USBankAccount.USBankAccountHolderType = // … val createParams = PaymentMethodCreateParams.create( usBankAccount = PaymentMethodCreateParams.USBankAccount( accountNumber = accountNumber, routingNumber = routingNumber, accountType = accountType, accountHolderType = accountHolderType, ), billingDetails = PaymentMethod.BillingDetails( name = accountholderName, email = email, ), ) val confirmParams = ConfirmSetupIntentParams.create( paymentMethodCreateParams = createParams, clientSecret = setupIntentClientSecret, ) paymentLauncher.confirm(confirmParams) } } ``` ## Optional: Standard-Zahlungsmethode aktualisieren [Serverseitig] Nachdem der `SetupIntent` den Status `succeeded` erreicht hat, können Sie die `default_payment_method` Ihres/Ihrer Kund/in aktualisieren. #### Ruby ```ruby # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. # Find your keys at https://dashboard.stripe.com/apikeys. client = Stripe::StripeClient.new('<>') if event.type == 'setup_intent.succeeded' setup_intent = event.data.object customer_id = setup_intent['customer'] payment_method_id = setup_intent['payment_method'] # Set the default payment method client.v1.customers.update( customer_id, { invoice_settings: { default_payment_method: payment_method_id } } ) end ``` # 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/set-up-payment?payment-ui=mobile&platform=react-native. Sie können der [Setup Intents API](https://docs.stripe.com/payments/setup-intents.md) verwenden, um die Details der Zahlungsmethode im Voraus zu erfassen, wobei der endgültige Betrag oder das Zahlungsdatum später festgelegt wird. Dies ist nützlich für Folgendes: - Speichern von Zahlungsmethoden in einer Wallet, um zukünftige Einkäufe zu optimieren - Einziehen von Zuschlägen nach Abwicklung einer Dienstleistung - Kostenlosen Testzeitraum für ein *Abonnement* (A Subscription represents the product details associated with the plan that your customer subscribes to. Allows you to charge the customer on a recurring basis) starten > 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. ## 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}} ``` ## SetupIntent erstellen [Serverseitig] Ein [SetupIntent](https://docs.stripe.com/api/setup_intents.md) ist ein Objekt, mit dem Sie eine Zahlungsmethode eines Kunden/einer Kundin für zukünftige Zahlungen einrichten können. Der `SetupIntent` verfolgt die Schritte dieses Einrichtungsvorgangs. ### Serverseitig Erstellen Sie einen `SetupIntent` auf Ihrem Server und fügen Sie `us_bank_account` zum [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types)-Array hinzu. Geben Sie die ID des `Customer` oder des kundenkonfigurierten `Account` 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/setup_intents \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[]=us_bank_account" \ -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/setup_intents \ -u "<>:" \ -d customer={{CUSTOMER_ID}} \ -d "payment_method_types[]=us_bank_account" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=payment_method" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][]=balances" ``` ### Clientseitig Ein SetupIntent 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 SetupIntent-Objekt zurückzugeben. Fordern Sie in Ihrer App einen SetupIntent 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: '', }), }); const {clientSecret} = await response.json(); return clientSecret; }; return ...; } ``` ## Angaben zur Zahlungsmethode erfassen [Clientseitig] Anstatt das gesamte SetupIntent-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 [collectBankAccountForSetup](https://docs.stripe.com/js/setup_intents/collect_bank_account_for_setup), 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 SetupIntent 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 {collectBankAccountForSetup} 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 {setupIntent, error} = await collectBankAccountForSetup( clientSecret, { paymentMethodType: 'USBankAccount', paymentMethodData: { billingDetails: { name: "John Doe", }, }, }, ); if (error) { Alert.alert(`Error code: ${error.code}`, error.message); } else if (setupIntent) { Alert.alert('Setup status:', setupIntent.status); if (setupIntent.status === SetupIntents.Status.RequiresConfirmation) { // The next step is to call `confirmSetup` } else if (setupIntent.status === SetupIntents.Status.RequiresAction) { // The next step is to call `verifyMicrodepositsForSetup` } } }; return ( setName(value.nativeEvent.text)} />