# Erfassen Sie ein Konto, um datengestützte Produkte zu entwickeln

Erfassen Sie die Konten Ihrer Nutzer/innen und nutzen Sie Daten wie Salden, Eigentumsrechte und Transaktionen zum Erstellen von Produkten.
Available in: US
Sie sind sich nicht sicher, welche Financial Connections-Integration Sie verwenden sollen? Sehen Sie sich unsere [Übersicht der Integrationsoptionen](https://docs.stripe.com/financial-connections/use-cases.md) an.

Mit Financial Connections können Ihre Nutzer/innen ihre Finanzdaten sicher teilen, indem sie ihre externen Finanzkonten mit Ihrem Unternehmen verknüpfen. Sie können Financial Connections verwenden, um auf von den Nutzer/innen freigegebene Finanzdaten zuzugreifen, wie zum Beispiel tokenisierte Konto- und Routingnummern, Kontoguthaben, Angaben zum Inhaber/zur Inhaberin des Kontos und historische Transaktionen.

Einige gängige Beispiele dafür, wie Sie Financial Connections nutzen können, um das Produkterlebnis für Ihre Nutzer/innen zu verbessern:

- Verringern Sie Betrug beim Onboarding eines Kunden/einer Kundin oder eines Unternehmens, indem Sie die Angaben zur [Inhaberschaft](https://docs.stripe.com/financial-connections/ownership.md) eines Kontos, wie den Namen und die Adresse der Bankkontoinhaber/innen verifizieren.
- Hilft Ihren Nutzern und Nutzerinnen Ausgaben zu verfolgen, Rechnungen zu bearbeiten, ihre Finanzen zu verwalten und mit [Transaktionsdaten](https://docs.stripe.com/financial-connections/transactions.md) die Kontrolle über ihr finanzielles Wohlergehen zu übernehmen.
- Beschleunigung der Risikoevaluation und Verbesserung des Zugangs zu Krediten und anderen Finanzdienstleistungen mit Transaktionen und Saldodaten.
- Mit Enable können Ihre Nutzer/innen ihre Konten in wenigen Schritten mit Link verknüpfen. So können sie ihre Bankkontodaten bei Stripe-Unternehmen speichern und wiederverwenden.

## Stripe einrichten [Serverseitig] [Clientseitig]

### Serverseitig

Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus:

#### Ruby

```bash
# Available as a gem
sudo gem install stripe
```

```ruby
# If you use bundler, you can add this line to your Gemfile
gem 'stripe'
```

### Clientseitig

Das [React Native SDK](https://github.com/stripe/stripe-react-native) ist Open Source und vollständig dokumentiert. Intern werden [native iOS](https://github.com/stripe/stripe-ios) und [Android](https://github.com/stripe/stripe-android) SDKs verwendet. Um das React Native SDK von Stripe zu installieren, führen Sie einen der folgenden Befehle im Verzeichnis Ihres Projekts aus (je nachdem, welchen Paket-Manager Sie verwenden):

#### yarn

```bash
yarn add @stripe/stripe-react-native
```

#### npm

```bash
npm install @stripe/stripe-react-native
```

Installieren Sie als Nächstes einige weitere erforderliche Abhängigkeiten:

- For iOS, go to the **ios** directory and run `pod install` to make sure that you also install the required native dependencies.
- Für Android müssen keine Abhängigkeiten mehr installiert werden.

> Wir empfehlen Ihnen, die [offizielle Anleitung zu TypeScript](https://reactnative.dev/docs/typescript#adding-typescript-to-an-existing-project) zu befolgen, um TypeScript zu unterstützen.

### Stripe Initialisierung

Um Stripe in Ihrer React Native-App zu initialisieren, umschließen Sie entweder Ihren Zahlungsbildschirm mit der Komponente `StripeProvider` oder verwenden Sie die Initialisierungsmethode `initStripe`. Nur der [veröffentlichbare API-Schlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) in `publishableKey` ist erforderlich. Das folgende Beispiel zeigt, wie Stripe mithilfe der Komponente `StripeProvider` initialisiert wird.

```jsx
import { useState, useEffect } from 'react';
import { StripeProvider } from '@stripe/stripe-react-native';

function App() {
  const [publishableKey, setPublishableKey] = useState('');

  const fetchPublishableKey = async () => {
    const key = await fetchKey(); // fetch key from your server here
    setPublishableKey(key);
  };

  useEffect(() => {
    fetchPublishableKey();
  }, []);

  return (
    <StripeProvider
      publishableKey={publishableKey}
      merchantIdentifier="merchant.identifier" // required for Apple Pay
      urlScheme="your-app" // required for 3D Secure and bank redirects
    >
      {/* Your app code here */}
    </StripeProvider>
  );
}
```

> Verwenden Sie Ihre API-[Testschlüssel](https://docs.stripe.com/keys.md#obtain-api-keys) beim Testen und Entwickeln Ihrer App und Ihre [Live-Modus](https://docs.stripe.com/keys.md#test-live-modes)-Schlüssel beim Veröffentlichen Ihrer App.

## Kundinnen/Kunden erstellen oder abrufen [Serverseitig]

Erstellen Sie ein kundenkonfiguriertes [Konto](https://docs.stripe.com/api/v2/core/accounts/create.md#v2_create_accounts-configuration-customer) oder einen [Kundin/Kunden](https://docs.stripe.com/api/customers/create.md), wenn Nutzer/innen ein Konto bei Ihrem Unternehmen erstellen. Financial Connections kann die E-Mail-Adresse verwenden, um wiederkehrende Nutzer/innen von [Link](https://support.stripe.com/questions/link-for-financial-connections-support-for-businesses) zu identifizieren und den [Authentifizierungsablauf](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) zu optimieren, indem dynamisch eine vereinfachte Nutzeroberfläche angezeigt wird.

> #### Verwenden Sie die Accounts&nbsp;v2 API zum Darstellen von Kundinnen und Kunden
> 
> Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn Sie an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben.
> 
> Um der Vorschau von Accounts v2 beizutreten, gehen Sie zu [Kontovorschauen und -funktionen](https://dashboard.stripe.com/settings/previews) in Ihrem Dashboard und aktivieren Sie **wiederverwendbare Zahlungsmethoden für Global Payouts**.
> 
> 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/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden.

#### Accounts&nbsp;v2

```curl
curl -X POST https://api.stripe.com/v2/core/accounts \
  -H "Authorization: Bearer <<YOUR_SECRET_KEY>>" \
  -H "Stripe-Version: 2026-10-28.preview" \
  --json '{
    "contact_email": "{{CUSTOMER_EMAIL}}",
    "display_name": "{{CUSTOMER_NAME}}",
    "configuration": {
        "customer": {}
    },
    "include": [
        "configuration.customer"
    ]
  }'
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/customers \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d email={{CUSTOMER_EMAIL}} \
  -d name={{CUSTOMER_NAME}}
```

## Financial Connections-Sitzung erstellen [Serverseitig]

> Eine laufende Implementierung dieses Endpoints für schnelle Tests ist [auf Glitch verfügbar](https://glitch.com/edit/#!/remix/stripe-mobile-connections-example).

Bevor Sie mit Financial Connections Daten vom Bankkonto eines Nutzers/einer Nutzerin abrufen können, muss Ihr/e Nutzer/in sein/ihr Konto über den [Authentifizierungsvorgang](https://docs.stripe.com/financial-connections/fundamentals.md#authentication-flow) authentifizieren.

{% ignore-validation terms=[“Link”] reason="Allgemeiner Linktext für eine Schaltflächenbeschriftung, nicht für das Zahlungsprodukt Link. %}Ihr/e Nutzer/in startet den Authentifizierungsablauf, wenn er sein Konto mit Ihrer Website oder Anwendung verknüpfen möchte. Fügen Sie auf Ihrer Website oder in Ihrer Anwendung eine Schaltfläche oder einen Link ein, über den ein Nutzer sein Konto verknüpfen kann&nbsp;– Ihre Schaltfläche könnte beispielsweise die Aufschrift „Bankkonto verknüpfen“ tragen.

Erstellen Sie eine Financial Connections-Sitzung, indem Sie sie unter `/v1/financial_connections/sessions` angeben:

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/financial_connections/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "account_holder[type]=customer" \
  -d "account_holder[customer_account]={{CUSTOMERACCOUNT_ID}}" \
  -d "permissions[]=balances" \
  -d "permissions[]=ownership" \
  -d "permissions[]=payment_method" \
  -d "permissions[]=transactions"
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/financial_connections/sessions \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "account_holder[type]=customer" \
  -d "account_holder[customer]={{CUSTOMER_ID}}" \
  -d "permissions[]=balances" \
  -d "permissions[]=ownership" \
  -d "permissions[]=payment_method" \
  -d "permissions[]=transactions"
```

1. Verwenden Sie die Kunden-ID, um [account_holder.customer_account](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-account_holder-customer_account) (für von Kunden und Kundinnen konfigurierte `Konto`-Objekte) oder [account_holder.customer](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-account_holder-customer) (für `Kundenobjekte`) festzulegen.
2. Fügen Sie die für Ihren Anwendungsfall erforderlichen Daten zum Array [Berechtigungen](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-permissions) hinzu.
3. (Optional) Legen Sie den [Prefetch](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-prefetch)-Parameter für das Abrufen der Daten bei der Kontoerstellung fest.

Der Parameter [Berechtigungen](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-permissions) steuert, auf welche Kontodaten Sie zugreifen können. Sie müssen mindestens eine Berechtigung anfordern. Wenn Sie den Authentifizierungsablauf abschließen, können Ihre Nutzer/innen die Daten sehen, auf die Sie Zugriff beantragt haben, und ihre Zustimmung zur Weitergabe erteilen.

Überlegen Sie sorgfältig, welche Daten Sie für Ihren Use Case benötigen und fordern Sie die Berechtigung zum Zugriff nur für die von Ihnen benötigten Daten an. Wenn Sie Berechtigungen anfordern, die über den Umfang Ihrer Anwendung hinausgehen, ist es möglich, dass Nutzer/innen Ihnen nicht mehr volles Vertrauen schenken, da sie sich fragen, wie ihre Daten verwendet werden. Wenn Sie zum Beispiel eine Anwendung für die persönliche Finanzverwaltung oder ein Kreditprodukt entwickeln, möchten Sie möglicherweise die `transactions`-Daten anfordern. Zur Eindämmung von Betrug fordern Sie möglicherweise Details zur `ownership` an.

Nachdem Ihre Nutzer/innen ihr Konto authentifiziert haben, können Sie Datenberechtigungen nur erweitern, indem Sie eine neue Financial Connections-Sitzung erstellen und einen neuen Wert im Parameter `permissions` angeben. Ihr/e Nutzer/in muss das Authentifizierungsverfahren erneut durchführen, wobei er/sie die zusätzlichen Daten sieht, für die Sie die Zugriffsberechtigung angefordert haben, und seine/ihre Zustimmung zum Teilen der Daten erteilt.

Der optionale [Prefetch-Parameter](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-prefetch) steuert, welche Daten Sie unmittelbar nach der Verbindung des Nutzers/der Nutzerin mit seinem/ihren Konto abrufen. Verwenden Sie diese Option, wenn Sie wissen, dass Sie immer eine bestimmte Art von Daten wünschen. So entfällt die Notwendigkeit, einen zusätzlichen API-Aufruf durchzuführen, um eine [Datenaktualisierung zu](https://docs.stripe.com/api/financial_connections/accounts/refresh.md) initiieren.

Um die Option beizubehalten, [Zahlungen per ACH-Lastschriftverfahren zu akzeptieren](https://docs.stripe.com/financial-connections/other-data-powered-products.md#accept-ach-direct-debit), fordern Sie die Berechtigung `payment_method` an. Um Konten auszuschließen, die nicht für Zahlungen per ACH Direct Debit verwendet werden können, setzen Sie den Parameter [filters.require_payment_method_support](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-filters-require_payment_method_support) auf `all`. Wenn Sie nur ein einzelnes Konto benötigen, setzen Sie außerdem [limits.accounts](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-limits) auf `1`.

## Financial Connections-Konto eröffnen [Client-seitig]

Importieren Sie die Funktion `collectFinancialConnectionsAccounts` aus dem React Native SDK von Stripe.

```javascript
import {collectFinancialConnectionsAccounts} from '@stripe/stripe-react-native';
```

Verwenden Sie `collectFinancialConnectionsAccounts`, um das Bankkonto zu erfassen, indem Sie das `client_secret` von oben übergeben, und das Ergebnis dann folgendermaßen behandeln:

```javascript
// Assume you have a <Button /> to collect payout accounts, whose onPress is handleCollectPress
const handleCollectPress = async () => {
  // Fetch the clientSecret you created above and pass it to collectFinancialConnectionsAccounts
  const {session, error} = await collectFinancialConnectionsAccounts(
    clientSecret,
  );

  if (error) {
    Alert.alert(`Error code: ${error.code}`, error.message);
  } else {
    Alert.alert('Success');
    console.log(
      'Successfully obtained session: ',
      JSON.stringify(session, null, 2),
    );
  }
};
```

`collectFinancialConnectionsAccounts` gibt ein `Promise` zurück. Wenn Nutzer/innen den Modal-Flow abschließen, wird `Promise` mit einem der folgenden Punkte aufgelöst:

- Eine `session`, die die abgeschlossene Financial Connections-Sitzung darstellt, wenn die Nutzer/innen ihr Konto erfolgreich verknüpfen können. Diese `session` enthält das Array `accounts`, das die Liste der verbundenen Konten enthält.
- Es wird `error` ausgegeben, wenn die Sitzung fehlschlägt oder abgebrochen wird.

Standardmäßig können Ihre verbundenen Konten im Authentifizierungsablauf nur Kontotypen wie Giro- oder Sparkonten hinzufügen, da Stripe nur Auszahlungen an ein ACH-fähiges Konto ermöglichen kann.

## Optional: Bankkonto-Collector anpassen [Clientseitig]

### Dunkelmodus

Standardmäßig wechselt der Bankkonto-Collector basierend auf den Geräteeinstellungen automatisch zwischen Farben, die mit dem hellen und dem dunklen Modus kompatibel sind. Wenn Ihre App den dunklen oder den hellen Modus nicht unterstützt, können Sie den `style` auf `alwaysLight` bzw. `alwaysDark` setzen.

```javascript
const {session, error} = await collectFinancialConnectionsAccounts(
   clientSecret,
   {
     style: 'alwaysLight',
   },
);
```

Um in Ihrer Android-App eine immer helle oder immer dunkle Darstellung zu erzielen, nutzen Sie `AppCompatDelegate` von Android. Unsere Nutzeroberfläche berücksichtigt diese Einstellung automatisch.

#### Kotlin

```kotlin
// force dark
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
// force light
AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
```

## Rückgabe-URL einrichten (nur für iOS) [Clientseitig]

Wenn Kundinnen/Kunden Ihre App verlassen (zum Beispiel um sich in Safari oder ihrer Banking-App zu authentifizieren), bieten Sie ihnen eine Möglichkeit, automatisch zu Ihrer App zurückzukehren. Für viele Arten von Zahlungsmethoden *ist* eine Rückgabe-URL erforderlich. Wenn Sie keine angeben, können wir Ihren Nutzer/innen keine Zahlungsmethoden anbieten, für die eine Rückgabe-URL erforderlich ist, selbst wenn Sie diese aktiviert haben.

So geben Sie eine Rückgabe-URL an:

1. [Registrieren](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app#Register-your-URL-scheme) Sie eine benutzerdefinierte URL. Universelle Links werden nicht unterstützt.
2. [Konfigurieren](https://reactnative.dev/docs/linking) Sie Ihre benutzerdefinierte URL.
3. Richten Sie Ihre Root-Komponente so ein, dass sie die URL an das Stripe SDK weitergibt, wie unten gezeigt.

> Wenn Sie Expo verwenden, [stellen Sie Ihr Schema](https://docs.expo.io/guides/linking/#in-a-standalone-app) in der Datei `app.json` ein.

```jsx
import { useEffect, useCallback } from 'react';
import { Linking, View } from 'react-native';
import { useStripe } from '@stripe/stripe-react-native';

export default function MyApp() {
  const { handleURLCallback } = useStripe();

  const handleDeepLink = useCallback(
    async (url: string | null) => {
      if (url) {
        const stripeHandled = await handleURLCallback(url);
        if (stripeHandled) {
          // This was a Stripe URL - you can return or add extra handling here as you see fit
        } else {
          // This was NOT a Stripe URL – handle as you normally would
        }
      }
    },
    [handleURLCallback]
  );

  useEffect(() => {
    const getUrlAsync = async () => {
      const initialUrl = await Linking.getInitialURL();
      handleDeepLink(initialUrl);
    };

    getUrlAsync();

    const deepLinkListener = Linking.addEventListener(
      'url',
      (event: { url: string }) => {
        handleDeepLink(event.url);
      }
    );

    return () => deepLinkListener.remove();
  }, [handleDeepLink]);

  return (
    <View>
      <AwesomeAppComponent />
    </View>
  );
}
```

Weitere Informationen zu nativen URL-Schemen finden Sie in der Dokumentation für [Android](https://developer.android.com/training/app-links/deep-linking) und [iOS](https://developer.apple.com/documentation/xcode/allowing_apps_and_websites_to_link_to_your_content/defining_a_custom_url_scheme_for_your_app).

## Daten für ein Financial Connections-Konto abrufen [Serverseitig]

Nachdem Ihr/e Nutzer/in das Authentifizierungsverfahren erfolgreich abgeschlossen hat, greifen Sie auf die Kontodaten zu, die Sie im Parameter `permissions` der Financial Connections-Sitzung angegeben haben, oder aktualisieren Sie diese.

Um die Privatsphäre der Daten Ihrer Nutzer/innen zu schützen, sind die für Sie zugänglichen Kontodaten auf die Daten beschränkt, die Sie im Parameter `permissions` angegeben haben.

Folgen Sie den Leitfäden für [Guthaben](https://docs.stripe.com/financial-connections/balances.md), [Inhaberschaft](https://docs.stripe.com/financial-connections/ownership.md) und [Transaktionen](https://docs.stripe.com/financial-connections/transactions.md), um mit dem Abruf von Kontodaten zu beginnen.

## Optional: ACH-Lastschriftzahlung von einem Financial Connections-Konto akzeptieren

Sie können optional ACH-Lastschriftzahlungen über ein zuvor erfasstes Financial Connections-Konto akzeptieren, solange das Attribut `supported_payment_method_types` des Kontos `us_bank_account` enthält. Um sicherzustellen, dass die Sitzung mindestens ein Konto zurückgibt, das ACH-Lastschriftzahlungen unterstützt, setzen Sie den Parameter [filters.require_payment_method_support](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-filters-require_payment_method_support) auf `all`, wenn Sie die Sitzung erstellen.

Nur US-Bankkonten können ACH-Lastschriften akzeptieren, beispielsweise Giro- oder Sparkonten.

Um eine ACH-Lastschriftzahlung für ein zuvor erfasstes Konto zu akzeptieren, müssen Sie in der Financial Connections-Sitzung `payment_method` im Parameter [data permissions](https://docs.stripe.com/financial-connections/fundamentals.md#data-permissions) angegeben haben.

### Manuelle Eingabe als Fallback zulassen

Die Sofortverifizierung ist nicht für jedes Bankkonto verfügbar. Damit Ihre Nutzer/innen ihre Bankdaten manuell eingeben können, setzen Sie den Parameter [manual_entry.mode](https://docs.stripe.com/api/financial_connections/sessions/create.md#financial_connections_create_session-manual_entry-mode) auf `automatic`, wenn Sie die Sitzung erstellen.

Manuell eingegebene Konten erfordern eine Verifizierung durch Mikroeinzahlungen, die 1–2 Werktage dauert. Wenn Sie `filters.require_payment_method_support` auf `all` setzen, ist nicht garantiert, dass ein manuell eingegebenes Konto verifiziert werden kann oder ACH-Lastschriftzahlungen unterstützt.

Wenn Ihre Nutzer/innen ihre Bankdaten manuell eingeben, enthält die Eigenschaft `bank_account_token` der Sitzung ein Bankkonto-Token und die Liste `accounts` ist leer:

```json
{
  "id": "fcsess_1Oacb82eZvKYlo2Cd4v3gvnD",
  "object": "financial_connections.session",
  "permissions": ["payment_method"],
  "accounts": {
    "object": "list",
    "data": [],
    "has_more": false,
    "total_count": 0,
    "url": "/v1/financial_connections/accounts?session=fcsess_1Oacb82eZvKYlo2Cd4v3gvnD"
  },
  "bank_account_token": {
    "id": "btok_1N3T00LkdIwHu7ixt44h1F8k",
    "object": "token",
    "bank_account": {
      "id": "ba_1NWScr2eZvKYlo2C8MgV5Cwn",
      "object": "bank_account",
      "account_holder_name": "Jenny Rosen",
      "account_holder_type": "individual",
      "account_type": null,
      "bank_name": "STRIPE TEST BANK",
      "country": "US",
      "currency": "usd",
      "fingerprint": "1JWtPxqbdX5Gamtz",
      "last4": "6789",
      "routing_number": "110000000",
      "status": "new"
    },
    "client_ip": null,
    "created": 1689981645,
    "livemode": false,
    "redaction": null,
    "type": "bank_account",
    "used": false
  },
  "status": "succeeded"
}
```

### Payment Intent oder Setup Intent erstellen

Verwenden Sie die *Payment Intents API* (The Payment Intents API tracks the lifecycle of a customer checkout flow and triggers additional authentication steps when required by regulatory mandates, custom Radar fraud rules, or redirect-based payment methods), um eine ACH-Lastschriftzahlung für ein Konto zu akzeptieren, das Sie jetzt belasten möchten. Verwenden Sie die *Setup Intents API* (The Setup Intents API lets you build dynamic flows for collecting payment method details for future payments. It tracks the lifecycle of a payment setup flow and can trigger additional authentication steps if required by law or by the payment method), um Daten für zukünftige ACH-Lastschriftzahlungen zu speichern. [Erfahren Sie mehr über den Unterschied zwischen](https://support.stripe.com/questions/payment-intents-api-vs-setup-intents-api) einem Payment Intent und einem Setup Intent.

Dieser Pfad zeigt Ihnen, wie Sie eine ACH-Lastschriftzahlung mit der Payment Intents API akzeptieren können.

Verwenden Sie die Financial Connections-Konto-ID und die Kunden-ID, um einen `PaymentIntent` zu erstellen:

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_data[us_bank_account][financial_connections_account]={{FINANCIALCONNECTIONSACCOUNT_ID}}" \
  -d "payment_method_data[type]=us_bank_account" \
  -d "payment_method_data[billing_details][name]=J. Customer" \
  -d amount=100 \
  -d currency=usd
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_data[us_bank_account][financial_connections_account]={{FINANCIALCONNECTIONSACCOUNT_ID}}" \
  -d "payment_method_data[type]=us_bank_account" \
  -d "payment_method_data[billing_details][name]=J. Customer" \
  -d amount=100 \
  -d currency=usd
```

Wenn Ihre Nutzer/innen ihre Bankdaten manuell eingegeben haben, verwenden Sie das Bankkonto-Token anstelle der Financial Connections-Konto-ID, um einen `PaymentIntent` zu erstellen:

#### Accounts&nbsp;v2

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer_account={{CUSTOMERACCOUNT_ID}}" \
  -d "payment_method_data[us_bank_account][token]=btok_1N3T00LkdIwHu7ixt44h1F8k" \
  -d "payment_method_data[type]=us_bank_account" \
  -d "payment_method_data[billing_details][name]=J. Customer" \
  -d amount=100 \
  -d currency=usd
```

#### Customers&nbsp;v1

```curl
curl https://api.stripe.com/v1/payment_intents \
  -u "<<YOUR_SECRET_KEY>>:" \
  -d "customer={{CUSTOMER_ID}}" \
  -d "payment_method_data[us_bank_account][token]=btok_1N3T00LkdIwHu7ixt44h1F8k" \
  -d "payment_method_data[type]=us_bank_account" \
  -d "payment_method_data[billing_details][name]=J. Customer" \
  -d amount=100 \
  -d currency=usd
```

Dies gibt einen `PaymentIntent` ähnlich dem folgenden zurück:

```json

{
  "id": "pi_1GszXf2eZvKYlo2Ce7rjvnPP",
  "object": "payment_intent",
  "amount": 100,
  "amount_capturable": 0,
  "amount_details": {
    "tip": {
      "amount": null
    }
  },
  "amount_received": 0,
  "application": null,
  "application_fee_amount": null,
  "automatic_payment_methods": null,
  "canceled_at": null,
  "cancellation_reason": null,
  "capture_method": "automatic",
  "charges": {
    "object": "list",
    "data": [

    ],
    "has_more": false,
    "total_count": 0,
    "url": "/v1/charges?payment_intent=pi_1GszXf2eZvKYlo2Ce7rjvnPP"
  },
  "client_secret": "pi_1GszXf2eZvKYlo2Ce7rjvnPP",
  "confirmation_method": "automatic",
  "created": 1651010665,
  "currency": "usd",
  "customer": null,
  "description": null,
  "invoice": null,
  "last_payment_error": null,
  "livemode": false,
  "metadata": {
  },
  "next_action": null,
  "on_behalf_of": null,
  "payment_method": "pm_1Mb4UkJGNKiWrCEmJ1PS72Cd",
  "payment_method_options": {
    "us_bank_account": {
      "verification_method": "automatic"
    }
  },
  "payment_method_types": [
    "us_bank_account"
  ],
  "processing": null,
  "receipt_email": null,
  "review": null,
  "setup_future_usage": null,
  "shipping": null,
  "source": null,
  "statement_descriptor": null,
  "statement_descriptor_suffix": null,
  "status": "requires_confirmation",
  "transfer_data": null,
  "transfer_group": null
}
```

### Mandatsbestätigung erfassen und die Zahlung übermitteln

Bevor Sie die Zahlung veranlassen können, müssen Sie eine Zahlungsautorisierung von Ihrem/Ihrer Kund/in einholen, indem Sie Mandatsbedingungen anzeigen, denen er/sie zustimmen muss.

Um die Nacha-Regeln einzuhalten, müssen Sie eine Autorisierung von Ihrem Kunden/Ihrer Kundin einholen, bevor Sie die Zahlung veranlassen können. Dies tun Sie durch Anzeigen von Mandatskonditionen, denen der Kunde/die Kundin zustimmen muss. Weitere Informationen finden Sie unter [Mandate](https://docs.stripe.com/payments/ach-direct-debit.md#mandates).

### Payment Intent bestätigen

Um diesen Payment Intent zu bestätigen, müssen Sie entweder einen Parameter [mandate](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-mandate) mit einer bestehenden Mandats-ID angeben oder [mandate_data](https://docs.stripe.com/api/payment_intents/confirm.md#confirm_payment_intent-mandate_data) bereitstellen, um ein neues Mandat zu erstellen.

Wenn Sie beispielsweise eine Bezahlseite mit der Schaltfläche „Bestellung aufgeben“ haben, kann durch Klicken auf diese Schaltfläche ein `POST` an einen Endpoint auf Ihrem Server ausgelöst werden. Dieser Endpoint kann den Nutzer-Agent der Anfrage und die IP-Adresse des Clients extrahieren und dann die folgende Anfrage an die API von Stripe senden:

```curl
curl https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}}/confirm \
  -u "<<YOUR_SECRET_KEY>>:" \
  --data-urlencode "return_url=https://example.com/return" \
  -d "mandate_data[customer_acceptance][accepted_at]=1647448692" \
  -d "mandate_data[customer_acceptance][type]=online" \
  -d "mandate_data[customer_acceptance][online][ip_address]=71.183.194.54" \
  --data-urlencode "mandate_data[customer_acceptance][online][user_agent]=Mozilla/5.0 ..."
```

Nach der erfolgreichen Bestätigung des Payment Intent sieht dieser ähnlich dem Folgenden aus:

```json
{
  "id": "pi_1GszXf2eZvKYlo2Ce7rjvnPP",
  "object": "payment_intent",
  "amount": 100,
  "amount_capturable": 0,
  "amount_received": 0,
  "application": null,
  "application_fee_amount": null,
  "automatic_payment_methods": null,
  "canceled_at": null,
  "cancellation_reason": null,
  "capture_method": "automatic",
  "charges": {
    "object": "list",
    "data": [
      {
        "id": "py_17F8CPDyDglZKgWE3uzOAUe9",
        "object": "charge",
        "amount": 100,
        "amount_captured": 100,
        "amount_refunded": 0,
        "application": null,
        "application_fee": null,
        "application_fee_amount": null,
        "balance_transaction": null,
        "billing_details": {
          "address": {
            "city": null,
            "country": null,
            "line1": null,
            "line2": null,
            "postal_code": null,
            "state": null
          },
          "email": null,
          "name": "J. Customer",
          "phone": null
        },
        "calculated_statement_descriptor": null,
        "captured": true,
        "created": 1647448692,
        "currency": "usd",
        "customer": "cus_LKe65xcPnrCiTZ",
        "description": null,
        "destination": null,
        "dispute": null,
        "disputed": false,
        "failure_code": null,
        "failure_message": null,
        "fraud_details": {
        },
        "invoice": null,
        "livemode": false,
        "metadata": {
        },
        "on_behalf_of": null,
        "order": null,
        "outcome": null,
        "paid": false,
        "payment_intent": "pi_1GszXf2eZvKYlo2Ce7rjvnPP",
        "payment_method": "pm_1Mb4UkJGNKiWrCEmJ1PS72Cd",
        "payment_method_details": {
          "type": "us_bank_account",
          "us_bank_account": {
            "account_holder_type": "individual",
            "account_type": "checking",
            "bank_name": "STRIPE TEST BANK",
            "fingerprint": "QnXqpAeqjjh8pPFa",
            "last4": "6789",
            "routing_number": "110000000"
          }
        },
        "receipt_email": null,
        "receipt_number": null,
        "receipt_url": null,
        "refunded": false,
        "refunds": {
          "object": "list",
          "data": [

          ],
          "has_more": false,
          "total_count": 0,
          "url": "/v1/charges/py_17F8CPDyDglZKgWE3uzOAUe9/refunds"
        },
        "review": null,
        "shipping": null,
        "source": null,
        "source_transfer": null,
        "statement_descriptor": null,
        "statement_descriptor_suffix": null,
        "status": "pending",
        "transfer_data": null,
        "transfer_group": null
      }
    ],
    "has_more": false,
    "total_count": 1,
    "url": "/v1/charges?payment_intent=pi_1GszXf2eZvKYlo2Ce7rjvnPP"
  },
  "client_secret": "pi_1GszXf2eZvKYlo2Ce7rjvnPP_secret_m38BKZvm3vSdpGdra360hPEov",
  "confirmation_method": "automatic",
  "created": 1647447792,
  "currency": "usd",
  "customer": "cus_LKe65xcPnrCiTZ",
  "description": null,
  "invoice": null,
  "last_payment_error": null,
  "livemode": false,
  "metadata": {
  },
  "next_action": null,
  "on_behalf_of": null,
  "payment_method": "pm_1Mb4UkJGNKiWrCEmJ1PS72Cd",
  "payment_method_options": {
    "us_bank_account": {
      "verification_method": "automatic"
    }
  },
  "payment_method_types": [
    "us_bank_account"
  ],
  "processing": null,
  "receipt_email": null,
  "review": null,
  "setup_future_usage": null,
  "shipping": null,
  "source": null,
  "statement_descriptor": null,
  "statement_descriptor_suffix": null,
  "status": "processing",
  "transfer_data": null,
  "transfer_group": null
}
```

Beim ACH-Lastschriftverfahren handelt es sich um eine *Zahlungsmethode mit verzögerter Benachrichtigung* (A payment method that can't immediately return payment status when a customer attempts a transaction (for example, ACH debits). Businesses commonly hold an order in a pending state until payment is successful with these payment methods). Das bedeutet, dass es bis zu vier Werktage dauern kann, bis Sie nach Initiierung der Lastschrift für das Konto Ihres/Ihrer Kund/in eine Mitteilung über eine erfolgreiche oder fehlgeschlagene Zahlung erhalten.

Der von Ihnen erstellte PaymentIntent befindet sich zunächst im Status `processing`. Wenn die Zahlung erfolgreich war, wird der Status des PaymentIntent von `processing` in `succeeded` geändert. Erfahren Sie mehr über die Ereignisse, die gesendet werden, wenn der [PaymentIntent-Status aktualisiert wird](https://docs.stripe.com/payments/ach-direct-debit/accept-a-payment.md#web-confirm-paymentintent-succeeded).

Bei manuell eingegebenen Konten ändert sich der Status des `PaymentIntent` in `requires_action` statt in `processing`, da das Konto eine Verifizierung durch Mikroeinzahlungen erfordert. Die Eigenschaft [next_action](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-next_action) beschreibt die Verifizierungsschritte.