# Daten zu BECS-Lastschriftverfahren in Australien für zukünftige Zahlungen speichern Mit der Setup Intents API können Sie Angaben zur Zahlungsmethode für künftige australische BECS-Lastschriftzahlungen speichern. # Elements > This is a Elements for when payment-ui is elements. View the full page at https://docs.stripe.com/payments/au-becs-debit/set-up-payment?payment-ui=elements. Verwenden Sie [Stripe Elements](https://docs.stripe.com/payments/elements.md), unsere vorkonfigurierten Nutzeroberflächenkomponenten, zum Erstellen von Zahlungsformularen zur sicheren Erfassung von Bankverbindungen, ohne die vertraulichen Daten selbst handhaben zu müssen. Mit der [Setup Intents API](https://docs.stripe.com/payments/setup-intents.md) können Sie Zahlungsinformationen für das BECS-Lastschriftverfahren vorab erfassen und den endgültigen Betrag bzw. Zahlungsdatum später festlegen. Verwenden Sie dies für: - Zahlungsmethoden in einer Wallet speichern, um zukünftige Einkäufe zu optimieren - Einziehen von Zuschlägen nach Abwicklung einer Dienstleistung - [Kostenlosen Testzeitraum für ein Abonnement starten](https://docs.stripe.com/billing/subscriptions/trials.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' ``` ## Kundinnen/Kunden erstellen oder abrufen [Serverseitig] Um ein BECS-Lastschriftkonto für zukünftige Zahlungen zu verwenden, müssen Sie 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 zuordnen. Erstellen Sie ein Customer-Objekt, wenn Ihre Kund/innen ein Konto bei Ihrem Unternehmen anlegen. Wenn Sie die ID des Customer-Objekts mit Ihrer eigenen Darstellung einer Kundin/eines Kunden verknüpfen, können Sie später die gespeicherten Angaben zur Zahlungsmethode abrufen und verwenden. Legen Sie neue Kund/innen an oder rufen Sie bestehende Kund/innen ab, um sie mit dieser Zahlung zu verknüpfen. Fügen Sie den folgenden Code auf Ihrem Server ein, um neue Kund/innen zu erstellen. ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## SetupIntent erstellen [Serverseitig] Ein [SetupIntent](https://docs.stripe.com/api/setup_intents.md) ist ein Objekt, das Ihre Absicht darstellt, die Zahlungsmethode einer Kundin/eines Kunden für zukünftige Zahlungen einzurichten. Mit dem `SetupIntent` werden die Schritte dieses Einrichtungsprozesses verfolgt. Für BECS-Lastschriftverfahren beinhaltet dies das Erfassen eines Mandats von der Kundin/dem Kunden und die Überprüfung der Gültigkeit während der Laufzeit des Mandats. Erstellen Sie einen [SetupIntent](https://docs.stripe.com/api/setup_intents.md) auf Ihrem Server, wobei die [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types) auf `au_becs_debit` festgelegt sind, und geben Sie die [ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) *des Kunden/der Kundin* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) an: #### curl ```bash curl https://api.stripe.com/v1/setup_intents \ -u <>: \ -d "payment_method_types[]"="au_becs_debit" \ -d "customer"="{{CUSTOMER_ID}}" ``` Nach Erstellen eines `SetupIntent` auf Ihrem Server können Sie die `SetupIntent`-ID im Datenmodell Ihrer Anwendung mit dem Kunden/der Kundin der aktuellen Sitzung verknüpfen. Dadurch können Sie nach erfolgreichem Erfassen einer Zahlungsmethode die Daten abrufen. Das zurückgegebene `SetupIntent`-Objekt enthält die Eigenschaft `client_secret`. Übergeben Sie das Client-Geheimnis an die Anwendung auf Client-Seite, um mit der Einrichtung fortzufahren. ## Angaben zur Zahlungsmethode und Mandatsbestätigung erfassen [Clientseitig] Sie können jetzt mit [Stripe Elements](https://docs.stripe.com/payments/elements.md) Zahlungsinformationen auf dem Client erfassen. Elements beinhaltet vorgefertigte Komponenten der Nutzeroberfläche zur Erfassung von Zahlungsdetails. Ein Stripe Element enthält ein iframe, dass die Zahlungsdaten über eine HTTPS-Verbindung sicher an Stripe sendet. Die Adresse der Bezahlseite muss ebenfalls mit https:// beginnen, nicht mit http://, damit Ihre Integration funktioniert. Sie können Ihre Integration ohne HTTPS testen. Dann müssen Sie das Protokoll aber [aktivieren](https://docs.stripe.com/security/guide.md#tls), bevor Sie Ihre ersten Live-Zahlungen empfangen. ### Stripe Elements einrichten #### HTML + JS Stripe Elements ist ein Feature von Stripe.js und steht damit automatisch zur Verfügung. Fügen Sie das Stripe.js-Skript auf Ihrer Zahlungsseite ein, indem Sie es in den `head` Ihrer HTML-Datei einbinden. Laden Sie Stripe.js immer direkt von js.stripe.com, um die PCI-Compliance zu gewährleisten. Fügen Sie das Skript nicht in ein Bundle ein und hosten Sie selbst keine Kopie davon. ```html Payment Setup ``` Erstellen Sie auf Ihrer Zahlungsseite mit dem folgenden JavaScript eine Instanz von [Elements](https://docs.stripe.com/js.md#stripe-elements): ```javascript const stripe = Stripe('<>'); const elements = stripe.elements(); ``` ### Lastschriftanfragen Bevor Sie eine BECS-Lastschriftzahlung erstellen können, muss Ihr/e Kund/in der Dienstleistungsvereinbarung zu Lastschriftenanfragen zustimmen. Dies können sie tun, indem sie eine ausgefüllte Lastschriftanfrage (DDR) einreichen. Durch die Genehmigung erhalten Sie ein Mandat, sein/ihr Konto zu belasten. Das `Mandate` ist eine Aufzeichnung der Zustimmung, Zahlungen über eine Zahlungsmethode einzuziehen. Für die Mandatsannahme online können Sie ein Formular erstellen, um die erforderlichen Informationen einzuholen. Stellen Sie das Formular über [HTTPS](https://docs.stripe.com/security/guide.md#tls) bereit und erfassen Sie die folgenden Informationen: | Informationen | Beschreibung | | --------------- | ------------------------------------------------------------------- | | **Kontoname** | Der vollständige Name des Kontoinhabers/der Kontoinhaberin | | **BSB-Nummer** | Die Zweigniederlassungsnummer des Bankkontos (z. B. `123-456`) | | **Kontonummer** | Die Bankkontonummer (z. B. `87654321`). | Bei Einzug einer Lastschriftanforderung befolgen Sie unsere [BECS-Lastschriftbedingungen](https://stripe.com/au-becs/legal) und tun Sie im Rahmen Ihres Bezahlformulars Folgendes: - Zeigen Sie die genauen Bedingungen der [Stripe-Dienstleistungsvereinbarung zu Lastschriftenanfragen](https://stripe.com/au-becs-dd-service-agreement/legal) entweder inline im Formular oder auf einer im Formular verlinkten Seite an und kennzeichnen Sie diese als „Dienstleistungsvereinbarung zu Lastschriftanfragen“. - Stellen Sie sicher, dass die akzeptierten Lastschriftanfragen und die dazugehörige [Dienstleistungsvereinbarung zu Lastschriftenanfragen](https://stripe.com/au-becs-dd-service-agreement/legal) zu jeder Zeit mit Ihren Kundinnen/Kunden geteilt werden kann, entweder als gedruckte oder unveränderliche elektronische Kopie (z. B. E-Mail). Stripe hostet dies für Sie. - Zeigen Sie den folgenden Standard-Autorisierungstext für Ihre Kund/innen an, um BECS-Lastschriftanfragen zu akzeptieren. Ersetzen Sie *Rocketship Inc* durch den Namen Ihres Unternehmens. Dadurch sind Sie berechtigt, Zahlungen mit BECS-Lastschrift vom Bankkonto Ihrer Kund/innen zu veranlassen. > Mit der Angabe Ihrer Bankdaten erklären Sie sich mit dieser Lastschriftanforderung und der [Dienstleistungsvereinbarung Lastschriftverfahren](https://stripe.com/au-becs-dd-service-agreement/legal) einverstanden und autorisieren Stripe Payments Australia Pty Ltd ACN 160 180 343, Lastschriftverfahren-Nutzer-ID 507156 („Stripe“), Ihr Konto über das Bulk Electronic Clearing System (BECS) im Namen von *Rocketship Inc* (dem „Händler“) für Zahlungen gemäß den Bedingungen Ihrer Vereinbarung mit dem Händler/der Händlerin zu belasten. Sie bestätigen, dass Sie entweder Kontoinhaber oder Zeichnungsberechtigter des oben genannten Kontos sind. Die Details des akzeptierten Mandats werden beim Einrichten einer [PaymentMethod](https://docs.stripe.com/payments/payment-methods.md) oder beim Bestätigen eines `PaymentIntent` generiert. Sie sollten jederzeit in der Lage sein, dieses Mandat – die akzeptierten Lastschriftanfragen und die dazugehörige Dienstleistungsvereinbarung – entweder in gedruckter Form oder als unveränderliche elektronische Kopie (z. B. per E-Mail) mit Ihren Kundinnen/Kunden zu teilen. Stripe hostet dies für Sie unter der `url`-Eigenschaft des `Mandate`-Objekts, das mit der `PaymentMethod` verknüpft ist. ### Australisches Bankkontoelement hinzufügen und konfigurieren Das australische Bankkontoelement hilft Ihnen beim Einziehen und Validieren der BSB-Nummer und der Kontonummer. Stellen Sie sicher, dass es in Ihrem Zahlungsformular erscheint. Erstellen Sie in Ihrem Zahlungsformular leere DOM-Knoten (Container) mit einmaligen IDs. Außerdem müssen Ihre Kund/innen die [Nutzungsvereinbarung für Lastschriftanforderungen](https://stripe.com/au-becs-dd-service-agreement/legal) lesen und akzeptieren. #### HTML ```html
By providing your bank account details, you agree to this Direct Debit Request and the Direct Debit Request service agreement, and authorise Stripe Payments Australia Pty Ltd ACN 160 180 343 Direct Debit User ID number 507156 (“Stripe”) to debit your account through the Bulk Electronic Clearing System (BECS) on behalf ofRocket Rides(the "Merchant") for any amounts separately communicated to you by the Merchant. You certify that you are either an account holder or an authorised signatory on the account listed above.
``` Wenn das Formular geladen wurde, [erstellen Sie eine Instanz](https://docs.stripe.com/js/elements_object/create_element?type=au_bank_account) des Australia Bank Account Element und verbinden sie mit dem Element-Container: ```javascript // Custom styling can be passed to options when creating an Element const style = { base: { color: '#32325d', fontSize: '16px', '::placeholder': { color: '#aab7c4' }, ':-webkit-autofill': { color: '#32325d', }, }, invalid: { color: '#fa755a', iconColor: '#fa755a', ':-webkit-autofill': { color: '#fa755a', }, } }; const options = { style: style, disabled: false, hideIcon: false, iconStyle: "default", // or "solid" } // Create an instance of the auBankAccount Element. const auBankAccount = elements.create('auBankAccount', options); // Add an instance of the auBankAccount Element into // the `au-bank-account-element`
. auBankAccount.mount('#au-bank-account-element'); ``` #### React #### npm 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 ``` #### umd Wir stellen auch einen UMD-Build für Websites zur Verfügung, die weder npm noch Module verwenden. Binden Sie das Skript Stripe.js ein, das eine globale `Stripe`-Funktion exportiert, und den UMD-Build von React Stripe.js, der ein globales `ReactStripe`-Objekt exportiert. Laden Sie das Skript Stripe.js immer direkt von **js.stripe.com**, um PCI-konform zu bleiben. Fügen Sie das Skript nicht in ein Bundle ein, oder hosten Sie nicht selbst eine Kopie davon. ```html ``` > Mit der [Demo in CodeSandbox](https://codesandbox.io/s/react-stripe-official-q1loc?fontsize=14&hidenavigation=1&theme=dark) können Sie React Stripe.js ausprobieren, ohne ein neues Projekt erstellen zu müssen. ### Stripe.js und Elements zu Ihrer Seite hinzufügen Um Element-Komponenten 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. ```jsx import React from 'react'; import ReactDOM from 'react-dom'; import {Elements} from '@stripe/react-stripe-js'; import {loadStripe} from '@stripe/stripe-js'; import PaymentSetupForm from './PaymentSetupForm'; // 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() { return ( ); }; ReactDOM.render(, document.getElementById('root')); ``` ### Lastschriftanfragen Bevor Sie eine BECS-Lastschriftzahlung erstellen können, muss Ihr/e Kund/in der Dienstleistungsvereinbarung zu Lastschriftenanfragen zustimmen. Dies können sie tun, indem sie eine ausgefüllte Lastschriftanfrage (DDR) einreichen. Durch die Genehmigung erhalten Sie ein Mandat, sein/ihr Konto zu belasten. Das `Mandate` ist eine Aufzeichnung der Zustimmung, Zahlungen über eine Zahlungsmethode einzuziehen. Für die Mandatsannahme online können Sie ein Formular erstellen, um die erforderlichen Informationen einzuholen. Stellen Sie das Formular über [HTTPS](https://docs.stripe.com/security/guide.md#tls) bereit und erfassen Sie die folgenden Informationen: | Informationen | Beschreibung | | --------------- | ------------------------------------------------------------------- | | **Kontoname** | Der vollständige Name des Kontoinhabers/der Kontoinhaberin | | **BSB-Nummer** | Die Zweigniederlassungsnummer des Bankkontos (z. B. `123-456`) | | **Kontonummer** | Die Bankkontonummer (z. B. `87654321`). | Bei Einzug einer Lastschriftanforderung befolgen Sie unsere [BECS-Lastschriftbedingungen](https://stripe.com/au-becs/legal) und tun Sie im Rahmen Ihres Bezahlformulars Folgendes: - Zeigen Sie die genauen Bedingungen der [Stripe-Dienstleistungsvereinbarung zu Lastschriftenanfragen](https://stripe.com/au-becs-dd-service-agreement/legal) entweder inline im Formular oder auf einer im Formular verlinkten Seite an und kennzeichnen Sie diese als „Dienstleistungsvereinbarung zu Lastschriftanfragen“. - Stellen Sie sicher, dass die akzeptierten Lastschriftanfragen und die dazugehörige [Dienstleistungsvereinbarung zu Lastschriftenanfragen](https://stripe.com/au-becs-dd-service-agreement/legal) zu jeder Zeit mit Ihren Kundinnen/Kunden geteilt werden kann, entweder als gedruckte oder unveränderliche elektronische Kopie (z. B. E-Mail). Stripe hostet dies für Sie. - Zeigen Sie den folgenden Standard-Autorisierungstext für Ihre Kund/innen an, um BECS-Lastschriftanfragen zu akzeptieren. Ersetzen Sie *Rocketship Inc* durch den Namen Ihres Unternehmens. Dadurch sind Sie berechtigt, Zahlungen mit BECS-Lastschrift vom Bankkonto Ihrer Kund/innen zu veranlassen. > Mit der Angabe Ihrer Bankdaten erklären Sie sich mit dieser Lastschriftanforderung und der [Dienstleistungsvereinbarung Lastschriftverfahren](https://stripe.com/au-becs-dd-service-agreement/legal) einverstanden und autorisieren Stripe Payments Australia Pty Ltd ACN 160 180 343, Lastschriftverfahren-Nutzer-ID 507156 („Stripe“), Ihr Konto über das Bulk Electronic Clearing System (BECS) im Namen von *Rocketship Inc* (dem „Händler“) für Zahlungen gemäß den Bedingungen Ihrer Vereinbarung mit dem Händler/der Händlerin zu belasten. Sie bestätigen, dass Sie entweder Kontoinhaber oder Zeichnungsberechtigter des oben genannten Kontos sind. Die Details des akzeptierten Mandats werden beim Einrichten einer [PaymentMethod](https://docs.stripe.com/payments/payment-methods.md) oder beim Bestätigen eines `PaymentIntent` generiert. Sie sollten jederzeit in der Lage sein, dieses Mandat – die akzeptierten Lastschriftanfragen und die dazugehörige Dienstleistungsvereinbarung – entweder in gedruckter Form oder als unveränderliche elektronische Kopie (z. B. per E-Mail) mit Ihren Kundinnen/Kunden zu teilen. Stripe hostet dies für Sie unter der `url`-Eigenschaft des `Mandate`-Objekts, das mit der `PaymentMethod` verknüpft ist. ### AuBankAccountElement-Komponente hinzufügen und konfigurieren Das `AuBankAccountElement` hilft Ihnen beim Einziehen und Validieren der BSB-Nummer und der Kontonummer. Außerdem müssen Ihre Kund/innen die [Nutzungsvereinbarung für Lastschriftanforderungen](https://stripe.com/au-becs-dd-service-agreement/legal) lesen und akzeptieren. #### JSX ```jsx /** * Use the CSS tab above to style your Element's container. */ import React from 'react'; import {AuBankAccountElement} from '@stripe/react-stripe-js'; import './BecsFormStyles.css' // Custom styling can be passed as options when creating an Element. const AU_BANK_ACCOUNT_STYLE = { base: { color: '#32325d', fontSize: '16px', '::placeholder': { color: '#aab7c4' }, ':-webkit-autofill': { color: '#32325d', }, }, invalid: { color: '#fa755a', iconColor: '#fa755a', ':-webkit-autofill': { color: '#fa755a', }, } }; const AU_BANK_ACCOUNT_ELEMENT_OPTIONS = { style: AU_BANK_ACCOUNT_STYLE, disabled: false, hideIcon: false, iconStyle: "default", // or "solid" }; export default function BecsForm({onSubmit, disabled}) { return (
{/* Display mandate acceptance text. */}
By providing your bank account details, you agree to this Direct Debit Request and the Direct Debit Request service agreement, and authorise Stripe Payments Australia Pty Ltd ACN 160 180 343 Direct Debit User ID number 507156 (“Stripe”) to debit your account through the Bulk Electronic Clearing System (BECS) on behalf ofRocket Rides(the "Merchant") for any amounts separately communicated to you by the Merchant. You certify that you are either an account holder or an authorised signatory on the account listed above.
``` Elements sind vollständig anpassbar. Sie können [Elements so konfigurieren](https://docs.stripe.com/js/elements_object/create_element?type=au_bank_account#elements_create-options), dass sie zum Erscheinungsbild Ihrer Website passen und den Bezahlvorgang für Ihre Kundinnen/Kunden weiter optimieren. Außerdem lassen sich verschiedene Eingabestatus konfigurieren, sodass z. B. sichtbar wird, wann der Fokus auf dem Element liegt. ## Angaben zur Zahlungsmethode an Stripe senden [Clientseitig] Anstatt das gesamte `SetupIntent`-Objekt an den Client zu senden, verwenden Sie dessen [Client-Geheimnis](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-client_secret) aus [Schritt 2](https://docs.stripe.com/payments/au-becs-debit/set-up-payment.md#web-create-setup-intent). Dieses unterscheidet sich von Ihren API-Schlüsseln, mit denen Anfragen der Stripe-API authentifiziert werden. Achten Sie auf einen vorsichtigen Umgang mit dem Client-Geheimnis, da mit ihm die Einrichtung abgeschlossen werden kann. Es darf nicht protokolliert, in URLs eingebettet oder Personen außer den Kund/innen selbst zugänglich gemacht werden. #### HTML + JS Verwenden Sie [stripe.confirmAuBecsDebitSetup](https://docs.stripe.com/js/setup_intents/confirm_au_becs_debit_setup), damit die Einrichtung abgeschlossen werden kann, wenn der/die Nutzer/in das Formular absendet. War die Einrichtung erfolgreich, wird der Wert `succeeded` für die Eigenschaft `status` des SetupIntent zurückgegeben. War die Einrichtung nicht erfolgreich, prüfen Sie den angegebenen `error`, um den Grund zu erfahren. Da [der Kunde/die Kundin](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-customer) festgelegt ist, wird die *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) nach erfolgreicher Einrichtung dem angegebenen `Customer`-Objekt zugeordnet. Nun können Sie die ID des `Customer`-Objekts mit Ihrer eigenen, internen Darstellung eines Kunden/einer Kundin verknüpfen. Dadurch können Sie die gespeicherte `PaymentMethod` verwenden, um zukünftige Zahlungen einzuziehen, ohne die Kundinnen/Kunden zur Angabe der Zahlungsmethode auffordern zu müssen. ```javascript const form = document.getElementById('setup-form'); const accountholderName = document.getElementById('accountholder-name'); const email = document.getElementById('email'); const submitButton = document.getElementById('submit-button'); const clientSecret = submitButton.dataset.secret; form.addEventListener('submit', async (event) => { event.preventDefault(); stripe.confirmAuBecsDebitSetup( clientSecret, { payment_method: { au_becs_debit: auBankAccount, billing_details: { name: accountholderName.value, email: email.value } } } ); }); ``` Teilen Sie nach Bestätigung des `SetupIntent` die [Mandats-URL](https://docs.stripe.com/api/mandates/object.md#mandate_object-payment_method_details-au_becs_debit-url) aus dem [Mandats-Objekt](https://docs.stripe.com/api/mandates.md) mit Ihrem Kunden/Ihrer Kundin. Wir empfehlen außerdem, die folgenden Details hinzuzufügen, wenn Sie bestätigen, dass sein/ihr Mandat eingerichtet wurde. - Eine eindeutige Bestätigungsnachricht über die Einrichtung des Lastschriftverfahrens - Der [Name des Unternehmens](https://docs.stripe.com/payments/au-becs-debit/set-up-payment.md#statement-descriptors), der auf den Kontoauszügen von Kund/innen angezeigt wird, wenn ihr Konto belastet wird - Der Zahlungsbetrag und der Zahlungsplan (falls zutreffend) - Ein Link zur generierten Mandats-URL für Lastschriftanfragen Sie können vom `mandate` für das SetupIntent-Objekt aus auf die ID des `Mandate`-Objekts zugreifen, das nach Bestätigung zusammen mit dem Ereignis `setup_intent.succeeded` gesendet wird. Oder Sie können sie [über die API abrufen](https://docs.stripe.com/api/setup_intents/retrieve.md). ```curl curl -G https://api.stripe.com/v1/setup_intents/{{SETUP_INTENT_ID}} \ -u "<>:" \ -d "expand[]"=mandate ``` #### React Verwenden Sie [stripe.confirmAuBecsDebitSetup](https://docs.stripe.com/js/setup_intents/confirm_au_becs_debit_setup), um die Mandatseinholung abzuschließen, wenn das Formular nutzerseitig eingereicht wird. Die Angabe von Kundenname und E-Mail-Adresse in der Eigenschaft `billing_details` des Parameters `payment_method` ist für die Erstellung der `PaymentMethod` BECS-Lastschriftverfahren erforderlich. Verwenden Sie die Hooks [useStripe](https://docs.stripe.com/sdks/stripejs-react.md#usestripe-hook) und [useElements](https://docs.stripe.com/sdks/stripejs-react.md#useelements-hook), um `stripe.confirmAuBecsDebitSetup` über die Komponente Ihres Zahlungsformulars aufzurufen. Wenn Sie herkömmliche Klassenkomponenten gegenüber Hooks bevorzugen, können Sie stattdessen einen [ElementsConsumer](https://docs.stripe.com/sdks/stripejs-react.md#elements-consumer) verwenden. #### Hooks ```jsx import React from 'react'; import {useStripe, useElements, AuBankAccountElement} from '@stripe/react-stripe-js'; import BecsForm from './BecsForm'; export default function PaymentSetupForm() { const stripe = useStripe(); const elements = useElements(); const handleSubmit = async (event) => { // We don't want to let default form submission happen here, // which would refresh the page. event.preventDefault(); if (!stripe || !elements) { // Stripe.js hasn't yet loaded. // Make sure to disable form submission until Stripe.js has loaded. return; } const auBankAccount = elements.getElement(AuBankAccountElement); // For brevity, this example is using uncontrolled components for // the accountholder's name and email. In a real world app you will // probably want to use controlled components. // https://reactjs.org/docs/uncontrolled-components.html // https://reactjs.org/docs/forms.html#controlled-components const accountholderName = event.target['accountholder-name']; const email = event.target.email; const result = await stripe.confirmAuBecsDebitSetup('{{CLIENT_SECRET}}', { payment_method: { au_becs_debit: auBankAccount, billing_details: { name: accountholderName.value, email: email.value, }, } }); if (result.error) { // Show error to your customer. console.log(result.error.message); } else { // Show a confirmation message to your customer. // The SetupIntent is in the 'succeeded' state. } }; return ( ); } ``` #### Klassenkomponenten ```jsx import React from 'react'; import {ElementsConsumer, AuBankAccountElement} from '@stripe/react-stripe-js'; import BecsForm from './BecsForm'; class PaymentSetupForm extends React.Component { handleSubmit = async (event) => { // We don't want to let default form submission happen here, // which would refresh the page. event.preventDefault(); const {stripe, elements} = this.props; if (!stripe || !elements) { // Stripe.js hasn't yet loaded. // Make sure to disable form submission until Stripe.js has loaded. return; } const auBankAccount = elements.getElement(AuBankAccountElement); // For brevity, this example is using uncontrolled components for // the accountholder's name and email. In a real world app you will // probably want to use controlled components. // https://reactjs.org/docs/uncontrolled-components.html // https://reactjs.org/docs/forms.html#controlled-components const accountholderName = event.target['accountholder-name']; const email = event.target.email; const result = await stripe.confirmAuBecsDebitSetup('{{CLIENT_SECRET}}', { payment_method: { au_becs_debit: auBankAccount, billing_details: { name: accountholderName.value, email: email.value, }, } }); if (result.error) { // Show error to your customer. console.log(result.error.message); } else { // Show a confirmation message to your customer. // The SetupIntent is in the 'succeeded' state. } }; render() { const {stripe} = this.props; return ( ); } } export default function InjectedPaymentSetupForm() { return ( {({stripe, elements}) => ( )} ); } ``` Teilen Sie nach Bestätigung des `SetupIntent` die [Mandats-URL](https://docs.stripe.com/api/mandates/object.md#mandate_object-payment_method_details-au_becs_debit-url) aus dem [Mandats-Objekt](https://docs.stripe.com/api/mandates.md) mit Ihrem Kunden/Ihrer Kundin. Wir empfehlen außerdem, die folgenden Details hinzuzufügen, wenn Sie bestätigen, dass sein/ihr Mandat eingerichtet wurde. - Eine eindeutige Bestätigungsnachricht über die Einrichtung des Lastschriftverfahrens - Der [Name des Unternehmens](https://docs.stripe.com/payments/au-becs-debit/set-up-payment.md#statement-descriptors), der auf den Kontoauszügen von Kund/innen angezeigt wird, wenn ihr Konto belastet wird - Der Zahlungsbetrag und der Zahlungsplan (falls zutreffend) - Ein Link zur generierten Mandats-URL für Lastschriftanfragen Sie können vom `mandate` für das SetupIntent-Objekt aus auf die ID des `Mandate`-Objekts zugreifen, das nach Bestätigung zusammen mit dem Ereignis `setup_intent.succeeded` gesendet wird. Oder Sie können sie [über die API abrufen](https://docs.stripe.com/api/setup_intents/retrieve.md). ```curl curl -G https://api.stripe.com/v1/setup_intents/{{SETUP_INTENT_ID}} \ -u "<>:" \ -d "expand[]"=mandate ``` ## Integration testen Sie können Ihr Formular mit der BSB-Nummer `000000` und einer der unten aufgeführten Kontonummern testen, wenn Sie [confirmAuBecsDebitSetup](https://docs.stripe.com/js/setup_intents/confirm_au_becs_debit_setup) anfordern. | BSB-Nummer | Kontonummer | Beschreibung | | ---------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000000` | `000123456` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `succeeded`. Der Mandatsstatus bleibt `active`. | | `000000` | `900123456` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `succeeded` (mit einer Verzögerung von drei Minuten). Der Mandatsstatus bleibt `active`. | | `000000` | `111111113` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `account_closed`. Der Mandatsstatus ändert sich an dieser Stelle in `inactive`. | | `000000` | `111111116` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `no_account`. Der Mandatsstatus ändert sich an dieser Stelle in `inactive`. | | `000000` | `222222227` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `refer_to_customer`. Der Mandatsstatus bleibt `active`. | | `000000` | `922222227` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `refer_to_customer` (mit einer Verzögerung von drei Minuten). Der Mandatsstatus bleibt `active`. | | `000000` | `333333335` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `debit_not_authorized`. Der Mandatsstatus ändert sich an dieser Stelle in `inactive`. | | `000000` | `666666660` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `succeeded`. Eine Zahlungsanfechtung wird jedoch sofort erstellt. | | `000000` | `343434343` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent schlägt mit dem Fehler `charge_exceeds_source_limit` fehl, da der Zahlungsbetrag dazu führt, dass das Konto sein wöchentliches Limit für das Zahlungsvolumen überschreitet. | | `000000` | `121212121` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent schlägt mit dem Fehler `charge_exceeds_transaction_limit` fehl, da der Zahlungsbetrag das Transaktionsvolumenlimit des Kontos überschreitet. | ## Optional: Australisches Bankkontoelement validieren [Clientseitig] Das australische Bankkontoelement validiert Nutzereingaben bereits bei der Eingabe. Achten Sie auf Change-Ereignisse am australischen Bankkontoelement und zeigen Sie etwaige Fehler an, um Ihren Kund/innen die Fehlerkorrektur zu erleichtern: #### HTML + JS ```javascript auBankAccount.on('change', (event) => { const displayError = document.getElementById('error-message'); if (event.error) { displayError.textContent = event.error.message; } else { displayError.textContent = ''; } }); ``` #### React ```jsx { if (event.error) { // Store event.error.message in state and display it. } else { // Remove existing error from state. } }}> ``` Das Change-Ereignis umfasst zusätzliche Parameter, mit denen Sie die Nutzererfahrung weiter optimieren können. Weitere Informationen finden Sie in der [Dokumentation zu Stripe.js](https://docs.stripe.com/js/element/events/on_change?type=auBankAccountElement#element_on_change-handler). ## Optional: Künftige Zahlungen annehmen [Clientseitig] Ist der SetupIntent erfolgreich, werden eine neue *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) und ein [Mandatsobjekt](https://docs.stripe.com/api/mandates.md) erstellt. Damit können künftige Zahlungen eingeleitet werden, ohne dass zusätzliche Daten von den Kundinnen/Kunden abgefragt werden müssen. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1000 \ -d currency=aud \ -d "payment_method_types[]"=au_becs_debit \ -d customer="{{CUSTOMER_ID}}" \ -d payment_method="{{PAYMENTMETHOD_ID}}" \ -d confirm=true ``` # iOS > This is a iOS for when payment-ui is mobile and platform is ios. View the full page at https://docs.stripe.com/payments/au-becs-debit/set-up-payment?payment-ui=mobile&platform=ios. Mit STPAUBECSFormView, der vorkonfigurierten Stripe-Nutzeroberfläche zur Erfassung von BECS-Lastschriftdaten, können Sie Zahlungsformulare zur sicheren Erfassung von Bankverbindungen erstellen, ohne vertrauliche Kundendaten selbst handhaben zu müssen. Mit der [Setup Intents API](https://docs.stripe.com/payments/setup-intents.md) können Sie Zahlungsinformationen für das BECS-Lastschriftverfahren vorab erfassen und den endgültigen Betrag bzw. Zahlungsdatum später festlegen. Verwenden Sie dies für: - Zahlungsmethoden in einer Wallet speichern, um zukünftige Einkäufe zu optimieren - Einziehen von Zuschlägen nach Abwicklung einer Dienstleistung - [Kostenlosen Testzeitraum für ein Abonnement starten](https://docs.stripe.com/billing/subscriptions/trials.md) ## Stripe einrichten [Serverseitig] [Clientseitig] Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register). ### Serverseitig Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie die offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus: #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` ### Clientseitig Das [Stripe iOS SDK](https://github.com/stripe/stripe-ios) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-ios/index.html) und kompatibel mit Apps, die iOS 13 oder höher unterstützen. #### Swift Package Manager Führen Sie zur Installation des SDK die folgenden Schritte aus: 1. Wählen Sie in Xcode **Datei** > **Add Package Dependencies** (Paketabhängigkeiten hinzufügen) aus und geben Sie als Repository-URL `https://github.com/stripe/stripe-ios-spm` ein. 1. Wählen auf unserer [Veröffentlichungsseite](https://github.com/stripe/stripe-ios/releases) die neueste Version aus. 1. Fügen Sie das Produkt **StripePaymentsUI** zum [Ziel Ihrer App](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) hinzu. #### CocoaPods 1. Falls noch nicht geschehen, installieren Sie bitte die aktuellste Version von [CocoaPods](https://guides.cocoapods.org/using/getting-started.html). 1. Wenn Sie keine bestehende [Podfile](https://guides.cocoapods.org/syntax/podfile.html) haben, führen Sie folgenden Befehl aus, um eine zu erstellen: ```bash pod init ``` 1. Fügen Sie folgende Zeile in Ihre `Podfile` ein: ```podfile pod 'StripePaymentsUI' ``` 1. Führen Sie folgenden Befehl aus: ```bash pod install ``` 1. Vergessen Sie nicht, ab jetzt in Zukunft anstelle der Datei `.xcodeproj` die Datei `.xcworkspace` zum Öffnen Ihres Projekts in Xcode zu verwenden. 1. Führen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK Folgendes aus: ```bash pod update StripePaymentsUI ``` #### Carthage 1. Falls noch nicht geschehen, installieren Sie bitte die aktuelle Version von [Carthage](https://github.com/Carthage/Carthage#installing-carthage). 1. Fügen Sie folgende Zeile in Ihre `Cartfile` ein: ```cartfile github "stripe/stripe-ios" ``` 1. Befolgen Sie die [Carthage-Installationsanweisungen](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Vergewissern Sie sich, dass Sie alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking) aufgeführten erforderlichen Frameworks einbetten. 1. Führen Sie für zukünftige Updates auf die aktuelle Version unseres SDK einfach folgenden Befehl aus: ```bash carthage update stripe-ios --platform ios ``` #### Manuelles Framework 1. Gehen Sie auf unsere [GitHub-Release-Seite](https://github.com/stripe/stripe-ios/releases/latest), laden Sie **Stripe.xcframework.zip** herunter und entpacken Sie die Datei. 1. Ziehen Sie **StripePaymentsUI.xcframework** in den Abschnitt **Embedded Binaries** (Eingebettete Binärdateien) der Einstellungen unter **General** (Allgemeines) Ihres Xcode-Projekts. Aktivieren Sie dabei die Option **Copy items if needed** (Elemente kopieren, falls nötig). 1. Wiederholen Sie Schritt 2 für alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentsUI/README.md#manual-linking) aufgeführten erforderlichen Frameworks. 1. Wiederholen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK die Schritte 1–3. > Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-ios/releases) auf GitHub. Um bei Veröffentlichung einer neuen Version eine Benachrichtigung zu erhalten, [achten Sie auf die Releases zum jeweiligen Repository](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository). Konfigurieren Sie das SDK mit Ihrem [veröffentlichbaren Schlüssel](https://dashboard.stripe.com/test/apikeys) von Stripe, um es beim Start der App auszuführen. Dadurch kann Ihre App Anfragen an die Stripe-API senden. #### Swift ```swift import UIKitimportStripePaymentsUI @main class AppDelegate: UIResponder, UIApplicationDelegate { func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {StripeAPI.defaultPublishableKey = "<>" // do any other necessary launch configuration return true } } ``` > Verwenden Sie Ihre [Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App. ## Kundinnen/Kunden erstellen oder abrufen [Serverseitig] Um ein BECS-Lastschriftkonto für zukünftige Zahlungen zu verwenden, müssen Sie 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 zuordnen. Erstellen Sie ein Customer-Objekt, wenn Ihre Kund/innen ein Konto bei Ihrem Unternehmen anlegen. Wenn Sie die ID des Customer-Objekts mit Ihrer eigenen Darstellung einer Kundin/eines Kunden verknüpfen, können Sie später die gespeicherten Angaben zur Zahlungsmethode abrufen und verwenden. Legen Sie neue Kund/innen an oder rufen Sie bestehende Kund/innen ab, um sie mit dieser Zahlung zu verknüpfen. Fügen Sie den folgenden Code auf Ihrem Server ein, um neue Kund/innen zu erstellen. ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## Angaben zur Zahlungsmethode und Mandatsbestätigung erfassen [Clientseitig] Mit der im SDK enthaltenen frei verwendbaren UI-Komponente [STPAUBECSFormView](https://stripe.dev/stripe-ios/stripe-payments-ui/Classes/STPAUBECSDebitFormView.html) können Sie Zahlungsdaten zum BECS-Lastschriftverfahren sicher erfassen. `STPAUBECSFormView​` erstellt eine Nutzeroberfläche, in die die Kundinnen/Kunden Name, E-Mail-Adresse, BSB-Nummer und Kontonummer eingeben können. Zudem zeigt sie die [Bedingungen des BECS-Lastschriftverfahrens](https://stripe.com/au-becs/legal) an. Erstellen Sie eine mit Ihrem Unternehmensnamen konfigurierte Instanz von `STPAUBECSFormView` und richten Sie eine Delegation für das SDK ein, um eine Nachricht zu erhalten, nachdem der/die Kund/in die erforderlichen Details eingegeben hat, um eine Instanz von `STPPaymentMethodParams` zu erstellen. Sie können `STPAUBECSFormView` auch an das Erscheinungsbild Ihrer Anwendung anpassen, indem Sie den öffentlichen Eigenschaften von `STPAUBECSFormView` Werte hinzufügen. #### Swift ```swift import UIKit import StripePaymentsUI class CheckoutViewController: UIViewController { private var becsFormView = STPAUBECSDebitFormView(companyName: "Example Company Inc.") private let saveButton = UIButton() private var setupIntentClientSecret: String? override func viewDidLoad() { super.viewDidLoad() view.backgroundColor = .secondarySystemBackground saveButton.layer.cornerRadius = 5 saveButton.contentEdgeInsets = UIEdgeInsets(top: 4, left: 8, bottom: 4, right: 8) saveButton.backgroundColor = .systemGray3 saveButton.titleLabel?.font = UIFont.systemFont(ofSize: 18) saveButton.setTitle("Save", for: .normal) saveButton.addTarget(self, action: #selector(save), for: .touchUpInside) saveButton.isEnabled = false saveButton.translatesAutoresizingMaskIntoConstraints = false view.addSubview(saveButton) becsFormView.becsDebitFormDelegate = self becsFormView.translatesAutoresizingMaskIntoConstraints = false view.addSubview(becsFormView) NSLayoutConstraint.activate([ becsFormView.leadingAnchor.constraint(equalTo: view.leadingAnchor), view.trailingAnchor.constraint(equalTo: becsFormView.trailingAnchor), becsFormView.topAnchor.constraint(equalToSystemSpacingBelow: view.safeAreaLayoutGuide.topAnchor, multiplier: 2), saveButton.centerXAnchor.constraint(equalTo: view.centerXAnchor), saveButton.topAnchor.constraint(equalToSystemSpacingBelow: becsFormView.bottomAnchor, multiplier: 2), ]) } @objc func save() { // ... } } extension CheckoutViewController: STPAUBECSDebitFormViewDelegate { func auBECSDebitForm(_ form: STPAUBECSDebitFormView, didChangeToStateComplete complete: Bool) { saveButton.isEnabled = complete saveButton.backgroundColor = complete ? .systemBlue : .systemGray3 } } ``` ## SetupIntent erstellen [Serverseitig] Ein [SetupIntent](https://docs.stripe.com/api/setup_intents.md) ist ein Objekt, das Ihre Absicht darstellt, die Zahlungsmethode einer Kundin/eines Kunden für zukünftige Zahlungen einzurichten. Mit dem `SetupIntent` werden die Schritte dieses Einrichtungsprozesses verfolgt. Für BECS-Lastschriftverfahren beinhaltet dies das Erfassen eines Mandats von der Kundin/dem Kunden und die Überprüfung der Gültigkeit während der Laufzeit des Mandats. Erstellen Sie einen [SetupIntent](https://docs.stripe.com/api/setup_intents.md) auf Ihrem Server, wobei die [payment_method_types](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-payment_method_types) auf `au_becs_debit` festgelegt sind, und geben Sie die [ID](https://docs.stripe.com/api/customers/object.md#customer_object-id) *des Kunden/der Kundin* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) an: #### curl ```bash curl https://api.stripe.com/v1/setup_intents \ -u <>: \ -d "payment_method_types[]"="au_becs_debit" \ -d "customer"="{{CUSTOMER_ID}}" ``` Nach Erstellen eines `SetupIntent` auf Ihrem Server können Sie die `SetupIntent`-ID im Datenmodell Ihrer Anwendung mit dem Kunden/der Kundin der aktuellen Sitzung verknüpfen. Dadurch können Sie nach erfolgreichem Erfassen einer Zahlungsmethode die Daten abrufen. Das zurückgegebene `SetupIntent`-Objekt enthält die Eigenschaft `client_secret`. Übergeben Sie das Client-Geheimnis an die Anwendung auf Client-Seite, um mit der Einrichtung fortzufahren. ## Angaben zur Zahlungsmethode an Stripe senden [Clientseitig] Bestätigen Sie den `SetupIntent`, um das Speichern der Debit-Informationen abzuschließen, nachdem der/die Nutzer/in seine/ihre Zahlungsdetails eingegeben hat. Stellen Sie zunächst ein STPSetupIntentConfirmParams-Objekt mit den folgenden Angaben zusammen: 1. Die Eigenschaft `paymentMethodParams` der [STPAUBECSFormView](https://stripe.dev/stripe-ios/stripe-payments-ui/Classes/STPAUBECSDebitFormView.html) 1. Client-Geheimnis des `SetupIntent` von Ihrem Server Anstatt das gesamte `SetupIntent`-Objekt an den Client zu senden, verwenden Sie dessen [Client-Geheimnis](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-client_secret) aus [Schritt 4](https://docs.stripe.com/payments/au-becs-debit/set-up-payment.md#ios-create-setup-intent). Dieses unterscheidet sich von Ihren API-Schlüsseln, mit denen Anfragen der Stripe-API authentifiziert werden. Achten Sie aber auf einen vorsichtigen Umgang mit dem Client-Geheimnis, da mit ihm die Einrichtung abgeschlossen werden kann. Es darf nicht protokolliert, in URLs eingebettet oder Personen außer der Kundin/dem Kunden selbst zugänglich gemacht werden. Schließen Sie als Nächstes die Zahlung ab, indem Sie die Methode [STPPaymentHandler confirmSetupIntent](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:objc\(cs\)STPPaymentHandler\(im\)confirmSetupIntent:withAuthenticationContext:completion:) aufrufen. Da [der Kunde/die Kundin](https://docs.stripe.com/api/setup_intents/create.md#create_setup_intent-customer) festgelegt ist, wird die *PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) nach erfolgreicher Einrichtung dem angegebenen *Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments)objekt zugeordnet. Dadurch können Sie die gespeicherte PaymentMethod verwenden, um zukünftige Zahlungen einzuziehen, ohne die Kundinnen/Kunden zur Angabe der Zahlungsmethode auffordern zu müssen. #### Swift ```swift import UIKit import StripePaymentsUI class CheckoutViewController: UIViewController { // ... @objc func save() { guard let setupIntentClientSecret = setupIntentClientSecret, let paymentMethodParams = becsFormView.paymentMethodParams else { return; } let setupIntentParams = STPSetupIntentConfirmParams(clientSecret: setupIntentClientSecret) setupIntentParams.paymentMethodParams = paymentMethodParams STPPaymentHandler.shared().confirmSetupIntent(withParams: setupIntentParams, authenticationContext: self) { (handlerStatus, setupIntent, error) in switch (handlerStatus) { case .failed: // Setup failed break case .canceled: // Setup canceled break case .succeeded: // Setup succeeded break @unknown default: fatalError() break } } } } extension CheckoutViewController: STPAuthenticationContext { func authenticationPresentingViewController() -> UIViewController { return self } } ``` Teilen Sie nach Bestätigung des `SetupIntent` die [Mandats-URL](https://docs.stripe.com/api/mandates/object.md#mandate_object-payment_method_details-au_becs_debit-url) aus dem [Mandats-Objekt](https://docs.stripe.com/api/mandates.md) mit Ihrem Kunden/Ihrer Kundin. Wir empfehlen außerdem, die folgenden Details hinzuzufügen, wenn Sie bestätigen, dass sein/ihr Mandat eingerichtet wurde. - Eine eindeutige Bestätigungsnachricht über die Einrichtung einer Lastschriftzahlung - Der [Name des Unternehmens](https://docs.stripe.com/payments/au-becs-debit/accept-a-payment.md), der auf den Kontoauszügen von Kundinnen/Kunden angezeigt wird, wenn ihr Konto belastet wird. - Der Zahlungsbetrag und der Zahlungsplan (falls zutreffend) - Ein Link zur generierten Mandats-URL für Lastschriftanfragen Sie können vom `Mandate​` auf dem [SetupIntent-Objekt](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-mandate) aus auf die ID des `mandate`-Objekts zugreifen (enthalten im Ereignis `setup_intent.succeeded`, das nach Bestätigung gesendet wird). Oder Sie können sie [über die API abrufen](https://docs.stripe.com/api/setup_intents/retrieve.md). ## Integration testen Sie können Ihr Formular mit der BSB-Nummer `000000` und einer der unten aufgeführten Kontonummern testen, indem Sie [STPPaymentHandler confirmSetupIntent](https://stripe.dev/stripe-ios/stripe-payments/Classes/STPPaymentHandler.html#/c:objc\(cs\)STPPaymentHandler\(im\)confirmSetupIntent:withAuthenticationContext:completion:) aufrufen. | BSB-Nummer | Kontonummer | Beschreibung | | ---------- | ----------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `000000` | `000123456` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `succeeded`. Der Mandatsstatus bleibt `active`. | | `000000` | `900123456` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `succeeded` (mit einer Verzögerung von drei Minuten). Der Mandatsstatus bleibt `active`. | | `000000` | `111111113` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `account_closed`. Der Mandatsstatus ändert sich an dieser Stelle in `inactive`. | | `000000` | `111111116` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `no_account`. Der Mandatsstatus ändert sich an dieser Stelle in `inactive`. | | `000000` | `222222227` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `refer_to_customer`. Der Mandatsstatus bleibt `active`. | | `000000` | `922222227` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `refer_to_customer` (mit einer Verzögerung von drei Minuten). Der Mandatsstatus bleibt `active`. | | `000000` | `333333335` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `requires_payment_method` mit dem Fehlercode `debit_not_authorized`. Der Mandatsstatus ändert sich an dieser Stelle in `inactive`. | | `000000` | `666666660` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent wechselt von `processing` zu `succeeded`. Eine Zahlungsanfechtung wird jedoch sofort erstellt. | | `000000` | `343434343` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent schlägt mit dem Fehler `charge_exceeds_source_limit` fehl, da der Zahlungsbetrag dazu führt, dass das Konto sein wöchentliches Limit für das Zahlungsvolumen überschreitet. | | `000000` | `121212121` | Der mit der resultierenden PaymentMethod erstellte PaymentIntent schlägt mit dem Fehler `charge_exceeds_transaction_limit` fehl, da der Zahlungsbetrag das Transaktionsvolumenlimit des Kontos überschreitet. | # Android > This is a Android for when payment-ui is mobile and platform is android. View the full page at https://docs.stripe.com/payments/au-becs-debit/set-up-payment?payment-ui=mobile&platform=android. Mit [BecsDebitWidget](https://stripe.dev/stripe-android/payments-core/com.stripe.android.view/-becs-debit-widget/index.html), der vorkonfigurierten Stripe-Nutzeroberfläche zur Erfassung von BECS-Lastschriftdaten, können Sie Zahlungsformulare zur sicheren Erfassung von Bankverbindungen erstellen, ohne vertrauliche Kundendaten selbst handhaben zu müssen. Mit der [Setup Intents API](https://docs.stripe.com/payments/setup-intents.md) können Sie Zahlungsinformationen für das BECS-Lastschriftverfahren vorab erfassen und den endgültigen bzw. das Zahlungsdatum später festlegen. Verwenden Sie dies für: - Zahlungsmethoden in einer Wallet speichern, um zukünftige Einkäufe zu optimieren - Einziehen von Zuschlägen nach Abwicklung einer Dienstleistung - [Kostenlosen Testzeitraum für ein Abonnement starten](https://docs.stripe.com/billing/subscriptions/trials.md) ## Stripe einrichten [Serverseitig] [Clientseitig] Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register). ### Serverseitig Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie diese offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus: #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` ### Clientseitig Das [Stripe Android SDK](https://github.com/stripe/stripe-android) ist Open Source und [vollständig dokumentiert](https://stripe.dev/stripe-android/). Um das SDK zu installieren, fügen Sie `stripe-android` in den Block `dependencies` Ihrer [app/build.gradle](https://developer.android.com/studio/build/dependencies)-Datei ein: #### Kotlin ```kotlin plugins { id("com.android.application") } android { ... } dependencies { // ... // Stripe Android SDK implementation("com.stripe:stripe-android:23.0.2") // Include the financial connections SDK to support US bank account as a payment method implementation("com.stripe:financial-connections:23.0.2") } ``` > Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-android/releases) auf GitHub. Um bei Veröffentlichung eines neuen Release eine Benachrichtigung zu erhalten, [beobachten Sie Veröffentlichungen für das jeweilige Repository](https://docs.github.com/en/github/managing-subscriptions-and-notifications-on-github/configuring-notifications#configuring-your-watch-settings-for-an-individual-repository). Konfigurieren Sie das SDK mit Ihrem [veröffentlichbaren Schlüssel](https://dashboard.stripe.com/apikeys) von Stripe so, dass dieser Anfragen an die API stellen kann, wie beispielsweise in Ihrer Unterklasse `Application`: #### Kotlin ```kotlin import com.stripe.android.PaymentConfiguration class MyApp : Application() { override fun onCreate() { super.onCreate() PaymentConfiguration.init( applicationContext, "<>" ) } } ``` > Verwenden Sie Ihre [Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App. Stripe-Beispiele nutzen auch [OkHttp](https://github.com/square/okhttp) und [GSON](https://github.com/google/gson), um HTTP-Anfragen an einen Server zu stellen. ## Kundinnen/Kunden erstellen oder abrufen [Serverseitig] Um ein BECS-Lastschriftkonto für zukünftige Zahlungen zu verwenden, müssen Sie 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 zuordnen. Erstellen Sie ein Customer-Objekt, wenn Ihre Kund/innen ein Konto bei Ihrem Unternehmen anlegen. Wenn Sie die ID des Customer-Objekts mit Ihrer eigenen Darstellung einer Kundin/eines Kunden verknüpfen, können Sie später die gespeicherten Angaben zur Zahlungsmethode abrufen und verwenden. Legen Sie neue Kund/innen an oder rufen Sie bestehende Kund/innen ab, um sie mit dieser Zahlung zu verknüpfen. Fügen Sie den folgenden Code auf Ihrem Server ein, um neue Kund/innen zu erstellen. ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## Angaben zur Zahlungsmethode und Mandatsbestätigung erfassen [Clientseitig] Mit der im SDK enthaltenen frei verwendbaren UI-Komponente [BecsDebitWidget](https://stripe.dev/stripe-android/payments-core/com.stripe.android.view/-becs-debit-widget/index.html) können Sie Zahlungsdaten zum BECS-Lastschriftverfahren sicher erfassen. `BecsDebitWidget` erstellt eine Nutzeroberfläche, in die die Kund/innen Name, E-Mail-Adresse, BSB-Nummer und Kontonummer eingeben können. Zudem zeigt sie die [Bedingungen des BECS-Lastschriftverfahrens](https://stripe.com/au-becs/legal) an. ### Fügen Sie das BecsDebitWidget zu Ihrem Layout hinzu Fügen Sie das `BecsDebitWidget` zu Ihrem Layout hinzu und konfigurieren Sie das Attribut `app:companyName` mit Ihrem Unternehmensnamen. ```xml