# Terminal mit Connect verwenden Vernetzen Sie Stripe Terminal mit Ihrer Connect-Plattform. Stripe Terminal ist kompatibel mit *Connect* (Connect is Stripe's solution for multi-party businesses, such as marketplace or software platforms, to route payments between sellers, customers, and other recipients) und ermöglicht es Ihrer Plattform oder Ihrem Marktplatz, persönliche Zahlungen anzunehmen. integrieren Sie Terminal mit Connect, je nachdem, wie Ihre Plattform Zahlungen für Ihre verbundenen Konten verarbeitet. - Wenn Sie [Direct Charges](https://docs.stripe.com/connect/direct-charges.md) nutzen, senden Sie Terminal-API-Anfragen, um Lesegeräte zu konfigurieren und Zahlungen mit dem API-Schlüssel Ihrer Plattform zu akzeptieren, und die `Stripe-Account`-Header, um das verbundene Konto zu identifizieren. - Wenn Sie [Destination Charges](https://docs.stripe.com/connect/destination-charges.md) verwenden, übermitteln Sie Terminal-API-Anfragen, um Lesegeräte zu konfigurieren und mit dem API-Schlüssel Ihrer Plattform Zahlungen zu akzeptieren. Außerdem identifizieren Sie das verbundene Konto anhand von Metadaten. - Wenn Sie [separate Zahlungen und Überweisungen](https://docs.stripe.com/connect/separate-charges-and-transfers.md) verwenden, übermitteln Sie Terminal-API-Anfragen unter Verwendung Ihres Plattform-API-Schlüssels, um Zahlungen auf Ihrem Plattformkonto zu erstellen und erstellen Sie dann separate Überweisungen, um Gelder auf Ihre verbundenen Konten zu überweisen. Verwenden Sie in allen Fällen [Standorte](https://docs.stripe.com/api/terminal/locations.md), um Lesegeräte entsprechend zu gruppieren. > Verbundene Terminal-Konten müssen die Funktion `card_payments` aufweisen, um Transaktionen durchführen zu können. # Direct Charges > This is a Direct Charges for when connect-charge-type is direct. View the full page at https://docs.stripe.com/terminal/features/connect?connect-charge-type=direct. ## Verbundene Konten besitzen Lesegeräte Bei Verwendung dieser Integration gehören alle API-Ressourcen zum verbundenen Konto und nicht zu Ihrer Plattform. Das verbundene Konto ist für die Kosten von Stripe-Gebühren, -Rückerstattungen und -Rückbuchungen verantwortlich. Im Dashboard können Sie Ihre Terminal-Daten anzeigen, indem Sie sich als verbundenes Konto anmelden. ### Standorte und Lesegeräte erstellen (Serverseitig) Erstellen Sie [Standorte](https://docs.stripe.com/terminal/fleet/locations-and-zones.md?dashboard-or-api=dashboard#create-locations-and-zones) und [Lesegeräte](https://docs.stripe.com/terminal/payments/connect-reader.md?reader-type=internet) für verbundene Konten, indem Sie den Header `Stripe Account` in die API-Anfragen aufnehmen. Sie können das Lesegerät auch registrieren, indem Sie im Stripe-Dashboard für Ihr verbundenes Konto auf **Ansicht als** klicken. ```curl curl https://api.stripe.com/v1/terminal/locations \ -u "<>:" \ -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \ -d display_name=HQ \ -d "address[line1]=1272 Valencia Street" \ -d "address[city]=San Francisco" \ -d "address[state]=CA" \ -d "address[country]=US" \ -d "address[postal_code]=94110" ``` ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` ### Verbindungstoken erstellen (Serverseitig) > Wenn Sie die [Connect OAuth](https://docs.stripe.com/connect/oauth-reference.md)-Authentifizierung verwenden, müssen Sie das verbundene Konto separat für Live-Modus und Sandboxes mit der jeweiligen Anwendungs-Client-ID jedes Modus autorisieren. Bei der Erstellung eines [ConnectionToken](https://docs.stripe.com/api/terminal/connection_tokens.md) für das Terminal-SDK setzen Sie den `Stripe-Account`-Header auf das verbundene Konto, dass die Zahlungen akzeptiert. Sie können auch einen `location`-Parameter angeben, um den Zugriff auf Lesegeräte einzuschränken. Wenn Sie einen Standort angeben, kann das `ConnectionToken` nur mit Lesegeräten verwendet werden, die diesem Standort zugeordnet sind. Wenn Sie keinen Standort angeben, kann das `ConnectionToken` mit allen Lesegeräten verwendet werden. ```curl curl https://api.stripe.com/v1/terminal/connection_tokens \ -u "<>:" \ -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \ -d "location={{TERMINALLOCATION_ID}}" ``` Wenn Sie eine servergesteuerte Integration verwenden, müssen Sie kein Verbindungstoken erstellen. ### PaymentIntents erstellen (Client-side) (Server-side) Mit dem iOS, Android und React Native SDK können Sie einen `PaymentIntent` auf dem Client oder auf dem Server erstellen. Das JavaScript SDK unterstützt nur die Erstellung auf dem Server. #### Clientseitig Wenn Sie auf der Client-Seite einen `PaymentIntent` für Direct Charges erstellen, geben Sie keine zusätzlichen Parameter für den `PaymentIntent` an. Erstellen Sie stattdessen ein `ConnectionToken` mit dem `Stripe-Account`-Header für das verbundene Konto, das Zahlungen akzeptiert. Die Client-SDKs erstellen den `PaymentIntent` auf demselben verbundenen Konto, zu dem das `ConnectionToken` gehört. Weitere Informationen finden Sie unter [PaymentIntents clientseitig erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-client-side). #### Serverseitig Für das JavaScript SDK müssen Sie den `PaymentIntent` auf Ihrem Server erstellen. Für die anderen Client-SDKs können Sie den `PaymentIntent` auf Ihrem Server erstellen, wenn die zum Starten einer Zahlung erforderlichen Informationen in Ihrer App nicht ohne weiteres verfügbar sind. Weitere Informationen finden Sie unter [Payment Intents serverseitig erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=js#create-payment). Wenn Sie einen `PaymentIntent` auf der Server-Seite für Direct Charges erstellen, setzen Sie den `Stripe-Account`-Header auf das verbundene Konto. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \ -d amount=1000 \ -d currency=usd \ -d "payment_method_types[]=card_present" \ -d capture_method=manual ``` Befolgen Sie dann die Schritte, um [eine Zahlung einzuziehen](https://docs.stripe.com/terminal/payments/collect-card-payment.md), um den PaymentIntent abzuwickeln. ## Plattformeigene Lesegeräte (Private Vorschau) > [Kontaktieren Sie uns](mailto:stripe-terminal-betas@stripe.com), wenn Sie daran interessiert sind, dass die Plattform Lesegeräte mit Direct Charges besitzt und verwaltet. Diese private Vorschaufunktion ist derzeit für [intelligente Lesegeräte](https://docs.stripe.com/terminal/smart-readers.md) verfügbar, die eine [servergestützte Integration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=server-driven) nutzen. Diese Integration funktioniert nur mit verbundenen Konten, die Sie über eine einzelne Plattform steuern. Bei dieser Integration besitzt Ihre Plattform Geräteressourcen wie [Standorte](https://docs.stripe.com/api/terminal/locations.md) und [Lesegeräte](https://docs.stripe.com/api/terminal/readers.md) und Ihre verbundenen Konten besitzen Zahlungsressourcen wie [PaymentIntents](https://docs.stripe.com/api/payment_intents.md). Auf diese Weise kann Ihre Plattform ein einziges Lesegerät verwalten, das Zahlungen für mehrere verbundene Konten verarbeitet. Die verbundenen Konten sind für die Zahlungsbeträge der Stripe-Gebühren, -Rückerstattungen und -Rückbuchungen verantwortlich. Im Dashboard können Sie Ihre Terminal-Geräteverwaltungsdaten direkt anzeigen, wenn Sie bei Ihrem Plattformkonto angemeldet sind. Sie können Zahlungsdaten anzeigen, indem Sie sich als verbundenes Konto anmelden. ### Standorte und Lesegeräte erstellen Reader-Objekte lassen sich am besten nach verbundenem Konto gruppieren, indem sie `Locations` zugewiesen werden. Erstellen Sie in Ihrem Plattformkonto [einen Ort](https://docs.stripe.com/terminal/fleet/locations-and-zones.md?dashboard-or-api=dashboard#create-locations-and-zones) für ein verbundenes Konto mit einem Anzeigenamen, der das Konto kennzeichnet. ```curl curl https://api.stripe.com/v1/terminal/locations \ -u "<>:" \ -d display_name=HQ \ -d "address[line1]=1272 Valencia Street" \ -d "address[city]=San Francisco" \ -d "address[state]=CA" \ -d "address[country]=US" \ -d "address[postal_code]=94110" ``` Bevor Sie Ihre Anwendung mit einem [intelligenten Lesegerät](https://docs.stripe.com/terminal/payments/connect-reader.md?reader-type=internet) verbinden können, müssen Sie das Lesegerät bei Ihrem Plattformkonto registrieren. ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` ### PaymentIntents erstellen Wenn Sie einen `PaymentIntent` für Direct Charges erstellen, setzen Sie den `Stripe-Account`-Header auf das verbundene Konto. > Die Plattform kann PaymentIntents später nur verarbeiten, wenn Sie diese für verbundene Konten erstellen, die Sie über eine einzelne Plattform steuern. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -H "Stripe-Account: {{CONNECTEDACCOUNT_ID}}" \ -d amount=1000 \ -d currency=usd \ -d "payment_method_types[]=card_present" \ -d capture_method=manual ``` ### PaymentIntents verarbeiten Die Plattform kann den `PaymentIntent` des verbundenen Kontos mit einem Lesegerät verarbeiten, das der Plattform gehört. > Der PaymentIntent kann nur verarbeitet werden, wenn Sie ihn mit dem `Stripe-Account`-Header erstellen. ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}}/process_payment_intent \ -u "<>:" \ -d "payment_intent={{PAYMENTINTENT_ID}}" ``` # Destination Charges > This is a Destination Charges for when connect-charge-type is destination. View the full page at https://docs.stripe.com/terminal/features/connect?connect-charge-type=destination. Wenn Sie [Destination Charges](https://docs.stripe.com/connect/destination-charges.md) verwenden, besitzt Ihre Plattform API-Ressourcen wie [PaymentIntents](https://docs.stripe.com/api/payment_intents.md) und [Standorte](https://docs.stripe.com/api/terminal/locations.md). Bei jeder Zahlung wird automatisch eine Übertragung auf ein verbundenes Konto erstellt. Im Dashboard können Sie Ihre Terminal-Daten direkt anzeigen, wenn Sie bei Ihrem Plattformkonto angemeldet sind. ## Standorte und Lesegeräte erstellen (Serverseitig) Lesegeräte-Objekte lassen sich nach verbundenem Konto gruppieren, indem sie `Locations` zugewiesen werden. [Erstellen Sie einen Standort](https://docs.stripe.com/terminal/fleet/locations-and-zones.md?dashboard-or-api=dashboard#create-locations-and-zones) für ein verbundenes Konto in Ihrem Plattformkonto mit einem Anzeigenamen, der das Konto kennzeichnet. ```curl curl https://api.stripe.com/v1/terminal/locations \ -u "<>:" \ -d display_name=HQ \ -d "address[line1]=1272 Valencia Street" \ -d "address[city]=San Francisco" \ -d "address[state]=CA" \ -d "address[country]=US" \ -d "address[postal_code]=94110" ``` Bevor Sie Ihre Anwendung mit einem [intelligenten Lesegerät](https://docs.stripe.com/terminal/payments/connect-reader.md?reader-type=internet) verbinden können, müssen Sie das Lesegerät bei Ihrem Plattformkonto registrieren. ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` ## Verbindungstoken erstellen (Serverseitig) Verwenden Sie den geheimen Schlüssel Ihres Plattformkontos, wenn Sie einen `ConnectionToken` für das Terminal SDK erstellen. Legen Sie den `Stripe-Account`-Header nicht fest. Geben Sie einen `location`-Parameter an, um den Zugriff auf Lesegeräte zu steuern. Wenn Sie einen Ort angeben, kann der `ConnectionToken` nur mit Lesegeräten verwendet werden, die diesem Ort zugewiesen sind. Wenn Sie keinen Ort angeben, kann der `ConnectionToken` mit allen Lesegeräten verwendet werden. ```curl curl https://api.stripe.com/v1/terminal/connection_tokens \ -u "<>:" \ -d "location={{TERMINALLOCATION_ID}}" ``` Wenn Sie eine servergesteuerte Integration verwenden, müssen Sie kein Verbindungstoken erstellen. ## PaymentIntents erstellen (Client-side) (Server-side) Wenn Sie einen `PaymentIntent` mit Destination Charges erstellen, geben Sie die Parameter [on_behalf_of](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-on_behalf_of) und [transfer_data[destination]](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-transfer_data-destination) und [application_fee_amount](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-application_fee_amount) an. Der Parameter `on_behalf_of` ist die ID des verbundenen Kontos, das zum Abwicklungshändler für die Zahlung wird. Bei Terminal-Transaktionen müssen Sie diesen Parameter in Fällen festlegen, bei denen das Land der Plattform nicht mit dem Land des verbundenen Kontos übereinstimmt. Wenn `on_behalf_of` festgelegt ist, führt Stripe automatisch Folgendes durch: - Stripe wickelt die Zahlungen im Land des angegebenen Kontos ab. Dadurch werden Ablehnungen minimiert und Währungsumrechnungen vermieden. - Verwendet die Gebührenstruktur für das Land des verbundenen Kontos. - Listet die Adresse und die Telefonnummer des verbundenen Kontos auf der Kreditkartenabrechnung des Kunden/der Kundin auf, und nicht die Adresse und die Telefonnummer Ihrer Plattform (nur, wenn sich das Konto und die Plattform in verschiedenen Ländern befinden). Legen Sie für `transfer_data[destination]` die ID des verbundenen Kontos fest, an das der Betrag gesendet wird. Abschließend können Sie eine Plattformgebühr für Ihre Plattform einbehalten, indem Sie den Parameter [application_fee_amount](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-application_fee_amount) angeben. ### Clientseitig Mit den SDKs für iOS, Android und React Native können Sie einen `PaymentIntent` auf dem Client erstellen und die Parameter `onBehalfOf`, `transferDataDestination` und `applicationFeeAmount` angeben. #### JavaScript > Die clientseitige Erstellung des `PaymentIntent` ist mit den anderen SDKs möglich. Wenn Sie das JavaScript SDK für Stripe Terminal verwenden, erstellen Sie einen `PaymentIntent` auf dem Server. #### iOS - [PaymentIntentParameters (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPPaymentIntentParameters.html) > Wenn Ihre App mit dem Verifone P400 verbunden ist, können Sie keinen `PaymentIntent` über das iOS SDK erstellen. > > Stattdessen müssen Sie den [PaymentIntent auf dem Server erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-server-side) und den `PaymentIntent` in Ihrer App mithilfe der Methode `Terminal.retrievePaymentIntent` im SDK abrufen. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController { // ... // Action for a "Checkout" button func checkoutAction() throws { let params = try PaymentIntentParametersBuilder(amount: 1000, currency: "usd") .setOnBehalfOf(""{{CONNECTED_ACCOUNT_ID}}"") .setTransferDataDestination(""{{CONNECTED_ACCOUNT_ID}}"") .setApplicationFeeAmount(200) .build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded") // ... } } } // ... } ``` #### Android - [PaymentIntentParameters (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-payment-intent-parameters/index.html) > Wenn Ihre App mit dem Verifone P400 verbunden ist, können Sie keinen `PaymentIntent` über das Android SDK erstellen. > > Stattdessen müssen Sie den [PaymentIntent auf dem Server erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-server-side) und den `PaymentIntent` in Ihrer App mithilfe der Methode `Terminal.retrievePaymentIntent` im SDK abrufen. #### Kotlin ```kotlin val params = PaymentIntentParameters.Builder() .setAmount(1000) .setCurrency("usd") .setOnBehalfOf(""{{CONNECTED_ACCOUNT_ID}}"") .setTransferDataDestination(""{{CONNECTED_ACCOUNT_ID}}"") .setApplicationFeeAmount(200) .build() Terminal.getInstance().createPaymentIntent( params, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` #### React Native - [CreatePaymentIntentParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#CreatePaymentIntentParams) > Wenn Ihre App mit dem Verifone P400 verbunden ist, können Sie keinen `PaymentIntent` über das React Native SDK erstellen. > > Stattdessen müssen Sie den [PaymentIntent auf dem Server erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-server-side) und den `PaymentIntent` in Ihrer App mithilfe der Methode `retrievePaymentIntent` im SDK abrufen. ```js const {paymentIntent, error} = await createPaymentIntent({ amount: 1000, currency: "usd", onBehalfOf: "{{CONNECTED_ACCOUNT_ID}}" , transferDataDestination: "{{CONNECTED_ACCOUNT_ID}}", applicationFeeAmount: 200, }); if (error) { // Placeholder for handling exception return; } // Placeholder for collecting a payment method with PaymentIntent ``` ### Serverseitig Für das JavaScript SDK müssen Sie den `PaymentIntent` auf Ihrem Server erstellen. Für die anderen Client-SDKs können Sie den `PaymentIntent` auf Ihrem Server erstellen, wenn die zum Starten einer Zahlung erforderlichen Informationen in Ihrer App nicht ohne weiteres verfügbar sind. Weitere Informationen finden Sie unter [Payment Intents serverseitig erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=js#create-payment). ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1000 \ -d currency=usd \ -d "payment_method_types[]=card_present" \ -d capture_method=manual \ -d application_fee_amount=200 \ -d "on_behalf_of={{CONNECTEDACCOUNT_ID}}" \ -d "transfer_data[destination]={{CONNECTEDACCOUNT_ID}}" ``` Befolgen Sie dann die Schritte, um [eine Zahlung einzuziehen](https://docs.stripe.com/terminal/payments/collect-card-payment.md), um den PaymentIntent abzuwickeln. # Separate Zahlungen und Transfers: > This is a Separate Zahlungen und Transfers: for when connect-charge-type is separate. View the full page at https://docs.stripe.com/terminal/features/connect?connect-charge-type=separate. Bei der Verwendung [separater Zahlungen und Überweisungen](https://docs.stripe.com/connect/separate-charges-and-transfers.md) verfügt Ihre Plattform über API-Ressourcen wie [PaymentIntents](https://docs.stripe.com/api/payment_intents.md) und [Standorte](https://docs.stripe.com/api/terminal/locations.md). Sie erstellen zunächst eine Belastung auf dem Konto Ihrer Plattform und anschließend separate Überweisungen, um Gelder auf Ihre verbundenen Konten zu übertragen. Auf diese Weise können Sie Zahlungen auf mehrere verbundene Konten aufteilen. Im Dashboard können Sie Ihre Terminal-Daten direkt anzeigen, wenn Sie bei Ihrem Plattformkonto angemeldet sind. ## Standorte und Lesegeräte erstellen (Serverseitig) Gruppieren Sie `Reader`-Objekte nach verbundenen Konten, indem Sie sie `locations` zuweisen. Erstellen Sie in Ihrem Plattformkonto [einen Standort](https://docs.stripe.com/terminal/fleet/locations-and-zones.md?dashboard-or-api=dashboard#create-locations-and-zones) für ein verbundenes Konto mit einem Anzeigenamen, der das Konto identifiziert. ```curl curl https://api.stripe.com/v1/terminal/locations \ -u "<>:" \ -d display_name=HQ \ -d "address[line1]=1272 Valencia Street" \ -d "address[city]=San Francisco" \ -d "address[state]=CA" \ -d "address[country]=US" \ -d "address[postal_code]=94110" ``` Bevor Sie Ihre Anwendung mit einem [intelligenten Lesegerät](https://docs.stripe.com/terminal/payments/connect-reader.md?reader-type=internet) verbinden können, müssen Sie das Lesegerät bei Ihrem Plattformkonto registrieren. ```curl curl https://api.stripe.com/v1/terminal/readers \ -u "<>:" \ -d registration_code={{READER_REGISTRATION_CODE}} \ --data-urlencode "label=Alice's reader" \ -d "location={{TERMINALLOCATION_ID}}" ``` ## Verbindungstoken erstellen (Serverseitig) Verwenden Sie den geheimen Schlüssel Ihres Plattformkontos, wenn Sie einen `ConnectionToken` für das Terminal SDK erstellen. Legen Sie den `Stripe-Account`-Header nicht fest. Geben Sie einen `location`-Parameter an, um den Zugriff auf Lesegeräte zu steuern. Wenn Sie einen Ort angeben, kann der `ConnectionToken` nur mit Lesegeräten verwendet werden, die diesem Ort zugewiesen sind. Wenn Sie keinen Ort angeben, kann der `ConnectionToken` mit allen Lesegeräten verwendet werden. ```curl curl https://api.stripe.com/v1/terminal/connection_tokens \ -u "<>:" \ -d "location={{TERMINALLOCATION_ID}}" ``` Wenn Sie eine servergesteuerte Integration verwenden, müssen Sie kein Verbindungstoken erstellen. ## Erstellen Sie PaymentIntents (Server-side) Erstellen Sie einen `PaymentIntent` auf Ihrem Plattformkonto. Optional können Sie einen `transfer_group`-Parameter angeben, um zugehörige Zahlungen und Überweisungen zu Tracking-Zwecken zu identifizieren. ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1000 \ -d currency=usd \ -d "payment_method_types[]=card_present" \ -d capture_method=manual \ -d transfer_group=ORDER_95 ``` Befolgen Sie dann die Schritte, um [eine Zahlung einzuziehen](https://docs.stripe.com/terminal/payments/collect-card-payment.md), um den PaymentIntent abzuwickeln. ## Erstellen Sie Übertragungen (Server-side) Nachdem Sie den `PaymentIntent` erfasst haben, können Sie eine oder mehrere [Übertragungen](https://docs.stripe.com/api/transfers.md) erstellen, um Gelder auf Ihre verbundenen Konten zu übertragen. Erstellen Sie eine Übertragung, in der Sie das verbundene Konto als Ziel angeben. Optional können Sie die `transfer_group` hinzufügen, um die Überweisung mit der ursprünglichen Zahlung zu verknüpfen: ```curl curl https://api.stripe.com/v1/transfers \ -u "<>:" \ -d amount=700 \ -d currency=usd \ -d "destination={{CONNECTEDACCOUNT_ID}}" \ -d transfer_group=ORDER100 ``` ### Verfügbarkeit von Überweisungen Standardmäßig schlägt eine Überweisungsanforderung fehl, wenn der Betrag das verfügbare Guthaben Ihrer Plattform übersteigt. Um dies zu vermeiden, können Sie die Überweisung mithilfe des Parameters [source_transaction](https://docs.stripe.com/api/transfers/create.md#create_transfer-source_transaction) an die jeweilige Belastung binden. Dadurch kann die Überweisungsanforderung auch dann erfolgreich ausgeführt werden, wenn die Gelder noch nicht auf Ihrem verfügbaren Guthaben verbucht sind. Die Überweisung wird automatisch ausgeführt, sobald die Gelder aus der zugehörigen Belastung verfügbar sind. Um eine `source_transaction` zu verwenden, rufen Sie zunächst die Charge-ID aus dem Attribut [latest_charge](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-latest_charge) von PaymentIntent ab: ```curl curl https://api.stripe.com/v1/transfers \ -u "<>:" \ -d amount=700 \ -d currency=usd \ -d "destination={{CONNECTEDACCOUNT_ID}}" \ -d "source_transaction={{CHARGE_ID}}" \ -d transfer_group=ORDER100 ``` ### Zahlungen auf mehrere Konten aufteilen Um eine Zahlung auf mehrere verbundene Konten aufzuteilen, erstellen Sie für jedes Konto separate Überweisungen: ```curl curl https://api.stripe.com/v1/transfers \ -u "<>:" \ -d amount=400 \ -d currency=usd \ -d "destination={{CONNECTEDACCOUNT_ID}}" \ -d transfer_group=ORDER100 ``` ```curl curl https://api.stripe.com/v1/transfers \ -u "<>:" \ -d amount=300 \ -d currency=usd \ -d destination={{OTHER_CONNECTED_ACCOUNT_ID}} \ -d transfer_group=ORDER100 ``` ## See also - [Anzeige des Warenkorbs](https://docs.stripe.com/terminal/features/display.md) - [Belege](https://docs.stripe.com/terminal/features/receipts.md)