# Zahlungen per Bacs-Lastschriftverfahren Akzeptieren Sie Zahlungen im BACS-Lastschriftverfahren von Kundinnen / Kunden mit einem Konto im Vereinigten Königreich. # Bezahlvorgang > This is a Bezahlvorgang for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/bacs-debit/accept-a-payment?payment-ui=checkout. > Stripe kann Ihren Kundinnen und Kunden automatisch die relevanten Zahlungsmethoden anzeigen, indem Währungen, Einschränkungen der Zahlungsmethode und andere Parameter ausgewertet werden. > > - Befolgen Sie den Leitfaden [Eine Zahlung akzeptieren](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted), um eine Checkout-Integration zu erstellen, die [dynamische Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md) verwendet. - Wenn Sie keine dynamischen Zahlungsmethoden verwenden möchten, befolgen Sie die folgenden Schritte, um die Zahlungsmethoden in Ihrer Checkout-Integration manuell zu konfigurieren. Stripe-Nutzer/innen im Vereinigten Königreich können [Checkout](https://docs.stripe.com/payments/checkout.md) im Zahlungsmodus verwenden, um Zahlungen per Bacs-Lastschriftverfahren zu akzeptieren. Eine [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md) repräsentiert die Details der Kaufabsicht Ihres Kunden/Ihrer Kundin. Sie erstellen eine Checkout-Sitzung, wenn Ihr Kunde/Ihre Kundin für etwas bezahlen 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 Ihre Kundinnen/Kunden einen Kauf getätigt haben, werden sie wieder auf Ihre Website zurückgeleitet. ## 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' ``` ## Produkte und Preise erstellen Um Checkout zu verwenden, müssen Sie zuerst ein *Produkt* (Products represent what your business sells—whether that's a good or a service) und einen *Preis* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) erstellen. Verschiedene physische Waren oder Dienstleistungsebenen sollten durch Produkte dargestellt werden. Die Preisgestaltung ist durch einen oder mehrere Preise dargestellt. Sie können beispielsweise ein T-Shirt-*Produkt* erstellen, das zwei *Preise* für verschiedene Währungen hat: 20 GBP und 25 EUR. Auf diese Weise können Sie Preise ändern und hinzufügen, ohne die Details der zugrundeliegenden Produkte ändern zu müssen. Sie können ein Produkt oder einen Preis entweder [über die API](https://docs.stripe.com/api/prices.md) oder im [Dashboard](https://dashboard.stripe.com/products) erstellen. Wenn Sie Ihren Preis beim Bezahlvorgang ermitteln (der Kunde/die Kundin legt beispielsweise einen Spendenbetrag fest), oder wenn Sie es vorziehen, Preise nicht im Voraus zu erstellen, können Sie [Preise ad-hoc](https://docs.stripe.com/payments/accept-a-payment.md?platform=web#redirect-customers) bei der Erstellung der Checkout-Sitzung mit einem vorhandenen Produkt erstellen. > Wenn Sie bereits eine Checkout-Integration haben, die Prices nicht nutzt, beachten Sie bitte, dass die Checkout API seit der Einführung von Prices geändert wurde. Verwenden Sie diesen [Migrationsleitfaden](https://docs.stripe.com/payments/checkout/migrating-prices.md), um ein Upgrade durchzuführen, oder [behalten Sie Ihre vorhandene Integration](https://support.stripe.com/questions/prices-api-and-existing-checkout-integrations) bei. #### Dashboard > In einer Sandbox erstellte Produkte können in den Live-Modus kopiert werden, sodass Sie sie nicht erneut erstellen müssen. Klicken Sie im Dashboard in der Detailansicht des Produkts oben rechts auf **In Live-Modus kopieren**. Dieser Schritt kann für jedes in einer Sandbox erstellte Produkt nur einmal vorgenommen werden. Spätere Aktualisierungen für das Test-Produkt werden im Live-Produkt nicht berücksichtigt. Stellen Sie sicher, dass Sie sich in einer Sandbox befinden, und definieren Sie die Artikel, die Sie verkaufen möchten. So erstellen Sie ein neues Produkt und einen neuen Preis: - Gehen Sie im Dashboard zum Bereich [Produkte](https://dashboard.stripe.com/test/products). - Klicken Sie auf **Produkt hinzufügen**. - Wählen Sie beim Festlegen des Preises **Einmalig** aus. Informationen wie Produktname, Beschreibung und Bild, die Sie angeben, werden Kund/innen beim Bezahlvorgang angezeigt. #### API Es ist nur ein `name` erforderlich, um ein [Produkt](https://docs.stripe.com/api/products.md) mit der API zu erstellen. Informationen wie `name` des Produkts, `description` und `images`, die Sie angeben, werden Kundinnen/Kunden beim Bezahlvorgang angezeigt. ```curl curl https://api.stripe.com/v1/products \ -u "<>:" \ -d name=T-shirt ``` Erstellen Sie als Nächstes einen [Preis](https://docs.stripe.com/api/prices.md), um zu definieren, wie viel Sie für ein Produkt berechnen möchten. Dazu gehört, wie viel das Produkt kostet und welche Währung verwendet werden soll. Zahlungen per Bacs-Lastschrift müssen in GBP erfolgen. ```curl curl https://api.stripe.com/v1/prices \ -u "<>:" \ -d "product={{PRODUCT_ID}}" \ -d unit_amount=2000 \ -d currency=gbp ``` ## Checkout-Sitzung erstellen [Clientseitig] [Serverseitig] Fügen Sie Ihrer Website eine Schaltfläche zum Bezahlen hinzu, über die ein serverseitiger Endpoint aufgerufen wird, um eine Checkout-Sitzung zu erstellen. ```html Checkout
``` Erstellen Sie eine Checkout-Sitzung mit [line_items](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-line_items). Posten geben an, welche Artikel die Kundinnen/Kunden erwerben. Wenn Ihre Kundinnen und Kunden eine Zahlung abschließen, werden sie an die `success_url` weitergeleitet. Dabei handelt es sich um eine Seite auf Ihrer Website, auf der sie darüber informiert werden, dass ihre Zahlungsinformationen erfasst wurden und die Zahlung abgewickelt wird. Wenn Ihre Kundin/Ihr Kunde in einer Checkout-Sitzung auf Ihr Logo klickt, ohne eine Zahlung abzuschließen, leitet Checkout sie/ihn zurück auf die Seite Ihrer Website, die vor der Weiterleitung zu Checkout angezeigt wurde. Mit Checkout können Zahlungen akzeptiert und Zahlungsmethoden für eine erneute Verwendung gespeichert werden. Gespeicherte Zahlungsmethoden können per [PaymentIntent](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method) für künftige Zahlungen wiederverwendet werden. 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[]"="bacs_debit" \ -d "line_items[][price]"="{{PRICE_ID}}" \ -d "line_items[][quantity]"=1 \ -d "mode"="payment" \ -d "customer"="{{CUSTOMER_ID}}" \ -d "payment_intent_data[setup_future_usage]"="off_session" \ -d "success_url"="https://example.com/success?session_id={CHECKOUT_SESSION_ID}" ``` > Gemäß den Regeln zum Bacs-Lastschriftverfahren schickt Stripe bei der erstmaligen Erfassung von Zahlungsinformationen sowie bei jeder Kontobelastung standardmäßig [Lastschriftankündigungen per E-Mail](https://docs.stripe.com/payments/payment-methods/bacs-debit.md#debit-notifications). Standardmäßig versendet Stripe diese E-Mails für Sie. Beim Erstellen einer Checkout-Sitzung wird eine Sitzungs-[ID](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-id) zurückgegeben. 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. > 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. ## Ereignisse nach der Zahlung verarbeiten [Serverseitig] 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. Beim Bacs-Lastschriftverfahren handelt es sich jedoch um eine Zahlungsmethode mit verzögerter Benachrichtigung. Das bedeutet, dass Gelder nicht sofort verfügbar sind. Bei einer Zahlung per Bacs-Lastschriftverfahren sind die Gelder in der Regel erst nach 3 Werktagen verfügbar. 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) 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`. Die folgenden Checkout-Ereignisse werden übermittelt, 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) | Der/die Kund/in hat die Lastschriftzahlung erfolgreich autorisiert, indem das Checkout-Formular eingereicht wurde. | Warten Sie, bis die Zahlung erfolgt ist oder fehlschlägt. | | [checkout.session.async_payment_succeeded](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_succeeded) | Die Kundenzahlung war erfolgreich. | Wickeln Sie die Kundenbestellung ab. | | [checkout.session.async_payment_failed](https://docs.stripe.com/api/events/types.md#event_types-checkout.session.async_payment_failed) | Die Zahlung wurde abgelehnt oder ist aus einem anderen Grund fehlgeschlagen. | Kontaktieren Sie den Kunden/die Kundin per E-Mail und fordern Sie eine neue Bestellung von ihm/ihr an. | Ihr *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests)-Code muss alle drei dieser Checkout-Ereignisse verarbeiten können. Jede Nutzlast des Checkout-Webhooks beinhaltet das [Checkout-Sitzungsobjekt](https://docs.stripe.com/api/checkout/sessions.md), das Informationen über die *Kundinnen/Kunden* (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) enthält. Der Webhook `checkout.session.completed` wird an Ihren Server übermittelt, 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 Ihren Kundinnen/Kunden auf Ihrer `success_url`-Seite eine Meldung über den Zahlungserfolg an und informieren Sie sie, dass die Ausführung der Bestellung einige Tage dauert, da die Zahlung mit dem Bacs-Lastschriftverfahren nicht sofort erfolgt. Wenn Sie neben Zahlungen mit verzögerter Benachrichtigung auch Sofortzahlungen (wie Kreditkarten) akzeptieren, aktualisieren Sie Ihren Webhook-Endpoint, um beim Empfang eines `checkout.session.completed`-Ereignisses beide Zahlungsarten zu verarbeiten. #### 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('<>') # 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'] # Check if the order is paid (for example, from a card payment) payment_intent = client.v1.payment_intents.retrieve(session.payment_intent) # A delayed notification payment will have the status 'processing' order_paid = payment_intent.status == "succeeded" # Save an order in your database, marked as 'awaiting payment' create_order(session) if order_paid fulfill_order(session) end when 'checkout.session.async_payment_succeeded' session = event['data']['object'] # Fulfill the purchase... fulfill_order(session) when 'checkout.session.async_payment_failed' session = event['data']['object'] # Send an email to the customer asking them to retry their order email_customer_about_failed_payment(session) end status 200 end ``` Sie können Informationen über die Kund/innen und die Zahlung abrufen, indem Sie die Customer- oder PaymentIntent-Objekte abrufen, auf die von den Eigenschaften `customer`, `payment_intent` in der Webhook-Payload verwiesen wird. ### 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). ## Integration testen Mittlerweile sollten Sie über eine grundlegende Integration des Bacs-Lastschriftverfahrens verfügen, die Bankverbindungen erfassen und Zahlungen akzeptieren kann. Es gibt mehrere [Testbankkontonummern](https://docs.stripe.com/keys.md#test-live-modes), die Sie 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) verwenden können. So können Sie sicherstellen, dass diese Integration bereit ist. | Bankleitzahl | Kontonummer | Beschreibung | | ------------ | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 108800 | 00012345 | Die Zahlung ist erfolgreich und der PaymentIntent von wird von `processing` auf `succeeded` umgestellt. | | 108800 | 90012345 | Die Zahlung erfolgt innerhalb von drei Minuten und der PaymentIntent von wird von `processing` auf `succeeded` umgestellt. | | 108800 | 33333335 | Die Zahlung wird akzeptiert, schlägt dann aber unmittelbar fehl. Der Fehlercode `debit_not_authorized` wird ausgegeben und der PaymentIntent geht vom Status `wird verarbeitet` zum Status `requires_payment_method` über. Das Mandat wechselt zu `inaktiv` und die PaymentMethod kann nicht erneut verwendet werden. | | 108800 | 93333335 | Die Zahlung schlägt nach drei Minuten fehl. Der Fehlercode `debit_not_authorized` wird ausgegeben und der PaymentIntent geht vom Status `wird verarbeitet` in den Status `requires_payment_method` über. Das Mandat wechselt zu `inaktiv` und die PaymentMethod kann nicht erneut verwendet werden. | | 108800 | 22222227 | Die Zahlung schlägt fehl, die Fehlerkennung `insufficient_funds` wird ausgegeben und der PaymentIntent wird von `processing` auf `requires_payment_method` umgestellt. Das Mandat bleibt `active` und die PaymentMethod kann erneut verwendet werden. | | 108800 | 92222227 | Die Zahlung schlägt nach drei Minuten fehl, die Fehlerkennung `insufficient_funds` wird ausgegeben und der PaymentIntent wird von `processing` auf `requires_payment_method` umgestellt. Das Mandat bleibt `active` und die PaymentMethod kann erneut verwendet werden. | | 108800 | 55555559 | Die Zahlung erfolgt innerhalb von drei Minuten und der PaymentIntent wechselt von `processing` zu `succeeded`. Eine Zahlungsanfechtung wird jedoch sofort erstellt. | | 108800 | 00033333 | Die Zahlungsmethode wurde erfolgreich erstellt, das Mandat wird jedoch von der Kundenbank verweigert und sofort deaktiviert. | | 108800 | 00044444 | Die Anfrage zur Einrichtung eines BACS-Lastschriftverfahrens wird aufgrund einer ungültigen Kontonummer sofort abgelehnt. Die Kundin/der Kunde wird aufgefordert, ihre/seine Angaben vor dem Absenden zu prüfen. Zahlungsdaten werden nicht erfasst. | | 108800 | 34343434 | Die Zahlung schlägt mit dem Fehlercode `charge_exceeds_source_limit` fehl, da der Zahlungsbetrag dazu führt, dass das Konto sein wöchentliches Zahlungsvolumenlimit überschreitet. | | 108800 | 12121212 | Die Zahlung schlägt mit dem Fehlercode `charge_exceeds_weekly_limit` fehl, da der Zahlungsbetrag das Transaktionsvolumenlimit des Kontos überschreitet. | Sie können die oben aufgeführten Kontonummern nach Belieben testen. Da die Verarbeitung von Zahlungen per Bacs-Lastschriftverfahren mehrere Tage in Anspruch nimmt, verwenden Sie bitte die Testkontonummern. Bei diesen ist eine dreiminütige Verzögerung eingebaut, um tatsächliche Zahlungen möglichst exakt nachzubilden. > Standardmäßig sendet Stripe den Kundinnen und Kunden bei der erstmaligen Erfassung ihrer Zahlungsinformationen sowie bei jeder Kontobelastung automatisch [E-Mails](https://docs.stripe.com/payments/payment-methods/bacs-debit.md#debit-notifications). Diese Benachrichtigungen werden nicht in Sandboxes gesendet. ## Fehlgeschlagene Zahlungen Für fehlgeschlagene Zahlungen gibt es verschiedene Ursachen. Diese entnehmen Sie dem [charge.failure_code](https://docs.stripe.com/api/charges/object.md#charge_object-failure_code). Sie können nur Zahlungen mit bestimmten Fehlercodes erneut versuchen. Wenn Sie keine Wiederholung durchführen können, empfehlen wir Ihnen, Kontakt zu den Betroffenen aufzunehmen und diese aufzufordern, die Zahlung mit einem anderen Bankkonto oder einer anderen Zahlungsmethode erneut zu tätigen. Unten finden Sie eine Liste der aktuellen Fehlercodes für das BACS-Lastschriftverfahren. Die Liste wird laufend ergänzt. Gehen Sie also bei der Erstellung und Wartung Ihres Codes davon aus, dass noch andere Fehlertypen existieren. | Fehlercode | Beschreibung | Wiederholbar | | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ | | `account_closed` | Das Bankkonto wurde geschlossen. | Nein | | `bank_ownership_changed` | Das Konto wurde an einen anderen Zahlungsdienstleister übertragen. Prüfen Sie, ob Ihnen dessen Angaben vorliegen. Andernfalls müssen Sie vom betroffenen Kunden oder der betroffenen Kundin ein neues Lastschriftmandat einholen. | Nein | | `debit_not_authorized` | Die Kund/innen haben die Zahlung ihrer Bank als nicht autorisiert gemeldet oder der Auszahlungsbank liegt kein entsprechendes Mandat vor. | Nein | | `generic_could_not_process` | Diese Zahlung konnte nicht abgewickelt werden. | Ja | | `insufficient_funds` | Das Kundenkonto ist für diese Zahlung nicht ausreichend gedeckt. | Ja | | `invalid_account_number` | Die Kontonummer ist ungültig. Möglicherweise bezieht sie sich auf ein Konto in einer anderen Währung als GBP oder über das Konto können keine Zahlungen per Lastschrift abgewickelt werden. | Nein | Um Zahlungen noch einmal zu versuchen, [bestätigen Sie den PaymentIntent](https://docs.stripe.com/api/payment_intents/confirm.md) erneut mit derselben *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs). Um die Erfolgsaussichten zu erhöhen, empfehlen wir vor dem erneuten Zahlungsversuch eine Kontaktaufnahme mit der zahlenden Person. ## Optional: Abbuchungsdatum für Kundin / Kunden konfigurieren Mit dem [Zieldatum](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-payment_method_options-bacs_debit-target_date) können Sie das Datum steuern, an dem Stripe das Bankkonto einer Kundin oder eines Kunden belastet. Das Zieldatum muss mindestens drei Tage in der Zukunft und maximal 15 Tage nach dem aktuellen Datum liegen. Mit dem Zieldatum wird geplant, dass das Geld das Konto der Kundin oder des Kunden am Zieldatum verlässt. Zieldaten, die eines der folgenden Kriterien erfüllen, verzögern die Abbuchung bis zum nächsten verfügbaren Werktag: - Das Zieldatum fällt auf ein Wochenende, einen Feiertag oder einen anderen arbeitsfreien Tag. - Das Zieldatum liegt weniger als drei Werktage in der Zukunft. Dieser Parameter wird auf Best-Effort-Basis ausgeführt. Es kann sein, dass die Bank jedes Kunden/jeder Kundin die Abbuchungen je nach örtlichen Feiertagen oder aus anderen Gründen zu unterschiedlichen Terminen vornimmt. # Elements > This is a Elements for when payment-ui is elements. View the full page at https://docs.stripe.com/payments/bacs-debit/accept-a-payment?payment-ui=elements. Für die Annahme von BACS-Lastschriftzahlungen auf Ihrer Website müssen Sie ein Objekt zum Nachverfolgen von Zahlungen erstellen, Informationen zur Zahlungsmethode erfassen und die Mandatsbestätigung einholen, Zahlungen zur Verarbeitung an Stripe senden und das Bankkonto Ihrer Kundin / Ihres Kunden verifizieren. Stripe verwendet dieses Zahlungsobjekt, den [PaymentIntent](https://docs.stripe.com/payments/payment-intents.md), um alle Bereiche der Zahlung zu verfolgen und alle Schritte der Zahlung abzuwickeln, bis die Zahlung abgeschlossen ist. ## 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' ``` ## Ein/e Kundin / Kunden erstellen oder abrufen [Serverseitig] Um ein Bankkonto für zukünftige Zahlungen wiederzuverwenden, muss es einem *Customer* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments)-Objekt zugeordnet werden. Erstellen Sie ein `Customer`-Objekt, wenn Ihre Kundin / Ihr Kunde ein Konto bei Ihrem Unternehmen anlegt. Wenn Sie die ID des `Customer`-Objekts mit Ihrer eigenen internen Darstellung einer Kundin / eines Kunden verknüpfen, können Sie die gespeicherten Angaben zur Zahlungsmethode später abrufen und verwenden. Legen Sie einen neuen `Customer` an oder rufen Sie einen bestehenden `Customer` ab, um ihn mit dieser Zahlung zu verknüpfen. Fügen Sie den folgenden Code auf Ihrem Server hinzu, um einen neuen `Customer` zu erstellen: ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## Angaben zur Zahlungsmethode erfassen > Die Regeln des BACS-Lastschriftverfahrens verlangen, dass Ihre Kundinnen und Kunden ein Mandat akzeptieren, damit Stripe deren Konto belasten kann. Das [Payment Element](https://docs.stripe.com/payments/payment-element.md) zieht dieses Mandat ein, wenn es die Zahlungsdaten der Kundin / des Kunden akzeptiert. Sie müssen also nichts unternehmen, um diese Anforderung zu erfüllen. Sie können nun mit dem Payment Element Zahlungsdetails auf dem Client erfassen. Das Payment Element ist eine vorgefertigte UI-Komponente, die die Erfassung von Zahlungsdaten für eine Vielzahl von Zahlungsmethoden vereinfacht. Das Payment Element enthält einen iFrame, der Zahlungsinformationen über eine sichere HTTPS-Verbindung an Stripe sendet. Vermeiden Sie es, das Payment Element in einem anderen iFrame zu platzieren, da einige Zahlungsmethoden die Weiterleitung an eine andere Seite zur Zahlungsbestätigung voraussetzen. Die Adresse der Bezahlseite muss mit `https://` und nicht `http://` beginnen, damit Ihre Integration funktioniert. Sie können Ihre Integration ohne HTTPS testen. Denken Sie jedoch daran, es zu [aktivieren](https://docs.stripe.com/security/guide.md#tls), wenn Sie bereit sind, Live-Zahlungen zu akzeptieren. #### HTML + JS ### Stripe.js einrichten Das Payment Element ist ein Feature von Stripe.js und steht damit automatisch zur Verfügung. Fügen Sie das Stripe.js-Skript auf Ihrer Bezahlseite ein, indem Sie es in den `head` Ihrer HTML-Datei einbinden. Laden Sie Stripe.js immer direkt von js.stripe.com, um die PCI-Konformität zu gewährleisten. Fügen Sie das Skript nicht in ein Paket ein und hosten Sie selbst keine Kopie davon. ```html Checkout ``` Erstellen Sie auf Ihrer Zahlungsseite eine Instanz von Stripe mit dem folgenden JavaScript: ```javascript // Set your publishable key: remember to change this to your live publishable key in production // See your keys here: https://dashboard.stripe.com/apikeys const stripe = Stripe('<>'); ``` ### Payment Element zu Ihrer Checkout-Seite hinzufügen Das Payment Element benötigt einen Platz auf Ihrer Checkout-Seite. Erstellen Sie einen leeren DOM-Knoten (Container) mit einer eindeutigen ID in Ihrem Zahlungsformular: ```html
``` #### Zahlungsmethoden über das Dashboard steuern Nachdem das obige Formular geladen wurde, erstellen Sie eine Elements-Instanz mit einem Wert für `mode`, `amount` und `currency`. Diese Werte bestimmen, welche Zahlungsmethoden Ihren Kundinnen/Kunden angezeigt werden. Um eine neue Zahlungsmethode in Ihrem Fomular anzugeben, müssen Sie sie unbedingt im [Dashboard](https://dashboard.stripe.com/settings/payment_methods) aktivieren. ```javascript const options = {mode:'payment', amount:1099, currency: 'gbp', // Fully customizable with appearance API. appearance: {/*...*/}, }; // Set up Stripe.js and Elements to use in checkout formconst elements = stripe.elements(options); // Create and mount the Payment Element const paymentElementOptions = { layout: 'accordion'}; const paymentElement = elements.create('payment', paymentElementOptions); paymentElement.mount('#payment-element'); ``` #### Zahlungsmethoden manuell auflisten Um die Zahlungsmethoden, die verfügbar sein sollen, manuell aufzulisten, fügen Sie jede einzelne zu den `paymentMethodTypes` hinzu. Erstellen Sie dann eine Instanz des Payment Element und verbinden Sie sie mit dem Container DOM-Knoten. ```javascript const options = {mode:'payment', amount:1099, currency: 'gbp', paymentMethodTypes: ['bacs_debit'], // Fully customizable with appearance API. appearance: {/*...*/}, }; // Set up Stripe.js and Elements to use in checkout formconst elements = stripe.elements(options); // Create and mount the Payment Element const paymentElementOptions = { layout: 'accordion'}; const paymentElement = elements.create('payment', paymentElementOptions); paymentElement.mount('#payment-element'); ``` #### React ### Stripe.js einrichten Installieren Sie [React Stripe.js](https://www.npmjs.com/package/@stripe/react-stripe-js) und den [Stripe.js-Loader](https://www.npmjs.com/package/@stripe/stripe-js) aus dem öffentlichen npm-Register. ```bash npm install --save @stripe/react-stripe-js @stripe/stripe-js ``` ### Den Elements-Anbieter zu Ihrer Checkout-Seite hinzufügen und konfigurieren Um die Payment Element-Komponente zu verwenden, schließen Sie die Komponente Ihrer Bezahlseite in einen [Elements-Anbieter](https://docs.stripe.com/sdks/stripejs-react.md#elements-provider) ein. Rufen Sie `loadStripe` mit Ihrem veröffentlichbaren Schlüssel auf und übergeben Sie das zurückgegebene `Promise` an den `Elements`-Anbieter. #### Zahlungsmethoden über das Dashboard steuern Der `Elements`-Anbieter akzeptiert auch Werte für `mode`, `amount` und `currency`. Diese Werte bestimmen, welche Zahlungsmethoden Ihren Kundinnen/Kunden angezeigt werden. Um eine neue Zahlungsmethode in Ihrem Formular anzugeben, müssen Sie sie unbedingt im [Dashboard](https://dashboard.stripe.com/settings/payment_methods) aktivieren. ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import CheckoutForm from './CheckoutForm'; // Make sure to call `loadStripe` outside of a component’s render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('<>'); function App() { const options = {mode:'payment', amount:1099, currency: 'gbp', // Fully customizable with appearance API. appearance: {/*...*/}, }; return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` #### Zahlungsmethoden manuell auflisten ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import CheckoutForm from './CheckoutForm'; // Make sure to call `loadStripe` outside of a component’s render to avoid // recreating the `Stripe` object on every render. const stripePromise = loadStripe('<>'); function App() { const options = {mode:'payment', amount:1099, currency: 'gbp', paymentMethodTypes: ['bacs_debit'], // Fully customizable with appearance API. appearance: {/*...*/}, }; return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` ### Payment Element hinzufügen Verwenden Sie die Komponente `PaymentElement`, um Ihr Formular zu erstellen. ```jsx import React from 'react'; import {PaymentElement} from '@stripe/react-stripe-js'; const CheckoutForm = () => { return (
); }; export default CheckoutForm; ``` Sie können das Payment Element an das Design Ihrer Website anpassen, indem Sie beim Erstellen des `Elements`-Anbieters das [Erscheinungs-Objekt](https://docs.stripe.com/elements/appearance-api.md) an `options` übergeben. ### Adressen einholen Standardmäßig erfasst das Payment Element nur die erforderlichen Angaben zur Rechnungsadresse. Einige Verhaltensweisen, wie z. B. die [Berechnung der Steuer](https://docs.stripe.com/api/tax/calculations/create.md) oder die Eingabe der Versanddaten, erfordern die vollständige Adresse Ihrer Kundin/Ihres Kunden. Sie können Folgendes tun: - Verwenden Sie das [Address Element](https://docs.stripe.com/elements/address-element.md), um die Vorteile der Funktionen der automatischen Vervollständigung und Lokalisierung zu nutzen, um die vollständige Adresse Ihrer Kundin oder Ihres Kunden zu erfassen. Dies trägt dazu bei, eine möglichst genaue Steuerberechnung zu gewährleisten. - Erfassen Sie Adressdaten mit Ihrem eigenen benutzerdefinierten Formular. ## Erstellen Sie ein PaymentIntent [Serverseitig] > #### Benutzerdefinierte Geschäftslogik unmittelbar vor der Zahlungsbestätigung ausführen > > Navigieren Sie zu [Schritt 5](https://docs.stripe.com/payments/finalize-payments-on-the-server.md?platform=web&type=payment#submit-payment) im Leitfaden zum Abschließen von Zahlungen, um Ihre nutzerdefinierte Geschäftslogik unmittelbar vor der Zahlungsbestätigung auszuführen. Führen Sie andernfalls die folgenden Schritte für eine einfachere Integration aus, die `stripe.confirmPayment` auf dem Client verwendet, um die Zahlung zu bestätigen und alle nächsten Aktionen abzuwickeln. #### Zahlungsmethoden über das Dashboard steuern Wenn der Kunde/die Kundin Ihr Zahlungsformular absendet, verwenden Sie einen *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods), um den Bestätigungs- und Zahlungsvorgang zu vereinfachen. Erstellen Sie einen PaymentIntent auf Ihrem Server mit einem `amount` und einer `currency`. Um zu verhindern, dass böswillige Kundinnen/Kunden ihre eigenen Preise wählen, entscheiden Sie, wie viel Sie berechnen möchten, immer auf der Serverseite (einer vertrauenswürdigen Umgebung) und nicht auf dem Client. Zu einem `PaymentIntent` gehört ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Geben Sie diesen Wert an Ihren Client zurück, damit Stripe.js den Zahlungsvorgang sicher abschließen kann. #### Accounts v2 #### Ruby ```ruby require 'stripe' client = Stripe::StripeClient.new('<>') post '/create-intent' do intent = client.v1.payment_intents.create({ # To allow saving and retrieving payment methods, provide the customer's Account ID. customer_account: "{{CUSTOMER_ACCOUNT_ID}}", amount: 1099, currency: 'gbp', }) {client_secret: intent.client_secret}.to_json end ``` #### Customers v1 #### Ruby ```ruby require 'stripe' client = Stripe::StripeClient.new('<>') post '/create-intent' do intent = client.v1.payment_intents.create({ # To allow saving and retrieving payment methods, provide the Customer ID. customer: customer.id, amount: 1099, currency: 'gbp', }) {client_secret: intent.client_secret}.to_json end ``` #### Zahlungsmethoden manuell auflisten Wenn der Kunde/die Kundin Ihr Zahlungsformular absendet, verwenden Sie einen *PaymentIntent* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods), um den Bestätigungs- und Zahlungsvorgang zu vereinfachen. Erstellen Sie einen PaymentIntent auf Ihrem Server mit einem `amount`, einer `currency` und einer oder mehreren Zahlungsmethoden mithilfe von `payment_method_types`. Um zu verhindern, dass böswillige Kundinnen und Kunden ihre eigenen Preise wählen, sollten Sie den Preis immer auf der Serverseite (einer vertrauenswürdigen Umgebung) festlegen und nicht auf dem Client. Zu einem PaymentIntent gehört ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)). Geben Sie diesen Wert an Ihren Client zurück, damit Stripe.js den Zahlungsvorgang sicher abschließen kann. #### Ruby ```ruby require 'stripe' client = Stripe::StripeClient.new('<>') post '/create-intent' do intent = client.v1.payment_intents.create({ # To allow saving and retrieving payment methods, provide the Customer ID. customer: customer.id, amount: 1099, currency: 'gbp', payment_method_types: ['bacs_debit'], }) {client_secret: intent.client_secret}.to_json end ``` ## Zahlung an Stripe senden [Clientseitig] Verwenden Sie [stripe.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment), um die Zahlung mit den Angaben aus dem Payment Element abzuschließen. Geben Sie eine [return_url](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-return_url) für diese Funktion an, um anzugeben, wohin Stripe den/die Nutzer/in nach Abschluss der Zahlung weiterleitet. Ihre Nutzer/innen werden möglicherweise zunächst an eine Zwischenwebsite, z. B. eine Bankautorisierungsseite, weitergeleitet, bevor sie zur `return_url` weitergeleitet werden. Bei Kartenzahlungen erfolgt die Weiterleitung zur `return_url` sofort, wenn eine Zahlung erfolgreich ist. Wenn Sie bei Kartenzahlungen nach Abschluss der Zahlung keine Weiterleitung wünschen, können Sie [redirect](https://docs.stripe.com/js/payment_intents/confirm_payment#confirm_payment_intent-options-redirect) auf `if_required` festlegen. Dadurch werden nur Kundinnen/Kunden weitergeleitet, die mit auf Weiterleitung basierenden Zahlungsmethoden bezahlen. #### HTML + JS ```javascript const form = document.getElementById('payment-form'); const submitBtn = document.getElementById('submit'); const handleError = (error) => { const messageContainer = document.querySelector('#error-message'); messageContainer.textContent = error.message; submitBtn.disabled = false; } form.addEventListener('submit', async (event) => { // We don't want to let default form submission happen here, // which would refresh the page. event.preventDefault(); // Prevent multiple form submissions if (submitBtn.disabled) { return; } // Disable form submission while loading submitBtn.disabled = true; // Trigger form validation and wallet collection const {error: submitError} = await elements.submit(); if (submitError) { handleError(submitError); return; } // Create the PaymentIntent and obtain clientSecret const res = await fetch("/create-intent", { method: "POST", }); const {client_secret: clientSecret} = await res.json(); // Confirm the PaymentIntent using the details collected by the Payment Element const {error} = await stripe.confirmPayment({ elements, clientSecret, confirmParams: { return_url: 'https://example.com/order/123/complete', }, }); if (error) { // This point is only reached if there's an immediate error when // confirming the payment. Show the error to your customer (for example, payment details incomplete) handleError(error); } else { // Your customer is redirected to your `return_url`. For some payment // methods like iDEAL, your customer is redirected to an intermediate // site first to authorize the payment, then redirected to the `return_url`. } }); ``` #### React ```jsx import React, {useState} from 'react'; import {useStripe, useElements, PaymentElement} from '@stripe/react-stripe-js'; export default function CheckoutForm() { const stripe = useStripe(); const elements = useElements(); const [errorMessage, setErrorMessage] = useState(); const [loading, setLoading] = useState(false); const handleError = (error) => { setLoading(false); setErrorMessage(error.message); } const handleSubmit = async (event) => { // We don't want to let default form submission happen here, // which would refresh the page. event.preventDefault(); if (!stripe) { // Stripe.js hasn't yet loaded. // Make sure to disable form submission until Stripe.js has loaded. return; } setLoading(true); // Trigger form validation and wallet collection const {error: submitError} = await elements.submit(); if (submitError) { handleError(submitError); return; } // Create the PaymentIntent and obtain clientSecret const res = await fetch("/create-intent", { method: "POST", }); const {client_secret: clientSecret} = await res.json(); // Confirm the PaymentIntent using the details collected by the Payment Element const {error} = await stripe.confirmPayment({ elements, clientSecret, confirmParams: { return_url: 'https://example.com/order/123/complete', }, }); if (error) { // This point is only reached if there's an immediate error when // confirming the payment. Show the error to your customer (for example, payment details incomplete) handleError(error); } else { // Your customer is redirected to your `return_url`. For some payment // methods like iDEAL, your customer is redirected to an intermediate // site first to authorize the payment, then redirected to the `return_url`. } }; return (
{errorMessage &&
{errorMessage}
} ); } ``` ## Ereignisse nach der Zahlung verarbeiten Das BACS-Lastschriftverfahren ist eine *Zahlungsmethode mit verzögerter Benachrichtigung* (A payment method that can't immediately return payment status when a customer attempts a transaction (for example, ACH debits). Businesses commonly hold an order in a pending state until payment is successful with these payment methods), so dass Gelder nicht sofort verfügbar sind. ### Zeitpläne Mit Bacs Direct Debit kann es mehrere Geschäftstage dauern, bis Gelder in Ihrem Stripe-Guthaben verfügbar sind. Die Anzahl der Geschäftstage, bis Gelder verfügbar werden, wird als Abwicklungszeit bezeichnet. Zahlungen werden in der Regel am selben Tag eingereicht, an dem sie erstellt werden, werden jedoch am folgenden Geschäftstag verarbeitet, wenn sie an einem Nicht-Geschäftstag oder nach dem Annahmeschluss erstellt wurden. Sie können das `expected_debit_date` für Bacs Direct Debit unter [payment_method_details](https://docs.stripe.com/api/charges/object.md#charge_object-payment_method_details) für [Zahlungen](https://docs.stripe.com/api/charges/object.md) abrufen. Dies ist ein geschätztes Datum, an dem die Gelder abgebucht werden können. Diese Schätzung kann nicht garantiert werden und das tatsächliche Datum kann variieren. Diese Informationen sind in API Antworten und in Webhook-Ereignissen der [charge.updated](https://docs.stripe.com/api/events/types.md#event_types-charge.updated), [charge.succeeded](https://docs.stripe.com/api/events/types.md#event_types-charge.succeeded) und [charge.failed](https://docs.stripe.com/api/events/types.md#event_types-charge.failed) verfügbar, wenn das Abbuchungsdatum ermittelt werden kann. Die Bestätigung des Erfolgs oder Misserfolgs einer Bacs-Lastschriftzahlung dauert 4 Werktage, wenn bereits ein Mandat vorliegt. Wenn Sie ein neues Mandat einholen müssen, beträgt die Bearbeitungszeit 7 Werktage. In einigen Fällen zeigt uns die Bank möglicherweise eine fehlgeschlagene Zahlung an, nachdem die Zahlung in Ihrem Stripe-Konto bereits als erfolgreich gekennzeichnet wurde. In diesem Fall wird die fehlgeschlagene Zahlung als angefochtene Zahlung mit entsprechendem Ursachencode ausgewiesen. Die folgende Tabelle beschreibt die Abwicklungszeiten für Bacs Direct Debit-Zahlungen, die Stripe anbietet. `T+x` bezieht sich auf `x`Geschäftstage nach der Einreichung, die sich vom Datum der Zahlungserstellung unterscheiden können. | Abwicklungsart | Erfolgreiche Zahlung | Verfügbare Gelder | Ablauffrist | | ------------------ | -------------------- | ----------------- | ------------------- | | Standardabwicklung | T+3 at 21:00 UTC | T+4 at 00:00 UTC | 20:00 Europe/London | ### Webhooks einrichten Stripe sendet beim Zahlungsvorgang und nach erfolgter Zahlung mehrere Ereignisse. Verwenden Sie das [Webhook-Tool im Dashboard](https://dashboard.stripe.com/webhooks) oder befolgen Sie die [Webhook-Anleitung](https://docs.stripe.com/webhooks/quickstart.md), um diese Ereignisse zu empfangen und führen Sie Aktionen aus, wie beispielsweise das Senden einer Bestellbestätigung per E-Mail, das Protokollieren des Verkaufs in der Datenbank oder das Starten eines Versand-Workflows. Bei BACS-Lastschriftverfahren müssen Sie das Ereignis [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded) verarbeiten, um zu bestätigen, dass die Zahlung erfolgreich war. Stripe empfiehlt außerdem die Verarbeitung der Ereignisse [payment_intent.processing](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.processing) und [payment_intent.payment_failed](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.payment_failed). 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). ## Integration testen Es gibt mehrere [Testbankkontonummern](https://docs.stripe.com/keys.md#test-live-modes), die Sie 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) verwenden können. So können Sie sicherstellen, dass diese Integration bereit ist. | Bankleitzahl | Kontonummer | Beschreibung | | ------------ | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | 108800 | 00012345 | Die Zahlung ist erfolgreich und der PaymentIntent von wird von `processing` auf `succeeded` umgestellt. | | 108800 | 90012345 | Die Zahlung erfolgt innerhalb von drei Minuten und der PaymentIntent von wird von `processing` auf `succeeded` umgestellt. | | 108800 | 33333335 | Die Zahlung wird akzeptiert, schlägt dann aber unmittelbar fehl. Der Fehlercode `debit_not_authorized` wird ausgegeben und der PaymentIntent geht vom Status `wird verarbeitet` zum Status `requires_payment_method` über. Das Mandat wechselt zu `inaktiv` und die PaymentMethod kann nicht erneut verwendet werden. | | 108800 | 93333335 | Die Zahlung schlägt nach drei Minuten fehl. Der Fehlercode `debit_not_authorized` wird ausgegeben und der PaymentIntent geht vom Status `wird verarbeitet` in den Status `requires_payment_method` über. Das Mandat wechselt zu `inaktiv` und die PaymentMethod kann nicht erneut verwendet werden. | | 108800 | 22222227 | Die Zahlung schlägt fehl, die Fehlerkennung `insufficient_funds` wird ausgegeben und der PaymentIntent wird von `processing` auf `requires_payment_method` umgestellt. Das Mandat bleibt `active` und die PaymentMethod kann erneut verwendet werden. | | 108800 | 92222227 | Die Zahlung schlägt nach drei Minuten fehl, die Fehlerkennung `insufficient_funds` wird ausgegeben und der PaymentIntent wird von `processing` auf `requires_payment_method` umgestellt. Das Mandat bleibt `active` und die PaymentMethod kann erneut verwendet werden. | | 108800 | 55555559 | Die Zahlung erfolgt innerhalb von drei Minuten und der PaymentIntent wechselt von `processing` zu `succeeded`. Eine Zahlungsanfechtung wird jedoch sofort erstellt. | | 108800 | 00033333 | Die Zahlungsmethode wurde erfolgreich erstellt, das Mandat wird jedoch von der Kundenbank verweigert und sofort deaktiviert. | | 108800 | 00044444 | Die Anfrage zur Einrichtung eines BACS-Lastschriftverfahrens wird aufgrund einer ungültigen Kontonummer sofort abgelehnt. Die Kundin/der Kunde wird aufgefordert, ihre/seine Angaben vor dem Absenden zu prüfen. Zahlungsdaten werden nicht erfasst. | | 108800 | 34343434 | Die Zahlung schlägt mit dem Fehlercode `charge_exceeds_source_limit` fehl, da der Zahlungsbetrag dazu führt, dass das Konto sein wöchentliches Zahlungsvolumenlimit überschreitet. | | 108800 | 12121212 | Die Zahlung schlägt mit dem Fehlercode `charge_exceeds_weekly_limit` fehl, da der Zahlungsbetrag das Transaktionsvolumenlimit des Kontos überschreitet. | Sie können die oben aufgeführten Kontonummern nach Belieben testen. Da die Verarbeitung von Zahlungen per Bacs-Lastschriftverfahren mehrere Tage in Anspruch nimmt, verwenden Sie bitte die Testkontonummern. Bei diesen ist eine dreiminütige Verzögerung eingebaut, um tatsächliche Zahlungen möglichst exakt nachzubilden. > Standardmäßig sendet Stripe den Kundinnen und Kunden bei der erstmaligen Erfassung ihrer Zahlungsinformationen sowie bei jeder Kontobelastung automatisch [E-Mails](https://docs.stripe.com/payments/payment-methods/bacs-debit.md#debit-notifications). Diese Benachrichtigungen werden nicht in Sandboxes gesendet. ## Fehlgeschlagene Zahlungen Zahlungen können aus verschiedenen Gründen fehlschlagen. Die Ursache für einen Fehler kann über [charge.failure_code](https://docs.stripe.com/api/charges/object.md#charge_object-failure_code) abgerufen werden. Nur Zahlungen mit bestimmten Fehlercodes können erneut durchgeführt werden. Wenn eine Zahlung nicht wiederholt werden kann, empfehlen wir Ihnen, Kontakt zu den Betroffenen aufzunehmen und diese aufzufordern, die Zahlung mit einem anderen Bankkonto oder einer anderen Zahlungsmethode erneut zu tätigen. Unten finden Sie eine Liste der aktuellen Fehlercodes für das BACS-Lastschriftverfahren. Die Liste wird laufend ergänzt. Gehen Sie also beim Erstellen und Warten Ihres Codes davon aus, dass noch andere Fehlertypen existieren. | Fehlercode | Beschreibung | Wiederholbar | | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------ | | `account_closed` | Das Bankkonto wurde geschlossen. | Nein | | `bank_ownership_changed` | Das Konto wurde an einen anderen Zahlungsdienstleister übertragen. Prüfen Sie, ob Ihnen dessen Angaben vorliegen. Andernfalls müssen Sie vom betroffenen Kunden oder der betroffenen Kundin ein neues Lastschriftmandat einholen. | Nein | | `debit_not_authorized` | Die Zahlung wurde als nicht autorisiert gemeldet oder der Auszahlungsbank liegt kein entsprechendes Mandat vor. | Nein | | `generic_could_not_process` | Diese Zahlung konnte nicht abgewickelt werden. | Ja | | `insufficient_funds` | Das Kundenkonto ist für diese Zahlung nicht ausreichend gedeckt. | Ja | | `invalid_account_number` | Die Kontonummer ist ungültig. Möglicherweise bezieht sie sich auf ein Konto in einer anderen Währung als GBP oder über das Konto können keine Zahlungen per Lastschrift abgewickelt werden. | Nein | Um Zahlungen noch einmal zu versuchen, [bestätigen Sie den PaymentIntent](https://docs.stripe.com/api/payment_intents/confirm.md) erneut mit derselben *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs). Um die Erfolgsaussichten zu erhöhen, empfehlen wir vor dem erneuten Zahlungsversuch eine Kontaktaufnahme mit dem Zahler. ## Optional: Abbuchungsdatum für Kundin / Kunden konfigurieren Das Datum, an dem Stripe das Bankkonto eines Kunden/einer Kundin belastet, können Sie über das [Zieldatum](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-payment_method_options-bacs_debit-target_date) steuern. Das Zieldatum muss mindestens drei Tage in der Zukunft und nicht mehr als 15 Tage ab dem aktuellen Datum liegen. Mit dem Zieldatum wird geplant, dass das Geld das Konto des Kunden/der Kundin zum Zieldatum verlässt. Sie können einen [PaymentIntent](https://docs.stripe.com/api/payment_intents/cancel.md), der mit einem Zieldatum erstellt wurde, bis zu drei Werktage vor dem konfigurierten Datum stornieren. Wenn das Zieldatum eines der folgenden Kriterien erfüllt, wird die Abbuchung am nächsten verfügbaren Werktag durchgeführt: - Das Zieldatum fällt auf ein Wochenende, einen Feiertag oder einen anderen arbeitsfreien Tag. - Das Zieldatum liegt weniger als drei Werktage in der Zukunft. Dieser Parameter wird auf Best-Effort-Basis ausgeführt. Es kann sein, dass die Bank jedes Kunden/jeder Kundin die Abbuchungen je nach örtlichen Feiertagen oder aus anderen Gründen zu unterschiedlichen Terminen vornimmt. ## Optional: Mandatsreferenzen mit einem Präfix anpassen Sie können die Mandatsreferenzen für BACS-Lastschriften anpassen, um die Mandatsidentifikation zu vereinfachen. Geben Sie dazu den optionalen Wert `payment_method_options.bacs_debit.mandate_options.reference_prefix` an. Wir fügen das `reference_prefix` an den Anfang einer eindeutigen Sequenz an, um sicherzustellen, dass die gesamte Referenz einzigartig bleibt. Der `reference_prefix` muss folgende Anforderungen erfüllen: - Maximale Länge: 12 Zeichen - Muss mit einer Zahl oder einem Großbuchstaben beginnen - Zulässige Zeichen: - Großbuchstaben - Zahlen - Freie Zeichen - Sonderzeichen: `.`, `/`, `&`, `-`, `_` - Darf nicht mit `DDIC` oder `STRIPE` beginnen Fügen Sie jedes gewünschte Trennzeichen in das Präfix ein, da wir standardmäßig keines hinzufügen. Wir kürzen nachgestellte Leerzeichen auf maximal ein Leerzeichen. Bei einem gültigen Präfix ist der resultierende Verweis immer 18 Zeichen lang. #### Payment Intent ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d currency=gbp \ -d amount=100 \ -d "payment_method_types[]=bacs_debit" \ -d "payment_method_options[bacs_debit][mandate_options][reference_prefix]=EX4MPL3-" ``` #### Intent einrichten ```curl curl https://api.stripe.com/v1/setup_intents \ -u "<>:" \ -d "payment_method_types[]=bacs_debit" \ -d "payment_method_options[bacs_debit][mandate_options][reference_prefix]=EX4MPL3-" ``` #### Checkout-Sitzung im Zahlungsmodus ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=payment \ -d currency=gbp \ -d "line_items[0][price_data][currency]=gbp" \ -d "line_items[0][price_data][product_data][name]=Llama" \ -d "line_items[0][price_data][unit_amount]=2000" \ -d "line_items[0][quantity]=1" \ -d "payment_method_types[0]=bacs_debit" \ -d "payment_method_options[bacs_debit][mandate_options][reference_prefix]=EX4MPL3-" ``` #### Checkout-Sitzung im Einrichtungsmodus ```curl curl https://api.stripe.com/v1/checkout/sessions \ -u "<>:" \ -d mode=setup \ -d "payment_method_types[]=bacs_debit" \ -d "payment_method_options[bacs_debit][mandate_options][reference_prefix]=EX4MPL3-" ``` Die generierte Referenz sieht wie folgt aus: `EX4MPL3-19CNCI920C`. | Fehlercode | Nachricht | | ---------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `invalid_bacs_mandate_reference_prefix_format` | Der `reference_prefix` muss mindestens 12 Zeichen lang sein und darf nur aus Großbuchstaben, Ziffern, Leerzeichen oder den folgenden Sonderzeichen bestehen: `/`, `_`, `-`, `&` und `.`. Er darf nicht mit `DDIC` oder `STRIPE` beginnen. | ## See also - [PaymentIntent-Webhooks](https://docs.stripe.com/payments/payment-intents/verifying-status.md#webhooks) - [Mandate verwalten](https://docs.stripe.com/payments/payment-methods/bacs-debit.md#mandates)