# Eine Zahlung akzeptieren und ein Mandat für zukünftige PayTo-Zahlungen speichern

So ziehen Sie PayTo-Zahlungen ein und autorisieren zukünftige Zahlungen.

Mit PayTo können Kundinnen/Kunden in Australien PayTo-Mandate für einmalige und wiederkehrende Zahlungen in ihren Banking-Apps [authentifizieren](https://docs.stripe.com/payments/payment-methods.md#customer-actions). *Kundinnen/Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments) zahlen mit PayTo, indem sie eine Benachrichtigung über eine ausstehende Mandatsanfrage erhalten, die Konditionen des Mandats autorisieren und dann wieder zu Ihrer App wechseln, wo Sie eine [verzögerte Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification) darüber erhalten, ob die Zahlung erfolgreich war oder nicht.

Durch die Einrichtung eines PayTo-Mandats für zukünftige Zahlungen können Sie zukünftige wiederkehrende Zahlungen ohne erneute Autorisierung durch Kundinnen und Kunden einziehen. Kundinnen und Kunden können ihre PayTo-Mandate in ihren Banking-Apps anzeigen, verwalten, pausieren und stornieren.

> Die Änderung oder Pausierung von PayTo-Mandaten durch Kundinnen/Kunden wird von Stripe nicht unterstützt. Wenn ein Kunde/eine Kundin versucht, ein Mandat zu pausieren oder zu ändern, stornieren wir das Mandat und senden Ihnen einen [`mandate.updated`-Webhook](https://docs.stripe.com/api/events/types.md#event_types-mandate.updated). Nach Erhalt des Webhooks können Sie sich mit dem Kunden/der Kundin in Verbindung setzen, um herauszufinden, warum er/sie ihr Mandat angepasst hat, und um ein neues Mandat zu erstellen.

# Checkout

> This is a Checkout for when payment-ui is checkout. View the full page at https://docs.stripe.com/payments/payto/save-during-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.

## Kompatibilität bestimmen

**Kundenregion**: Australia

**Unterstützte Währungen**: `aud`

**Transaktionswährungen**: `aud`

**Zahlungsmodus**: Yes

**Einrichtungsmodus**: Yes

**Abonnementmodus**: Yes

Um PayTo-Zahlungen in Checkout zu unterstützen, drücken Sie alle *Preise* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) für alle Posten in AUD aus (Währungscode `aud`).

## Eine Zahlung akzeptieren

> Diese Anleitung baut auf der grundlegenden Checkout-Integration zum [Akzeptieren von Zahlungen](https://docs.stripe.com/payments/accept-a-payment.md?ui=stripe-hosted) auf.

Um Payto als Zahlungsmethode zu aktivieren, erstellen Sie eine neue [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions.md):

1. Fügen Sie `payto` zur Liste der `payment_method_types` hinzu.
1. Stellen Sie sicher, dass alle Ihre `line_items` die Währung `aud` verwenden.
1. Geben Sie die Konditionen des Mandats an, dem Ihre Kundin/Ihr Kunde unter Verwendung der [Zahlungsmethoden-Optionen](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-payment_method_options-payto) zustimmen soll.

#### Von Stripe gehostete Seite

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=aud" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][quantity]=1" \
  -d mode=payment \
  -d "payment_method_options[payto][mandate_options][amount]=10000" \
  -d "payment_method_options[payto][mandate_options][amount_type]=maximum" \
  -d "payment_method_options[payto][mandate_options][payment_schedule]=adhoc" \
  -d "payment_method_options[payto][setup_future_usage]=off_session" \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=payto" \
  --data-urlencode "success_url=https://example.com/success"
```

#### Eingebettetes Formular

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price_data][currency]=aud" \
  -d "line_items[0][price_data][product_data][name]=T-shirt" \
  -d "line_items[0][price_data][unit_amount]=2000" \
  -d "line_items[0][quantity]=1" \
  -d mode=payment \
  -d "payment_method_options[payto][mandate_options][amount]=10000" \
  -d "payment_method_options[payto][mandate_options][amount_type]=maximum" \
  -d "payment_method_options[payto][mandate_options][payment_schedule]=adhoc" \
  -d "payment_method_options[payto][setup_future_usage]=off_session" \
  -d "payment_method_types[0]=card" \
  -d "payment_method_types[1]=payto" \
  --data-urlencode "return_url=https://example.com/return" \
  -d ui_mode=embedded_page
```

### Abwicklung Ihrer Bestellungen

Informieren Sie sich über die [Ausführung von Bestellungen](https://docs.stripe.com/checkout/fulfillment.md), nachdem Sie eine Zahlung angenommen haben.

## Ihre Integration testen

Testen Sie Ihre PayTo-Integration mit Ihren Test-API-Schlüsseln, indem Sie die verschiedenen Test-PayIDs und Bankkontodaten unten verwenden. Jeder Datensatz hat ein anderes Szenario zufolge, mit dem Ihre Integration im Live-Modus häufig konfrontiert wird.

#### PayID

| PayID                                                    | Beschreibung                                                                                                                                                                                                                                                                                                                            |
| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{any_prefix}+succeed@{any_domain}`                      | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat geht in den Status `active` über.                                                                                                                                   |
| `{any_prefix}+decline@{any_domain}`                      | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück. Das Mandat geht in den Status `inactive` über.                                                      |
| `{any_prefix}+expire@{any_domain}`                       | Der Status des PaymentIntent wechselt nach 10&nbsp;Minuten von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `generic_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                             |
| `{any_prefix}+insufficient_funds@{any_domain}`           | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method` . Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. Das Mandat geht in den Status `inactive` über. |
| `{any_prefix}+revoke@{any_domain}`                       | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat beginnt im Status `active` und wechselt nach 1&nbsp;Minute zu `inactive`.                                                                                           |
| `{any_prefix}+agreement_type_not_supported@{any_domain}` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                                                                              |

#### Konto- + BSB-Nummern

| BSB-Nummer | Kontonummer | Beschreibung                                                                                                                                                                                                                                                                                                                            |
| ---------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000000`   | `000123456` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat geht in den Status `active` über.                                                                                                                                   |
| `000000`   | `333333335` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück. Das Mandat geht in den Status `inactive` über.                                                      |
| `000000`   | `333333337` | Der Status des PaymentIntent wechselt nach 10&nbsp;Minuten von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `generic_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                             |
| `000000`   | `222222227` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method` . Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. Das Mandat geht in den Status `inactive` über. |
| `000000`   | `444444447` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat beginnt im Status `active` und wechselt nach 1&nbsp;Minute zu `inactive`.                                                                                           |
| `000000`   | `666666667` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                                                                              |


# Elements

> This is a Elements for when payment-ui is elements. View the full page at https://docs.stripe.com/payments/payto/save-during-payment?payment-ui=elements.

Um PayTo-Zahlungen anzunehmen, erstellen Sie ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekt zur Nachverfolgung einer Zahlung, erfassen Sie Details zur Zahlungsmethode und übermitteln Sie die Zahlung dann zur Verarbeitung an Stripe. Stripe verwendet den PaymentIntent, um sämtliche Status der Zahlung zu verfolgen und zu verarbeiten, bis die Zahlung abgeschlossen ist. Verwenden Sie die ID des von Ihrem ursprünglichen PayTo PaymentIntent erfassten [Mandats](https://docs.stripe.com/api/mandates.md), um zukünftige Zahlungen zu erstellen.

## Stripe einrichten [Serverseitig]

Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register).

Um von Ihrer Anwendung auf die Stripe API zuzugreifen, verwenden Sie unsere offiziellen Bibliotheken:

#### 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'
```

## Kundin/Kunden erstellen [Serverseitig]

Erstellen Sie *Kundinnen/Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments), nachdem diese ein Konto bei Ihrem Unternehmen angelegt haben, und verknüpfen Sie es mit Ihrer internen Darstellung ihres Kontos. So können Sie zu einem späteren Zeitpunkt die gespeicherten Details zur Zahlungsmethode abrufen und verwenden.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "name=Jenny Rosen" \
  --data-urlencode "email=jenny@example.com"
```

## PaymentIntent erstellen [Serverseitig]

Erstellen Sie einen PaymentIntent auf Ihrem Server und geben Sie den einzuziehenden `amount`, die Währung `aud`, die Kunden-ID und `off_session` als Argument für die [Einrichtung der zukünftigen Verwendung](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) an. Der Mindestzahlungsbetrag beträgt 0,50&nbsp;AUD und PayTo unterstützt keine anderen Währungen. Wenn Sie über eine bestehende [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md)-Integration verfügen, fügen Sie `payto` der Liste der [Arten der Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) hinzu.

Sie können die Konditionen des Mandats für die Zustimmung Ihrer Kundinnen und Kunden in den [Zahlungsmethoden-Optionen für Pay To](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-payto) festlegen.

> Der `amount` der Zahlungsmethodenoption muss dem `amount` des PaymentIntent entsprechen, es sei denn, Sie legen den `amount_type` auf `maximum` fest. In diesem Fall können Sie einen Optionswert für die Zahlungsmethode festlegen, der höher ist als der des PaymentIntent.

Das folgende Codebeispiel zeigt einen PaymentIntent-Betrag von 10&nbsp;AUD und einen Betrag für Zahlungsmethodenoptionen von 1.500&nbsp;AUD, da der `amount_type` auf `maximum` festgelegt ist.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1000 \
  -d currency=aud \
  -d "payment_method_types[]=payto" \
  -d customer={{CUSTOMER_ID}} \
  -d setup_future_usage=off_session \
  -d "payment_method_options[payto][mandate_options][amount_type]=maximum" \
  -d "payment_method_options[payto][mandate_options][payment_schedule]=annual" \
  -d "payment_method_options[payto][mandate_options][amount]=150000" \
  -d "payment_method_options[payto][mandate_options][payments_per_period]=13" \
  -d "payment_method_options[payto][mandate_options][end_date]=2036-12-25" \
  -d "payment_method_options[payto][mandate_options][purpose]=mortgage"
```

Stripe unterstützt verschiedene Arten von Mandaten, wobei Betrag, Dauer, Frequenz und der Zweck des Mandats gesteuert werden können. Gestalten Sie Ihre Mandatsbedingungen so, dass sie am besten zu Ihren Anforderungen passen. Kundinnen und Kunden sehen diese genauen Konditionen zum Zeitpunkt der Autorisierung, unmissverständliche Formulierungen können daher Ihre Konversionsrate verbessern.

Stripe legt den Standardwert `purpose` auf der Grundlage Ihres *Händlerkategorie-Codes (MCC)* (A Merchant Category Code (MCC) is a four-digit number that classifies the type of goods or services a business offers) fest. Überschreiben Sie dieses Feld mit [einem der gültigen Werte](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-payto-mandate_options-purpose), wenn der Standardwert den Zweck des Mandats nicht genau wiedergibt. Sie können den Standardwert im Objekt [Mandat](https://docs.stripe.com/api/mandates/object.md#mandate_object-payment_method_details-payto) prüfen, wenn Sie den Zweck nicht angeben.

### Client-Geheimnis abrufen

Im PaymentIntent ist ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) enthalten, das auf dem Client verwendet wird, um Zahlungen sicher abzuschließen. Es gibt verschiedene Verfahren zum Übergeben des Client-Geheimnisses an den Client.

#### Einseitige Anwendung

Rufen Sie das Client-Geheimnis von einem Endpoint auf Ihrem Server ab, indem Sie die Browser-Funktion `fetch` verwenden. Diese Vorgehensweise funktioniert am besten, wenn es sich bei Ihrer Client-Seite um eine einseitige Anwendung handelt, insbesondere wenn sie mit einem modernen Frontend-Framework wie React erstellt wurde. Erstellen Sie den Server-Endpoint, der das Client-Geheimnis bereitstellt:

#### Ruby

```ruby
get '/secret' do
  intent = # ... Create or retrieve the PaymentIntent
  {client_secret: intent.client_secret}.to_json
end
```

Und dann rufen Sie das Client-Geheimnis mit JavaScript auf der Client-Seite ab:

```javascript
(async () => {
  const response = await fetch('/secret');
  const {client_secret: clientSecret} = await response.json();
  // Render the form using the clientSecret
})();
```

#### Serverseitiges Rendering

Übergeben Sie das Client-Geheimnis von Ihrem Server an den Client. Diese Vorgehensweise funktioniert am besten, wenn Ihre Anwendung statische Inhalte auf dem Server generiert, bevor sie an den Browser gesendet werden.

Fügen Sie das [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) in Ihr Bezahlformular ein. Rufen Sie in Ihrem serverseitigen Code das Client-Geheimnis aus dem PaymentIntent ab:

#### Ruby

```erb
<form id="payment-form" data-secret="<%= @intent.client_secret %>">
  <button id="submit">Submit</button>
</form>
```

```ruby
get '/checkout' do
  @intent = # ... Fetch or create the PaymentIntent
  erb :checkout
end
```

## Angaben zur Zahlungsmethode erfassen und die Zahlung übermitteln [Clientseitig]

Erfassen Sie Zahlungsdetails auf dem Client mit dem [Payment Element](https://docs.stripe.com/payments/payment-element.md). Das Payment Element ist eine vorgefertigte Komponente der Nutzeroberfläche, 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.

Wenn Sie sich für die Verwendung eines Iframes entscheiden und Apple Pay oder Google Pay akzeptieren möchten, muss das Attribut [Zulassen](https://developer.mozilla.org/en-US/docs/Web/HTML/Element/iframe#attr-allowpaymentrequest) des Iframes auf `"payment*"` gesetzt sein.

Die Adresse der Bezahlseite muss mit `https://` beginnen, nicht mit `http://`, damit Ihre Integration funktioniert. Sie können Ihre Integration ohne HTTPS testen. Denken Sie jedoch daran, dieses zu [aktivieren](https://docs.stripe.com/security/guide.md#tls), wenn Sie bereit sind, Live-Zahlungen zu akzeptieren.

#### HTML + JS

### 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
<head>
  <title>Checkout</title>
  <script src="https://js.stripe.com/dahlia/stripe.js"></script>
</head>
```

Erstellen Sie auf Ihrer Bezahlseite 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('<<YOUR_PUBLISHABLE_KEY>>');
```

### Payment Element Ihrer Bezahlseite hinzufügen

Das Payment Element benötigt einen festen Platz auf Ihrer Zahlungsseite. Erstellen Sie einen leeren DOM-Knoten (Container) mit einer eindeutigen ID in Ihrem Zahlungsformular:

```html
<form id="payment-form">
  <div id="payment-element">
    <!-- Elements will create form elements here -->
  </div>
  <button id="submit">Submit</button>
  <div id="error-message">
    <!-- Display error message to your customers here -->
  </div>
</form>
```

Wenn das vorherige Formular geladen wurde, erstellen Sie eine Instanz des Payment Element und verbinden es mit dem DOM-Knoten (Container). Übergeben Sie das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) aus dem vorherigen Schritt an `options`, wenn Sie die [Elements](https://docs.stripe.com/js/elements_object/create)-Instanz erstellen:

Gehen Sie sorgfältig mit dem Client-Geheimnis um, denn es kann die Zahlung abschließen. Protokollieren Sie es nicht, betten Sie es nicht in URLs ein und geben Sie es nur dem/der Kund/in preis.

```javascript
const options = {
  clientSecret: '{{CLIENT_SECRET}}',
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout form, passing the client secret obtained in a previous stepconst elements = stripe.elements(options);
// Optional: Autofill user's saved payment methods. If the customer's
// email is known when the page is loaded, you can pass the email
// to the linkAuthenticationElement on mount:
//
//   linkAuthenticationElement.mount("#link-authentication-element",  {
//     defaultValues: {
//       email: 'jenny.rosen@example.com',
//     }
//   })

// 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 Zahlungsseite 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. Übergeben Sie auch das [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) aus dem vorherigen Schritt als `options` 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 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('<<YOUR_PUBLISHABLE_KEY>>');

function App() {
  const options = {
    // passing the client secret obtained in step 3
    clientSecret: '{{CLIENT_SECRET}}',
    // Fully customizable with appearance API.
    appearance: {/*...*/},
  };

  return (
    <Elements stripe={stripePromise} options={options}>
      <CheckoutForm />
    </Elements>
  );
};

ReactDOM.render(<App />, 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 (
    <form>
      // Optional: Autofill user's saved payment methods. If the customer's
      // email is known when the page is loaded, you can pass the email
      // to the linkAuthenticationElement
      //
      // <LinkAuthenticationElement id="link-authentication-element"
        // Prefill the email field like so:
        // options={{defaultValues: {email: 'foo@bar.com'}}}
      // /><PaymentElement />
      <button>Submit</button>
    </form>
  );
};

export default CheckoutForm;
```

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. Dadurch wird eine Autorisierungsanfrage an die Käufer/innen gesendet.

> Die Ausführung von `stripe.confirmPayment` kann einige Sekunden dauern, während Sie auf die Autorisierung der Zahlung auf Kundenseite warten. Während dieser Zeit sollten Sie Ihr Formular deaktivieren, damit keine erneute Absendung erfolgen kann. Lassen Sie stattdessen ein Wartesymbol einblenden, wie beispielsweise eine Sanduhr. Tritt ein Fehler auf, lassen Sie eine Fehlermeldung für die Kundin/den Kunden anzeigen, aktivieren Sie das Formular erneut und blenden Sie das Wartesymbol aus.

#### HTML + JS

```javascript
const form = document.getElementById('payment-form');

form.addEventListener('submit', async (event) => {
  event.preventDefault();
const {error, paymentIntent} = await stripe.confirmPayment({
    //`Elements` instance that was used to create the Payment Element
    elements,
    redirect: 'if_required',
    confirmParams: {
      mandate_data: {
        customer_acceptance: {
          type: 'online',
          online: {
            infer_from_client: true,
          },
        },
      }
    },
  });

  const message = document.querySelector('#message')
  if (error) {
    // This point will only be reached if there is an immediate error when
    // confirming the payment. Show error to your customer (for example, payment
    // details incomplete)
    message.innerText = error.message;
  } else {
    // This will execute if the confirm request is successful, or if the
    // payment fails asynchronously.
    switch (paymentIntent.status) {
      case 'succeeded':
        message.innerText = 'Success! Payment received.';
        break;

      case 'processing':
        message.innerText = "Payment processing. We'll update you when payment is received.";
        break;

      case 'requires_payment_method':
        message.innerText = 'Payment failed. Please try another payment method.';
        // Redirect your user back to your payment page to attempt collecting
        // payment again
        break;

      default:
        message.innerText = 'Something went wrong.';
        break;
    }
  }
});
```

#### React

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.confirmPayment](https://docs.stripe.com/js/payment_intents/confirm_payment) ü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) nutzen.

```jsx
import React, {useState} from 'react';
import {useStripe, useElements, PaymentElement} from '@stripe/react-stripe-js';

const CheckoutForm = () => {
  const stripe = useStripe();
  const elements = useElements();

  const [message, setMessage] = useState(null);

  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 {error, paymentIntent} = await stripe.confirmPayment({
      //`Elements` instance that was used to create the Payment Element
      elements,
      redirect: 'if_required',
      confirmParams: {
        mandate_data: {
          customer_acceptance: {
            type: 'online',
            online: {
              infer_from_client: true,
            },
          },
        }
      },
    });


    if (error) {
      // This point will only be reached if there is an immediate error when
      // confirming the payment. Show error to your customer (for example, payment
      // details incomplete)
      setMessage(error.message);
    } else {
      // This will execute if the confirm request is successful, or if the
      // payment fails asynchronously.
      switch (paymentIntent.status) {
        case 'succeeded':
          setMessage('Success! Payment received.');
          break;

        case 'processing':
          setMessage("Payment processing. We'll update you when payment is received.");
          break;

        case 'requires_payment_method':
          setMessage('Payment failed. Please try another payment method.');
          // Redirect your user back to your payment page to attempt collecting
          // payment again
          break;

        default:
          setMessage('Something went wrong.');
          break;
      }
    }
  };

  return (
    <form onSubmit={handleSubmit}>
      <PaymentElement />
      <button disabled={!stripe}>Submit</button>
      {/* Show message to your customers */}
      {message && <div>{message}</div>}
    </form>
  )
};

export default CheckoutForm;
```

## PayTo PaymentMethod später belasten

Wenn Sie ein Kundenkonto erneut belasten müssen, erstellen Sie einen neuen PaymentIntent. Um nach der Mandats-ID, der Kunden-ID und der ID der Zahlungsmethode zu suchen, [rufen](https://docs.stripe.com/api/payment_intents/retrieve.md) Sie den vorherigen PaymentIntent ab und [erweitern](https://docs.stripe.com/api/expanding_objects.md) das Feld `latest_charge`.

```curl
curl -G https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "expand[]=latest_charge"
```

Sehen Sie sich die erforderlichen IDs in der Antwort unten an.

#### Json

```json
{
  // ...
  "customer": "cus_PW6rQWRGAaBD7z", // <---- Here's the customer
  "latest_charge": {
    "payment_method": "pm_1Ok4l9A8DuEjWaGwhB4SGrWh", // <---- Here's the payment method
    "payment_method_details": {
      "payto": {
        "bsb_number": null,
        "last4": null,
        "mandate": "mandate_1Ok4lVA8DuEjWaGwu0uTwI94", // <----- Here's the mandate
        "pay_id": "jenny@example.com"
      },
      "type": "payto"
    },
  },
  "payment_method_types": [
    "payto"
  ],
  // ...
}
```

Erstellen Sie einen PaymentIntent mit der PaymentMethod, dem Mandat und den Kunden-IDs.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "payment_method_types[]=payto" \
  -d amount=1099 \
  -d currency=aud \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method={{PAYMENTMETHOD_ID}}" \
  -d "mandate={{MANDATE_ID}}" \
  -d confirm=true
```

## Integration testen

Testen Sie Ihre PayTo-Integration mit Ihren Test-API-Schlüsseln, indem Sie die verschiedenen Test-PayIDs und Bankkontodaten unten verwenden. Jeder Datensatz hat ein anderes Szenario zufolge, mit dem Ihre Integration im Live-Modus häufig konfrontiert wird.

#### PayID

| PayID                                                    | Beschreibung                                                                                                                                                                                                                                                                                                                            |
| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{any_prefix}+succeed@{any_domain}`                      | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat geht in den Status `active` über.                                                                                                                                   |
| `{any_prefix}+decline@{any_domain}`                      | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück. Das Mandat geht in den Status `inactive` über.                                                      |
| `{any_prefix}+expire@{any_domain}`                       | Der Status des PaymentIntent wechselt nach 10&nbsp;Minuten von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `generic_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                             |
| `{any_prefix}+insufficient_funds@{any_domain}`           | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method` . Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. Das Mandat geht in den Status `inactive` über. |
| `{any_prefix}+revoke@{any_domain}`                       | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat beginnt im Status `active` und wechselt nach 1&nbsp;Minute zu `inactive`.                                                                                           |
| `{any_prefix}+agreement_type_not_supported@{any_domain}` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                                                                              |

#### Konto- + BSB-Nummern

| BSB-Nummer | Kontonummer | Beschreibung                                                                                                                                                                                                                                                                                                                            |
| ---------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000000`   | `000123456` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat geht in den Status `active` über.                                                                                                                                   |
| `000000`   | `333333335` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück. Das Mandat geht in den Status `inactive` über.                                                      |
| `000000`   | `333333337` | Der Status des PaymentIntent wechselt nach 10&nbsp;Minuten von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `generic_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                             |
| `000000`   | `222222227` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method` . Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. Das Mandat geht in den Status `inactive` über. |
| `000000`   | `444444447` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat beginnt im Status `active` und wechselt nach 1&nbsp;Minute zu `inactive`.                                                                                           |
| `000000`   | `666666667` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                                                                              |

## Optional: Ereignisse nach der Zahlung verarbeiten

Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs).

Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide).

### Ereignisse empfangen und Geschäftsaktionen ausführen

Es gibt mehrere Möglichkeiten, Geschäftsaktionen zu empfangen und auszuführen.

#### Manuell

Verwenden Sie das Stripe-Dashboard, um alle Stripe-Zahlungen anzuzeigen, Zahlungsbelege per E-Mail zu senden, Auszahlungen abzuwickeln oder fehlgeschlagene Zahlungen erneut durchzuführen.

- [Testzahlungen im Dashboard anzeigen](https://dashboard.stripe.com/test/payments)

#### Benutzerdefinierter Code

Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Zahlungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben.

- [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)

#### Vorgefertigte Apps

Verarbeiten Sie häufige Geschäftsereignisse, wie [Automatisierung](https://stripe.partners/?f_category=automation) oder [Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales) durch Integration einer Partneranwendung.


# Direkte API

> This is a Direkte API for when payment-ui is direct-api. View the full page at https://docs.stripe.com/payments/payto/save-during-payment?payment-ui=direct-api.

Um PayTo-Zahlungen anzunehmen, erstellen Sie ein [PaymentIntent](https://docs.stripe.com/api/payment_intents/object.md)-Objekt zur Nachverfolgung einer Zahlung, erfassen Sie Details zur Zahlungsmethode und übermitteln Sie die Zahlung dann zur Verarbeitung an Stripe. Stripe verwendet den PaymentIntent, um sämtliche Status der Zahlung zu verfolgen und zu verarbeiten, bis die Zahlung abgeschlossen ist. Verwenden Sie die ID des von Ihrem ursprünglichen PayTo PaymentIntent erfassten [Mandats](https://docs.stripe.com/api/mandates.md), um zukünftige Zahlungen zu erstellen.

## Stripe einrichten [Serverseitig]

Zunächst benötigen Sie ein Stripe-Konto. [Registrieren Sie sich jetzt](https://dashboard.stripe.com/register).

Um von Ihrer Anwendung auf die Stripe API zuzugreifen, verwenden Sie unsere offiziellen Bibliotheken:

#### 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'
```

## Kundin/Kunden erstellen [Serverseitig]

Erstellen Sie *Kundinnen/Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments), nachdem diese ein Konto bei Ihrem Unternehmen angelegt haben, und verknüpfen Sie es mit Ihrer internen Darstellung ihres Kontos. So können Sie zu einem späteren Zeitpunkt die gespeicherten Details zur Zahlungsmethode abrufen und verwenden.

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "name=Jenny Rosen" \
  --data-urlencode "email=jenny@example.com"
```

## PaymentIntent erstellen [Serverseitig]

Erstellen Sie einen PaymentIntent auf Ihrem Server und geben Sie den einzuziehenden `amount`, die Währung `aud`, die Kunden-ID und `off_session` als Argument für die [Einrichtung der zukünftigen Verwendung](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-setup_future_usage) an. Der Mindestzahlungsbetrag beträgt 0,50&nbsp;AUD und PayTo unterstützt keine anderen Währungen. Wenn Sie über eine bestehende [Payment Intents API](https://docs.stripe.com/payments/payment-intents.md)-Integration verfügen, fügen Sie `payto` der Liste der [Arten der Zahlungsmethoden](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) hinzu.

Sie können die Konditionen des Mandats für die Zustimmung Ihrer Kundinnen und Kunden in den [Zahlungsmethoden-Optionen für Pay To](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-payto) festlegen.

> Der `amount` der Zahlungsmethodenoption muss dem `amount` des PaymentIntent entsprechen, es sei denn, Sie legen den `amount_type` auf `maximum` fest. In diesem Fall können Sie einen Optionswert für die Zahlungsmethode festlegen, der höher ist als der des PaymentIntent.

Das folgende Codebeispiel zeigt einen PaymentIntent-Betrag von 10&nbsp;AUD und einen Betrag für Zahlungsmethodenoptionen von 1.500&nbsp;AUD, da der `amount_type` auf `maximum` festgelegt ist.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1000 \
  -d currency=aud \
  -d "payment_method_types[]=payto" \
  -d customer={{CUSTOMER_ID}} \
  -d setup_future_usage=off_session \
  -d "payment_method_options[payto][mandate_options][amount_type]=maximum" \
  -d "payment_method_options[payto][mandate_options][payment_schedule]=annual" \
  -d "payment_method_options[payto][mandate_options][amount]=150000" \
  -d "payment_method_options[payto][mandate_options][payments_per_period]=13" \
  -d "payment_method_options[payto][mandate_options][end_date]=2036-12-25" \
  -d "payment_method_options[payto][mandate_options][purpose]=mortgage"
```

Stripe unterstützt verschiedene Arten von Mandaten, wobei Betrag, Dauer, Frequenz und der Zweck des Mandats gesteuert werden können. Gestalten Sie Ihre Mandatsbedingungen so, dass sie am besten zu Ihren Anforderungen passen. Kundinnen und Kunden sehen diese genauen Konditionen zum Zeitpunkt der Autorisierung, unmissverständliche Formulierungen können daher Ihre Konversionsrate verbessern.

Stripe legt den Standardwert `purpose` auf der Grundlage Ihres *Händlerkategorie-Codes (MCC)* (A Merchant Category Code (MCC) is a four-digit number that classifies the type of goods or services a business offers) fest. Überschreiben Sie dieses Feld mit [einem der gültigen Werte](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-payto-mandate_options-purpose), wenn der Standardwert den Zweck des Mandats nicht genau wiedergibt. Sie können den Standardwert im Objekt [Mandat](https://docs.stripe.com/api/mandates/object.md#mandate_object-payment_method_details-payto) prüfen, wenn Sie den Zweck nicht angeben.

### Client-Geheimnis abrufen

Im PaymentIntent ist ein *Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) enthalten, das auf dem Client verwendet wird, um Zahlungen sicher abzuschließen. Es gibt verschiedene Verfahren zum Übergeben des Client-Geheimnisses an den Client.

#### Einseitige Anwendung

Rufen Sie das Client-Geheimnis von einem Endpoint auf Ihrem Server ab, indem Sie die Browser-Funktion `fetch` verwenden. Diese Vorgehensweise funktioniert am besten, wenn es sich bei Ihrer Client-Seite um eine einseitige Anwendung handelt, insbesondere wenn sie mit einem modernen Frontend-Framework wie React erstellt wurde. Erstellen Sie den Server-Endpoint, der das Client-Geheimnis bereitstellt:

#### Ruby

```ruby
get '/secret' do
  intent = # ... Create or retrieve the PaymentIntent
  {client_secret: intent.client_secret}.to_json
end
```

Und dann rufen Sie das Client-Geheimnis mit JavaScript auf der Client-Seite ab:

```javascript
(async () => {
  const response = await fetch('/secret');
  const {client_secret: clientSecret} = await response.json();
  // Render the form using the clientSecret
})();
```

#### Serverseitiges Rendering

Übergeben Sie das Client-Geheimnis von Ihrem Server an den Client. Diese Vorgehensweise funktioniert am besten, wenn Ihre Anwendung statische Inhalte auf dem Server generiert, bevor sie an den Browser gesendet werden.

Fügen Sie das [client_secret](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret) in Ihr Bezahlformular ein. Rufen Sie in Ihrem serverseitigen Code das Client-Geheimnis aus dem PaymentIntent ab:

#### Ruby

```erb
<form id="payment-form" data-secret="<%= @intent.client_secret %>">
  <button id="submit">Submit</button>
</form>
```

```ruby
get '/checkout' do
  @intent = # ... Fetch or create the PaymentIntent
  erb :checkout
end
```

## Angaben zur Zahlungsmethode erfassen und die Zahlung übermitteln [Clientseitig]

Wenn Sie die Zahlung bestätigen, übergeben Sie das Client-Geheimnis.

> Gehen Sie sorgfältig mit dem Client-Geheimnis um, da es den Zugriff auf den PaymentIntent ermöglicht. Es darf nicht protokolliert, in URLs eingebettet oder Personen außer der Kundin/dem Kunden selbst zugänglich gemacht werden.

Verwenden Sie `stripe.confirmPayToPayment`, um die Autorisierung des Mandats mit Ihrer Kundin/Ihrem Kunden zu initiieren.

Die Kundin/der Kunde erhält eine Benachrichtigung über die Anfrage des Mandats und genehmigt oder lehnt diese über die Banking-App ab.

```javascript
// Inititates the mandate request notification to the customer
stripe.confirmPayToPayment(
  '{{PAYMENT_INTENT_CLIENT_SECRET}}',
  {
    payment_method: {
      payto: {
        // Either provide a PayID (typically an email or phone number)
        pay_id: 'jenny@example.com'
        // ...or provide bank account details
        account_number: '000123456',
        bsb_number: '000000'
      }
    }
  }
).then(function(result) {
  if (result.error) {
    // Inform the customer that there was an error.
    console.log(result.error.message);
  }
});
```

Standardmäßig fragt Stripe.js nach Aktualisierungen des PaymentIntent. Das von `confirmPayToPayment` zurückgegebene Promise wird aufgelöst, wenn der PaymentIntent den Status `succeeded` erreicht, oder wenn die Zahlung fehlschlägt und der PaymentIntent wieder in den Status `requires_payment_method` wechselt. Nähere Informationen dazu, wie diese Übergänge stattfinden, finden Sie unter [PaymentIntent-Lebenszyklus](https://docs.stripe.com/payments/paymentintents/lifecycle.md).

Um sich selbst abzufragen, können Sie die automatische Abfrage deaktivieren, indem Sie `handleActions: false` festlegen:

```javascript
stripe.confirmPayToPayment(
  '{{PAYMENT_INTENT_CLIENT_SECRET}}',
  {
    payment_method: {
      payto: {
        account_number: '000123456',
        bsb_number: '000000'
      }
    }
  },
  { handleActions: false } // <---- Like this
)
```

In diesem Fall können Sie die [PaymentIntents API](https://docs.stripe.com/api/payment_intents/retrieve.md) aufrufen, um den Status des PaymentIntent selbst abzurufen.

## PayTo PaymentMethod später belasten

Wenn Sie ein Kundenkonto erneut belasten müssen, erstellen Sie einen neuen PaymentIntent. Um nach der Mandats-ID, der Kunden-ID und der ID der Zahlungsmethode zu suchen, [rufen](https://docs.stripe.com/api/payment_intents/retrieve.md) Sie den vorherigen PaymentIntent ab und [erweitern](https://docs.stripe.com/api/expanding_objects.md) das Feld `latest_charge`.

```curl
curl -G https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}} \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "expand[]=latest_charge"
```

Sehen Sie sich die erforderlichen IDs in der Antwort unten an.

#### Json

```json
{
  // ...
  "customer": "cus_PW6rQWRGAaBD7z", // <---- Here's the customer
  "latest_charge": {
    "payment_method": "pm_1Ok4l9A8DuEjWaGwhB4SGrWh", // <---- Here's the payment method
    "payment_method_details": {
      "payto": {
        "bsb_number": null,
        "last4": null,
        "mandate": "mandate_1Ok4lVA8DuEjWaGwu0uTwI94", // <----- Here's the mandate
        "pay_id": "jenny@example.com"
      },
      "type": "payto"
    },
  },
  "payment_method_types": [
    "payto"
  ],
  // ...
}
```

Erstellen Sie einen PaymentIntent mit der PaymentMethod, dem Mandat und den Kunden-IDs.

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "payment_method_types[]=payto" \
  -d amount=1099 \
  -d currency=aud \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method={{PAYMENTMETHOD_ID}}" \
  -d "mandate={{MANDATE_ID}}" \
  -d confirm=true
```

## Integration testen

Testen Sie Ihre PayTo-Integration mit Ihren Test-API-Schlüsseln, indem Sie die verschiedenen Test-PayIDs und Bankkontodaten unten verwenden. Jeder Datensatz hat ein anderes Szenario zufolge, mit dem Ihre Integration im Live-Modus häufig konfrontiert wird.

#### PayID

| PayID                                                    | Beschreibung                                                                                                                                                                                                                                                                                                                            |
| -------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `{any_prefix}+succeed@{any_domain}`                      | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat geht in den Status `active` über.                                                                                                                                   |
| `{any_prefix}+decline@{any_domain}`                      | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück. Das Mandat geht in den Status `inactive` über.                                                      |
| `{any_prefix}+expire@{any_domain}`                       | Der Status des PaymentIntent wechselt nach 10&nbsp;Minuten von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `generic_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                             |
| `{any_prefix}+insufficient_funds@{any_domain}`           | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method` . Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. Das Mandat geht in den Status `inactive` über. |
| `{any_prefix}+revoke@{any_domain}`                       | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat beginnt im Status `active` und wechselt nach 1&nbsp;Minute zu `inactive`.                                                                                           |
| `{any_prefix}+agreement_type_not_supported@{any_domain}` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                                                                              |

#### Konto- + BSB-Nummern

| BSB-Nummer | Kontonummer | Beschreibung                                                                                                                                                                                                                                                                                                                            |
| ---------- | ----------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `000000`   | `000123456` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat geht in den Status `active` über.                                                                                                                                   |
| `000000`   | `333333335` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `invalid_authorization` zurück. Das Mandat geht in den Status `inactive` über.                                                      |
| `000000`   | `333333337` | Der Status des PaymentIntent wechselt nach 10&nbsp;Minuten von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `generic_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                             |
| `000000`   | `222222227` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `requires_payment_method` . Stripe gibt den Fehlercode `payment_method_provider_decline` und den Ablehnungscode `insufficient_funds` zurück. Das Mandat geht in den Status `inactive` über. |
| `000000`   | `444444447` | Der Status des PaymentIntent wechselt nach 10&nbsp;Sekunden von `requires_action` zu `processing` und dann nach weiteren 5&nbsp;Sekunden zu `succeeded`. Das Mandat beginnt im Status `active` und wechselt nach 1&nbsp;Minute zu `inactive`.                                                                                           |
| `000000`   | `666666667` | Der PaymentIntent Status wechselt nach 10 Sekunden von `requires_action` zu `requires_payment_method`. Stripe gibt den Fehlercode `payment_method_provider_decline` zurück. Das Mandat geht in den Status `inactive` über.                                                                                                              |

## Optional: Ereignisse nach der Zahlung verarbeiten

Stripe übermittelt ein [payment_intent.succeeded](https://docs.stripe.com/api/events/types.md#event_types-payment_intent.succeeded)-Ereignis, wenn die Zahlung abgeschlossen ist. Verwenden Sie im Dashboard einen *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) oder eine Partnerlösung, um diese Ereignisse zu empfangen und Aktionen auszuführen (Versenden einer Bestellbestätigung per E-Mail an die Kund/innen, Erfassen des Verkaufs in einer Datenbank oder Einleiten des Versandablaufs).

Überwachen Sie diese Ereignisse, statt auf einen Callback vom Client zu warten. Auf dem Client könnte der Kunde/die Kundin das Browserfenster schließen oder die App beenden, bevor der Callback erfolgt ist und böswillige Clients könnten die Antwort manipulieren. Wenn Sie Ihre Integration so einrichten, dass asynchrone Ereignisse überwacht werden, hilft Ihnen dies auch dabei, in Zukunft mehr Zahlungsmethoden zu akzeptieren. Hier erhalten Sie Informationen zu den [Unterschieden zwischen allen unterstützten Zahlungsmethoden](https://stripe.com/payments/payment-methods-guide).

### Ereignisse empfangen und Geschäftsaktionen ausführen

Es gibt mehrere Möglichkeiten, Geschäftsaktionen zu empfangen und auszuführen.

#### Manuell

Verwenden Sie das Stripe-Dashboard, um alle Stripe-Zahlungen anzuzeigen, Zahlungsbelege per E-Mail zu senden, Auszahlungen abzuwickeln oder fehlgeschlagene Zahlungen erneut durchzuführen.

- [Testzahlungen im Dashboard anzeigen](https://dashboard.stripe.com/test/payments)

#### Benutzerdefinierter Code

Erstellen Sie einen Webhook-Handler, um Ereignisse zu überwachen und benutzerdefinierte asynchrone Zahlungsabläufe zu erstellen. Mit der Stripe-CLI können Sie Ihre Webhook-Integration lokal testen und Fehler beheben.

- [Build a custom webhook](https://docs.stripe.com/webhooks/handling-payment-events.md#build-your-own-webhook)

#### Vorgefertigte Apps

Verarbeiten Sie häufige Geschäftsereignisse, wie [Automatisierung](https://stripe.partners/?f_category=automation) oder [Marketing und Vertrieb](https://stripe.partners/?f_category=marketing-and-sales) durch Integration einer Partneranwendung.