# Zahlungsmethode eines Kunden/einer Kundin speichern, wenn er/sie diese für eine Zahlung verwendet

Erfahren Sie, wie Sie die Zahlungsdetails Ihrer Kund/innen für zukünftige Käufe speichern, wenn sie eine Zahlung tätigen.

# Checkout Sessions API

> This is a Checkout Sessions API for when payment-ui is embedded-components. View the full page at https://docs.stripe.com/payments/save-during-payment?payment-ui=embedded-components.

Verwenden Sie die [Checkout Sessions API](https://docs.stripe.com/api/checkout/sessions.md), um Zahlungsdetails während eines Kaufs zu speichern. Dies ist nützlich für Situationen wie:

- Belasten Sie ein Kundenkonto für eine E-Commerce-Bestellung und speichern Sie die Zahlungsdetails für zukünftige Einkäufe.
- Erste Zahlung einer Reihe wiederkehrender Zahlungen initiieren.
- Abbuchung einer Anzahlung und Speicherung der Zahlungsdetails, um später den vollen Betrag abzubuchen.

## Compliance

Sie sind dafür verantwortlich, alle geltenden Gesetze, Vorschriften und Netzwerkregeln einzuhalten, wenn Sie die Zahlungsdaten eines Kunden oder einer Kundin für die zukünftige Verwendung speichern, beispielsweise um dem Kunden oder der Kundin seine bzw. ihre Zahlungsmethode beim Bezahlvorgang für einen zukünftigen Kauf anzuzeigen oder um ihm Kosten in Rechnung zu stellen, wenn er Ihre Website oder App nicht aktiv nutzt. Bevor Sie die Zahlungsmethode eines Kunden oder einer Kundin speichern oder ihm Kosten in Rechnung stellen, stellen Sie bitte sicher, dass Sie:

- Fügen Sie Ihrer Website oder App Bestimmungen hinzu, die darlegen, wie Sie Zahlungsmethoden speichern möchten, beispielsweise:
  - Die kundenseitige Zustimmung, eine Zahlung oder mehrere Zahlungen für bestimmte Transaktionen in deren Namen einzuleiten
  - Der erwartete Zeitpunkt und die voraussichtliche Häufigkeit von Zahlungen (z. B. Zahlungen für geplante Raten- oder Abo-Zahlungen oder für außerplanmäßige Aufstockungen).
  - Wie Sie den Zahlbetrag ermitteln.
  - Ihre Stornorichtlinie, wenn die Zahlungsmethode für einen Abo-Dienst ist.
- Verwenden Sie eine gespeicherte Zahlungsmethode ausschließlich für den in Ihren Bedingungen angegebenen Zweck.
- Holen Sie die ausdrückliche Zustimmung der Kundin oder des Kunden für diese spezifische Verwendung ein. Fügen Sie beispielsweise ein Kontrollkästchen „Meine Zahlungsmethode für zukünftige Transaktionen speichern“ hinzu.
- Bewahren Sie die schriftliche Zustimmung Ihrer Kundinnen und Kunden zu Ihren Bedingungen auf.

> Wenn Sie Elements mit der Checkout Sessions API verwenden, werden als gespeicherte Zahlungsmethoden nur Karten und ACH Direct Debit unterstützt. Andere Zahlungsmethoden, wie beispielsweise Bankkonten, können nicht gespeichert werden.

## Voraussetzungen

1. Befolgen Sie die Anweisungen beim Bezahlvorgang, um [eine Zahlung zu akzeptieren](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=checkout&ui=stripe-hosted).
1. Befolgen Sie diese Anleitung, um die bei einer Zahlung verwendete Zahlungsmethode zu speichern, damit Sie sie für zukünftige Zahlungen desselben Kunden oder derselben Kundin wiederverwenden können.

## Gespeicherte Zahlungsmethoden aktivieren

> Die globalen Datenschutzgesetze sind komplex und vielschichtig. Bevor Sie sich mit der Implementierung zur Speicherung von Kundenzahlungsdetails befassen, sollten Sie zuerst mit Ihrem Rechtsteam abstimmen, dass dies Ihren Datenschutz- und Compliance-Rahmenbedingungen entspricht.

Damit ein/e Kund/in eine Zahlungsmethode zur zukünftigen Verwendung speichern kann, geben Sie beim Erstellen der Checkout-Sitzung den Parameter [saved_payment_method_options.payment_method_save](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-saved_payment_method_options-payment_method_save) an.

> #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden
> 
> The Accounts v2 API is generally available for Connect users, and in public preview for other Stripe users. If you’re part of the Accounts v2 preview, you need to specify a [specify a preview version](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in your code.
> 
> To request access to the Accounts v2 preview, 
> 
> Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/connect/use-accounts-as-customers.md), anstatt das [Kundenobjekt](https://docs.stripe.com/api/customers.md) zu verwenden.

Zum Speichern einer Zahlungsmethode ist ein Objekt erforderlich, das Ihre/n Kunden/Kundin darstellt. Dieses Objekt kann ein vom Kunden/von der Kundin konfiguriertes [Account](https://docs.stripe.com/api/v2/core/accounts/object.md)-Objekt sein, wenn Sie die Accounts v2 API verwenden, oder ein [Customer](https://docs.stripe.com/api/customers/object.md)-Objekt, wenn Sie die Customers API verwenden. Übergeben Sie eine/n bestehende/n Kunden/Kundin oder erstellen Sie eine/n neue/n, indem Sie für [customer_creation](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer_creation) in der Checkout-Sitzung `always` festlegen.

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price]={{PRICE_ID}}" \
  -d "line_items[0][quantity]=2" \
  -d mode=payment \
  -d ui_mode=elements \
  -d customer_creation=always \
  -d "saved_payment_method_options[payment_method_save]=enabled"
```

Nachdem Sie die Checkout-Sitzung erstellt haben, verwenden Sie das [Client-Geheimnis](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-client_secret), das in der Antwort zurückgegeben wurde, zum [Erstellen Ihrer Bezahlvorgangseite](https://docs.stripe.com/payments/quickstart-checkout-sessions.md).

> In der neuesten Version von Stripe.js ist die Einstellung von `enableSave` auf `auto` optional, da dies der Standardwert ist, wenn gespeicherte Zahlungsmethoden in der Checkout-Sitzung aktiviert sind.

#### HTML + JS

Das Payment Element zeigt automatisch ein Kontrollkästchen zur Einholung der Zustimmung an, wenn gespeicherte Zahlungsmethoden in der Checkout-Session aktiviert sind. Sie können dieses Verhalten explizit über [elementsOptions](https://docs.stripe.com/js/custom_checkout/init#custom_checkout_init-options-elementsOptions) in der `initCheckoutElementsSdk` konfigurieren.

```javascript
const checkout = stripe.initCheckoutElementsSdk({
  clientSecret,
  elementsOptions: {savedPaymentMethod: {
      // Default is 'auto' in the latest version of Stripe.js - this configuration is optional
      enableSave: 'auto',
    }
  }
});
```

#### React

Das Payment Element zeigt automatisch ein Kontrollkästchen zur Einholung der Zustimmung an, wenn gespeicherte Zahlungsmethoden in der Checkout-Sitzung aktiviert sind. Sie können dieses Verhalten explizit über [elementsOptions](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider#react_checkout_provider-options-elementsOptions) im `CheckoutElementsProvider` konfigurieren.

```jsx
import React from 'react';
import {CheckoutElementsProvider} from '@stripe/react-stripe-js/checkout';
import CheckoutForm from './CheckoutForm';

const App = () => {
  const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
    .then((response) => response.json())
    .then((json) => json.checkoutSessionClientSecret);

  return (
    <CheckoutElementsProvider
      stripe={stripe}
      options={{
        clientSecret,
        elementsOptions: {savedPaymentMethod: {
            // Default is 'auto' in the latest version of Stripe.js - this configuration is optional
            enableSave: 'auto',
          },
        },
      }}
    >
      <CheckoutForm />
    </CheckoutElementsProvider>
  );
};

export default App;
```

## Zuvor gespeicherte Zahlungsmethode wiederverwenden

Jede gespeicherte Zahlungsmethode ist mit einem Objekt verknüpft, das Ihre/n Kunden/Kundin darstellt. Dieses Objekt kann ein vom Kunden/von der Kundin konfiguriertes [Account](https://docs.stripe.com/api/v2/core/accounts/object.md)-Objekt sein, wenn Sie die Accounts v2 API verwenden, oder ein [Customer](https://docs.stripe.com/api/customers/object.md)-Objekt, wenn Sie die Customers API verwenden. Bevor Sie die Checkout-Sitzung erstellen, authentifizieren Sie Ihre/n Kunden/Kundin und übergeben Sie die entsprechende Objekt-ID an die Checkout-Sitzung.

> In der neuesten Version von Stripe.js ist `enableRedisplay` standardmäßig auf `auto` gesetzt, wenn gespeicherte Zahlungsmethoden in der Checkout-Sitzung aktiviert sind.

Das Payment Element zeigt automatisch zuvor gespeicherte Zahlungsmethoden erneut an, damit Ihre Kundin/Ihr Kunde sie während des Bezahlvorgangs verwenden kann, wenn gespeicherte Zahlungsmethoden in der Checkout-Sitzung aktiviert sind.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price]={{PRICE_ID}}" \
  -d "line_items[0][quantity]=2" \
  -d mode=payment \
  -d ui_mode=elements \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/checkout/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "line_items[0][price]={{PRICE_ID}}" \
  -d "line_items[0][quantity]=2" \
  -d mode=payment \
  -d ui_mode=elements \
  -d "customer={{CUSTOMER_ID}}"
```

#### HTML + JS

Sie können das Verhalten der erneuten Anzeige explizit über [elementsOptions](https://docs.stripe.com/js/custom_checkout/init#custom_checkout_init-options-elementsOptions) in der `initCheckoutElementsSdk` konfigurieren.

```javascript
const checkout = stripe.initCheckoutElementsSdk({
  clientSecret,
  elementsOptions: {
    savedPaymentMethod: {
      // Default is 'auto' in the latest version of Stripe.js - this configuration is optional
      enableSave: 'auto',// Default is 'auto' in the latest version of Stripe.js - this configuration is optional
      enableRedisplay: 'auto',
    }
  }
});
```

#### React

Sie können das Verhalten der erneuten Anzeige explizit über [elementsOptions](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider#react_checkout_provider-options-elementsOptions) im `CheckoutElementsProvider` konfigurieren.

```jsx
import React from 'react';
import {CheckoutElementsProvider} from '@stripe/react-stripe-js/checkout';
import CheckoutForm from './CheckoutForm';

const App = () => {
  const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
    .then((response) => response.json())
    .then((json) => json.checkoutSessionClientSecret)

  return (
    <CheckoutElementsProvider
      stripe={stripe}
      options={{
        clientSecret,
        elementsOptions: {
          savedPaymentMethod: {
            // Default is 'auto' in the latest version of Stripe.js - this configuration is optional
            enableSave: 'auto',// Default is 'auto' in the latest version of Stripe.js - this configuration is optional
            enableRedisplay: 'auto',
          }
        },
      }}
    >
      <CheckoutForm />
    </CheckoutElementsProvider>
  );
};

export default App;
```

## Optional: Nutzeroberfläche für gespeicherte Zahlungsmethoden erstellen

#### HTML + JS

Sie können Ihre eigene Nutzeroberfläche für gespeicherte Zahlungsmethoden erstellen, anstatt die integrierte Nutzeroberfläche des Payment Element zu verwenden.

Um zu verhindern, dass das Payment Element das Einholen der Zustimmung und die Anzeige der zuvor gespeicherten Zahlungsmethoden verarbeitet, übergeben Sie zusätzliche [elementsOptions](https://docs.stripe.com/js/custom_checkout/init#custom_checkout_init-options-elementsOptions) für `initCheckoutElements`.

```javascript
const checkout = stripe.initCheckoutElementsSdk({
  clientSecret,
  elementsOptions: {savedPaymentMethod: {
      enableSave: 'never',
      enableRedisplay: 'never',
    },
  }
});
```

#### React

Sie können Ihre eigene Nutzeroberfläche für gespeicherte Zahlungsmethoden erstellen, anstatt die integrierte Nutzeroberfläche des Payment Element zu verwenden. Um zu verhindern, dass das Payment Element das Einholen der Zustimmung und die Anzeige der zuvor gespeicherten Zahlungsmethoden verarbeitet, übergeben Sie zusätzliche [elementsOptions](https://docs.stripe.com/js/react_stripe_js/checkout/checkout_provider#react_checkout_provider-options-elementsOptions) für `CheckoutElementsProvider`.

```jsx
import React from 'react';
import {CheckoutElementsProvider} from '@stripe/react-stripe-js/checkout';
import CheckoutForm from './CheckoutForm';

const App = () => {
  const clientSecret = fetch('/create-checkout-session', {method: 'POST'})
    .then((response) => response.json())
    .then((json) => json.checkoutSessionClientSecret)

  return (
    <CheckoutElementsProvider
      stripe={stripe}
      options={{
        clientSecret,
        elementsOptions: {savedPaymentMethod: {
            enableSave: 'never',
            enableRedisplay: 'never',
          },
        },
      }}
    >
      <CheckoutForm />
    </CheckoutElementsProvider>
  );
};

export default App;
```

### Einwilligung einholen

> Die globalen Datenschutzgesetze sind komplex und vielschichtig. Bevor Sie sich mit der Implementierung zur Speicherung von Kundenzahlungsdetails befassen, sollten Sie zuerst mit Ihrem Rechtsteam abstimmen, dass dies Ihren Datenschutz- und Compliance-Rahmenbedingungen entspricht.

In den meisten Fällen müssen Sie die Zustimmung des/der Kund/in einholen, bevor Sie Details zu deren Zahlungsmethoden speichern dürfen. Im folgenden Beispiel zeigen wir Ihnen, wie Sie die Einwilligung mithilfe eines Kontrollkästchens einholen.

#### HTML + JS

```html
<label>
  <input type="checkbox" id="save-payment-method-checkbox" />
  Save my payment information for future purchases
</label>
<button id="pay-button">Pay</button>
<div id="confirm-errors"></div>
```

#### React

```jsx
import React from 'react';

type Props = {
  savePaymentMethod: boolean;
  onSavePaymentMethodChange: (save: boolean) => void;
}
const ConsentCollection = (props: Props) => {
  const handleChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    props.onSavePaymentMethodChange(e.target.checked);
  };
  return (
    <label>
      <input
        type="checkbox"
        checked={props.savePaymentMethod}
        onChange={handleChange}
      />
      Save my payment information for future purchases
    </label>
  );
};

export default ConsentCollection;
```

Wenn Sie [confirm](https://docs.stripe.com/js/custom_checkout/confirm) aufrufen, können Sie Stripe mitteilen, dass Ihr/e Kund/in die Zustimmung erteilt hat, indem Sie den Parameter `savePaymentMethod` übergeben. Wenn Sie die Zahlungsdetails von Kund/innen speichern, sind Sie dafür verantwortlich, alle geltenden Gesetze, Vorschriften und Netzwerkregeln einzuhalten.

#### HTML + JS

```js
const checkout = stripe.initCheckoutElementsSdk({clientSecret});
const button = document.getElementById('pay-button');
const errors = document.getElementById('confirm-errors');
const checkbox = document.getElementById('save-payment-method-checkbox');
const loadActionsResult = await checkout.loadActions();
if (loadActionsResult.type === 'success') {
  const {actions} = loadActionsResult;
  button.addEventListener('click', () => {
    // Clear any validation errors
    errors.textContent = '';
const savePaymentMethod = checkbox.checked;
    actions.confirm({savePaymentMethod}).then((result) => {
      if (result.type === 'error') {
        errors.textContent = result.error.message;
      }
    });
  });
}
```

#### React

```jsx
import React from 'react';
import {useCheckout} from '@stripe/react-stripe-js/checkout';

type Props = {
  savePaymentMethod: boolean;
}
const PayButton = (props: Props) => {
  const checkoutState = useCheckout();
  const [loading, setLoading] = React.useState(false);
  const [error, setError] = React.useState(null);

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  } else if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }
  const {confirm} = checkoutState.checkout;
  const handleClick = () => {
    setLoading(true);confirm({savePaymentMethod: props.savePaymentMethod}).then((result) => {
      if (result.type === 'error') {
        setError(result.error)
      }
      setLoading(false);
    })
  };

  return (
    <div>
      <button disabled={!loading} onClick={handleClick}>
        Pay
      </button>
      {error && <div>{error.message}</div>}
    </div>
  )
};

export default PayButton;
```

### Gespeicherte Zahlungsmethoden rendern

Verwenden Sie das Array [savedPaymentMethods](https://docs.stripe.com/js/custom_checkout/session_object#custom_checkout_session_object-savedPaymentMethods) im Frontend, um die verfügbaren Zahlungsmethoden der Kund/innen zu rendern.

> Das Array `savedPaymentMethods` enthält nur die Zahlungsmethoden, für die [allow_redisplay](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-allow_redisplay) auf `always` gesetzt ist. Befolgen Sie die Schritte zum [Einholen der Zustimmung](https://docs.stripe.com/payments/save-during-payment.md#collect-consent) von den Kund/innen und stellen Sie sicher, dass der Parameter `allow_redisplay` ordnungsgemäß festgelegt ist.

#### HTML + JS

```html
<div id="saved-payment-methods"></div>
```

```js
const checkout = stripe.initCheckoutElementsSdk({clientSecret});
const loadActionsResult = await checkout.loadActions();
if (loadActionsResult.type === 'success') {
  const container = document.getElementById('saved-payment-methods');
  const {actions} = loadActionsResult;
  actions.getSession().savedPaymentMethods.forEach((pm) => {
    const label = document.createElement('label');
    const radio = document.createElement('input');

    radio.type = 'radio';
    radio.value = pm.id;

    label.appendChild(radio);
    label.appendChild(document.createTextNode(`Card ending in ${pm.card.last4}`));
    container.appendChild(label);
  });
}
```

#### React

```jsx
import React from 'react';
import {useCheckout} from '@stripe/react-stripe-js/checkout';

type Props = {
  selectedPaymentMethod: string | null;
  onSelectPaymentMethod: (paymentMethod: string) => void;
};
const PaymentMethods = (props: Props) => {const checkoutState = useCheckout();

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  } else if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }const {savedPaymentMethods} = checkoutState.checkout;

  const handleOptionChange = (e: React.ChangeEvent<HTMLInputElement>) => {
    props.onSelectPaymentMethod(e.target.value);
  };

  return (
    <div>
      {savedPaymentMethods.map((pm) => (
        <label key={pm.id}>
          <input
            type="radio"
            value={pm.id}
            checked={props.selectedPaymentMethod === pm.id}
            onChange={handleOptionChange}
          />
          Card ending in {pm.card.last4}
        </label>
      ))}
    </div>
  );
};

export default PaymentMethods;
```

### Mit einer gespeicherten Zahlungsmethode bestätigen

Wenn Ihr/e Kund/in eine gespeicherte Zahlungsmethode auswählt und bereit ist, den Bezahlvorgang abzuschließen, rufen Sie [confirm](https://docs.stripe.com/js/custom_checkout/confirm) auf und übergeben Sie die [paymentMethod](https://docs.stripe.com/js/custom_checkout/confirm#custom_checkout_session_confirm-options-paymentMethod)-ID.

#### HTML + JS

```html
<button id="pay-button">Pay</button>
```

```js
const checkout = stripe.initCheckoutElementsSdk({clientSecret});

const loadActionsResult = await checkout.loadActions();
if (loadActionsResult.type === 'success') {
  const container = document.getElementById('saved-payment-methods');
  const {actions} = loadActionsResult;
  actions.getSession().savedPaymentMethods.forEach((pm) => {
    const label = document.createElement('label');
    const radio = document.createElement('input');

    radio.type = 'radio';
    radio.value = pm.id;

    label.appendChild(radio);
    label.appendChild(document.createTextNode(`Card ending in ${pm.card.last4}`));
    container.appendChild(label);
  });
}
```

#### React

```jsx
import React from 'react';
import {useCheckout} from '@stripe/react-stripe-js/checkout';

type Props = {
  selectedPaymentMethod: string | null;
}
const PayButton = (props: Props) => {
  const checkoutState = useCheckout();
  const [loading, setLoading] = React.useState(false);

  if (checkoutState.type === 'loading') {
    return (
      <div>Loading...</div>
    );
  } else if (checkoutState.type === 'error') {
    return (
      <div>Error: {checkoutState.error.message}</div>
    );
  }
  const {confirm} = checkoutState.checkout;

  const handleClick = () => {
    setLoading(true);confirm({paymentMethod: props.selectedPaymentMethod}).then((result) => {
      if (result.error) {
        // Confirmation failed. Display the error message.
      }
      setLoading(false);
    })
  };

  return (
    <button disabled={loading} onClick={handleClick}>
      Pay
    </button>
  )
};

export default PayButton;
```


# Payment Intents API

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

Verwenden Sie die [Payment Intents API](https://docs.stripe.com/api/payment_intents.md), um Zahlungsdetails aus einem Einkauf zu speichern. Es gibt mehrere Anwendungsszenarien:

- Belasten Sie das Konto eines Kunden/einer Kundin für eine E-Commerce-Bestellung und speichern Sie die Details für zukünftige Einkäufe.
- Leiten Sie die erste Zahlung einer Reihe wiederkehrender Zahlungen ein.
- Buchen Sie eine Anzahlung ab und speichern Sie die Details, um den vollen Betrag später abzubuchen.

> #### Transaktionen mit vorhandener Karte
> 
> Card-Present-Transaktionen, wie zum Beispiel Zahlungen über Stripe Terminal, verwenden ein anderes Verfahren zum Speichern der Zahlungsmethode. Weitere Informationen finden Sie in der [Terminal-Dokumentation](https://docs.stripe.com/terminal/features/saving-payment-details/save-after-payment.md).

## Konformität

Sie sind dafür verantwortlich, alle geltenden Gesetze, Vorschriften und Netzwerkregeln einzuhalten, wenn Sie die Zahlungsdaten eines Kunden oder ein Kundin für die zukünftige Verwendung speichern, beispielsweise um dem Kunden oder der Kundin seine bzw. ihre Zahlungsmethode beim Bezahlvorgang für einen zukünftigen Kauf anzuzeigen oder um ihm Kosten in Rechnung zu stellen, wenn er Ihre Website oder App nicht aktiv nutzt. Bevor Sie die Zahlungsmethode eines Kunden oder einer Kundin speichern oder ihm Kosten in Rechnung stellen, stellen Sie bitte sicher, dass Sie:

- Fügen Sie Ihrer Website oder App Bestimmungen hinzu, die darlegen, wie Sie Zahlungsmethoden speichern möchten, beispielsweise:
  - Die kundenseitige Zustimmung, eine Zahlung oder mehrere Zahlungen für bestimmte Transaktionen in deren Namen einzuleiten
  - Der erwartete Zeitpunkt und die voraussichtliche Häufigkeit von Zahlungen (z. B. Zahlungen für geplante Raten- oder Abonnementzahlungen oder für außerplanmäßige Aufstockungen).
  - Wie Sie den Zahlbetrag ermitteln.
  - Ihre Stornorichtlinie, wenn die Zahlungsmethode für einen Abonnementdienst ist.
- Verwenden Sie eine gespeicherte Zahlungsmethode ausschließlich für den in Ihren Bedingungen angegebenen Zweck.
- Bitte holen Sie die ausdrückliche Zustimmung des Kunden oder der Kundin für diese spezifische Verwendung ein. Fügen Sie beispielsweise ein Kontrollkästchen „Meine Zahlungsmethode für zukünftige Transaktionen speichern“ hinzu.
- Bewahren Sie die schriftliche Zustimmung Ihrer Kundinnen und Kunden zu Ihren Bedingungen auf.

## Voraussetzungen

1. Bitte befolgen Sie die Anleitung zur Payment Intents API, um [eine Zahlung zu akzeptieren](https://docs.stripe.com/payments/accept-a-payment.md?payment-ui=elements&api-integration=paymentintents).
1. Befolgen Sie diese Anleitung, um die bei einer Zahlung verwendete Zahlungsmethode zu speichern, damit Sie sie für zukünftige Zahlungen desselben Kunden oder derselben Kundin wiederverwenden können.

## Zahlungsmethoden während der Zahlung speichern [Serverseitig]

Sie können das Payment Element so konfigurieren, dass die Zahlungsmethoden Ihrer Kundinnen und Kunden für die zukünftige Verwendung gespeichert werden. In diesem Abschnitt erfahren Sie, wie Sie die neue Funktion für [gespeicherte Zahlungsmethoden](https://docs.stripe.com/payments/save-customer-payment-methods.md) integrieren, mit der das Payment Element Folgendes tun kann:

- Käufer/innen um Zustimmung zur Speicherung einer Zahlungsmethode bitten
- Zahlungsmethoden speichern, wenn Käufer/innen zustimmen
- Gespeicherte Zahlungsmethoden für zukünftige Käufe anzeigen
- [Aktualisieren Sie verlorene oder abgelaufene Karten automatisch](https://docs.stripe.com/payments/cards/overview.md#automatic-card-updates), wenn Käufer/innen sie ersetzen
![Das Kontrollkästchen für Payment Element und eine gespeicherte Zahlungsmethode](https://b.stripecdn.com/docs-statics-srv/assets/spm-save.fe0b24afd0f0a06e0cf4eecb0ce2403a.png)

Zahlungsmethoden speichern.
![Das Payment Element mit einer gespeicherten Zahlungsmethode ausgewählt](https://b.stripecdn.com/docs-statics-srv/assets/spm-saved.5dba5a8a190a9a0e9f1a99271bed3f4b.png)

Verwenden Sie eine zuvor gespeicherte Zahlungsmethode erneut.

### Speichern der Zahlungsmethode im Payment Element aktivieren

Wenn Sie einen [PaymentIntent](https://docs.stripe.com/api/payment_intents/.md) auf Ihrem Server erstellen, erstellen Sie auch eine [CustomerSession](https://docs.stripe.com/api/customer_sessions/.md), mit der Sie die Kunden-ID angeben (entweder mit `customer` für ein `Kunden`-Objekt oder mit `customer_account` für ein von kundenseitig konfiguriertes `Konto`-Objekt) und die Komponente [payment_element](https://docs.stripe.com/api/customer_sessions/object.md#customer_session_object-components-payment_element) für Ihre Sitzung aktivieren. Konfigurieren Sie, welche [Funktionen](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components-payment_element-features) Sie für gespeicherte Zahlungsmethoden aktivieren möchten. Wenn Sie beispielsweise [payment_method_save](https://docs.stripe.com/api/customer_sessions/create.md#create_customer_session-components-payment_element-features-payment_method_save) aktivieren, wird ein Kontrollkästchen angezeigt, in dem Kundinnen/Kunden ihre Zahlungsdaten für die zukünftige Verwendung speichern können.

Sie können `setup_future_usage` für einen PaymentIntent oder eine Checkout-Sitzung angeben, um das Standardverhalten zum Speichern von Zahlungsmethoden zu überschreiben. Dadurch wird sichergestellt, dass Sie die Zahlungsmethode automatisch für die zukünftige Verwendung speichern, auch wenn die Kundin/der Kunde sich nicht explizit dafür entscheidet. Wenn Sie beabsichtigen, `setup_future_usage` anzugeben, legen Sie `payment_method_save_usage` nicht in derselben Transaktion fest, da dies zu einem Integrationsfehler führt.

> #### Verwenden Sie die Accounts&nbsp;v2 API zum Darstellen von Kundinnen und Kunden
> 
> The Accounts v2 API is generally available for Connect users, and in public preview for other Stripe users. If you’re part of the Accounts v2 preview, you need to specify a [specify a preview version](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in your code.
> 
> To request access to the Accounts v2 preview, 
> 
> Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/connect/use-accounts-as-customers.md), anstatt das [Kundenobjekt](https://docs.stripe.com/api/customers.md) zu verwenden.

#### Accounts&nbsp;v2

#### Ruby

```ruby

# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
# Find your keys at https://dashboard.stripe.com/apikeys.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/create-intent-and-customer-session' do
  intent = client.v1.payment_intents.create({
    amount: 1099,
    currency: 'usd',
    automatic_payment_methods: {enabled: true},
    customer_account: {{CUSTOMER_ACCOUNT_ID}},
  })
  customer_session = client.v1.customer_sessions.create({
    customer_account: {{CUSTOMER_ACCOUNT_ID}},
    components: {
      payment_element: {
          enabled: true,
          features: {
            payment_method_redisplay: 'enabled',
            payment_method_save: 'enabled',
            payment_method_save_usage: 'off_session',
            payment_method_remove: 'enabled',
          },
        },
    },
  })
  {
    client_secret: intent.client_secret,
    customer_session_client_secret: customer_session.client_secret
  }.to_json
end
```

#### Customers&nbsp;v1

#### Ruby

```ruby

# Don't put any keys in code. See https://docs.stripe.com/keys-best-practices.
# Find your keys at https://dashboard.stripe.com/apikeys.
client = Stripe::StripeClient.new('<<YOUR_SECRET_KEY>>')

post '/create-intent-and-customer-session' do
  intent = client.v1.payment_intents.create({
    amount: 1099,
    currency: 'usd',
    # In the latest version of the API, specifying the `automatic_payment_methods` parameter
    # is optional because Stripe enables its functionality by default.
    automatic_payment_methods: {enabled: true},
    customer: {{CUSTOMER_ID}},
  })
  customer_session = client.v1.customer_sessions.create({
    customer: {{CUSTOMER_ID}},
    components: {
      payment_element: {
          enabled: true,
          features: {
            payment_method_redisplay: 'enabled',
            payment_method_save: 'enabled',
            payment_method_save_usage: 'off_session',
            payment_method_remove: 'enabled',
          },
        },
    },
  })
  {
    client_secret: intent.client_secret,
    customer_session_client_secret: customer_session.client_secret
  }.to_json
end
```

Ihre Elements-Instanz verwendet das *Client-Geheimnis* (A client secret is used with your publishable key to authenticate a request for a single object. Each client secret is unique to the object it's associated with) der CustomerSession, um auf die gespeicherten Zahlungsmethoden dieses Kunden/dieser Kundin zuzugreifen. [Umgang mit Fehlern](https://docs.stripe.com/error-handling.md), wenn Sie die CustomerSession korrekt erstellen. Wenn ein Fehler auftritt, müssen Sie das Client-Geheimnis der CustomerSession nicht für die Elements-Instanz bereitstellen, da dies optional ist.

Erstellen Sie die Elements-Instanz mit den Client-Geheimnissen sowohl für den PaymentIntent als auch für die CustomerSession. Verwenden Sie dann diese Elements-Instanz, um ein Payment Element zu erstellen.

```javascript
// Create the CustomerSession and obtain its clientSecret
const res = await fetch("/create-intent-and-customer-session", {
  method: "POST"
});

const {
  customer_session_client_secret: customerSessionClientSecret
} = await res.json();

const elementsOptions = {
  clientSecret: '{{CLIENT_SECRET}}',customerSessionClientSecret,
  // Fully customizable with appearance API.
  appearance: {/*...*/},
};

// Set up Stripe.js and Elements to use in checkout form, passing the client secret
// and CustomerSession's client secret obtained in a previous step
const elements = stripe.elements(elementsOptions);

// Create and mount the Payment Element
const paymentElementOptions = { layout: 'accordion'};
const paymentElement = elements.create('payment', paymentElementOptions);
paymentElement.mount('#payment-element');
```

Bei der Bestätigung der PaymentIntent steuert Stripe.js automatisch die Einstellung [setup_future_usage](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-setup_future_usage) für den PaymentIntent und [allow_redisplay](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-allow_redisplay) für die PaymentMethod, je nachdem, ob die Kundin/der Kunde das Kontrollkästchen aktiviert hat, um die Zahlungsdetails zu speichern.

### Erneute Erfassung der CVC erzwingen

Geben Sie optional `require_cvc_recollection` [beim Erstellen der PaymentIntent](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_options-card-require_cvc_recollection) an, um die erneute Erfassung der Prüfziffer/CVC zu erzwingen, wenn ein Kunde/eine Kundin mit einer Karte bezahlt.

### Auswahl einer gespeicherten Zahlungsmethode erkennen

Um dynamische Inhalte zu steuern, wenn eine gespeicherte Zahlungsmethode ausgewählt wird, überwachen Sie das `change`-Ereignis des Payment Element, das automatisch mit der ausgewählten Zahlungsmethode ausgefüllt wird.

```javascript
paymentElement.on('change', function(event) {
  if (event.value.payment_method) {
    // Control dynamic content if a saved payment method is selected
  }
})
```

## Nur Zahlungsmethoden speichern, die eine Wiederverwendung unterstützen [Serverseitig]

Es ist nicht möglich, alle Zahlungsmethoden [wiederverwendbar](https://docs.stripe.com/payments/accept-a-payment.md#save-payment-method-details) zu machen, indem Sie `setup_future_usage` in der Zahlungsabsicht aktivieren. Weitere Informationen darüber, welche Zahlungsmethoden mit `setup_future_usage` kompatibel sind, finden Sie unter [Unterstützte Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/payment-method-support.md#additional-api-supportability).

Stattdessen können Sie Zahlungsmethoden-Details nur dann speichern, wenn ein Kunde oder eine Kundin eine Zahlungsmethode auswählt, die dies unterstützt. Wenn Sie beispielsweise sowohl Kartenzahlungen als auch Giropay akzeptieren (das Sie nicht wiederverwenden können), konfigurieren Sie `setup_future_usage=off_session` im Objekt `payment_method_options[card]`.

Wenn Kund/innen die Speicherung ihrer Zahlungsdaten ablehnen, deaktivieren Sie `setup_future_usage` im PaymentIntent auf der Serverseite. Diese Anpassung auf Client-Seite wird von uns nicht unterstützt.

#### Zahlungsmethoden über das Dashboard verwalten

Zahlungsmethoden können Sie über das [Dashboard](https://dashboard.stripe.com/settings/payment_methods) verwalten. Stripe handhabt die Rückgabe geeigneter Zahlungsmethoden basierend auf Faktoren wie Betrag, Währung und Zahlungsablauf der Transaktion.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "automatic_payment_methods[enabled]"="true" \
  -d "payment_method_options[card][setup_future_usage]"="off_session"
```

#### Zahlungsmethoden manuelle auflisten

Alternativ können Sie `card` und `giropay` unter Verwendung von [Zahlungsmethodentypen](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-payment_method_types) wie im folgenden Beispiel auflisten.

#### curl

```bash
curl https://api.stripe.com/v1/payment_intents \
  -u <<YOUR_SECRET_KEY>>: \
  -d "amount"=1099 \
  -d "currency"="usd" \
  -d "payment_method_types[]"="card" \
  -d "payment_method_types[]"="giropay" \
  -d "payment_method_options[card][setup_future_usage]"="off_session"
```

## Gespeicherte Zahlungsmethode später belasten [Serverseitig]

> Die Zahlungsmethoden `bancontact`, `ideal` und `sofort` sind standardmäßig für die einmalige Nutzung gedacht. Wenn sie für die zukünftige Verwendung eingerichtet werden, wird eine wiederverwendbare Art der Zahlungsmethode `sepa_debit` erzeugt. Sie müssen dann `sepa_debit` verwenden, um gespeicherte Zahlungsmethoden abzufragen.

> #### Compliance
> 
> Sie sind für die Einhaltung aller geltenden Gesetze, Vorschriften und Netzwerkregeln verantwortlich, wenn Sie die Zahlungsdaten von Kundinnen und Kunden speichern. Wenn Sie Ihren Endkundinnen und Endkunden zuvor genutzte Zahlungsmethoden für zukünftige Einkäufe anzeigen, dürfen Sie nur Zahlungsmethoden auflisten, für die Sie bereits eine kundenseitige Zustimmung eingeholt haben, dank der Sie die Details der Zahlungsmethode für diese spezifische zukünftige Verwendung speichern können. Verwenden Sie den Parameter [allow_redisplay](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-allow_redisplay), um zwischen Zahlungsmethoden zu unterscheiden, die mit Kundinnen und Kunden verknüpft sind und Ihren Endkundinnen und Endkunden als gespeicherte Zahlungsmethode für zukünftige Einkäufe angezeigt werden können oder nicht.

Um eine Zahlungsmethode zum Belasten zu finden, listen Sie die Zahlungsmethoden auf, die mit Ihrer Kundin/Ihrem Kunden verknüpft sind. In diesem Beispiel sind Karten aufgeführt, Sie können jedoch jeden unterstützten [Typ](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-type) auflisten.

> #### Verwenden Sie die Accounts&nbsp;v2 API zum Darstellen von Kundinnen und Kunden
> 
> The Accounts v2 API is generally available for Connect users, and in public preview for other Stripe users. If you’re part of the Accounts v2 preview, you need to specify a [specify a preview version](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in your code.
> 
> To request access to the Accounts v2 preview, 
> 
> Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/connect/use-accounts-as-customers.md), anstatt das [Kundenobjekt](https://docs.stripe.com/api/customers.md) zu verwenden.

#### Accounts&nbsp;v2

```curl
curl -G https://api.stripe.com/v1/payment_methods \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d type=card
```

#### Customers&nbsp;v1

```curl
curl -G https://api.stripe.com/v1/payment_methods \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer={{CUSTOMER_ID}}" \
  -d type=card
```

Wenn Sie bereit sind, die Zahlungsmethode Ihrer Kundin/Ihres Kunden *off-session* (A payment is described as off-session if it occurs without the direct involvement of the customer, using previously-collected payment information) zu belasten, verwenden Sie die Kunden-ID und die `PaymentMethod`-ID, um einen `PaymentIntent` mit dem Betrag und der Währung der Zahlung zu erstellen. Legen Sie einige weitere Parameter fest, um die Off-Session-Zahlung durchzuführen:

- Legen Sie [off_session](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-off_session) auf `true` fest, um anzugeben, dass der Kunde/die Kundin sich während eines Zahlungsversuchs nicht in Ihrem Bezahlvorgang befindet und somit eine Authentifizierungsanfrage eines Partners, wie z.&nbsp;B. eines Kartenausstellers, einer Bank oder eines anderen Zahlungsinstituts, nicht erfüllen kann. Wenn ein Partner während Ihres Bezahlvorgangs eine Authentifizierung anfordert, fordert Stripe Ausnahmen unter Verwendung von Kundendetails aus einer vorherigen *On-Session*-Transaktion an. Wenn die Bedingungen für die Ausnahme nicht erfüllt sind, kann der `PaymentIntent` einen Fehler ergeben.
- Legen Sie den Wert der Eigenschaft [confirm](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-confirm) des `PaymentIntent` auf „true“ fest, wodurch die Bestätigung sofort beim Erstellen des `PaymentIntent` erfolgt.
- Legen Sie [payment_method](https://docs.stripe.com/api.md#create_payment_intent-payment_method) auf die ID der `PaymentMethod` fest.
- Je nachdem, wie Sie Kundinnen/Kunden in Ihrer Integration darstellen, legen Sie entweder [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) auf die ID des kundenseitig konfigurierten `Kontos` oder [customer](https://docs.stripe.com/api.md#create_payment_intent-customer) auf die `Kunden`-ID fest.

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d "automatic_payment_methods[enabled]=true" \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d payment_method={{PAYMENT_METHOD_ID}} \
  --data-urlencode "return_url=https://example.com/order/123/complete" \
  -d off_session=true \
  -d confirm=true
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d amount=1099 \
  -d currency=usd \
  -d "automatic_payment_methods[enabled]=true" \
  -d "customer={{CUSTOMER_ID}}" \
  -d payment_method={{PAYMENT_METHOD_ID}} \
  --data-urlencode "return_url=https://example.com/order/123/complete" \
  -d off_session=true \
  -d confirm=true
```

## Integration testen

Verwenden Sie Test-Zahlungsdaten und die Test-Weiterleitungsseite um Ihre Integration zu überprüfen. Klicken Sie auf die nachfolgenden Registerkarten, um Details zu jeder Zahlungsmethode anzuzeigen.

#### Karten

| Zahlungsmethode | Szenario                                                                                                                                                                                                                                                                                                                                       | So führen Sie den Test durch                                                                                                                                 |
| --------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Kreditkarte     | Die Einrichtung der Karte ist erfolgreich und es ist keine *Authentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4242 4242 4242 4242` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. |
| Kreditkarte     | Die Karte erfordert für die Ersteinrichtung, um nachfolgende Zahlungen erfolgreich abschließen zu können.                                                                                                                                                                                                                                      | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4000 0025 0000 3155` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. |
| Kreditkarte     | Die Karte erfordert für die Ersteinrichtung sowie für nachfolgende Zahlungen eine Authentifizierung.                                                                                                                                                                                                                                           | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4000 0027 6000 3184` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. |
| Kreditkarte     | Die Karte wurde während der Einrichtung abgelehnt.                                                                                                                                                                                                                                                                                             | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer `4000 0000 0000 9995` mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. |

#### Bankumleitungen

| Zahlungsmethode  | Szenario                                                                                                                                                                     | So führen Sie den Test durch                                                                                                                                                                     |
| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Bancontact       | Ihr/e Kund/in richtet erfolgreich die Zahlungsmethode SEPA-Lastschrift für zukünftige Nutzung durch Bancontact ein.                                                          | Geben Sie im Bancontact-Formular einen beliebigen Namen ein und klicken Sie dann auf der Weiterleitungsseite auf die Option **Testeinrichtung autorisieren**.                                    |
| Bancontact       | Ihre Kundin/Ihr Kunde konnte sich auf der Bancontact-Weiterleitungsseite nicht authentifizieren.                                                                             | Geben Sie im Bancontact-Formular einen beliebigen Namen ein und klicken Sie dann auf der Weiterleitungsseite auf die Option für eine **fehlgeschlagene Testeinrichtung**.                        |
| BECS-Lastschrift | Ihr/e Kund/in zahlt erfolgreich mit dem BECS-Lastschriftverfahren.                                                                                                           | Füllen Sie das Formular mit der Kontonummer `900123456` aus. Die bestätigte PaymentIntent geht zunächst in den Status `processing` über und dann 3 Minuten später in den Status `succeeded`.     |
| BECS-Lastschrift | Die Zahlung Ihres/Ihrer Kund/in schlägt fehl mit Code `account_closed` fehl.                                                                                                 | Füllen Sie das Formular mit der Kontonummer `111111113` aus.                                                                                                                                     |
| iDEAL            | Ihr Kunde/Ihre Kundin richtet die Zahlungsmethode [SEPA-Lastschrift](https://docs.stripe.com/payments/sepa-debit.md) erfolgreich für die zukünftige Nutzung durch iDEAL ein. | Geben Sie im iDEAL-Formular einen beliebigen Namen und eine beliebige Bank ein und klicken Sie dann auf der Weiterleitungsseite auf die Option zum **Autorisieren der Testeinrichtung**.         |
| iDEAL            | Ihr/Ihre Kund/in konnte sich auf der iDEAL-Weiterleitungsseite nicht authentifizieren.                                                                                       | Wählen Sie eine beliebige Bank, verwenden Sie einen beliebigen Namen im iDEAL-Formular und klicken Sie dann auf der Weiterleitungsseite auf die Option **Einrichtung des Tests fehlgeschlagen**. |

#### Lastschriften

| Zahlungsmethode  | Szenario                                                                                                 | So führen Sie den Test durch                                                                                                                                                                                       |
| ---------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| SEPA-Lastschrift | Ihr/e Kund/in zahlt erfolgreich mit dem SEPA-Lastschriftverfahren.                                       | Füllen Sie das Formular mit der Kontonummer `AT321904300235473204` aus. Die bestätigte PaymentIntent geht zunächst in den Status „wird verarbeitet“ und dann drei Minuten später in den Status „erfolgreich“ über. |
| SEPA-Lastschrift | Der Status der PaymentIntent Ihres/Ihrer Kund/in wechselt von `processing` zu `requires_payment_method`. | Füllen Sie das Formular mit der Kontonummer `AT861904300235473202` aus.                                                                                                                                            |

### Testen Sie das Belasten mit einer gespeicherten SEPA-Lastschrift

Wenn der PaymentIntent  für die Nutzung mit iDEAL, Bancontact oder Sofort bestätigt ist, wird eine wiederverwendbare [SEPA-Lastschrift](https://docs.stripe.com/payments/sepa-debit.md) *-PaymentMethod* (PaymentMethods represent your customer's payment instruments, used with the Payment Intents or Setup Intents APIs) erstellt. SEPA-Lastschrift ist eine Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification), die in den Übergangsstatus `processing` wechselt, bevor sie einige Tage später den Status `succeeded` oder `requires_payment_method` annimmt.

#### E-Mail-Adresse

Setzen Sie `payment_method.billing_details.email` auf einen der folgenden Werte, um die `PaymentIntent`-Statusübergänge zu testen. Sie können Ihren eigenen benutzerdefinierten Text am Anfang der E-Mail-Adresse, gefolgt von einem Unterstrich, einfügen. Beispielsweise ergibt sich aus `test_1_generatedSepaDebitIntentsFail@example.com` eine SEPA-Lastschrift-PaymentMethod, die immer fehlschlägt, wenn sie mit einem `PaymentIntent` verwendet wird.

| E-Mail-Adresse                                                     | Beschreibung                                                                                                                          |
| ------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------- |
| `generatedSepaDebitIntentsSucceed@example.com`                     | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `erfolgreich`.                                                       |
| `generatedSepaDebitIntentsSucceedDelayed@example.com`              | Der Status des `PaymentIntent` wechselt nach drei Minuten von `wird bearbeitet` zu `erfolgreich`.                                     |
| `generatedSepaDebitIntentsFail@example.com`                        | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `requires_payment_method`.                                           |
| `generatedSepaDebitIntentsFailDelayed@example.com`                 | Der Status des `PaymentIntent` wechselt nach mindestens drei Minuten von `wird bearbeitet` zu `requires_payment_method`.              |
| `generatedSepaDebitIntentsSucceedDisputed@example.com`             | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `erfolgreich`, aber es wird sofort eine Zahlungsanfechtung erstellt. |
| `generatedSepaDebitIntentsFailsDueToInsufficientFunds@example.com` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `requires_payment_method` mit dem Fehlercode `insufficient_funds`.   |

#### PaymentMethod

Verwenden Sie diese PaymentMethods, um die `PaymentIntent`-Statusübergänge zu testen. Diese Token sind nützlich für automatisierte Test, um die PaymentMethod sofort zum SetupIntent auf dem Server hinzuzufügen.

| Zahlungsmethode                                                      | Beschreibung                                                                                                                          |
| -------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| `pm_bancontact_generatedSepaDebitIntentsSucceed`                     | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `erfolgreich`.                                                       |
| `pm_bancontact_generatedSepaDebitIntentsSucceedDelayed`              | Der Status des `PaymentIntent` wechselt nach drei Minuten von `wird bearbeitet` zu `erfolgreich`.                                     |
| `pm_bancontact_generatedSepaDebitIntentsFail`                        | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `requires_payment_method`.                                           |
| `pm_bancontact_generatedSepaDebitIntentsFailDelayed`                 | Der Status des `PaymentIntent` wechselt nach mindestens drei Minuten von `wird bearbeitet` zu `requires_payment_method`.              |
| `pm_bancontact_generatedSepaDebitIntentsSucceedDisputed`             | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `erfolgreich`, aber es wird sofort eine Zahlungsanfechtung erstellt. |
| `pm_bancontact_generatedSepaDebitIntentsFailsDueToInsufficientFunds` | Der Status des `PaymentIntent` wechselt von `wird bearbeitet` zu `requires_payment_method` mit dem Fehlercode `insufficient_funds`.   |

## See also

- [Zahlungsdaten bei In-App-Zahlungen speichern](https://docs.stripe.com/payments/mobile/save-during-payment.md)
- [Zahlungsdetails in einer Checkout-Sitzung speichern](https://docs.stripe.com/payments/checkout/how-checkout-works.md#save-payment-methods)
- [Zukünftige Zahlungen einrichten](https://docs.stripe.com/payments/save-and-reuse.md)
- [Ereignisse nach der Zahlung verarbeiten](https://docs.stripe.com/webhooks/handling-payment-events.md)