# Ein Abonnement per ACH Direct Debit einrichten Erfahren Sie, wie Sie ein Abonnement mit US-Bankkonto erstellen und abrechnen. Verwenden Sie diesen Leitfaden, um 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) mit [ACH-Lastschriftverfahren](https://docs.stripe.com/payments/ach-direct-debit.md) einzurichten. # Erweiterte Integration > This is a Erweiterte Integration for when platform is web and payment-ui is elements. View the full page at https://docs.stripe.com/billing/subscriptions/ach-debit?platform=web&payment-ui=elements. > Wenn Sie neue Nutzerin oder neuer Nutzer sind, verwenden Sie das [Payment Element](https://docs.stripe.com/payments/payment-element.md) anstelle von Stripe Elements, wie in diesem Leitfaden beschrieben. Das Payment Element bietet einen Low-Code-Integrationspfad mit integrierten Conversion-Optimierungen. Anleitungen finden Sie unter [Abo erstellen](https://docs.stripe.com/billing/subscriptions/build-subscriptions.md?payment-ui=elements). ## Produkt und Preis erstellen [Dashboard] [Produkte](https://docs.stripe.com/api/products.md) stehen für den von Ihnen angebotenen Artikel oder Dienst. [Preise](https://docs.stripe.com/api/prices.md) geben an, wie viel und wie häufig Sie für ein Produkt berechnen. Dies schließt ein, wie viel ein Produkt kostet, welche Währung Sie akzeptieren und ob es sich um eine einmalige oder eine wiederkehrende Zahlung handelt. Wenn Sie nur ein paar wenige Produkte und Preise haben, können Sie diese im Dashboard erstellen und verwalten. In diesem Leitfaden wird ein Stock-Foto-Service als Beispiel verwendet, für den Kund/innen ein monatliches Abonnement mit dem Betrag von 15 USD berechnet werden. Um dies zu modellieren: 1. Gehen Sie zur Seite [Produkte](https://dashboard.stripe.com/products?active=true) und klicken Sie auf **Produkt erstellen**. 1. Geben Sie einen **Namen** für das Produkt an. Sie können optional eine **Beschreibung** hinzufügen und ein Bild des Produkts hochladen. 1. Wählen Sie einen **Produktsteuercode** aus. Erfahren Sie mehr über [Produktsteuercodes](https://docs.stripe.com/tax/tax-codes.md). 1. Wählen Sie **Wiederkehrend** aus. Geben Sie im Anschluss daran **15** für den Preis ein und wählen Sie **USD** als Währung aus. 1. Wählen Sie, ob die **Steuer im Preis berücksichtigt** werden soll. Sie können entweder den Standardwert aus Ihren [Steuereinstellungen](https://dashboard.stripe.com/test/settings/tax) verwenden oder den Wert manuell festlegen. Wählen Sie in diesem Beispiel **Auto** aus. 1. Wählen Sie **Monatlich** als **Abrechnungszeitraum** aus. 1. Klicken Sie auf **Weitere Preisoptionen**. Wählen Sie dann **Pauschalpreis** als Preismodell für dieses Beispiel aus. Erfahren Sie mehr über [Pauschalpreise](https://docs.stripe.com/products-prices/pricing-models.md#flat-rate) und andere [Preismodelle](https://docs.stripe.com/products-prices/pricing-models.md). 1. Fügen Sie eine interne **Preisbeschreibung** und einen [Lookup-Schlüssel](https://docs.stripe.com/products-prices/manage-prices.md#lookup-keys) hinzu, um bestimmte Preise in Zukunft zu organisieren, abzufragen und zu aktualisieren. 1. Klicken Sie auf **Weiter**. Klicken Sie dann auf **Produkt hinzufügen**. Zeichnen Sie nach Erstellen des Produkts und des Preises die Preis-ID auf, sodass Sie diese in nachfolgenden Schritten verwenden können. Die ID wird auf der Preisseite angezeigt und sieht in etwa so aus: `price_G0FvDp6vZvdwRZ`. ## Abonnement erstellen [Serverseitig] > Informationen dazu, wie Sie 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) mit einer kostenlosen Testphase erstellen, finden Sie unter [Abonnement-Testphasen](https://docs.stripe.com/billing/subscriptions/ach-debit.md#trial-periods). Erstellen Sie ein [Abonnement](https://docs.stripe.com/api/subscriptions.md) mit dem Preis und dem Kunden/der Kundin mit dem Status `incomplete`, indem Sie den Parameter [payment_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-payment_behavior) mit dem Wert `default_incomplete` angeben. #### curl ```bash curl https://api.stripe.com/v1/subscriptions \ -u <>: \ -d "customer"="{{CUSTOMER_ID}}" \ -d "items[0][price]"="price_F52b2UdntfQsfR" \ -d "payment_behavior"="default_incomplete" \ -d "payment_settings[payment_method_types][]"="us_bank_account" \ -d "expand[0]"="latest_invoice.payment_intent" ``` Die Antwort enthält die erste [Rechnung](https://docs.stripe.com/api/invoices.md) des *Abonnements* (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). Dies enthält die Zahlungen der Rechnung, einschließlich eines Standard-PaymentIntent, den Stripe für diese Rechnung generiert hat, und des Bestätigungsgeheimnisses, das Sie clientseitig verwenden können, um den Zahlungsvorgang sicher abzuschließen, anstatt das gesamte PaymentIntent-Objekt zu übergeben. Geben Sie das `latest_invoice.confirmation_secret.client_secret` an das Frontend zurück, um die Zahlung abzuschließen. ## Angaben zur Zahlungsmethode erfassen [Clientseitig] Wenn Kundinnen/Kunden über das „Click to Pay“-Verfahren mit ACH Direct Debit zahlen, empfehlen wir Ihnen, Stripe.js zu verwenden, um die Zahlung an Stripe zu übermitteln. [Stripe.js](https://docs.stripe.com/payments/elements.md) ist unsere grundlegende JavaScript-Bibliothek für die Erstellung von Zahlungsabläufen. Sie übernimmt automatisch komplexe Integrationsaufgaben und ermöglicht es Ihnen, Ihre Integration in Zukunft unkompliziert um andere Zahlungsmethoden zu erweitern. Binden Sie das Stripe.js-Skript in Ihre Zahlungsseite ein, indem Sie es im `head` Ihrer HTML-Datei einfügen. ```html Checkout ``` Erstellen Sie auf Ihrer Bezahlseite eine Instanz von Stripe.js mit dem folgenden JavaScript. ```javascript // Set your publishable key. Remember to change this to your live publishable key in production! // See your keys here: https://dashboard.stripe.com/apikeys const stripe = Stripe('<>'); ``` Anstatt das gesamte PaymentIntent-Objekt an den Client zu übermitteln, verwenden Sie dessen *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) aus dem vorherigen Schritt. Dieses unterscheidet sich von Ihren API-Schlüsseln, mit denen Anfragen der Stripe API authentifiziert werden. Gehen Sie vorsichtig mit dem Client-Geheimnis um, da es die Zahlung abschließen kann. Protokollieren Sie es nicht, betten Sie es nicht in URLs ein und machen Sie es nur dem Kunden/der Kundin zugänglich. Verwenden Sie [stripe.collectBankAccountForPayment](https://docs.stripe.com/js/payment_intents/collect_bank_account_for_payment) , um Bankkontodaten mit [Financial Connections](https://docs.stripe.com/financial-connections.md) zu erfassen, eine *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) zu erstellen und diese PaymentMethod an den PaymentIntent anzuhängen. Der Parameter `billing_details` muss den Namen des Kontoinhabers/der Kontoinhaberin enthalten, um eine PaymentMethod für ein ACH-Lastschriftkonto zu erstellen. ```javascript // Use the form that already exists on the web page. const paymentMethodForm = document.getElementById('payment-method-form'); const confirmationForm = document.getElementById('confirmation-form'); paymentMethodForm.addEventListener('submit', (ev) => { ev.preventDefault(); const accountHolderNameField = document.getElementById('account-holder-name-field'); const emailField = document.getElementById('email-field'); // Calling this method will open the instant verification dialog. stripe.collectBankAccountForPayment({ clientSecret: clientSecret, params: { payment_method_type: 'us_bank_account', payment_method_data: { billing_details: { name: accountHolderNameField.value, email: emailField.value, }, }, }, expand: ['payment_method'], }) .then(({paymentIntent, error}) => { if (error) { console.error(error.message); // PaymentMethod collection failed for some reason. } else if (paymentIntent.status === 'requires_payment_method') { // Customer canceled the hosted verification modal. Present them with other // payment method type options. } else if (paymentIntent.status === 'requires_confirmation') { // We collected an account - possibly instantly verified, but possibly // manually-entered. Display payment method details and mandate text // to the customer and confirm the intent once they accept // the mandate. confirmationForm.show(); } }); }); ``` Der [Stripe Financial Connections-Authentifizierungsvogang](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) verarbeitet die Erfassung und Überprüfung von Bankkontodaten automatisch. Wenn Ihr Kunde/Ihre Kundin den Authentifizierungsvorgang abschließt, wird die *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) automatisch an den PaymentIntent angehängt und ein [Financial Connections Account](https://docs.stripe.com/api/financial_connections/accounts.md) wird erstellt. > Bankkonten, die Ihre Kundinnen/Kunden durch manuelle Eingabe und Testeinzahlungen verknüpfen, haben keinen Zugriff auf zusätzliche Bankkontodaten wie Salden, Kontoinhaberschaft und Transaktionen. Um die beste Nutzererfahrung auf allen Geräten zu bieten, setzen Sie die `minimum-scale` des Darstellungsfelds für Ihre Seite mithilfe des `meta`-Tags des Darstellungsfelds auf 1. ```html ``` ## Mandatsbestätigung einziehen und übermitteln [Clientseitig] Bevor Sie die Zahlung veranlassen können, müssen Sie eine Zahlungsautorisierung von Ihrem/Ihrer Kund/in einholen, indem Sie Mandatsbedingungen anzeigen, denen er/sie zustimmen muss. Um die Nacha-Regeln einzuhalten, müssen Sie eine Autorisierung von Ihrem Kunden/Ihrer Kundin einholen, bevor Sie die Zahlung veranlassen können. Dies tun Sie durch Anzeigen von Mandatskonditionen, denen der Kunde/die Kundin zustimmen muss. Weitere Informationen finden Sie unter [Mandate]](/payments/ach-direct-debit#mandates). Wenn der Kunde/die Kundin den Mandatskonditionen zustimmt, müssen Sie den PaymentIntent bestätigen. Verwenden Sie [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment), um die Zahlung abzuschließen, wenn der Kunde/die Kundin das Formular absendet. ```javascript confirmationForm.addEventListener('submit', (ev) => { ev.preventDefault(); stripe.confirmUsBankAccountPayment(clientSecret) .then(({paymentIntent, error}) => { if (error) { console.error(error.message); // The payment failed for some reason. } else if (paymentIntent.status === "requires_payment_method") { // Confirmation failed. Attempt again with a different payment method. } else if (paymentIntent.status === "processing") { // Confirmation succeeded! The account will be debited. // Display a message to customer. } else if (paymentIntent.next_action?.type === "verify_with_microdeposits") { // The account needs to be verified through microdeposits. // Display a message to consumer with next steps (consumer waits for // microdeposits, then enters a statement descriptor code on a page sent to them through email). } }); }); ``` > Die Ausführung von [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) kann einige Sekunden dauern. Während dieser Zeit sollten Sie Ihr Formular deaktivieren, damit keine erneute Übermittlung erfolgen kann. Lassen Sie stattdessen ein Wartesymbol einblenden, wie beispielsweise eine Sanduhr. Tritt ein Fehler auf, lassen Sie eine Fehlermeldung für die Kundin/den Kunden anzeigen, aktivieren Sie das Formular erneut und blenden Sie das Wartesymbol aus. Wenn der/die Kund/in die Sofortüberprüfung abschließt, wird das Abonnement automatisch `active`. Lesen Sie andernfalls [Bankkonto mit Testeinzahlungen verifizieren](https://docs.stripe.com/billing/subscriptions/ach-debit.md#verify-with-microdeposits), um zu erfahren, wie die Verifizierung von Testeinzahlungen abgewickelt wird, während das Abonnement `incomplete` bleibt. ## Bankkonto mit Testeinzahlungen verifizieren [Clientseitig] > Kundinnen/Kunden haben 10 Tage Zeit, um Testeinzahlungen für Abonnement ein erfolgreich zu verifizieren, statt der normalerweise im [Lebenszylus eines Abonnements](https://docs.stripe.com/billing/subscriptions/overview.md#subscription-lifecycle) angegebenen 23 Stunden. Diese Ablauffrist kann jedoch nicht nach dem [Datum des Abrechnungszyklus](https://docs.stripe.com/billing/subscriptions/ach-debit.md#billing-cycle) liegen. Nicht alle Kund/innen können das Bankkonto sofort verifizieren. Dieser Schritt wird nur ausgeführt, wenn Ihr/e Kund/in die Sofortverifizierung im vorherigen Schritt deaktiviert hat. In diesen Fällen sendet Stripe eine `descriptor_code`-Testeinzahlung und greift möglicherweise auf eine `amount`-Testeinzahlung zurück, falls weitere Probleme bei der Verifizierung des Bankkontos auftreten. Es dauert 1–2 Werktage, bis diese Einzahlungen auf der Online-Abrechnung des Kunden/der Kundin erscheinen - **Code der Zahlungsbeschreibung**. Stripe sendet eine einzelne Mikroeinzahlung über 0,01 USD an das Bankkonto des/der Kund/in mit einem einmaligen, 6-stelligen `descriptor_code`, der mit SM beginnt. Ihr/e Kund/in verwendet diese Zeichenfolge, um sein/ihr Bankkonto zu verifizieren. - **Betrag**: Stripe sendet zwei nicht eindeutige Testeinzahlungen an das Kundenbankkonto, wobei `ACCTVERIFY` als Zahlungsbeschreibung in der Abrechnung angegeben ist. Ihre Kundin/Ihr Kunde verwendet die Einzahlungsbeträge zur Verifizierung des Bankkontos. Das Ergebnis des Aufrufs der Methode [stripe.confirmUsBankAccountPayment](https://docs.stripe.com/js/payment_intents/confirm_us_bank_account_payment) im vorhergehenden Schritt ist ein PaymentIntent mit dem Status `requires_action`. Der PaymentIntent enthält das Feld `next_action`, das einige nützliche Informationen zum Abschließen der Verifizierung enthält. ```javascript next_action: { type: "verify_with_microdeposits", verify_with_microdeposits: { arrival_date: 1647586800, hosted_verification_url: "https://payments.stripe.com/…", microdeposit_type: "descriptor_code" } } ``` Wenn Sie eine [E-Mail-Adresse für die Rechnungsstellung](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-billing_details-email) angegeben haben, benachrichtigt Stripe Ihre Kundinnen und Kunden über diese E-Mail-Adresse, wann die Einzahlungen voraussichtlich eingehen werden. Die E-Mail enthält einen Link zu einer von Stripe gehosteten Verifizierungsseite, auf der sie die Beträge der Einzahlungen bestätigen und die Verifizierung abschließen können. > Verifizierungsversuche dürfen für beschreibungsbasierte Testeinzahlungen bis zu 10 mal und für betragsbasierte bis zu 3 mal fehlschlagen. Wenn Sie dieses Limit überschreiten, können wir das Bankkonto nicht mehr verifizieren. Darüber hinaus gilt für Verifizierungen von Testeinzahlungen eine Zeitüberschreitung von 10 Tagen. Werden Testeinzahlungen nicht innerhalb dieser Zeit verifiziert, fordert der PaymentIntent wieder neue Angaben zur Zahlungsmethode an. Wenn Sie Ihren Kund/innen genau erläutern, was Testeinzahlungen sind und wie sie verwendet werden, können Sie Probleme bei der Verifizierung vermeiden. ### Optional: Nutzerdefinierte E-Mails-Benachrichtigungen senden Optional können Sie [personalisierte E-Mail-Benachrichtigungen](https://docs.stripe.com/payments/ach-direct-debit.md#mandate-and-microdeposit-emails) an Ihren Kunden/Ihre Kundin senden. Nachdem Sie die nutzerspezifischen E-Mails eingerichtet haben, müssen Sie angeben, wie der Kunde/die Kundin auf die Verifizierungs-E-Mail antwortet. Wählen Sie dazu *eine* der folgenden Optionen aus: - Verwenden Sie die von Stripe gehostete Verifizierungsseite. Verwenden Sie dazu die URL `verify_with_microdeposits[hosted_verification_url]` im [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action-verify_with_microdeposits-hosted_verification_url)-Objekt, um Ihre Kundinnen/Kunden zum Abschluss des Verifizierungsvorgangs zu leiten. - Wenn Sie die von Stripe gehostete Verifizierungsseite nicht verwenden möchten, können Sie auf Ihrer Website ein Formular für Ihre Kundinnen/Kunden zur Weiterleitung von Testeinzahlungen an Sie erstellen und das Bankkonto mit [Stripe.js](https://docs.stripe.com/js/payment_intents/verify_microdeposits_for_payment) verifizieren. - Richten Sie das Formular mindestens so ein, dass es den Parameter `descriptor code` verarbeitet, bei dem es sich um eine 6-stellige Zeichenfolge zu Verifizierungszwecken handelt. - Stripe empfiehlt außerdem, dass Sie Ihr Formular so konfigurieren, dass der Parameter `beträge` verarbeitet wird, da einige der von Ihren Kund/innen verwenden Banken dies möglicherweise verlangen. Integrationen übergeben nur den `descriptor_code` *oder* `amounts`. Um festzustellen, welches Ihre Integration verwendet, prüfen Sie den Wert für `verify_with_microdeposits[microdeposit_type]` im `next_action`-Objekt. ```javascript stripe.verifyMicrodepositsForPayment(clientSecret, { // Provide either a descriptor_code OR amounts, not both descriptor_code: 'SMT86W', amounts: [32, 45], }); ``` ## Standard-Zahlungsmethode festlegen [Server] Sie haben jetzt ein aktives *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) eines/einer Kund/in mit einer Zahlungsmethode. Diese Zahlungsmethode wird jedoch nicht automatisch für zukünftige Zahlungen verwendet. Um diese Zahlungsmethode in Zukunft automatisch zu belasten, verwenden Sie einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests)-Consumer, um das Ereignis `invoice.payment_succeeded` für neue Abonnements zu überwachen und die Standard-Zahlungsmethode festzulegen. #### 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. Stripe.api_key = '<>' if event.type == 'invoice.payment_succeeded' invoice = event.data.object if invoice['billing_reason'] == 'subscription_create' subscription_id = invoice['parent']['subscription_details']['subscription'] # This example assumes you're using the default PaymentIntent that Stripe generated for the invoice. invoice_payments = Stripe::InvoicePayment.list({invoice: invoice['id']}) payment_intent_id = invoice_payments.data[0].payment.payment_intent # Retrieve the payment intent used to pay the subscription payment_intent = Stripe::PaymentIntent.retrieve(payment_intent_id) # Set the default payment method Stripe::Subscription.update( subscription_id, default_payment_method: payment_intent.payment_method ) end end ``` ## Abonnementstatus verwalten [Clientseitig] Sofern die erste Zahlung erfolgreich war, ist der Status des Abonnements `active`, und es sind keine weiteren Maßnahmen erforderlich. Wenn Zahlungen fehlschlagen, ändert sich der Status in den **Abonnementstatus**, der in Ihren [Einstellungen für den automatischen Einzug](https://docs.stripe.com/invoicing/automatic-collection.md) konfiguriert ist. Benachrichtigen Sie die Kundinnen/Kunden, wenn die Zahlung fehlgeschlagen ist, und [belasten Sie deren Konto mit einer anderen Zahlungsmethode](https://docs.stripe.com/billing/subscriptions/overview.md#requires-payment-method). ## 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 aktivieren](https://docs.stripe.com/get-started/account/activate.md), bevor Sie diese E-Mails beim Testen 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/billing/subscriptions/ach-debit.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Optional: Abrechnungszyklus festlegen Wenn Sie ein Abonnement erstellen, wird der Abrechnungszyklus automatisch auf Standard eingestellt. Wenn ein Kunde/eine Kundin beispielsweise am 7. September einen monatlichen Plan abonniert, wird dies danach am 7. jedes Monats in Rechnung gestellt. Manche Unternehmen legen ihren Abrechnungszyklus lieber selbst fest, damit sie ihren Kundinnen/Kunden jeden Zyklus zur selben Zeit in Rechnung stellen können. Das Argument [Abrechnungszyklusanker](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-billing_cycle_anchor) macht dies möglich. ```curl curl https://api.stripe.com/v1/subscriptions \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d "items[0][price]={{PRICE_ID}}" \ -d billing_cycle_anchor=1611008505 ``` Durch manuelles Festlegen des Abrechnungszyklus wird dem Kunden/der Kundin automatisch ein anteilsmäßig verrechneter Betrag für die Zeit zwischen der Erstellung des Abonnements und dem Abrechnungszyklusanker berechnet. Wenn Sie Kundinnen/Kunden diesen Zeitraum nicht in Rechnung stellen möchten, können Sie das Argument [proration_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-proration_behavior) auf `none` setzen. Sie können den Abrechnungszyklusanker auch mit [Testzeiträumen](https://docs.stripe.com/billing/subscriptions/ach-debit.md#trial-periods) kombinieren, um Nutzern und Nutzerinnen kostenlosen Zugriff auf Ihr Produkt zu gewähren und ihnen dann einen anteiligen Betrag zu berechnen. ## Optional: Abonnement-Testphasen Mit kostenlosen Testversionen können Kundinnen und Kunden für einen bestimmten Zeitraum auf Ihr Produkt zugreifen, ohne dass ihnen Kosten entstehen. Um einen Testzeitraum festzulegen, übergeben Sie einen Zeitstempel in [trial_end](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-trial_end). > Die Verwendung von kostenlosen Testversionen unterscheidet sich vom Festlegen des [proration_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-proration_behavior) auf `none`, da Sie die Dauer des kostenlosen Testzeitraums anpassen können. Wenn Sie ein Abonnement mit einem Testzeitraum mit dem [payment_behavior](https://docs.stripe.com/api/subscriptions/create.md#create_subscription-payment_behavior)-Wert `default_incomplete` starten, gibt Stripe einen `pending_setup_intent`-Wert im Abonnement-Objekt zurück. Lesen Sie die Dokumentation, um mehr über das [SetupIntent](https://docs.stripe.com/api/setup_intents.md)-Objekt zu erfahren. #### curl ```bash curl https://api.stripe.com/v1/subscriptions \ -u <>: \ -d "customer"="cus_4fdAW5ftNQow1a" \ -d "items[0][price]"="price_CBb6IXqvTLXp3f" \ -d "payment_behavior"="default_incomplete" \ -d "payment_settings[payment_method_types][]"="us_bank_account" \ -d "trial_end"=1610403705 \ -d "expand[0]"="pending_setup_intent" ``` Geben Sie das `client_secret` aus dem `pending_setup_intent` des Abonnements an das Frontend zurück, um die Einrichtung abzuschließen. Dieser Schritt ist erforderlich, um eine Zahlung für den ersten Abrechnungszeitraum erfolgreich zu veranlassen. Befolgen Sie die Anweisungen unter [Angaben zur Zahlungsmethode erfassen](https://docs.stripe.com/billing/subscriptions/ach-debit.md#collect-payment-details), [Mandatsbestätigung erfassen und absenden](https://docs.stripe.com/billing/subscriptions/ach-debit.md#collect-mandate-and-submit) und [Bankkonten mit Testeinzahlungen verifizieren](https://docs.stripe.com/billing/subscriptions/ach-debit.md#verify-with-microdeposits) mit zwei Unterschieden: - Verwenden Sie `stripe.collectBankAccountForSetup` statt `stripe.collectBankAccountForPayment`. - Verwenden Sie `stripe.confirmUsBankAccountSetup` statt `stripe.confirmUsBankAccountPayment`. Falls Ihr/e Kund/in die Verifizierung von Testeinzahlungen wählt, verwenden Sie `stripe.verifyMicrodepositsForSetup` anstelle von `stripe.verifyMicrodepositsForPayment`. Der SetupIntent wechselt nach der Verifizierung sofort in den Status `succeeded`, und Stripe setzt die `default_payment_method` des Abonnements auf die neu erstellte *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs). Sie können einen [Abrechnungszyklusanker](https://docs.stripe.com/billing/subscriptions/ach-debit.md#billing-cycle) auch mit einer kostenlosen Testphase kombinieren. Angenommen, Sie möchten am 15. September Ihrem/Ihrer Kund/in eine kostenlose siebentägige Testphase schenken und am 1. Oktober mit dem normalen Abrechnungszyklus starten. Sie können den Ablauf der kostenlosen Testphase auf den 22. September festlegen und den Abrechnungszyklusanker auf den 1. Oktober. So kann der/die Kund/in sieben Tage lang eine kostenlose Testversion nutzen, und für den Zeitraum zwischen dem Ablauf der Testphase und dem 1. Oktober wird ein anteilsmäßig verrechneter Betrag berechnet. Am 1. Oktober berechnen Sie dem/der Kund/in dann den normalen Abonnementbetrag für seinen/ihren ersten vollen Abrechnungszyklus. ## Optional: Details der Zahlungsmethode für spätere Verwendung speichern Sie können die US-Bankkontodaten Ihrer Kundinnen/Kunden zur automatischen Verwendung mit *Rechnungen* (Invoices are statements of amounts owed by a customer. They track the status of payments from draft through paid or otherwise finalized. Subscriptions automatically generate invoices, or you can manually create a one-off invoice), Abonnements oder Abonnementzeitplänen speichern, die Sie später erstellen. Verwenden Sie hierfür einen [SetupIntent](https://docs.stripe.com/api/setup_intents.md), der die Schritte dieses Einrichtungsvorgangs verfolgt. Befolgen Sie die Anleitung zum [Speichern von US-Bankkontodaten für zukünftige Zahlungen](https://docs.stripe.com/payments/ach-direct-debit/set-up-payment.md). Nachdem der `SetupIntent` den Status `succeeded` erreicht hat, aktualisieren Sie die `default_payment_method` Ihres/Ihrer Kund/in. #### 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. Stripe.api_key = '<>' 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 Stripe::Customer.update( customer_id, { invoice_settings: { default_payment_method: payment_method_id } } ) end ``` # Gehostete Seite > This is a Gehostete Seite for when platform is web and payment-ui is stripe-hosted. View the full page at https://docs.stripe.com/billing/subscriptions/ach-debit?platform=web&payment-ui=stripe-hosted. Wenn es Ihre Stripe Checkout-Integration Kundinnen/Kunden ermöglicht, Abonnements in einer [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md) zu erstellen, können Sie ein US-Bankkonto als Zahlungsmethode hinzufügen. Eine [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md) repräsentiert die Details der Kaufabsicht eines Kunden/einer Kundin. Erstellen Sie eine Checkout-Sitzung, wenn ein Kunde/eine Kundin ein Abonnement starten möchte. Nachdem Ihre Kundinnen/Kunden zu einer Checkout-Sitzung umgeleitet wurden, präsentiert Stripe ein Zahlungsformular, von dem aus sie ihren Kauf abschließen können. Nachdem sie einen Kauf abgeschlossen haben, leitet Stripe sie auf Ihre Website zurück. Nachdem Sie die Integration abgeschlossen haben, können Sie sie auf Folgendes erweitern: - [Mehrere Preise hinzufügen](https://docs.stripe.com/products-prices/how-products-and-prices-work.md#multiple-prices) - [Variable Preise erstellen](https://docs.stripe.com/products-prices/how-products-and-prices-work.md#variable-pricing) - [Umgang mit bestehenden Kundinnen/Kunden](https://docs.stripe.com/payments/existing-customers.md?platform=web&ui=stripe-hosted) - [Umgang mit Testzeiträumen](https://docs.stripe.com/billing/subscriptions/trials.md) - [Steuern einziehen](https://docs.stripe.com/billing/taxes/collect-taxes.md?tax-calculation=tax-rates) - [Abrechnungsgutscheine erstellen](https://docs.stripe.com/billing/subscriptions/coupons.md) ## Stripe einrichten [Serverseitig] Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register). Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API über Ihre Anwendung: #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` ## Preismodell erstellen [Dashboard] [Stripe-CLI] [Wiederkehrende Preismodelle](https://docs.stripe.com/products-prices/pricing-models.md) umfassen die Produkte und Dienstleistungen, die Sie anbieten, die Preise dafür, welche Währungen Sie für Zahlungen verwenden und den Leistungszeitraum (für Abos). Verwenden Sie zum Aufbau des Preismodells [Produkte](https://docs.stripe.com/api/products.md) (was Sie anbieten) und [Preise](https://docs.stripe.com/api/prices.md) (Höhe und Abrechnungsintervall). In diesem Beispiel wird ein Pauschalpreisdienst mit zwei verschiedenen Service-Optionen verwendet: Basis und Premium. Für jede Service-Option müssen Sie ein Produkt und einen wiederkehrenden Preis erstellen. Um eine einmalige Gebühr, z. B. für die Einrichtung, hinzufügen möchten, erstellen Sie ein drittes Produkt mit einem einmaligen Preis. Jedes Produkt wird in monatlichen Intervallen abgerechnet. Der Preis für das Basisprodukt beträgt 5 USD. Der Preis für das Premiumprodukt beträgt 15 USD. Ein Beispiel mit drei Stufen finden Sie im Leitfaden zu [Pauschalpreismodellen](https://docs.stripe.com/subscriptions/pricing-models/flat-rate-pricing.md). #### Dashboard Gehen Sie zur Seite [Produkt hinzufügen](https://dashboard.stripe.com/test/products/create) und erstellen Sie zwei Produkte. Fügen Sie für jedes Produkt einen Preis hinzu, jeweils mit einem monatlich wiederkehrenden Abrechnungszeitraum: - Premium-Produkt: Premium-Dienstleistung mit zusätzlichen Funktionen - Preis: Pauschalpreis | 15 USD - Basic-Produkt: Basic-Dienstleistung mit minimalem Funktionsumfang - Preis: Pauschalpreis | 5 USD Zeichnen Sie nach Erstellung der Preise die Preis-IDs auf, sodass diese in anderen Schritten verwendet werden können. Preis-IDs sehen in etwa wie folgt aus: `price_G0FvDp6vZvdwRZ`. Wenn Sie bereit sind, verwenden Sie die Schaltfläche **In Live-Modus kopieren** oben rechts auf der Seite, um Ihr Produkt aus der [Sandbox in den Live-Modus zu kopieren](https://docs.stripe.com/keys.md#test-live-modes). #### API Sie können die API zum Erstellen der [Produkte](https://docs.stripe.com/api/products.md) und [Preise](https://docs.stripe.com/api/prices.md) verwenden. Premiumprodukt erstellen: ```curl curl https://api.stripe.com/v1/products \ -u "<>:" \ --data-urlencode "name=Billing Guide: Premium Service" \ -d "description=Premium service with extra features" ``` Basisprodukt erstellen: ```curl curl https://api.stripe.com/v1/products \ -u "<>:" \ --data-urlencode "name=Billing Guide: Basic Service" \ -d "description=Basic service with minimum features" ``` Zeichnen Sie Preis-ID für jedes Produkt auf. Die Preis-IDs sehen in etwa wie folgt aus: ```json { "id": "prod_H94k5odtwJXMtQ", "object": "product", "active": true, "attributes": [ ], "created": 1587577341, "description": "Premium service with extra features", "images": [ ], "livemode": false, "metadata": { }, "name": "Billing Guide: Premium Service", "statement_descriptor": null, "type": "service", "unit_label": null, "updated": 1587577341 } ``` Verwenden Sie die Produkt-IDs, um einen Preis für jedes Produkt zu erstellen. Die Zahl [unit_amount](https://docs.stripe.com/api/prices/object.md#price_object-unit_amount) wird in Cent angegeben, also z. B.`1500` = 15 USD. Premiumpreis erstellen: ```curl curl https://api.stripe.com/v1/prices \ -u "<>:" \ -d product={{PREMIUM_PRODUCT_ID}} \ -d unit_amount=1500 \ -d currency=usd \ -d "recurring[interval]=month" ``` Basispreis erstellen: ```curl curl https://api.stripe.com/v1/prices \ -u "<>:" \ -d product={{BASIC_PRODUCT_ID}} \ -d unit_amount=500 \ -d currency=usd \ -d "recurring[interval]=month" ``` Zeichnen Sie Preis-ID für jeden Preis auf, sodass diese in nachfolgenden Schritten verwendet werden können. Die Preis-IDs sehen in etwa wie folgt aus: ```json { "id": "price_HGd7M3DV3IMXkC", "object": "price", "product": "prod_HGd6W1VUqqXGvr", "type": "recurring", "currency": "usd", "recurring": { "interval": "month", "interval_count": 1, "trial_period_days": null, "usage_type": "licensed" }, "active": true, "billing_scheme": "per_unit", "created": 1589319695, "livemode": false, "lookup_key": null, "metadata": {}, "nickname": null, "unit_amount": 1500, "unit_amount_decimal": "1500", "tiers": null, "tiers_mode": null, "transform_quantity": null } ``` Hier finden Sie Beispiele für andere [Preismodelle](https://docs.stripe.com/products-prices/pricing-models.md). ## Checkout-Sitzung erstellen [Clientseitig] [Serverseitig] Fügen Sie Ihrer Website eine Checkout-Schaltfläche hinzu, die einen serverseitigen Endpoint aufruft, um eine Checkout-Sitzung zu erstellen. ```html Checkout
``` ### Checkout-Sitzungsparameter Eine vollständige Liste aller Parameter, die Sie verwenden können, finden Sie unter [Sitzung erstellen](https://docs.stripe.com/api/checkout/sessions/create.md). Erstellen Sie eine Checkout-Sitzung mit der ID eines bestehenden [Preises](https://docs.stripe.com/api/prices.md). Stellen Sie sicher, dass der Modus auf `subscription` gesetzt ist und dass Sie mindestens einen wiederkehrenden Preis übergeben. Zusätzlich zu wiederkehrenden Preisen können Sie auch einmalige Preise hinzufügen. Leiten Sie Ihre Kundinnen/Kunden nach dem Erstellen der Checkout-Sitzung zu der in der Antwort zurückgegebenen [URL](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-url) weiter. #### cURL ```bash curl https://api.stripe.com/v1/checkout/sessions \ -u <>: \ -d "payment_method_types[]"="us_bank_account" \ -d "line_items[][price]"="{{PRICE_ID}}" \ -d "line_items[][quantity]"=1 \ -d "mode"="subscription" \ -d "success_url"="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" \ ``` Wenn Ihre Kundinnen und Kunden ihre Zahlung erfolgreich abgeschlossen haben, werden Sie an die `success_url` weitergeleitet. Hierbei handelt es sich um eine Seite auf Ihrer Website, auf der sie darüber informiert werden, dass ihre Zahlung erfolgreich durchgeführt wurde. Stellen Sie die Sitzungs-ID auf Ihrer Erfolgsseite zur Verfügung, indem Sie die Vorlagenvariable `{CHECKOUT_SESSION_ID}` wie im obigen Beispiel in die `success_url` einfügen. Checkout-Sitzungen laufen standardmäßig 24 Stunden nach Erstellung ab. > Verlassen Sie sich beim Erkennen von initiierten Zahlungen nicht allein auf die Weiterleitung auf die `success_url`: > > - Böswillige Nutzer/innen könnten, ohne zu bezahlen, direkt auf die `success_url` zugreifen und sich so unberechtigt Zugang zu Waren und Dienstleistungen verschaffen. - Nach einer erfolgreichen Zahlung schließen Kundinnen und Kunden möglicherweise ihren Browser-Tab, bevor sie zur `success_url` weitergeleitet werden. ## Bestätigen, dass die Zahlung erfolgreich durchgeführt wurde Wenn Ihre Kund/innen ihre Zahlung erfolgreich abschließen, werden sie von Stripe an die URL weitergeleitet, die Sie im `success_url`-Parameter angegeben haben. Hierbei handelt es sich in der Regel um eine Seite auf Ihrer Website, auf der Ihre Kund/innen darüber informiert werden, dass ihre Zahlung erfolgreich durchgeführt wurde. Bei handelt es sich jedoch um eine Zahlungsmethode mit verzögerter Benachrichtigung, was bedeutet, dass Geldmittel nicht sofort verfügbar sind. Deshalb sollten Sie mit der *Ausführung* (Fulfillment is the process of providing the goods or services purchased by a customer, typically after payment is collected) der Bestellung warten, bis das Geld auf Ihrem Konto ist. Nach erfolgreicher Zahlung ändert sich der zugrunde liegende *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods)-Status von `„processing`“ in `„succeeded“`. Eine Zahlung über US bank account debit dauert in der Regel four days, bis die Gelder verfügbar sind. Sie können auf verschiedene Weise bestätigen, dass die Zahlung erfolgreich ist: #### Dashboard Erfolgreiche Zahlungen werden in der [Zahlungsliste](https://dashboard.stripe.com/payments) des Dashboards angezeigt. Wenn Sie auf eine Zahlung klicken, gelangen Sie zur Seite mit den Zahlungsdetails. Der Abschnitt **Checkout-Übersicht** enthält Abrechnungsinformationen und die Liste der gekauften Artikel, die Sie zur manuellen Ausführung der Bestellung verwenden können. ![](https://b.stripecdn.com/docs-statics-srv/assets/source.16d3029596357c80a8efdbbfe106108a.png) > Durch Senden von E-Mail-Benachrichtigungen über erfolgreich abgeschlossene Kundenzahlungen kann Stripe Ihnen helfen, den Überblick über eingehende Zahlungen zu behalten. Verwenden Sie das Dashboard, um [E-Mail-Benachrichtigungen zu konfigurieren](https://dashboard.stripe.com/settings/user). #### Webhooks Wir senden die folgenden Checkout-Ereignisse, wenn sich der Zahlungsstatus ändert: | Ereignisname | Beschreibung | Nächste Schritte | | -------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------- | | [checkout.session.completed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.completed) | Die Kundin/der Kunde hat die Lastschriftzahlung nach Übermittlung des Checkout-Formulars erfolgreich autorisiert. | Warten Sie, bis die Zahlung erfolgt oder fehlschlägt. | | [checkout.session.async_payment_succeeded](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_succeeded) | Die verzögerte Zahlungsmethode war letztendlich erfolgreich. | Wickeln Sie die Bestellung der Kundin/des Kunden ab. | | [checkout.session.async_payment_failed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_failed) | Die verzögerte Zahlungsmethode ist letztendlich fehlgeschlagen. | Senden Sie der Kundin/dem Kunden eine E-Mail und bitten Sie sie/ihn, die Zahlung erneut zu versuchen. | | [invoice.paid](https://docs.stripe.com/api/events/types.md#event_types-invoice.paid) | Die Zahlung der Kundin/des Kunden war erfolgreich. | Wickeln Sie die Bestellung der Kundin/des Kunden ab. | | [invoice.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-invoice.payment_failed) | Die Zahlung der Kundin/des Kunden wurde abgelehnt oder ist aus einem anderen Grund fehlgeschlagen. | Fordern Sie den/die Kund/in per E-Mail auf, die Zahlung erneut zu versuchen. | Ihr Webhook-Code muss alle diese Checkout-Ereignisse verarbeiten können. Jede Webhook-Nutzlast in Checkout beinhaltet das [Session-Objekt von Checkout](https://docs.stripe.com/api/checkout/sessions.md) und Rechnungs-Webhooks enthalten das [Invoice](https://docs.stripe.com/api/invoices/object.md)-Objekt. Beide enthalten Informationen über die *Kunden/Kundinnen* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) und den *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods). Stripe sendet den Webhook `checkout.session.completed` an Ihren Server, bevor Ihre Kund/innen weitergeleitet werden. Ihre Annahme des Webhooks (ein beliebiger `2xx`-Statuscode) löst die Weiterleitung der Kund/innen an die `success_url` aus. Wenn Stripe innerhalb von 10 Sekunden nach erfolgreicher Zahlung keine volle Empfangsbestätigung erhält, werden Ihre Kund/innen automatisch zur `success_url`-Seite weitergeleitet. Zeigen Sie auf Ihrer `success_url`-Seite Ihren Kundinnen/Kunden eine Meldung über den Zahlungserfolg an und informieren Sie sie, dass die Ausführung der Bestellung bis zu four days in Anspruch nehmen wird, da die Zahlung mit US bank account debit nicht sofort erfolgt. Wir empfehlen die [Verwendung von Webhooks](https://docs.stripe.com/webhooks.md), um den Erfolg der Zahlung zu bestätigen und die gekauften Waren zu versenden bzw. Dienstleistungen zu erbringen. Nachfolgend finden Sie ein Beispiel für einen Webhook-Endpoint, der den Erfolg oder Misserfolg einer Zahlung handhabt: #### 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. Stripe.api_key = '<>' # You can find your endpoint's secret in your webhook settings endpoint_secret = 'whsec_...' # Using Sinatra post '/webhook' do payload = request.body.read event = nil # Verify webhook signature and extract the event # See https://stripe.com/docs/webhooks#verify-events for more information. sig_header = request.env['HTTP_STRIPE_SIGNATURE'] begin event = Stripe::Webhook.construct_event( payload, sig_header, endpoint_secret ) rescue JSON::ParserError => e # Invalid payload status 400 return rescue Stripe::SignatureVerificationError => e # Invalid signature status 400 return end case event['type'] when 'checkout.session.completed' session = event['data']['object'] subscription_id = session.subscription # Find the subscription or save it to your database. # invoice.paid may have fired before this so there # could already be a subscription. find_or_create_subscription(subscription_id) when 'invoice.paid' invoice = event['data']['object'] subscription_id = invoice.parent.subscription_details.subscription # Find the subscription or save it to your database. # checkout.session.completed may not have fired yet # so we may need to create the subscription. subscription = find_or_create_subscription(subscription_id) # Fulfill the purchase fulfill_order(invoice) # Record that the subscription has been paid for # this payment period. invoice.paid will fire every # time there is a payment made for this subscription. record_as_paid_for_this_period(subscription) when 'invoice.payment_failed' invoice = event['data']['object'] # Send an email to the customer asking them to retry their payment email_customer_about_failed_payment(invoice) end status 200 end ``` Sie können Informationen über die Kund/innen, Zahlungen oder Abonnements abrufen, indem Sie die `Kunden`-, `PaymentIntent`- oder `Abo`-Objekte abrufen, auf die von den Eigenschaften `Kunde/Kundin`, `payment_intent` und `Abo` in der Webhook-Nutzlast verwiesen wird. ### Posten aus einem Webhook abrufen Checkout-Webhooks geben standardmäßig keine `line_items` zurück. Um die mit der Checkout-Sitzung erstellten Posten abzurufen, führen Sie eine zusätzliche Anfrage mit der ID der Checkout-Sitzung durch: #### curl ```bash curl https://api.stripe.com/v1/checkout/sessions/{{CHECKOUT_SESSION_ID}}/line_items \ -u <>: ``` #### Stripe-CLI ```bash stripe get /v1/checkout/sessions/{{CHECKOUT_SESSION_ID}}/line_items ``` ### Webhooks lokal testen Verwenden Sie die [Stripe-CLI](https://docs.stripe.com/stripe-cli.md), um Webhooks lokal zu testen. Nach der Installation können Sie Ereignisse an Ihren Server weiterleiten: ```bash stripe listen --forward-to localhost:4242/webhook Ready! Your webhook signing secret is '{{WEBHOOK_SIGNING_SECRET}}' (^C to quit) ``` Erfahren Sie mehr über die [Einrichtung von Webhooks](https://docs.stripe.com/webhooks.md). #### Drittanbieter-Plugins Sie können Plugins wie [[Zapier]](https://stripe.com/works-with/zapier) verwenden, um Ihre Systeme für die Bestellausführung automatisch mit Informationen aus Stripe-Zahlungen zu aktualisieren. Nachfolgend finden Sie einige Beispiele für unterstützte Automatisierungen mithilfe von Plugins: - Aktualisieren der zur Bestellungsverfolgung verwendeten Tabellen nach einer erfolgreichen Zahlung - Aktualisieren der Bestandsverwaltungssysteme nach einer erfolgreichen Zahlung - Auslösen von Benachrichtigungen an interne Kundenservice-Teams mittels E-Mail- oder Chat-Anwendungen ## 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 aktivieren](https://docs.stripe.com/get-started/account/activate.md), bevor Sie diese E-Mails beim Testen 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/billing/subscriptions/ach-debit.md#timing) dauern kann, bis Transaktionen Ihrem verfügbaren Guthaben gutgeschrieben werden. ## Zusätzliche Überlegungen ### Fehlschlagen der Verifizierung einer Testeinzahlung Wenn die Verifizierung eines Bankkontos mittels Testeinzahlungen noch aussteht, kann die Verifizierung durch die Kundin/den Kunden aus drei Gründen fehlschlagen: - Die Testeinzahlungen haben das Kundenbankkonto nicht erreicht. (Dies weist in der Regel auf ein geschlossenes/nicht verfügbares Bankkonto oder eine falsche Kontonummer hin). - Die Verifizierungsversuche des Kontos durch die Kundin/den Kunden sind 10 mal fehlgeschlagen. Wird diese Grenze überschritten, kann das Bankkonto nicht mehr verifiziert oder erneut verwendet werden. - Die Kundin/der Kunde hat das Bankkonto nicht innerhalb der Frist von 10 Tagen verifiziert. Wenn die Verifizierung des Bankkontos aus einem der genannten Gründe fehlschlägt, können Sie [das Ereignis `checkout.session.async_payment_failed` verarbeiten](https://docs.stripe.com/api/events/types.md?event_types-invoice.payment_succeeded=#event_types-checkout.session.async_payment_failed), um den Kunden/die Kundin zum Aufgeben einer neuen Bestellung aufzufordern. ## Optional: Nur Sofortverifizierung Standardmäßig können Ihre Kund/innen bei Verwendung von ACH-Lastschriftzahlungen die sofortige Bankkontoverifizierung oder Testeinzahlungen nutzen. Optional können Sie die sofortige Verifizierung des Bankkontos nur mit dem Parameter `payment_method_options[us_bank_account][verification_method]` verlangen, wenn Sie die Checkout-Sitzung erstellen. #### Accounts v2 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=subscription \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ -d "line_items[0][price]={{PRICE_ID}}" \ -d "line_items[0][quantity]=1" \ --data-urlencode "success_url=https://example.com/success" ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=subscription \ -d "customer={{CUSTOMER_ID}}" \ -d "payment_method_types[0]=card" \ -d "payment_method_types[1]=us_bank_account" \ -d "payment_method_options[us_bank_account][verification_method]=instant" \ -d "payment_method_options[us_bank_account][financial_connections][permissions][0]=payment_method" \ -d "line_items[0][price]={{PRICE_ID}}" \ -d "line_items[0][quantity]=1" \ --data-urlencode "success_url=https://example.com/success" ``` ## See also - [Ihre Integration anpassen](https://docs.stripe.com/payments/checkout/customization.md) - [Verwalten Sie Abos über das Kundenportal](https://docs.stripe.com/billing/subscriptions/build-subscriptions.md?payment-ui=checkout&ui=stripe-hosted)