# Kartenzahlungen einziehen Bereiten Sie Ihre Anwendung und Ihr Backend auf das Einziehen von Kartenzahlungen mit Stripe Terminal vor. # Servergestützt > This is a Servergestützt for when terminal-sdk-platform is server-driven. View the full page at https://docs.stripe.com/terminal/payments/collect-card-payment?terminal-sdk-platform=server-driven. Für die Lesegeräte BBPOS WisePOS E und Stripe Reader S700/S710 empfehlen wir eine serverseitige Integration, da sie die Stripe API anstelle eines Terminal-SDK verwendet, um Zahlungen einzuziehen. Sie kennen die Payment Intents API noch nicht? Hier finden Sie einige nützliche Informationen: - [Die Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) - [Das PaymentIntent-Objekt](https://docs.stripe.com/api/payment_intents.md) - [Weitere Zahlungsszenarien](https://docs.stripe.com/payments/more-payment-scenarios.md) Zum Einziehen von Zahlungen mit Stripe Terminal müssen Sie einen Zahlungsablauf in Ihrer Anwendung programmieren. Verwenden Sie das Stripe Terminal SDK, um einen [PaymentIntent](https://docs.stripe.com/api.md#payment_intents) zu erstellen und zu aktualisieren. Bei einem PaymentIntent handelt es sich um ein Objekt, das eine einzelne Zahlungssitzung darstellt. Während die Kernkonzepte SDK-basierten Integrationen ähneln, sehen die Schritte bei der servergesteuerten Integration etwas anders aus: 1. [PaymentIntent erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#create-payment) Sie können definieren, ob Ihre Zahlungen [automatisch](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) oder [manuell](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md) erfasst werden sollen. 1. [Zahlung verarbeiten](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#process-payment) Die Autorisierung der Kundenkarte erfolgt, wenn das Lesegerät die Zahlung verarbeitet. 1. (Optional) [PaymentIntent erfassen](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#capture-payment). > Diese Integrationsform unterstützt [Offline-Kartenzahlungen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md) nicht. ## PaymentIntent erstellen - [PaymentIntent erstellen](https://docs.stripe.com/api/payment_intents/create.md) Der erste Schritt beim Einziehen von Zahlungen ist das Starten des Zahlungsablaufs. Wenn Kundinnen/Kunden den Bestellvorgang abschließen, muss Ihr Backend ein [PaymentIntent](https://docs.stripe.com/api/payment_intents.md)-Objekt erstellen. Dieses Objekt stellt eine neue Zahlungssitzung bei Stripe dar. Bei der servergestützten Integration erstellen Sie den PaymentIntent serverseitig. In einer Sandbox können Sie [Testbeträge](https://docs.stripe.com/terminal/references/testing.md#physical-test-cards) verwenden, um verschiedene Fehlerszenarien zu simulieren. Im Live-Modus wird der Betrag des PaymentIntent zum Bezahlen auf dem Lesegerät angezeigt. Für Terminal-Zahlungen muss der Parameter `payment_method_types` `card_present` enthalten. Um Interac-Zahlungen in Kanada zu akzeptieren, müssen Sie auch `interac_present` in `payment_method_types` aufnehmen. Erfahren Sie mehr über [regionale Überlegungen für Kanada](https://docs.stripe.com/terminal/payments/regional.md?integration-country=CA#create-a-paymentintent). Um in unterstützten Ländern kartenlose Zahlungsmethoden zu akzeptieren, müssen Sie auch Ihre bevorzugten Arten in `payment_method_types` angeben. Erfahren Sie mehr über [zusätzliche Zahlungsmethoden](https://docs.stripe.com/terminal/payments/additional-payment-methods.md). Sie können den Zahlungsablauf wie folgt steuern: - Um den Zahlungsablauf für `card_present`-Zahlungen vollständig zu steuern, setzen Sie die `capture_method` auf `manual`. Dadurch können Sie vor der endgültigen Finalisierung der Zahlung einen Abgleichschritt hinzufügen. - Um Zahlungen in einem Schritt zu autorisieren und zu erfassen, setzen Sie `capture_method` auf `automatic`. > Erstellen Sie einen PaymentIntent nicht neu, wenn eine Karte abgelehnt wird. Verwenden Sie stattdessen denselben PaymentIntent wieder, um [doppelte Abbuchungen zu vermeiden](https://docs.stripe.com/terminal/payments/collect-card-payment.md#avoiding-double-charges). ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d currency=usd \ -d "payment_method_types[]=card_present" \ -d capture_method=manual \ -d amount=1000 ``` ## Zahlung abwickeln Sie können eine Zahlung sofort mit der von einem Kunden/einer Kundin vorgelegten Karte abwickeln oder stattdessen die Kartenangaben überprüfen, bevor Sie mit der Zahlungsabwicklung fortfahren. Für die meisten Anwendungsszenarien empfehlen wir eine sofortige Verarbeitung, da es sich um eine einfachere Integration mit weniger API-Aufrufen und Webhook-Ereignissen handelt. Wenn Sie jedoch Ihre eigene Geschäftslogik hinzufügen möchten, bevor die Karte autorisiert wird, können Sie die Erfassung und Bestätigung in zwei Schritten verwenden. #### Sofort verarbeiten - [Einen PaymentIntent verarbeiten](https://docs.stripe.com/api/terminal/readers/process_payment_intent.md) Nach Erstellen eines PaymentIntent besteht der nächste Schritt darin, die Zahlung zu verarbeiten. Das Lesegerät fordert den/die Kund/in auf, seine/ihre Karte aufzulegen und autorisiert die Zahlung dann. Um eine Zahlung zu erfassen, stellen Sie eine Anfrage an Stripe mit der ID des erstellten PaymentIntent und dem Lesegerät, das Sie für die Transaktion verwenden möchten. ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}}/process_payment_intent \ -u "<>:" \ -d "payment_intent={{PAYMENTINTENT_ID}}" ``` Die Abwicklung der Zahlung erfolgt asynchron. Es kann einige Sekunden dauern, bis Karteninhaber/innen ihre Karten herausholen oder möglicherweise stellen sie dem Betreiber eine Frage. Wenn Sie eine Zahlung abwickeln, antwortet Stripe sofort mit einem HTTP-Statuscode `200` auf die Anfrage als Bestätigung, dass das Lesegerät die Aktion erhalten hat. In den meisten Fällen gibt die Anfrage ein [Lesegerät](https://docs.stripe.com/api/terminal/readers.md) mit dem Status `in_progress` zurück. Da die Abwicklung jedoch asynchron erfolgt, kann der Aktionsstatus bereits den endgültigen Status (`succeeded` oder `failed`) widerspiegeln, wenn die Zahlung schnell abgeschlossen wird. Gleichzeitig wechselt der Bildschirm des Lesegeräts zu einer Benutzeroberfläche, in der die Kundinnen/Kunden aufgefordert werden, ihre Karte einzulegen. Um den [Status des Lesegeräts zu verifizieren](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#verify-reader), überwachen Sie den Webhook `terminal.reader.action_succeeded` oder fragen Sie die Lesegerät- und PaymentIntent-Status ab, um den Status der Zahlung zu erhalten. ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}} \ -u "<>:" ``` ```json { "id": "{{READER_ID}}", "object": "terminal.reader", ... "status": "online", "action": { "type": "process_payment_intent", "process_payment_intent": { "payment_intent": "{{PAYMENT_INTENT_ID}}" }, "status": "in_progress", "failure_code": null, "failure_message": null } } ``` #### Einziehen, prüfen und bestätigen Nach Erstellen eines PaymentIntent besteht der nächste Schritt darin, die Zahlung zu verarbeiten. Das Lesegerät fordert Kundinnen und Kunden auf, ihre Karte einzuführen oder aufzulegen und erstellt dann eine PaymentMethod. ### Eine PaymentMethod erfassen - [Eine Zahlungsmethode erfassen](https://docs.stripe.com/api/terminal/readers/collect_payment_method.md) Um eine Zahlung zu erfassen, stellen Sie eine Anfrage an Stripe mit der ID des erstellten PaymentIntent und dem Lesegerät, das Sie für die Transaktion verwenden möchten. ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}}/collect_payment_method \ -u "<>:" \ -d "payment_intent={{PAYMENTINTENT_ID}}" ``` > Nach Erfassung der Zahlungsmethode müssen Sie die Zahlung autorisieren oder den Einzug innerhalb von 30 Sekunden abbrechen. Der Zahlungseinzug erfolgt asynchron. Es kann einige Sekunden dauern, bis Karteninhaber/innen ihre Karten herausholen oder möglicherweise stellen sie dem Betreiber eine Frage. Wenn Sie mit dem Erfassen einer Zahlungsmethode beginnen, antwortet Stripe sofort mit einem Statuscode des Typs HTTP `200` auf diese Anfrage und gibt ein Lesegerät mit dem Aktionsstatus `in_progress` zurück. Im selben Zug wechselt der Bildschirm des Lesegeräts zu einer Nutzeroberfläche, die Kundinnen und Kunden auffordert, ihre Karte einzulegen. Nachdem das Lesegerät Kartendaten erfasst hat, wird die PaymentMethod mit dem serverseitigen PaymentIntent verknüpft und im Lesegeräte-Objekt als `action.collect_payment_method.payment_method` gespeichert. Um den [Status des Lesegeräts zu verifizieren](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#verify-reader), überwachen Sie den Webhook `terminal.reader.action_updated` oder fragen Sie den Status der Lesegerät-Aktion ab, um die PaymentMethod zu überprüfen. An dieser Stelle können Sie auf Attribute wie Kartenmarke, Finanzierung und andere nützliche Daten aus der PaymentMethod zugreifen. Stripe versucht zu erkennen, ob eine mobile Wallet bei einer Transaktion verwendet wird, wie im Attribut `wallet.type` gezeigt. Das Attribut wird jedoch nicht ausgefüllt, wenn die ausstellende Bank die lesegerätegestützte Identifizierung einer mobilen Wallet nicht unterstützt, sodass eine genaue Erkennung nicht garantiert werden kann. Nach der Autorisierung im [Bestätigungsschritt](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven&process=inspect#confirm-the-paymentintent) erhält Stripe aktuelle Informationen von den Netzwerken und aktualisiert `wallet.type` zuverlässig. ### PaymentIntent bestätigen - [PaymentIntent bestätigen](https://docs.stripe.com/api/terminal/readers/confirm_payment_intent.md) Nachdem Sie eine PaymentMethod erfolgreich erfasst haben, können Sie mit der Zahlungsautorisierung fortfahren. ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}}/confirm_payment_intent \ -u "<>:" \ -d "payment_intent={{PAYMENTINTENT_ID}}" ``` Die Bestätigung des PaymentIntent erfolgt asynchron. Sie können den Webhook `terminal.reader.action_succeeded` überwachen oder den Lesegerät- und PaymentIntent-Status abfragen, um den Status der Zahlung zu erhalten. Wenn Sie ein simuliertes Lesegerät nutzen, verwenden Sie den Endpoint [present_payment_method](https://docs.stripe.com/terminal/references/testing.md#simulated-card-presentment), um zu simulieren, dass Karteninhaber/innen ihre Karte auf das Lesegerät auflegen oder in diesen einführen. Verwenden Sie [Testkarten](https://docs.stripe.com/terminal/references/testing.md#standard-test-cards), um verschiedene Erfolgs- oder Fehlerszenarien zu simulieren. ## Erfassen Sie die Zahlung Wenn Sie bei der Erstellung des PaymentIntent in [Schritt 1](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment) `capture_method` als `manual` definiert haben, gibt das SDK einen autorisierten, aber nicht erfassten PaymentIntent an Ihre Anwendung zurück. Erfahren Sie mehr über den Unterschied zwischen [Autorisierung und Erfassung](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md). Wenn Ihre Anwendung einen bestätigten PaymentIntent erhält, sollten Sie sicherstellen, dass diese ihr Backend benachrichtigt, um den PaymentIntent zu erfassen. Erstellen Sie dazu einen Endpoint in Ihrem Backend, der eine PaymentIntent-ID akzeptiert und zwecks Erfassung eine Anfrage an die Stripe-API sendet. ```curl curl -X POST https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}}/capture \ -u "<>:" ``` War der Aufruf zur Erfassung erfolgreich, ist der Status eines PaymentIntent `succeeded`. Um sicherzustellen, dass die erfasste Plattformgebühr für verbundene Konten korrekt ist, überprüfen Sie jeden PaymentIntent und ändern Sie die Plattformgebühr bei Bedarf, bevor Sie die Zahlung manuell erfassen. > Sie müssen `PaymentIntents` innerhalb von zwei Tagen manuell erfassen. Andernfalls läuft die Autorisierung ab und die Gelder werden für den/die Kund/in freigegeben. ### Trinkgelder einziehen (US only) In den USA können berechtigte Nutzer/innen [beim Einzug von Zahlungen ein auf dem Zahlungsbeleg vermerktes Trinkgeld einziehen ](https://docs.stripe.com/terminal/features/collecting-tips/on-receipt.md). ## Status des Lesegeräts verifizieren Um sicherzustellen, dass das Lesegerät eine Aktion abgeschlossen hat, muss Ihre Anwendung den Status des Geräts überprüfen, bevor Sie eine neue Lesegeräte-Aktion veranlassen oder mit der Erfassung fortfahren können. In den meisten Fällen können Sie mit dieser Verifizierung eine erfolgreiche (genehmigte) Zahlung bestätigen und Ihrem Betreiber jede relevante Nutzererfahrung anzeigen, damit er die Transaktion abschließen kann. In anderen Fällen müssen Sie möglicherweise [Fehler beheben](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=api#handle-errors), wie zum Beispiel abgelehnte Zahlungen. Verwenden Sie eine der folgenden Methoden, um den Status des Lesegeräts zu überprüfen: - [Webhooks überwachen](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#webhooks) - [Stripe API abfragen](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#stripe-api) - [PaymentIntent verwenden](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#payment-intent) - [Lesegerät-Objekt verwenden](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#reader-object) #### Webhooks überwachen (Empfohlen) Für maximale Ausfallsicherheit empfehlen wir, dass Ihre Anwendung [Webhooks](https://docs.stripe.com/webhooks.md) von Stripe überwacht, um in Echtzeit Benachrichtigungen über den Status des Lesegeräts zu erhalten. Stripe sendet drei Webhooks, um Ihre Anwendung über den Aktionsstatus eines Lesegeräts zu informieren: | Status | Beschreibung | | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `terminal.reader.action_succeeded` | Wird gesendet, wenn eine Lesegerät-Aktion erfolgreich war, zum Beispiel wenn eine Zahlung erfolgreich autorisiert wurde. | | `terminal.reader.action_failed` | Wird gesendet, wenn eine Aktion eines Lesegerätes fehlschlägt, zum Beispiel wenn eine Karte aufgrund unzureichender Deckung abgelehnt wird. | | `terminal.reader.action_updated` (Vorschau) | Wird gesendet, wenn eine Aktion eines Lesegerätes aktualisiert wird, zum Beispiel wenn eine Zahlungsmethode eingezogen wird (wird nur für die Aktion `collect_payment_method` ausgelöst). | Um diese Webhooks zu überwachen, erstellen Sie einen [Webhook](https://docs.stripe.com/webhooks.md)-Endpoint. Wir empfehlen, einen speziellen Webhook-Endpoint nur für diese Ereignisse einzurichten, da sie hohe Priorität haben und sich im kritischen Zahlungspfad befinden. ```curl curl https://api.stripe.com/v1/webhook_endpoints \ -u "<>:" \ -d "enabled_events[]=terminal.reader.action_succeeded" \ -d "enabled_events[]=terminal.reader.action_failed" \ --data-urlencode "url=https://example.com/my/webhook/endpoint" ``` #### Die Stripe-API abfragen Bei Problemen mit der Webhook-Zustellung können Sie die Stripe-API abfragen, indem Sie Ihrer Point-of-Sale-Nutzeroberfläche die Schaltfläche `check status` hinzufügen, die der Operator bei Bedarf aufrufen kann. #### PaymentIntent verwenden Sie können den PaymentIntent abrufen, den Sie zur Verarbeitung an das Lesegerät übergeben haben. Wenn Sie einen PaymentIntent erstellen, befindet dieser sich zunächst im Status `requires_payment_method`. Nachdem Sie die Zahlungsmethode erfolgreich erfasst haben, wird der Status auf `requires_confirmation` aktualisiert. Nachdem die Zahlung erfolgreich verarbeitet wurde, wird der Status auf `requires_capture` aktualisiert. ```curl curl https://api.stripe.com/v1/payment_intents/{{PAYMENTINTENT_ID}} \ -u "<>:" ``` #### Das Lesegerät-Objekt verwenden Sie können das [Lesegeräte](https://docs.stripe.com/api/terminal/readers/object.md)-Objekt verwenden, das ein [Aktions](https://docs.stripe.com/api/terminal/readers/object.md#terminal_reader_object-action)-Attribut enthält, das die letzte vom Lesegerät empfangene Aktion und ihren Status anzeigt. Ihre Anwendung kann ein [Lesegerät abrufen](https://docs.stripe.com/api/terminal/readers/retrieve.md), um zu prüfen, ob sich der [Status](https://docs.stripe.com/api/terminal/readers/object.md#terminal_reader_object-action-status) der Lesegerät-Aktion geändert hat. ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}} \ -u "<>:" ``` Das Reader-Objekt wird ebenfalls als Antwort auf den Zahlungsvorgangsschritt zurückgegeben. Der `action`-Typ beim Verarbeiten einer Zahlung ist `process_payment_intent`. Der `action.status` wird bei erfolgreicher Zahlung auf `succeeded` aktualisiert. Das bedeutet, Sie können mit dem Abschluss der Transaktion fortfahren. Andere mögliche Werte für `action.status` sind `failed` oder `in_progress`. ## Umgang mit Fehlern Die folgenden Fehler sind die häufigsten Typen, die Ihre Anwendung verarbeiten muss: - [Doppelte Abbuchungen vermeiden](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#avoiding-double-charges) - [Fehlgeschlagene Zahlungen](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#payment-failures) - [Zeitüberschreitung der Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#payment-timeout) - [Stornierung der Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#payment-cancellation) - [Lesegerät bereits in Nutzung](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#reader-busy) - [Zeitüberschreitung des Lesegeräts](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#reader-timeout) - [Lesegerät offline](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#reader-offline) - [Fehlende Webhooks](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#missing-webhooks) - [Verzögerte Webhooks](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#delayed-webhooks) ### Doppelte Abbuchungen vermeiden Das PaymentIntent-Objekt ermöglicht Geldbewegungen bei Stripe – verwenden Sie einen einzigen PaymentIntent, um eine Transaktion darzustellen. Verwenden Sie denselben PaymentIntent, nachdem eine Karte abgelehnt wurde (z. B. wenn sie nicht ausreichend gedeckt ist), damit Ihre Kundin/Ihr Kunde es mit einer anderen Karte erneut versuchen kann. Wenn Sie den PaymentIntent bearbeiten, müssen Sie [process_payment_intent](https://docs.stripe.com/api/terminal/readers/process_payment_intent.md) aufrufen, um die Zahlungsinformationen auf dem Lesegerät zu aktualisieren. Ein PaymentIntent muss sich im Status `requires_payment_method` befinden, bevor Stripe ihn verarbeiten kann. Ein autorisierter, erfasster oder stornierter PaymentIntent kann nicht von einem Lesegerät verarbeitet werden und resultiert im Fehler `intent_invalid_state`: ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}}/process_payment_intent \ -u "<>:" \ -d "payment_intent={{PAYMENTINTENT_ID}}" ``` ```json { "error": { "code": "intent_invalid_state", "doc_url": "https://docs.stripe.com/error-codes#intent-invalid-state", "message": "Payment intent must be in the requires_payment_method state to be processed by a reader.", "type": "invalid_request_error" } } ``` ### Fehlgeschlagene Zahlungen Zu den häufigsten Zahlungsfehlern gehört eine fehlgeschlagene Zahlung. (Zum Beispiel, wenn eine Zahlung von der Bank des/der Kund/in aufgrund unzureichender Deckung abgelehnt wird). Wenn die Autorisierung einer Zahlung fehlschlägt, sendet Stripe den Webhook `terminal.reader.action_failed`. Überprüfen Sie die Attribute [action.failure_code](https://docs.stripe.com/api/terminal/readers/object.md#terminal_reader_object-action-failure_code) und [action.failure_message](https://docs.stripe.com/api/terminal/readers/object.md#terminal_reader_object-action-failure_message), um herauszufinden, ob eine Zahlung abgelehnt wurde: ```json { "id": "{{READER_ID}}", "object": "terminal.reader","action": { "failure_code": "card_declined", "failure_message": "Your card has insufficient funds.", "process_payment_intent": { "payment_intent": "{{PAYMENT_INTENT_ID}}" }, "status": "failed", "type": "process_payment_intent" }, ... } ``` Fordern Sie Kundinnen/Kunden im Falle einer abgelehnten Karte auf, eine alternative Zahlungsmethode anzugeben. Verwenden Sie denselben PaymentIntent in einer anderen Anfrage an den Endpoint [process_payment_intent](https://docs.stripe.com/api/terminal/readers/object.md#terminal_reader_object-action-process_payment_intent). Wenn Sie einen neuen PaymentIntent erstellen, müssen Sie den fehlgeschlagenen PaymentIntent [stornieren](https://docs.stripe.com/api/payment_intents/cancel.md), um doppelte Zahlungen zu vermeiden. Bei Kartenlesefehlern (z. B. Fehler beim Lesen des Chips) fordert das Lesegerät Kundinnen/Kunden automatisch zu einem Wiederholungsversuch auf, ohne dass Ihre Anwendung benachrichtigt wird. Wenn mehrere Wiederholungsversuche fehlschlagen, können Sie durch Stellen einer weiteren [process_payment_intent](https://docs.stripe.com/api/terminal/readers/object.md#terminal_reader_object-action-process_payment_intent)-Anfrage eine andere Zahlungsmethode anfordern. ### Zeitüberschreitung bei der Zahlung Ein Lesegerät mit unzuverlässiger Internetverbindung kann aufgrund einer Netzwerkanfrage bei der Autorisierung der Karte eine Zahlung nicht verarbeiten. Das Lesegerät zeigt einige Sekunden lang einen Verarbeitungsbildschirm an, gefolgt von einer Fehlermeldung, und Sie erhalten `terminal.reader.action_failed`-Webhook mit dem `failure_code` `connection_error`: ```json { "id": "{{READER_ID}}", "object": "terminal.reader","action": { "failure_code": "connection_error", "failure_message": "Could not connect to Stripe.", "process_payment_intent": { "payment_intent": "{{PAYMENT_INTENT_ID}}" }, "status": "failed", "type": "process_payment_intent" }, ... } ``` Die Zahlungsbestätigungsanfrage wurde möglicherweise von den Backend-Systemen von Stripe verarbeitet, aber das Lesegerät hat die Verbindung möglicherweise getrennt, bevor es die Antwort von Stripe erhalten hat. Wenn Sie einen Webhook mit diesem Fehlercode erhalten, rufen Sie den PaymentIntent-`status` ab, um zu überprüfen, ob die Zahlung erfolgreich autorisiert wurde. Stellen Sie sicher, dass Ihr Netzwerk unsere [Netzwerkanforderungen](https://docs.stripe.com/terminal/network-requirements.md) erfüllt, um Zeitüberschreitungen zu vermeiden. ### Stornierung der Zahlung #### Programmgesteuerte Stornierung Möglicherweise müssen Sie eine Zahlung, die bereits unterwegs ist, stornieren. Beispielsweise wenn Kundinnen/Kunden Artikel zu ihrem Kauf hinzufügen, nachdem Ihre Integration die Erfassung der Zahlung auf dem Lesegerät bereits eingeleitet hat. Verwenden Sie den Endpoint [cancel_action](https://docs.stripe.com/api/terminal/readers/object.md#terminal_reader_object-action-cancel_action), um das Lesegerät zurückzusetzen: ```curl curl -X POST https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}}/cancel_action \ -u "<>:" ``` > Es ist nicht möglich, eine Lesegeräteaktion mitten in einer Zahlungsautorisierung zu stornieren. Wenn Kundinnen/Kunden ihre Karte bereits zur Zahlung am Lesegerät vorgelegt haben, müssen Sie warten, bis die Verarbeitung abgeschlossen ist. Eine Autorisierung dauert in der Regel ein paar Sekunden. Der Aufruf von [cancel_action](https://docs.stripe.com/api/terminal/readers/object.md#terminal_reader_object-action-cancel_action) während einer Autorisierung führt zu einem Fehler vom Typ `terminal_reader_busy`. #### Kundenseitig initiierte Stornierung Nutzer/innen können den Wert von `enable_customer_cancellation` auf diesen Endpoints festlegen: - [process_payment_intent](https://docs.stripe.com/api/terminal/readers/process_payment_intent.md) - [process_setup_intent](https://docs.stripe.com/api/terminal/readers/process_setup_intent.md) - [collect_payment_method](https://docs.stripe.com/api/terminal/readers/collect_payment_method.md) - [refund_payment](https://docs.stripe.com/api/terminal/readers/refund_payment.md) ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}}/process_payment_intent \ -u "<>:" \ -d "payment_intent={{PAYMENTINTENT_ID}}" \ -d "process_config[enable_customer_cancellation]=true" ``` Wenn „true“, sehen Nutzer/innen intelligenter Kartenlesegeräte eine Schaltfläche zum Stornieren. ![Bildschirm für Zahlungseinzug mit Schaltfläche für Stornierung auf Kundenseite](https://b.stripecdn.com/docs-statics-srv/assets/customer-cancellation-light-mode.c9ff8361795a2bf4d9e307eee8669775.png) Zahlungseinzug mit aktivierter Stornierung Durch Tippen auf die Schaltfläche „Abbrechen“ wird die aktive Transaktion abgebrochen. Stripe sendet einen Webhook `terminal.reader.action_failed` mit dem failure_code `customer_canceled`. ```json { "action": { "failure_code": "customer_canceled", "failure_message": "This action could not be completed due to an error on the card reader.", "process_payment_intent": { "payment_intent": "{{PAYMENT_INTENT_ID}}", "process_config": { "enable_customer_cancellation": true } }, "status": "failed", "type": "process_payment_intent" } } ``` ### Lesegerät beschäftigt Ein Lesegerät kann jeweils nur eine Zahlung verarbeiten. Während eine Zahlung verarbeitet wird, schlägt der Versuch einer neuen Zahlung mit einem `terminal_reader_busy`-Fehler fehl: ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}}/process_payment_intent \ -u "<>:" \ -d "payment_intent={{PAYMENTINTENT_ID}}" ``` ```json { "error": { "code": "terminal_reader_busy", "doc_url": "https://docs.stripe.com/error-codes#terminal-reader-timeout", "message": "Reader is currently busy processing another request. Please reference the integration guide at https://stripe.com/docs/terminal/payments/collect-card-payment?terminal-sdk-platform=server-driven#handle-errors for details on how to handle this error.", "type": "invalid_request_error" } } ``` Zahlungen, deren Bearbeitung noch nicht begonnen hat, können durch neue ersetzt werden. Ein Lesegerät lehnt eine API-Anfrage auch ab, wenn es mit Updates oder Einstellungen beschäftigt ist oder wenn eine Karte aus der vorherigen Transaktion verwendet wird. ### Timeout des Lesegeräts In seltenen Fällen kann es vorkommen, dass ein Lesegerät aufgrund von temporären Netzwerkproblemen nicht rechtzeitig auf eine API-Anfrage reagiert. In diesem Fall erhalten Sie den Fehlercode `terminal_reader_timeout`: ```curl curl https://api.stripe.com/v1/terminal/readers/{{TERMINALREADER_ID}}/process_payment_intent \ -u "<>:" \ -d "payment_intent={{PAYMENTINTENT_ID}}" ``` ```json { "error": { "code": "terminal_reader_timeout", "doc_url": "https://docs.stripe.com/error-codes#terminal-reader-timeout", "message": "There was a timeout when sending this command to the reader. Please reference the integration guide at https://stripe.com/docs/terminal/payments/collect-card-payment?terminal-sdk-platform=server-driven#handle-errors for details on how to handle this error.", "type": "invalid_request_error" } } ``` In diesem Fall empfehlen wir Ihnen, die API-Anfrage erneut durchzuführen. Stellen Sie sicher, dass Ihr Netzwerk unsere [Netzwerkanforderungen](https://docs.stripe.com/terminal/network-requirements.md) erfüllt, um Zeitüberschreitungen zu vermeiden. In seltenen Fällen ist der Fehlercode `terminal_reader_timeout` falsch negativ. In diesem Szenario erhalten Sie, wie oben beschrieben, den Fehler `terminal_reader_timeout` von der API, das Lesegerät hat den Befehl jedoch empfangen. Falsch negative Ergebnisse treten auf, wenn Stripe eine Nachricht an das Lesegerät sendet, aber aufgrund vorübergehender Netzwerkfehler keine Bestätigung vom Lesegerät erhält. ### Lesegerät offline Wenn an einem Standort die Internetverbindung unterbrochen wird, kann dies zu einer Unterbrechung der Kommunikation zwischen dem Lesegerät und Stripe führen. In diesem Fall reagieren ein Lesegeräte möglicherweise nicht auf Ereignisse, die von Ihrer Point-of-Sale-Anwendung und Backend-Infrastruktur ausgelöst werden. Ein Lesegerät, das regelmäßig nicht auf API-Anfragen reagiert, ist höchstwahrscheinlich ausgeschaltet (z. B. das Netzkabel ist nicht angeschlossen oder der Akku leer) oder nicht korrekt mit dem Internet verbunden. Ein Lesegerät gilt als offline, wenn Stripe in den letzten 2 Minuten kein Signal von diesem Lesegerät erhalten hat. Der Versuch, API-Methoden auf einem Offline-Lesegerät aufzurufen, führt zu einem `terminal_reader_offline`-Fehlercode: ```json { "error": { "code": "terminal_reader_offline", "doc_url": "https://docs.stripe.com/error-codes#terminal-reader-offline", "message": "Reader is currently offline, please ensure the reader is powered on and connected to the internet before retrying your request. Reference the integration guide at https://docs.stripe.com/terminal/payments/collect-card-payment?terminal-sdk-platform=server-driven#reader-offline for details on how to handle this error.", "type": "invalid_request_error" } } ``` Halten Sie sich an unsere [Netzwerkanforderungen](https://docs.stripe.com/terminal/network-requirements.md), um sicherzustellen, dass ein Lesegerät korrekt mit dem Internet verbunden ist. ### Fehlende Webhooks Wenn ein Lesegerät während einer Zahlung die Verbindung trennt, kann es seinen Aktionsstatus in der API nicht aktualisieren. In diesem Szenario zeigt das Lesegerät nach dem Vorzeigen einer Karte einen Fehlerbildschirm an. Das Lesegerät-Objekt in der API wird jedoch nicht so aktualisiert, dass der Fehler auf dem Gerät widergespiegelt wird, und Sie erhalten auch keine Webhooks für die Lesegerätaktion. Ein Lesegerät kann in diesem Fall den Aktionsstatus `in_progress` haben. Kassierer/innen müssen dann eingreifen, indem sie den Endpoint [cancel_action](https://docs.stripe.com/api/terminal/readers/object.md#terminal_reader_object-action-cancel_action) zum Zurücksetzen des Lesegerätstatus aufrufen. ### Verzögerte Webhooks In seltenen Fällen kann es bei einem Stripe-Ausfall zu Verzögerungen bei den Webhooks für Lesegerätaktionen kommen. Sie können den Status der Reader- oder PaymentIntent-Objekte abfragen, um den aktuellen Status zu ermitteln. ## Webhook-Ereignisse | Webhook | Beschreibung | | ---------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `terminal.reader.action_succeeded` | Wird gesendet, wenn eine asynchrone Aktion erfolgreich ist. Wird für Aktionen gesendet, die eine vorgelegte Karte benötigen, beispielsweise `process_payment_intent`, `confirm_payment_intent`, `process_setup_intent` und `refund_payment`. | | `terminal.reader.action_failed` | Wird gesendet, wenn eine asynchrone Aktion fehlschlägt. Wird für Aktionen gesendet, bei denen eine Karte vorgelegt werden muss, wie `process_payment_intent`, `process_setup_intent` und `refund_payment`. Für die Aktionen `set_reader_display` und `cancel_action` wird kein Webhook gesendet. Ihre Integration muss [diese Fehler beheben](https://docs.stripe.com/terminal/payments/collect-card-payment.md?terminal-sdk-platform=server-driven#handle-errors). | | `terminal.reader.action_updated` | Wird gesendet, wenn eine asynchrone Aktion aktualisiert wird. Wird für Aktionen wie `collect_payment_method` gesendet. | # JavaScript > This is a JavaScript for when terminal-sdk-platform is js. View the full page at https://docs.stripe.com/terminal/payments/collect-card-payment?terminal-sdk-platform=js. > #### Empfehlung für intelligente Lesegeräte > > Für intelligente Lesegeräte wie das Lesegerät [BBPOS WisePOS E](https://docs.stripe.com/terminal/payments/setup-reader/bbpos-wisepos-e.md), [Stripe Reader S700/S710](https://docs.stripe.com/terminal/readers/stripe-reader-s700-s710.md) und [Verifone-Lesegeräte](https://docs.stripe.com/terminal/payments/setup-reader/verifone.md) empfehlen wir die Verwendung der [servergestützten Integration](https://docs.stripe.com/terminal/payments/setup-integration.md?terminal-sdk-platform=server-driven) anstelle des JavaScript-SDK. > > Das JavaScript-SDK erfordert Ihr POS und Lesegerät im selben lokalen Netzwerk mit funktionierendem lokalen DNS. Die Server-gestützte Integration verwendet stattdessen die Stripe API, was in komplexen Netzwerkumgebungen einfacher sein kann. Lesen Sie unseren [Plattformvergleich](https://docs.stripe.com/terminal/payments/setup-reader.md#sdk), um die beste Plattform für Ihre Anforderungen auszuwählen. Sie kennen die Payment Intents API noch nicht? Hier finden Sie einige nützliche Informationen: - [Die Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) - [Das PaymentIntent-Objekt](https://docs.stripe.com/api/payment_intents.md) - [Weitere Zahlungsszenarien](https://docs.stripe.com/payments/more-payment-scenarios.md) Zum Einziehen von Zahlungen mit Stripe Terminal müssen Sie einen Zahlungsablauf in Ihrer Anwendung programmieren. Verwenden Sie das Stripe Terminal SDK, um einen [PaymentIntent](https://docs.stripe.com/api.md#payment_intents) zu erstellen und zu aktualisieren. Bei einem PaymentIntent handelt es sich um ein Objekt, das eine einzelne Zahlungssitzung darstellt. Die fehlerresistente Terminal-Integration teilt den Zahlungsvorgang in mehrere Schritte auf, von denen jeder sicher erneut versucht werden kann: 1. [PaymentIntent erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment). 1. [Zahlungsmethode erfassen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment). Sie können definieren, ob Ihre Zahlungen [automatisch](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-capture_method) oder [manuell](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md) erfasst werden sollen. 1. [Abwickeln der Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Die Autorisierung für die Karte der Kundin/des Kunden erfolgt, wenn das SDK die Zahlung verarbeitet. 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#capture-payment) > Diese Integrationsform unterstützt [Offline-Kartenzahlungen](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md) nicht. ## Erstellen Sie ein PaymentIntent [Serverseitig] Der erste Schritt beim Einziehen von Zahlungen ist das Starten des Zahlungsablaufs. Wenn Kundinnen/Kunden den Bestellvorgang abschließen, muss Ihre Anwendung ein `PaymentIntent`-Objekt erstellen. Dies stellt eine neue Zahlungssitzung auf Stripe dar. Verwenden Sie [Test-Beträge](https://docs.stripe.com/terminal/references/testing.md#physical-test-cards), um verschiedene Ergebnisse zu erzielen. Ein Betrag, der auf `00` endet, führt zu einer bestätigten Zahlung. > #### Erstellen Sie PaymentIntents für abgelehnte Karten nicht erneut > > Erstellen Sie einen PaymentIntent nicht neu, wenn eine Karte abgelehnt wird. Verwenden Sie stattdessen denselben PaymentIntent wieder, um [doppelte Abbuchungen zu vermeiden](https://docs.stripe.com/terminal/payments/collect-card-payment.md#avoiding-double-charges). Das folgende Beispiel zeigt, wie Sie einen `PaymentIntent` auf Ihrem Server erstellen: #### curl ```bash 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" ``` Für Terminal-Zahlungen muss der Parameter `payment_method_types` `card_present` enthalten. Sie können den Zahlungsablauf wie folgt steuern: - Um den Zahlungsablauf für `card_present`-Zahlungen vollständig zu steuern, setzen Sie `capture_method` auf `manual`. So können Sie vor der endgültigen Finalisierung der Zahlung einen Abgleichschritt hinzufügen. - Um Zahlungen in einem Schritt zu autorisieren und zu erfassen, setzen Sie `capture_method` auf `automatic`. Um Interac-Zahlungen in Kanada zu akzeptieren, müssen Sie außerdem `interac_present` in `payment_method_types` aufnehmen. Weitere Details finden Sie in unserer [Dokumentation für Kanada](https://docs.stripe.com/terminal/payments/regional.md?integration-country=CA). Der `PaymentIntent` enthält ein [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret), einen Schlüssel, der für jeden `PaymentIntent` eindeutig ist. Um das Client-Geheimnis zu verwenden, müssen Sie es vom `PaymentIntent` auf Ihrem Server beziehen und [an den Client übergeben](https://docs.stripe.com/payments/payment-intents.md#passing-to-client). #### Ruby ```ruby post '/create_payment_intent' do intent = # ... Create or retrieve the PaymentIntent {client_secret: intent.client_secret}.to_json end ``` Verwenden Sie das Client-Geheimnis als Parameter beim Aufruf von [collectPaymentMethod](https://docs.stripe.com/terminal/references/api/js-sdk.md#collect-payment-method). Sie benötigen in Ihrer clientseitigen Anwendung nur das `client_secret`, um mit der Erfassung der Zahlungsmethode fortzufahren. ## Zahlungsmethode erfassen [Clientseitig] - [collectPaymentMethod (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#collect-payment-method) Nachdem Sie einen `PaymentIntent` erstellt haben, erfassen Sie als Nächstes eine Zahlungsmethode mit dem SDK. Das verbundene Lesegerät wartet auf die Vorlage einer Karte, nachdem Ihre App `CollectPaymentMethodAsync` aufgerufen hat.Um eine Zahlungsmethode zu erfassen, muss Ihre App mit einem Lesegerät verbunden sein. Das verbundene Lesegerät wartet auf die Vorlage einer Karte, nachdem Ihre App `collectPaymentMethod` aufgerufen hat. ```javascript async () => { // clientSecret is the client_secret from the PaymentIntent you created in Step 1. const result = await terminal.collectPaymentMethod(clientSecret); if (result.error) { // Placeholder for handling result.error } else { // Placeholder for processing result.paymentIntent } } ``` Diese Methode erfasst die verschlüsselten Daten einer Zahlungsmethode mithilfe des verbundenen Lesegeräts und ordnet die verschlüsselten Daten dem lokalen `PaymentIntent` zu. ### Optionale Prüfung der Angaben zur Zahlungsmethode - [collectPaymentMethod config_override (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#collect-payment-method) Für erweiterte Use cases können Sie die Details der Zahlungsmethode der vorgelegten Karte prüfen und Ihre eigene Geschäftslogik vor der Autorisierung ausführen. Verwenden Sie den Parameter `update_payment_intent`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent`anzufügen. Diese Daten werden in der `collectPaymentMethod`-Antwort zurückgegeben. ```javascript async () => { // clientSecret is the client_secret from the PaymentIntent you created in Step 1. const result = await terminal.collectPaymentMethod(clientSecret, { config_override: { update_payment_intent: true } }); if (result.error) { // Placeholder for handling result.error } else { const pm = result.paymentIntent.payment_method const card = pm?.card_present ?? pm?.interac_present // Placeholder for business logic on card before processing result.paymentIntent } } ``` Diese Methode fügt die erfassten verschlüsselten Zahlungsmethodendaten mit einer Aktualisierung zum `PaymentIntent`-Objekt hinzu. Eine Autorisierung ist erst erforderlich, wenn Sie [die Zahlung verarbeiten](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment). Dieser erweiterte Anwendungsfall wird auf dem Verifone P400 nicht unterstützt. Nach Erfassung der Zahlungsmethode müssen Sie die Zahlung autorisieren oder den Einzug innerhalb von 30 Sekunden abbrechen. Wenn das SDK [offline ist](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md), ist das Feld `paymentMethod` im `PaymentIntent`-Objekt nicht vorhanden. Sie können an dieser Stelle auf Attribute wie Kartenmarke, Finanzierung und andere nützliche Daten zugreifen. Stripe versucht zu erkennen, ob eine mobile Wallet bei einer Transaktion verwendet wird, wie im Attribut `wallet.type` gezeigt. Das Attribut wird jedoch nicht ausgefüllt, wenn die ausstellende Bank die lesegerätegestützte Identifizierung einer mobilen Wallet nicht unterstützt, sodass eine genaue Erkennung nicht garantiert werden kann. Nach der Autorisierung im [Bestätigungsschritt](https://docs.stripe.com/terminal/payments/collect-card-payment.md#confirm-payment) erhält Stripe aktuelle Informationen von den Netzwerken und aktualisiert `wallet.type` zuverlässig. ### Erfassung abbrechen #### Programmgesteuerte Stornierung Sie können die Erfassung einer Zahlungsmethode durch Aufruf von [cancelCollectPaymentMethod](https://docs.stripe.com/terminal/references/api/js-sdk.md#cancel-collect-payment-method) im JavaScript SDK stornieren. #### Kundenseitig initiierte Stornierung - [enable_customer_cancellation (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#collect-payment-method) Wenn Sie `enable_customer_cancellation` für eine Transaktion auf „true“ gesetzt haben, wird Nutzerinnen und Nutzern von intelligenten Lesegeräten eine Schaltfläche zum Abbrechen angezeigt. Durch Tippen auf die Schaltfläche „Abbrechen“ wird die aktive Transaktion abgebrochen. ```javascript terminal.collectPaymentMethod( clientSecret, { config_override: {enable_customer_cancellation: true } } ) ``` ### Ereignisse verarbeiten > Das JavaScript-SDK unterstützt nur Verifone P400, BBPOS WisePOS E und Stripe Reader S700/S710, die über einen integrierten Bildschirm verfügen. Ihre Anwendung muss den Kundinnen und Kunden keine Ereignisse zur Erfassung der Zahlungsmethode anzeigen, da sie auf dem Lesegerät angezeigt werden. Um die Zahlungsmethode für eine Transaktion zu löschen, kann der Kassierer die rote Taste (❌) drücken. ## Zahlung bestätigen [Clientseitig] - [processPayment (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#process-payment) Nachdem eine Zahlungsmethode erfolgreich vom Kunden/von der Kundin erfasst wurde, müssen Sie als Nächstes die Zahlung mit dem SDK verarbeiten. Wenn Sie bereit sind, mit der Zahlung fortzufahren, rufen Sie `processPayment` mit dem aktualisierten `PaymentIntent` aus [Schritt 2](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-payment) auf. - Bei einer manuellen Erfassung von Zahlungen führt ein erfolgreicher Aufruf von `processPayment` zu einem `PaymentIntent` mit dem Status `requires_capture`. - Bei einer automatischen Erfassung von Zahlungen wechselt der `PaymentIntent` zum Status `succeeded`. Bestätigen Sie PaymentIntents immer mithilfe des Terminal SDK auf der Client-Seite. Bei der serverseitigen Bestätigung werden wichtige Interaktionen, wie z. B. PIN-Abfragen, umgangen, was zu fehlgeschlagenen Transaktionen führen kann. ```javascript async () => { const result = await terminal.processPayment(paymentIntent); if (result.error) { // Placeholder for handling result.error } else if (result.paymentIntent) { // Placeholder for notifying your backend to capture result.paymentIntent.id } } ``` Sie müssen einen PaymentIntent innerhalb von 2 Tagen manuell erfassen. Andernfalls läuft die Autorisierung ab und die Gelder werden für den Kunden/die Kundin freigegeben. ### Umgang mit Fehlern - [Fehlercodes (JavaScript)](https://docs.stripe.com/terminal/references/api/js-sdk.md#error-codes) Wenn die Verarbeitung einer Zahlung fehlschlägt, gibt das SDK einen Fehler zurück, der den aktualisierten `PaymentIntent` enthält. Ihre Anwendung muss den `PaymentIntent` überprüfen, um zu entscheiden, wie mit dem Fehler umgegangen wird. | PaymentIntent-Status | Bedeutung | Lösung | | ------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `requires_payment_method` | Zahlungsmethode abgelehnt | Versuchen Sie, eine andere Zahlungsmethode zu erfassen, indem Sie `collectPaymentMethod` mit demselben `PaymentIntent` erneut aufrufen. | | `requires_confirmation` | Vorübergehendes Verbindungsproblem | Rufen Sie `processPayment` mit demselben `PaymentIntent` erneut auf, um die Anfrage zu wiederholen. | | `PaymentIntent` ist `nil` | Anfrage an Stripe ist abgelaufen, unbekannter Status des `PaymentIntent` | Verarbeiten Sie den ursprünglichen `PaymentIntent` erneut. Erstellen Sie keinen neuen PaymentIntent, da dies zu mehreren Autorisierungen für den/die Karteninhaber/in führen könnte. | Wenn Anfragen mehrmals hintereinander ablaufen, liegt möglicherweise ein Verbindungsproblem vor. Stellen Sie sicher, dass Ihre App mit dem Internet verbunden ist. ### Doppelte Abbuchungen vermeiden Das `PaymentIntent`-Objekt ermöglicht Geldbewegungen bei Stripe – verwenden Sie einen einzigen `PaymentIntent`, um eine Transaktion darzustellen. Verwenden Sie denselben `PaymentIntent`, nachdem eine Karte abgelehnt wurde (z. B. wenn sie nicht ausreichend gedeckt ist), damit Ihre Kundin/Ihr Kunde es mit einer anderen Karte erneut versuchen kann. Wenn Sie den `PaymentIntent` bearbeiten, müssen Sie `CollectPaymentMethodAsync` aufrufen, um die Zahlungsinformationen auf dem Lesegerät zu aktualisieren.Wenn Sie den `PaymentIntent` bearbeiten, müssen Sie `collectPaymentMethod` aufrufen, um die Zahlungsinformationen auf dem Lesegerät zu aktualisieren. Ein `PaymentIntent` muss sich im Status `requires_payment_method` befinden, bevor Stripe ihn verarbeiten kann. Ein autorisierter, erfasster oder stornierter `PaymentIntent` kann nicht von einem Lesegerät verarbeitet werden. ## Zahlung erfassen [Serverseitig] Wenn Sie bei der Erstellung des `PaymentIntent` in [Schritt 1](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment) `capture_method` als `manual` definiert haben, gibt das SDK einen autorisierten, aber nicht erfassten `PaymentIntent` an Ihre Anwendung zurück. Erfahren Sie mehr über den Unterschied zwischen [Autorisierung und Erfassung](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md). Wenn Ihre App einen bestätigten `PaymentIntent` von Ihrem SDK empfängt, stellen Sie sicher, dass Ihr Backend angewiesen wird, die Zahlung zu erfassen. Erstellen Sie einen Endpoint in Ihrem Backend, der eine `PaymentIntent`-ID akzeptiert und eine Anfrage zum Erfassen des `PaymentIntent` an die Stripe-API übermittelt: ```curl curl -X POST https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/capture \ -u "<>:" ``` Eine erfolgreiche `capture` führt zu einem `PaymentIntent` mit dem Status `succeeded`. Um sicherzustellen, dass die erfasste Plattformgebühr für verbundene Konten korrekt ist, überprüfen Sie jeden `PaymentIntent` und ändern Sie die Plattformgebühr bei Bedarf, bevor Sie die Zahlung manuell erfassen. ### Zahlungen abgleichen Um die Zahlungsaktivität Ihres Unternehmens zu überwachen, können Sie am Tagesende PaymentIntents mit Ihrem internen Bestellsystem auf Ihrem Server abgleichen. Ein `PaymentIntent`, der den Status `requires_capture` beibehält, kann eines der folgenden zwei Szenarien darstellen: **Überflüssige Autorisierung auf der Kartenabrechnung Ihrer Kundin/Ihres Kunden** - Ursache: Der/die Nutzer/in hat den Bezahlvorgang Ihrer App während einer Transaktion verlassen. - Lösung: Wenn der nicht erfasste `PaymentIntent` keiner abgeschlossenen Bestellung auf Ihrem Server zugeordnet ist, können Sie ihn [abbrechen](https://docs.stripe.com/api/payment_intents/cancel.md). Sie können einen stornierten `PaymentIntent` nicht zur Durchführung von Zahlungen verwenden. **Unvollständiger Einzug von Geldern von einer Kundin/einem Kunden** - Ursache: Die Anfrage Ihrer App, die Ihr Backend zur Erfassung der Zahlung anweist, ist fehlgeschlagen. - Lösung: Wenn der nicht erfasste `PaymentIntent` einer abgeschlossenen Bestellung auf Ihrem Server zugeordnet ist und keine andere Zahlung (zum Beispiel eine Barzahlung) für die Bestellung angenommen wurde, können Sie ihn [erfassen](https://docs.stripe.com/api/payment_intents/capture.md). ### Trinkgelder einziehen (US only) In den USA können berechtigte Nutzer/innen [beim Erfassen von Zahlungen ein Trinkgeld über den Zahlungsbeleg einziehen](https://docs.stripe.com/terminal/features/collecting-tips/on-receipt.md). # iOS > This is a iOS for when terminal-sdk-platform is ios. View the full page at https://docs.stripe.com/terminal/payments/collect-card-payment?terminal-sdk-platform=ios. Sie kennen die Payment Intents API noch nicht? Hier finden Sie einige nützliche Informationen: - [Die Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) - [Das PaymentIntent-Objekt](https://docs.stripe.com/api/payment_intents.md) - [Weitere Zahlungsszenarien](https://docs.stripe.com/payments/more-payment-scenarios.md) Zum Einziehen von Zahlungen mit Stripe Terminal müssen Sie einen Zahlungsablauf in Ihrer Anwendung programmieren. Verwenden Sie das Stripe Terminal SDK, um einen [PaymentIntent](https://docs.stripe.com/api.md#payment_intents) zu erstellen und zu aktualisieren. Bei einem PaymentIntent handelt es sich um ein Objekt, das eine einzelne Zahlungssitzung darstellt. Die fehlerresistente Terminal-Integration teilt den Zahlungsvorgang in mehrere Schritte auf, von denen jeder sicher erneut versucht werden kann: 1. [PaymentIntent erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment). 1. [Abwickeln der Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment). Die Autorisierung der Karte der Kundin/des Kunden erfolgt, wenn das SDK die Zahlung abwickelt. 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#capture-payment) ## Erstellen Sie ein PaymentIntent [Clientseitig] [Serverseitig] Der erste Schritt beim Einziehen von Zahlungen ist das Starten des Zahlungsablaufs. Wenn Kundinnen/Kunden den Bestellvorgang abschließen, muss Ihre Anwendung ein `PaymentIntent`-Objekt erstellen. Dies stellt eine neue Zahlungssitzung auf Stripe dar. - [createPaymentIntent (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)createPaymentIntent:completion:) Einen `PaymentIntent` können Sie auf dem Client oder auf dem Server erstellen. Verwenden Sie [Test-Beträge](https://docs.stripe.com/terminal/references/testing.md#physical-test-cards), um verschiedene Ergebnisse zu erzielen. Ein Betrag, der auf `00` endet, führt zu einer bestätigten Zahlung. > #### Erstellen Sie PaymentIntents für abgelehnte Karten nicht erneut > > Erstellen Sie einen PaymentIntent nicht neu, wenn eine Karte abgelehnt wird. Verwenden Sie stattdessen denselben PaymentIntent wieder, um [doppelte Abbuchungen zu vermeiden](https://docs.stripe.com/terminal/payments/collect-card-payment.md#avoiding-double-charges). ### Clientseitig Erstellen Sie einen `PaymentIntent` auf Ihrem Client: > Wenn Ihre App mit dem Lesegerät Verifone P400 verbunden ist, können Sie keinen PaymentIntent über das iOS SDK erstellen. Sie müssen stattdessen 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").build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded") // ... } } } // ... } ``` ### Serverseitig Wenn die zum Starten einer Zahlung erforderlichen Informationen in Ihrer App nicht jederzeit verfügbar sind, können Sie den `PaymentIntent` auch auf Ihrem Server erstellen. Das folgende Beispiel zeigt, wie Sie einen `PaymentIntent` auf Ihrem Server erstellen: #### curl ```bash 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" ``` Für Terminal-Zahlungen muss der Parameter `payment_method_types` `card_present` enthalten. Sie können den Zahlungsablauf wie folgt steuern: - Um den Zahlungsablauf für `card_present`-Zahlungen vollständig zu steuern, setzen Sie `capture_method` auf `manual`. So können Sie vor der endgültigen Finalisierung der Zahlung einen Abgleichschritt hinzufügen. - Um Zahlungen in einem Schritt zu autorisieren und zu erfassen, setzen Sie `capture_method` auf `automatic`. Um in Australien Zahlungen zu akzeptieren, müssen Sie `capture_method` auf `automatic` oder `manual_preferred` setzen. Weitere Informationen finden Sie in unserer [Dokumentation zu Australien](https://docs.stripe.com/terminal/payments/regional.md?integration-country=AU). Um Interac-Zahlungen in Kanada zu akzeptieren, müssen Sie auch `interac_present` in `payment_method_types` aufnehmen. Weitere Informationen finden Sie in unserer [Dokumentation zu Kanada](https://docs.stripe.com/terminal/payments/regional.md?integration-country=CA). Der `PaymentIntent` enthält ein [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret), einen Schlüssel, der für jeden `PaymentIntent` eindeutig ist. Um das Client-Geheimnis zu verwenden, müssen Sie es vom `PaymentIntent` auf Ihrem Server beziehen und [an den Client übergeben](https://docs.stripe.com/payments/payment-intents.md#passing-to-client). #### Ruby ```ruby post '/create_payment_intent' do intent = # ... Create or retrieve the PaymentIntent {client_secret: intent.client_secret}.to_json end ``` - [retrievePaymentIntent (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)retrievePaymentIntent:completion:) Um einen `PaymentIntent` abzurufen, rufen Sie mithilfe des Client-Geheimnisses `retrievePaymentIntent` auf. Nachdem Sie den `PaymentIntent` abgerufen haben, verwenden Sie ihn, um `processPaymentIntent` aufzurufen. #### Swift ```swift func checkoutButtonAction() { // ... Fetch the client secret from your backend Terminal.shared.retrievePaymentIntent(clientSecret: clientSecret) { retrieveResult, retrieveError in if let error = retrieveError { print("retrievePaymentIntent failed: \(error)") } else if let paymentIntent = retrieveResult { print("retrievePaymentIntent succeeded: \(paymentIntent)") // ... } } } ``` ## Zahlung abwickeln [Clientseitig] Sie können eine Zahlung sofort mit der von einer Kundin/einem Kunden vorgelegten Karte abwickeln oder stattdessen die Kartenangaben überprüfen, bevor Sie mit dem Prozess der Zahlung fortfahren. Für die meisten Use Cases empfehlen wir eine sofortige Verarbeitung, da es sich um eine einfachere Integration mit weniger API-Aufrufen handelt. Wenn Sie jedoch Ihre eigene Geschäftslogik hinzufügen möchten, bevor die Karte autorisiert wird, können Sie den Vorgang zur Erfassung und Bestätigung in zwei Schritten verwenden. #### Sofort verarbeiten Nach Erstellen eines PaymentIntent besteht der nächste Schritt darin, die Zahlung zu verarbeiten. Das Lesegerät fordert den Kunden/die Kundin auf, seine/ihre Karte aufzulegen oder einzuschieben und autorisiert die Zahlung dann. - [processPaymentIntent (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)processPaymentIntent:delegate:completion:) Während der Abwicklung einer Zahlung kann es einige Sekunden dauern, bis die Karteninhaberin oder der Karteninhaber ihre bzw. seine Karte aus der Wallet erhält oder während der Zahlung eine Frage an den Betreiber stellt. #### Swift ```swift // Action for a "Checkout" button func checkoutAction() throws { let params = try PaymentIntentParametersBuilder(amount: 1000, currency: "usd").build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded") self.processCancelable = Terminal.shared.processPaymentIntent(paymentIntent, collectConfig: nil, confirmConfig: nil) { processResult, processError in if let error = processError { print("processPaymentIntent failed: \(error)") } else if let processedPaymentIntent = processResult { print("processPaymentIntent succeeded") // Notify your backend to capture the PaymentIntent if let stripeId = processedPaymentIntent.stripeId { APIClient.shared.capturePaymentIntent(stripeId) { captureError in if let error = captureError { print("capturePaymentIntent failed: \(error)") } else { print("capturePaymentIntent succeeded") } } } else { print("Payment processed offline"); } } } } } } ``` ### Erfassung abbrechen #### Programmgesteuerte Stornierung - [Cancelable (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCancelable.html) Sie können die Verarbeitung eines PaymentIntents mithilfe des vom iOS-SDK zurückgegebenen `Cancelable`-Objekts abbrechen. #### Kundenseitig initiierte Stornierung - [setCustomerCancellation (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCollectPaymentIntentConfigurationBuilder.html#/c:objc\(cs\)SCPCollectPaymentIntentConfigurationBuilder\(im\)setCustomerCancellation) - [CustomerCancellation (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPCustomerCancellation.html) Intelligente Lesegeräte zeigen Kundinnen und Kunden standardmäßig eine Schaltfläche zum Abbrechen an. Sie können dies deaktivieren, indem Sie `customerCancellation` auf `.disableIfAvailable` festlegen. Durch Tippen auf die Schaltfläche „Abbrechen“ wird die aktive Transaktion abgebrochen. #### Swift ```swift let collectConfig = try CollectPaymentIntentConfigurationBuilder() .setCustomerCancellation(.disableIfAvailable) // turn OFF the cancel button, ON by default .build() Terminal.shared.collectPaymentMethod(paymentIntent: paymentIntent, collectConfig: collectConfig) { intentWithPaymentMethod, attachError in } ``` ### Ereignisse verarbeiten - [ReaderDisplayDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDisplayDelegate.html) Wenn Sie eine Zahlungsmethode mit einem Lesegerät wie dem [Stripe M2](https://docs.stripe.com/terminal/readers/stripe-m2.md) ohne integriertes Display erfassen, muss Ihre App in der Lage sein, den Nutzerinnen und Nutzern Ereignisse aus der Erfassung der Zahlungsmethode anzuzeigen. Diese Ereignisse helfen Nutzerinnen und Nutzern, Zahlungen erfolgreich einzuziehen (beispielsweise beim erneuten Versuch einer Karte, bei der Verwendung einer anderen Lesemethode). Wenn eine Transaktion startet, übergibt das SDK einen `ReaderInputOptions`-Wert an den Bildschirm-Handler des Lesegeräts Ihrer App, wobei die akzeptierten Eingabetypen (beispielsweise `Swipe`, `Insert`, oder `Tap`) angezeigt werden. Fordern Sie die Nutzerinnen und Nutzer über die Nutzeroberfläche des Bezahlvorgangs Ihrer App auf, die Karte unter Verwendung einer dieser Optionen vorzulegen. Während der Transaktion kann das SDK unter Umständen Ihre App auffordern, Ihren Nutzerinnen und Nutzern zusätzliche Anweisungen anzuzeigen (beispielsweise `Retry Card`). Dazu wird ein Wert `ReaderDisplayMessage` an den Handler der Anzeige Ihres Lesegeräts übergeben. Stellen Sie sicher, dass die Nutzeroberfläche Ihres Bezahlvorgangs Ihren Nutzerinnen und Nutzern diese Meldungen anzeigt. #### Swift ```swift // MARK: MobileReaderDelegate - only needed for Bluetooth readers, this is the delegate set during connectReader func reader(_ reader: Reader, didRequestReaderInput inputOptions: ReaderInputOptions = []) { readerMessageLabel.text = Terminal.stringFromReaderInputOptions(inputOptions) } func reader(_ reader: Reader, didRequestReaderDisplayMessage displayMessage: ReaderDisplayMessage) { readerMessageLabel.text = Terminal.stringFromReaderDisplayMessage(displayMessage) } ``` ### Ziehen Sie Zahlungen mit Tap to Pay auf dem iPhone ein Wenn Ihre Anwendung bereit ist, eine Zahlung einzuziehen, übernimmt das Stripe-Terminal-iOS-SDK die Anzeige, um den Einzugsvorgang abzuwickeln. Nach dem Aufruf der [Zahlungsmethode](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment) zur Abwicklung läuft Ihre Anwendung weiter. Doch das iPhone zeigt dem/der Karteninhaber/in eine Vollbildaufforderung an, die ihn/sie anweist, seine/ihre Karte oder NFC-basierte mobile Wallet vorzulegen. Wenn beim Lesen der Karte ein Fehler auftritt, wird eine Aufforderung zum erneuten Versuch angezeigt. Eine erfolgreiche Vorlage gibt eine Erfolgsmeldung zurück und dann kehrt die Kontrolle zu Ihrer Anwendung zurück. ![Zahlungseinzug mit Tap to Pay auf dem iPhone](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-payment-collection.50a552f2d75b8a3b92a439810cd9361d.png) Zahlungseinzug - Bei einer manuellen Erfassung von Zahlungen führt ein erfolgreicher Aufruf von `processPaymentIntent` zu einem `PaymentIntent` mit dem Status `requires_capture`. - Bei einer automatischen Erfassung von Zahlungen wechselt der `PaymentIntent` zum Status `succeeded`. Sie müssen einen PaymentIntent innerhalb von 2 Tagen manuell erfassen. Andernfalls läuft die Autorisierung ab und die Gelder werden für den Kunden/die Kundin freigegeben. ### Umgang mit Fehlern - [ConfirmPaymentIntentError (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPConfirmPaymentIntentError.html#/c:objc\(cs\)SCPConfirmPaymentIntentError\(py\)paymentIntent) Wenn eine Zahlung fehlschlägt, gibt das SDK einen Fehler zurück, der den aktualisierten `PaymentIntent` beinhaltet, wenn sie von Stripe abgelehnt wurde. Ihre Anwendung muss den `PaymentIntent` prüfen, um zu entscheiden, wie der Fehler gehandhabt wird. | PaymentIntent-Status | Bedeutung | Lösung | | ------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `requires_payment_method` | Zahlungsmethode abgelehnt | Versuchen Sie, eine andere Zahlungsmethode zu erfassen, indem Sie `processPaymentIntent` mit demselben `PaymentIntent` erneut aufrufen. | | `requires_confirmation` | Vorübergehendes Verbindungsproblem | Rufen Sie `processPaymentIntent` mit demselben `PaymentIntent` erneut auf, um die Anfrage zu wiederholen. | | `PaymentIntent` ist `nil` | Anfrage an Stripe ist abgelaufen, unbekannter Status des `PaymentIntent` | Verarbeiten Sie den ursprünglichen `PaymentIntent` erneut. Erstellen Sie keinen neuen PaymentIntent, da dies zu mehreren Autorisierungen für den/die Karteninhaber/in führen könnte. | Wenn Anfragen mehrmals hintereinander ablaufen, liegt möglicherweise ein Verbindungsproblem vor. Stellen Sie sicher, dass Ihre App mit dem Internet verbunden ist. ### Doppelte Zahlungen vermeiden Das `PaymentIntent`-Objekt ermöglicht Geldbewegungen bei Stripe – verwenden Sie einen einzigen `PaymentIntent`, um eine Transaktion darzustellen. Verwenden Sie denselben `PaymentIntent`, nachdem eine Karte abgelehnt wurde (z. B. wenn sie nicht ausreichend gedeckt ist), damit Ihre Kundin/Ihr Kunde es mit einer anderen Karte erneut versuchen kann. Wenn Sie den `PaymentIntent` bearbeiten, müssen Sie `processPaymentIntent` aufrufen, um die Zahlungsinformationen auf dem Lesegerät zu aktualisieren. Ein `PaymentIntent` muss sich im Status `requires_payment_method` befinden, bevor Stripe ihn verarbeiten kann. Ein autorisierter, erfasster oder stornierter `PaymentIntent` kann nicht von einem Lesegerät verarbeitet werden. #### Einziehen, prüfen und bestätigen Nach Erstellen eines PaymentIntent besteht der nächste Schritt darin, die Zahlung zu verarbeiten. Das Lesegerät fordert Kundinnen und Kunden auf, ihre Karte einzuführen oder aufzulegen und erstellt dann eine PaymentMethod. ## Eine PaymentMethod erfassen - [collectPaymentMethod (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)collectPaymentMethod:delegate:completion:) Nachdem Sie einen `PaymentIntent` erstellt haben, erfassen Sie als Nächstes eine Zahlungsmethode mit dem SDK. Um eine Zahlungsmethode zu erfassen, muss Ihre App mit einem Lesegerät verbunden sein. Nach dem Aufruf von `collectPaymentMethod` durch Ihre App wartet das verbundene Lesegerät darauf, dass eine Karte vorgezeigt wird. #### Swift ```swift import UIKit import StripeTerminal class PaymentViewController: UIViewController, ReaderDisplayDelegate { // Label for displaying messages from the card reader let readerMessageLabel = UILabel(frame: .zero) var collectCancelable: Cancelable? = nil // ... // Action for a "Checkout" button func checkoutAction() throws { let params = try PaymentIntentParametersBuilder(amount: 1000, currency: "usd").build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded") self.collectCancelable = Terminal.shared.collectPaymentMethod(paymentIntent) { collectResult, collectError in if let error = collectError { print("collectPaymentMethod failed: \(error)") } else if let paymentIntent = collectResult { print("collectPaymentMethod succeeded") // ... Confirm the payment } } } } } } // MARK: MobileReaderDelegate - only needed for mobile readers, this is the delegate set during connectReader func reader(_ reader: Reader, didRequestReaderInput inputOptions: ReaderInputOptions = []) { readerMessageLabel.text = Terminal.stringFromReaderInputOptions(inputOptions) } func reader(_ reader: Reader, didRequestReaderDisplayMessage displayMessage: ReaderDisplayMessage) { readerMessageLabel.text = Terminal.stringFromReaderDisplayMessage(displayMessage) } // MARK: ReaderDisplayDelegate func terminal(_ terminal: Terminal, didRequestReaderInput inputOptions: ReaderInputOptions = []) { readerMessageLabel.text = Terminal.stringFromReaderInputOptions(inputOptions) } func terminal(_ terminal: Terminal, didRequestReaderDisplayMessage displayMessage: ReaderDisplayMessage) { readerMessageLabel.text = Terminal.stringFromReaderDisplayMessage(displayMessage) } ``` Diese Methode erfasst die verschlüsselten Daten einer Zahlungsmethode mithilfe des verbundenen Lesegeräts und ordnet die verschlüsselten Daten dem lokalen `PaymentIntent` zu. ### Optionale Prüfung der Angaben zur Zahlungsmethode - [CollectPaymentIntentConfiguration (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCollectPaymentIntentConfiguration.html) - [CardPresentDetails (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCardPresentDetails.html) Für erweiterte Use cases können Sie die Details der Zahlungsmethode der vorgelegten Karte prüfen und Ihre eigene Geschäftslogik vor der Autorisierung ausführen. Verwenden Sie den Setter `setUpdatePaymentIntent` in `CollectPaymentIntentConfigurationBuilder`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort `collectPaymentMethod` zurückgegeben. Verwenden Sie den Parameter `updatePaymentIntent` in `CollectPaymentIntentConfiguration`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort `collectPaymentMethod` zurückgegeben. Verwenden Sie den Parameter `updatePaymentIntent`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort von `collectPaymentMethod` zurückgegeben. Verwenden Sie die Methode `updatePaymentIntent` in `CollectPaymentIntentConfiguration`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort von `collectPaymentMethod` zurückgegeben. #### Swift ```swift class PaymentViewController: UIViewController, ReaderDisplayDelegate { // ... // Action for a "Checkout" button func checkoutAction() throws { let params = try PaymentIntentParametersBuilder(amount: 1000, currency: "usd").build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded") let collectConfig = try CollectPaymentIntentConfigurationBuilder().setUpdatePaymentIntent(true).build() self.collectCancelable = Terminal.shared.collectPaymentMethod(paymentIntent: paymentIntent, collectConfig: collectConfig) { collectResult, collectError in if let error = collectError { print("collectPaymentMethod failed: \(error)") } else if let paymentIntent = collectResult { print("collectPaymentMethod succeeded") if let paymentMethod = paymentIntent.paymentMethod, let card = paymentMethod.cardPresent ?? paymentMethod.interacPresent { // ... Perform business logic on card } // ... Confirm the payment } } } } } } ``` Diese Methode fügt die erfassten verschlüsselten Zahlungsmethodendaten mit einer Aktualisierung an das `PaymentIntent`-Objekt an. Eine Autorisierung ist erst erforderlich, wenn Sie die Zahlung bestätigen. Dieser erweiterte Anwendungsfall wird auf dem Verifone P400 nicht unterstützt. Nach der Erfassung der Zahlungsmethode müssen Sie die Zahlung innerhalb von 30 Sekunden autorisieren oder stornieren. Wenn das SDK [offline ist](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md), ist das Feld `paymentMethod` im `PaymentIntent`-Objekt nicht vorhanden. Sie können an dieser Stelle auf Attribute wie Kartenmarke, Finanzierung und andere nützliche Daten zugreifen. Stripe versucht zu erkennen, ob eine mobile Wallet bei einer Transaktion verwendet wird, wie im Attribut `wallet.type` gezeigt. Das Attribut wird jedoch nicht ausgefüllt, wenn die Karten-ausstellende Bank die lesegerätgestützte Identifizierung einer mobilen Wallet nicht unterstützt, sodass eine genaue Erkennung nicht garantiert werden kann. Nach der Autorisierung und beim [Abwickeln der Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment) erhält Stripe aktuelle Informationen von den Netzwerken und aktualisiert `wallet.type`. ### Erfassung abbrechen #### Programmgesteuerte Stornierung - [Cancelable (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCancelable.html) Sie können die Erfassung einer Zahlungsmethode, mit dem vom iOS SDK zurückgegebenen Objekt `Cancelable` abbrechen. #### Kundenseitig initiierte Stornierung - [setCustomerCancellation (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPCollectPaymentIntentConfigurationBuilder.html#/c:objc\(cs\)SCPCollectPaymentIntentConfigurationBuilder\(im\)setCustomerCancellation) - [CustomerCancellation (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Enums/SCPCustomerCancellation.html) Intelligente Lesegeräte zeigen Kundinnen und Kunden standardmäßig eine Schaltfläche zum Abbrechen an. Sie können dies deaktivieren, indem Sie `customerCancellation` auf `.disableIfAvailable` festlegen. Durch Tippen auf die Schaltfläche „Abbrechen“ wird die aktive Transaktion abgebrochen. #### Swift ```swift let collectConfig = try CollectPaymentIntentConfigurationBuilder() .setCustomerCancellation(.disableIfAvailable) // turn OFF the cancel button, ON by default .build() Terminal.shared.collectPaymentMethod(paymentIntent: paymentIntent, collectConfig: collectConfig) { intentWithPaymentMethod, attachError in } ``` ### Ereignisse verarbeiten - [ReaderDisplayDelegate (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Protocols/SCPReaderDisplayDelegate.html) Wenn Sie eine Zahlungsmethode mit einem Lesegerät wie dem [Stripe M2](https://docs.stripe.com/terminal/readers/stripe-m2.md) ohne integriertes Display erfassen, muss Ihre App in der Lage sein, den Nutzerinnen und Nutzern Ereignisse aus der Erfassung der Zahlungsmethode anzuzeigen. Diese Ereignisse helfen Nutzerinnen und Nutzern, Zahlungen erfolgreich einzuziehen (beispielsweise beim erneuten Versuch einer Karte, bei der Verwendung einer anderen Lesemethode). Wenn eine Transaktion startet, übergibt das SDK einen `ReaderInputOptions`-Wert an den Bildschirm-Handler des Lesegeräts Ihrer App, wobei die akzeptierten Eingabetypen (beispielsweise `Swipe`, `Insert`, oder `Tap`) angezeigt werden. Fordern Sie die Nutzerinnen und Nutzer über die Nutzeroberfläche des Bezahlvorgangs Ihrer App auf, die Karte unter Verwendung einer dieser Optionen vorzulegen. Während der Transaktion kann das SDK unter Umständen Ihre App auffordern, Ihren Nutzerinnen und Nutzern zusätzliche Anweisungen anzuzeigen (beispielsweise `Retry Card`). Dazu wird ein Wert `ReaderDisplayMessage` an den Handler der Anzeige Ihres Lesegeräts übergeben. Stellen Sie sicher, dass die Nutzeroberfläche Ihres Bezahlvorgangs Ihren Nutzerinnen und Nutzern diese Meldungen anzeigt. #### Swift ```swift // MARK: MobileReaderDelegate - only needed for Bluetooth readers, this is the delegate set during connectReader func reader(_ reader: Reader, didRequestReaderInput inputOptions: ReaderInputOptions = []) { readerMessageLabel.text = Terminal.stringFromReaderInputOptions(inputOptions) } func reader(_ reader: Reader, didRequestReaderDisplayMessage displayMessage: ReaderDisplayMessage) { readerMessageLabel.text = Terminal.stringFromReaderDisplayMessage(displayMessage) } ``` ### Ziehen Sie Zahlungen mit Tap to Pay auf dem iPhone ein Wenn Ihre Anwendung bereit ist, eine Zahlung einzuziehen, übernimmt das Stripe-Terminal-iOS-SDK die Anzeige, um den Einzugsvorgang abzuwickeln. Nach dem Aufruf der [Zahlungsmethode](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment) zur Abwicklung läuft Ihre Anwendung weiter. Doch das iPhone zeigt dem/der Karteninhaber/in eine Vollbildaufforderung an, die ihn/sie anweist, seine/ihre Karte oder NFC-basierte mobile Wallet vorzulegen. Wenn beim Lesen der Karte ein Fehler auftritt, wird eine Aufforderung zum erneuten Versuch angezeigt. Eine erfolgreiche Vorlage gibt eine Erfolgsmeldung zurück und dann kehrt die Kontrolle zu Ihrer Anwendung zurück. ![Zahlungseinzug mit Tap to Pay auf dem iPhone](https://b.stripecdn.com/docs-statics-srv/assets/ttpoi-payment-collection.50a552f2d75b8a3b92a439810cd9361d.png) Zahlungseinzug ## PaymentIntent bestätigen - [confirmPaymentIntent (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPTerminal.html#/c:objc\(cs\)SCPTerminal\(im\)confirmPaymentIntent:completion:) Nachdem eine Zahlungsmethode erfolgreich vom Kunden/von der Kundin erfasst wurde, müssen Sie als Nächstes die Zahlung mit dem SDK verarbeiten. Wenn Sie bereit sind, mit der Zahlung fortzufahren, rufen Sie `confirmPaymentIntent` mit dem aktualisierten `PaymentIntent` aus [Schritt 2](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-inspect-payment-method) auf. - Bei einer manuellen Erfassung von Zahlungen führt ein erfolgreicher Aufruf von `confirmPaymentIntent` zu einem `PaymentIntent` mit dem Status `requires_capture`. - Bei einer automatischen Erfassung von Zahlungen wechselt der `PaymentIntent` zum Status `succeeded`. Bestätigen Sie PaymentIntents immer mit dem Terminal-SDK auf dem Client. Die Server-seitige Bestätigung umgeht wichtige Interaktionen, wie PIN-Aufforderungen, und kann zu fehlgeschlagenen Transaktionen führen. #### Swift ```swift // Action for a "Checkout" button func checkoutAction() throws { let params = try PaymentIntentParametersBuilder(amount: 1000, currency: "usd").build() Terminal.shared.createPaymentIntent(params) { createResult, createError in if let error = createError { print("createPaymentIntent failed: \(error)") } else if let paymentIntent = createResult { print("createPaymentIntent succeeded") self.collectCancelable = Terminal.shared.collectPaymentMethod(paymentIntent) { collectResult, collectError in if let error = collectError { print("collectPaymentMethod failed: \(error)") } else if let collectPaymentMethodPaymentIntent = collectResult { print("collectPaymentMethod succeeded") // ... Confirm the payment self.confirmCancelable = Terminal.shared.confirmPaymentIntent(collectPaymentMethodPaymentIntent) { confirmResult, confirmError in if let error = confirmError { print("confirmPaymentIntent failed: \(error)") } else if let confirmedPaymentIntent = confirmResult { print("confirmPaymentIntent succeeded") // Notify your backend to capture the PaymentIntent if let stripeId = confirmedPaymentIntent.stripeId { APIClient.shared.capturePaymentIntent(stripeId) { captureError in if let error = captureError { print("capture failed: \(error)") } else { print("capture succeeded") } } } else { print("Payment collected offline"); } } } } } } } ``` Sie müssen einen PaymentIntent innerhalb von 2 Tagen manuell erfassen. Andernfalls läuft die Autorisierung ab und die Gelder werden für den Kunden/die Kundin freigegeben. ### Umgang mit Fehlern - [ConfirmPaymentIntentError (iOS)](https://stripe.dev/stripe-terminal-ios/docs/Classes/SCPConfirmPaymentIntentError.html#/c:objc\(cs\)SCPConfirmPaymentIntentError\(py\)paymentIntent) Wenn eine Zahlung fehlschlägt, gibt das SDK einen Fehler zurück, der den aktualisierten `PaymentIntent` beinhaltet. Ihre Anwendung muss den `PaymentIntent` prüfen, um zu entscheiden, wie der Fehler gehandhabt wird. | PaymentIntent-Status | Bedeutung | Lösung | | ------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `requires_payment_method` | Zahlungsmethode abgelehnt | Versuchen Sie, eine andere Zahlungsmethode zu erfassen, indem Sie `collectPaymentMethod` mit demselben `PaymentIntent` erneut aufrufen. | | `requires_confirmation` | Vorübergehendes Verbindungsproblem | Rufen Sie `confirmPaymentIntent` mit demselben `PaymentIntent` erneut auf, um die Anfrage zu wiederholen. | | `PaymentIntent` ist `nil` | Anfrage an Stripe ist abgelaufen, unbekannter Status des `PaymentIntent` | Versuchen Sie erneut, den ursprünglichen `PaymentIntent` zu bestätigen. Erstellen Sie keinen neuen PaymentIntent, da dies zu mehreren Autorisierungen für den/die Karteninhaber/in führen könnte. | Wenn Anfragen mehrmals hintereinander ablaufen, liegt möglicherweise ein Verbindungsproblem vor. Stellen Sie sicher, dass Ihre App mit dem Internet verbunden ist. ### Doppelte Zahlungen vermeiden Das `PaymentIntent`-Objekt ermöglicht Geldbewegungen bei Stripe – verwenden Sie einen einzigen `PaymentIntent`, um eine Transaktion darzustellen. Verwenden Sie denselben `PaymentIntent`, nachdem eine Karte abgelehnt wurde (z. B. wenn sie nicht ausreichend gedeckt ist), damit Ihre Kundin/Ihr Kunde es mit einer anderen Karte erneut versuchen kann. Wenn Sie den `PaymentIntent` bearbeiten, müssen Sie `collectPaymentMethod` aufrufen, um die Zahlungsinformationen auf dem Lesegerät zu aktualisieren. Ein `PaymentIntent` muss sich im Status `requires_payment_method` befinden, bevor Stripe ihn verarbeiten kann. Ein autorisierter, erfasster oder stornierter `PaymentIntent` kann nicht von einem Lesegerät bestätigt werden. ## Zahlung erfassen [Serverseitig] Wenn Sie bei der Erstellung des `PaymentIntent` in [Schritt 1](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment) `capture_method` als `manual` definiert haben, gibt das SDK einen autorisierten, aber nicht erfassten `PaymentIntent` an Ihre Anwendung zurück. Erfahren Sie mehr über den Unterschied zwischen [Autorisierung und Erfassung](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md). Wenn Ihre App einen bestätigten `PaymentIntent` von Ihrem SDK empfängt, stellen Sie sicher, dass Ihr Backend angewiesen wird, die Zahlung zu erfassen. Erstellen Sie einen Endpoint in Ihrem Backend, der eine `PaymentIntent`-ID akzeptiert und eine Anfrage zum Erfassen des `PaymentIntent` an die Stripe-API übermittelt: ```curl curl -X POST https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/capture \ -u "<>:" ``` Eine erfolgreiche `capture` führt zu einem `PaymentIntent` mit dem Status `succeeded`. Um sicherzustellen, dass die erfasste Plattformgebühr für verbundene Konten korrekt ist, überprüfen Sie jeden `PaymentIntent` und ändern Sie die Plattformgebühr bei Bedarf, bevor Sie die Zahlung manuell erfassen. ### Zahlungen abgleichen Um die Zahlungsaktivität Ihres Unternehmens zu überwachen, können Sie am Tagesende PaymentIntents mit Ihrem internen Bestellsystem auf Ihrem Server abgleichen. Ein `PaymentIntent`, der den Status `requires_capture` beibehält, kann eines der folgenden zwei Szenarien darstellen: **Überflüssige Autorisierung auf der Kartenabrechnung Ihrer Kundin/Ihres Kunden** - Ursache: Der/die Nutzer/in hat den Bezahlvorgang Ihrer App während einer Transaktion verlassen. - Lösung: Wenn der nicht erfasste `PaymentIntent` keiner abgeschlossenen Bestellung auf Ihrem Server zugeordnet ist, können Sie ihn [abbrechen](https://docs.stripe.com/api/payment_intents/cancel.md). Sie können einen stornierten `PaymentIntent` nicht zur Durchführung von Zahlungen verwenden. **Unvollständiger Einzug von Geldern von einer Kundin/einem Kunden** - Ursache: Die Anfrage Ihrer App, die Ihr Backend zur Erfassung der Zahlung anweist, ist fehlgeschlagen. - Lösung: Wenn der nicht erfasste `PaymentIntent` einer abgeschlossenen Bestellung auf Ihrem Server zugeordnet ist und keine andere Zahlung (zum Beispiel eine Barzahlung) für die Bestellung angenommen wurde, können Sie ihn [erfassen](https://docs.stripe.com/api/payment_intents/capture.md). ### Trinkgelder einziehen (US only) In den USA können berechtigte Nutzer/innen [beim Erfassen von Zahlungen ein Trinkgeld über den Zahlungsbeleg einziehen](https://docs.stripe.com/terminal/features/collecting-tips/on-receipt.md). # Android > This is a Android for when terminal-sdk-platform is android. View the full page at https://docs.stripe.com/terminal/payments/collect-card-payment?terminal-sdk-platform=android. Sie kennen die Payment Intents API noch nicht? Hier finden Sie einige nützliche Informationen: - [Die Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) - [Das PaymentIntent-Objekt](https://docs.stripe.com/api/payment_intents.md) - [Weitere Zahlungsszenarien](https://docs.stripe.com/payments/more-payment-scenarios.md) Zum Einziehen von Zahlungen mit Stripe Terminal müssen Sie einen Zahlungsablauf in Ihrer Anwendung programmieren. Verwenden Sie das Stripe Terminal SDK, um einen [PaymentIntent](https://docs.stripe.com/api.md#payment_intents) zu erstellen und zu aktualisieren. Bei einem PaymentIntent handelt es sich um ein Objekt, das eine einzelne Zahlungssitzung darstellt. Die fehlerresistente Terminal-Integration teilt den Zahlungsvorgang in mehrere Schritte auf, von denen jeder sicher erneut versucht werden kann: 1. [PaymentIntent erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment). 1. [Abwickeln der Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment). Die Autorisierung der Karte der Kundin/des Kunden erfolgt, wenn das SDK die Zahlung abwickelt. 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#capture-payment) ## Erstellen Sie ein PaymentIntent [Clientseitig] [Serverseitig] Der erste Schritt beim Einziehen von Zahlungen ist das Starten des Zahlungsablaufs. Wenn Kundinnen/Kunden den Bestellvorgang abschließen, muss Ihre Anwendung ein `PaymentIntent`-Objekt erstellen. Dies stellt eine neue Zahlungssitzung auf Stripe dar. - [createPaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/create-payment-intent.html) Einen `PaymentIntent` können Sie auf dem Client oder auf dem Server erstellen. Verwenden Sie [Test-Beträge](https://docs.stripe.com/terminal/references/testing.md#physical-test-cards), um verschiedene Ergebnisse zu erzielen. Ein Betrag, der auf `00` endet, führt zu einer bestätigten Zahlung. > #### Erstellen Sie PaymentIntents für abgelehnte Karten nicht erneut > > Erstellen Sie einen PaymentIntent nicht neu, wenn eine Karte abgelehnt wird. Verwenden Sie stattdessen denselben PaymentIntent wieder, um [doppelte Abbuchungen zu vermeiden](https://docs.stripe.com/terminal/payments/collect-card-payment.md#avoiding-double-charges). ### Clientseitig Erstellen Sie einen `PaymentIntent` auf Ihrem Client: > Wenn Ihre App mit dem Verifone P400 verbunden ist, können Sie keinen PaymentIntent über das Android SDK erstellen. Sie müssen stattdessen 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") .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 } } ) ``` ### Serverseitig Wenn die zum Starten einer Zahlung erforderlichen Informationen in Ihrer App nicht jederzeit verfügbar sind, können Sie den `PaymentIntent` auch auf Ihrem Server erstellen. Das folgende Beispiel zeigt, wie Sie einen `PaymentIntent` auf Ihrem Server erstellen: #### curl ```bash 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" ``` Für Terminal-Zahlungen muss der Parameter `payment_method_types` `card_present` enthalten. Sie können den Zahlungsablauf wie folgt steuern: - Um den Zahlungsablauf für `card_present`-Zahlungen vollständig zu steuern, setzen Sie `capture_method` auf `manual`. So können Sie vor der endgültigen Finalisierung der Zahlung einen Abgleichschritt hinzufügen. - Um Zahlungen in einem Schritt zu autorisieren und zu erfassen, setzen Sie `capture_method` auf `automatic`. Um in Australien Zahlungen zu akzeptieren, müssen Sie `capture_method` auf `automatic` oder `manual_preferred` setzen. Weitere Informationen finden Sie in unserer [Dokumentation zu Australien](https://docs.stripe.com/terminal/payments/regional.md?integration-country=AU). Um Interac-Zahlungen in Kanada zu akzeptieren, müssen Sie auch `interac_present` in `payment_method_types` aufnehmen. Weitere Informationen finden Sie in unserer [Dokumentation zu Kanada](https://docs.stripe.com/terminal/payments/regional.md?integration-country=CA). Der `PaymentIntent` enthält ein [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret), einen Schlüssel, der für jeden `PaymentIntent` eindeutig ist. Um das Client-Geheimnis zu verwenden, müssen Sie es vom `PaymentIntent` auf Ihrem Server beziehen und [an den Client übergeben](https://docs.stripe.com/payments/payment-intents.md#passing-to-client). #### Ruby ```ruby post '/create_payment_intent' do intent = # ... Create or retrieve the PaymentIntent {client_secret: intent.client_secret}.to_json end ``` - [retrievePaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/retrieve-payment-intent.html) Um einen `PaymentIntent` abzurufen, rufen Sie mithilfe des Client-Geheimnisses `retrievePaymentIntent` auf. Nachdem Sie den `PaymentIntent` abgerufen haben, verwenden Sie ihn, um `processPaymentIntent` aufzurufen. #### Kotlin ```kotlin Terminal.getInstance().retrievePaymentIntent( clientSecret, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` ## Zahlung abwickeln [Clientseitig] Sie können eine Zahlung sofort mit der von einer Kundin/einem Kunden vorgelegten Karte abwickeln oder stattdessen die Kartenangaben überprüfen, bevor Sie mit dem Prozess der Zahlung fortfahren. Für die meisten Use Cases empfehlen wir eine sofortige Verarbeitung, da es sich um eine einfachere Integration mit weniger API-Aufrufen handelt. Wenn Sie jedoch Ihre eigene Geschäftslogik hinzufügen möchten, bevor die Karte autorisiert wird, können Sie den Vorgang zur Erfassung und Bestätigung in zwei Schritten verwenden. #### Sofort verarbeiten Nach Erstellen eines PaymentIntent besteht der nächste Schritt darin, die Zahlung zu verarbeiten. Das Lesegerät fordert den Kunden/die Kundin auf, seine/ihre Karte aufzulegen oder einzuschieben und autorisiert die Zahlung dann. - [processPaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/process-payment-intent.html) Während der Abwicklung einer Zahlung kann es einige Sekunden dauern, bis die Karteninhaberin oder der Karteninhaber ihre bzw. seine Karte aus der Wallet erhält oder während der Zahlung eine Frage an den Betreiber stellt. #### Kotlin ```kotlin val cancelable = Terminal.getInstance().processPaymentIntent( paymentIntent = paymentIntent, collectConfig = CollectPaymentIntentConfiguration.Builder().build(), confirmConfig = ConfirmPaymentIntentConfiguration.Builder().build(), callback = object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { println("processPaymentIntent succeeded") // Notify your backend to capture the PaymentIntent if (paymentIntent.id != null) { ApiClient.capturePaymentIntent(paymentIntent.id) { error -> if (error != null) { println("capturePaymentIntent failed: $error") } else { println("capturePaymentIntent succeeded") } } } else { println("Payment collected offline") } } override fun onFailure(e: TerminalException) { println("processPaymentIntent failed: $e") } } ) ``` ### Erfassung abbrechen #### Programmgesteuerte Stornierung - [Cancelable (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-cancelable/index.html) Sie können die Verarbeitung eines PaymentIntent mit dem vom Android-SDK zurückgegebenen Objekt `Cancelable` abbrechen. #### Kundenseitig initiierte Stornierung - [setCustomerCancellation (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/-builder/set-customer-cancellation.html) - [Kunden-Stornierung (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-customer-cancellation/index.html) Intelligente Lesegeräte zeigen Kundinnen und Kunden standardmäßig eine Schaltfläche zum Abbrechen an. Sie können diese deaktivieren, indem Sie `customerCancellation` auf `DISABLE_IF_AVAILABLE` festlegen. Durch Tippen auf die Schaltfläche „Abbrechen“ wird die aktive Transaktion abgebrochen. #### Kotlin ```kotlin Terminal.getInstance().collectPaymentMethod( paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } },CollectPaymentIntentConfiguration.Builder() .setCustomerCancellation(CustomerCancellation.DISABLE_IF_AVAILABLE) // turn OFF the cancel button, ON by default .build(), ) ``` ### Ereignisse verarbeiten - [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html) Wenn Sie eine Zahlungsmethode mit einem Lesegerät wie dem [Stripe M2](https://docs.stripe.com/terminal/readers/stripe-m2.md) ohne integriertes Display erfassen, muss Ihre App in der Lage sein, den Nutzerinnen und Nutzern Ereignisse aus der Erfassung der Zahlungsmethode anzuzeigen. Diese Ereignisse helfen Nutzerinnen und Nutzern, Zahlungen erfolgreich einzuziehen (beispielsweise beim erneuten Versuch einer Karte, bei der Verwendung einer anderen Lesemethode). Wenn eine Transaktion startet, übergibt das SDK einen `ReaderInputOptions`-Wert an den Bildschirm-Handler des Lesegeräts Ihrer App, wobei die akzeptierten Eingabetypen (beispielsweise `Swipe`, `Insert`, oder `Tap`) angezeigt werden. Fordern Sie die Nutzerinnen und Nutzer über die Nutzeroberfläche des Bezahlvorgangs Ihrer App auf, die Karte unter Verwendung einer dieser Optionen vorzulegen. Während der Transaktion kann das SDK unter Umständen Ihre App auffordern, Ihren Nutzerinnen und Nutzern zusätzliche Anweisungen anzuzeigen (beispielsweise `Retry Card`). Dazu wird ein Wert `ReaderDisplayMessage` an den Handler der Anzeige Ihres Lesegeräts übergeben. Stellen Sie sicher, dass die Nutzeroberfläche Ihres Bezahlvorgangs Ihren Nutzerinnen und Nutzern diese Meldungen anzeigt. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onRequestReaderInput(options: ReaderInputOptions) { Toast.makeText(activity, options.toString(), Toast.LENGTH_SHORT).show() } override fun onRequestReaderDisplayMessage(message: ReaderDisplayMessage) { Toast.makeText(activity, message.toString(), Toast.LENGTH_SHORT).show() } // ... } ``` ### Ziehen Sie Zahlungen mit Tap to Pay auf Android ein Wenn Ihre Anwendung bereit ist, eine Zahlung einzuziehen, übernimmt das Stripe-Terminal-Android-SDK die Anzeige, um den Einzugsvorgang abzuwickeln. Nach dem Aufruf der [Zahlungsmethode](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment) zur Abwicklung läuft Ihre Anwendung weiter. Das Android-Gerät zeigt dem/der Karteninhaber/in eine Vollbildaufforderung an, die ihn/sie anweist, seine/ihre Karte oder NFC-basierte mobile Wallet vorzulegen. Wenn beim Lesen der Karte ein Fehler auftritt, wird eine Aufforderung zum erneuten Versuch angezeigt. Eine erfolgreiche Vorlage gibt eine Erfolgsmeldung zurück und dann kehrt die Kontrolle zu Ihrer Anwendung zurück. ![Zahlungseinzug mit Tap to Pay auf Android](https://b.stripecdn.com/docs-statics-srv/assets/ttpa-payment-collection.bd48493bc27d1f5ebb076aeeeaa43456.png) Zahlungseinzug - Bei einer manuellen Erfassung von Zahlungen führt ein erfolgreicher Aufruf von `processPaymentIntent` zu einem `PaymentIntent` mit dem Status `requires_capture`. - Bei einer automatischen Erfassung von Zahlungen wechselt der `PaymentIntent` zum Status `succeeded`. Sie müssen einen PaymentIntent innerhalb von 2 Tagen manuell erfassen. Andernfalls läuft die Autorisierung ab und die Gelder werden für den Kunden/die Kundin freigegeben. ### Umgang mit Fehlern - [TerminalException (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-exception/index.html) Wenn eine Zahlung fehlschlägt, gibt das SDK einen Fehler zurück, der den aktualisierten `PaymentIntent` beinhaltet, wenn sie von Stripe abgelehnt wurde. Ihre Anwendung muss den `PaymentIntent` prüfen, um zu entscheiden, wie der Fehler gehandhabt wird. | PaymentIntent-Status | Bedeutung | Lösung | | ------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `requires_payment_method` | Zahlungsmethode abgelehnt | Versuchen Sie, eine andere Zahlungsmethode zu erfassen, indem Sie `processPaymentIntent` mit demselben `PaymentIntent` erneut aufrufen. | | `requires_confirmation` | Vorübergehendes Verbindungsproblem | Rufen Sie `processPaymentIntent` mit demselben `PaymentIntent` erneut auf, um die Anfrage zu wiederholen. | | `PaymentIntent` ist `nil` | Anfrage an Stripe ist abgelaufen, unbekannter Status des `PaymentIntent` | Verarbeiten Sie den ursprünglichen `PaymentIntent` erneut. Erstellen Sie keinen neuen PaymentIntent, da dies zu mehreren Autorisierungen für den/die Karteninhaber/in führen könnte. | Wenn Anfragen mehrmals hintereinander ablaufen, liegt möglicherweise ein Verbindungsproblem vor. Stellen Sie sicher, dass Ihre App mit dem Internet verbunden ist. ### Doppelte Zahlungen vermeiden Das `PaymentIntent`-Objekt ermöglicht Geldbewegungen bei Stripe – verwenden Sie einen einzigen `PaymentIntent`, um eine Transaktion darzustellen. Verwenden Sie denselben `PaymentIntent`, nachdem eine Karte abgelehnt wurde (z. B. wenn sie nicht ausreichend gedeckt ist), damit Ihre Kundin/Ihr Kunde es mit einer anderen Karte erneut versuchen kann. Wenn Sie den `PaymentIntent` bearbeiten, müssen Sie `processPaymentIntent` aufrufen, um die Zahlungsinformationen auf dem Lesegerät zu aktualisieren. Ein `PaymentIntent` muss sich im Status `requires_payment_method` befinden, bevor Stripe ihn verarbeiten kann. Ein autorisierter, erfasster oder stornierter `PaymentIntent` kann nicht von einem Lesegerät verarbeitet werden. #### Einziehen, prüfen und bestätigen Nach Erstellen eines PaymentIntent besteht der nächste Schritt darin, die Zahlung zu verarbeiten. Das Lesegerät fordert Kundinnen und Kunden auf, ihre Karte einzuführen oder aufzulegen und erstellt dann eine PaymentMethod. ## Eine PaymentMethod erfassen - [collectPaymentMethod (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/collect-payment-method.html) Nachdem Sie einen `PaymentIntent` erstellt haben, erfassen Sie als Nächstes eine Zahlungsmethode mit dem SDK. Um eine Zahlungsmethode zu erfassen, muss Ihre App mit einem Lesegerät verbunden sein. Nach dem Aufruf von `collectPaymentMethod` durch Ihre App wartet das verbundene Lesegerät darauf, dass eine Karte vorgezeigt wird. #### Kotlin ```kotlin val cancelable = Terminal.getInstance().collectPaymentMethod( paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` Diese Methode erfasst die verschlüsselten Daten einer Zahlungsmethode mithilfe des verbundenen Lesegeräts und ordnet die verschlüsselten Daten dem lokalen `PaymentIntent` zu. ### Optionale Prüfung der Angaben zur Zahlungsmethode - [CollectPaymentIntentConfiguration (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/index.html) - [CardPresentDetails (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-card-present-details/index.html) Für erweiterte Use cases können Sie die Details der Zahlungsmethode der vorgelegten Karte prüfen und Ihre eigene Geschäftslogik vor der Autorisierung ausführen. Verwenden Sie den Parameter `updatePaymentIntent` in `CollectPaymentIntentConfiguration`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort `collectPaymentMethod` zurückgegeben. Verwenden Sie den Parameter `updatePaymentIntent`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort von `collectPaymentMethod` zurückgegeben. Verwenden Sie die Methode `updatePaymentIntent` in `CollectPaymentIntentConfiguration`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort von `collectPaymentMethod` zurückgegeben. #### Kotlin ```kotlin val collectConfig = CollectPaymentIntentConfiguration.Builder() .updatePaymentIntent(true) .build() val cancelable = Terminal.getInstance().collectPaymentMethod(paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { val pm = paymentIntent.paymentMethod val card = pm?.cardPresentDetails ?: pm?.interacPresentDetails // Placeholder for business logic on card before confirming paymentIntent } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` Diese Methode fügt die erfassten verschlüsselten Zahlungsmethodendaten mit einer Aktualisierung an das `PaymentIntent`-Objekt an. Eine Autorisierung ist erst erforderlich, wenn Sie die Zahlung bestätigen. Dieser erweiterte Anwendungsfall wird auf dem Verifone P400 nicht unterstützt. Nach der Erfassung der Zahlungsmethode müssen Sie die Zahlung innerhalb von 30 Sekunden autorisieren oder stornieren. Wenn das SDK [offline ist](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md), ist das Feld `paymentMethod` im `PaymentIntent`-Objekt nicht vorhanden. Sie können an dieser Stelle auf Attribute wie Kartenmarke, Finanzierung und andere nützliche Daten zugreifen. Stripe versucht zu erkennen, ob eine mobile Wallet bei einer Transaktion verwendet wird, wie im Attribut `wallet.type` gezeigt. Das Attribut wird jedoch nicht ausgefüllt, wenn die Karten-ausstellende Bank die lesegerätgestützte Identifizierung einer mobilen Wallet nicht unterstützt, sodass eine genaue Erkennung nicht garantiert werden kann. Nach der Autorisierung und beim [Abwickeln der Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment) erhält Stripe aktuelle Informationen von den Netzwerken und aktualisiert `wallet.type`. ### Erfassung abbrechen #### Programmgesteuerte Stornierung - [Cancelable (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-cancelable/index.html) Sie können die Erfassung einer Zahlungsmethode, mit dem vom Android SDK zurückgegebenen Objekt `Cancelable` abbrechen. #### Kundenseitig initiierte Stornierung - [setCustomerCancellation (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-collect-payment-intent-configuration/-builder/set-customer-cancellation.html) - [Kunden-Stornierung (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-customer-cancellation/index.html) Intelligente Lesegeräte zeigen Kundinnen und Kunden standardmäßig eine Schaltfläche zum Abbrechen an. Sie können diese deaktivieren, indem Sie `customerCancellation` auf `DISABLE_IF_AVAILABLE` festlegen. Durch Tippen auf die Schaltfläche „Abbrechen“ wird die aktive Transaktion abgebrochen. #### Kotlin ```kotlin Terminal.getInstance().collectPaymentMethod( paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder for handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } },CollectPaymentIntentConfiguration.Builder() .setCustomerCancellation(CustomerCancellation.DISABLE_IF_AVAILABLE) // turn OFF the cancel button, ON by default .build(), ) ``` ### Ereignisse verarbeiten - [MobileReaderListener (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.callable/-mobile-reader-listener/index.html) Wenn Sie eine Zahlungsmethode mit einem Lesegerät wie dem [Stripe M2](https://docs.stripe.com/terminal/readers/stripe-m2.md) ohne integriertes Display erfassen, muss Ihre App in der Lage sein, den Nutzerinnen und Nutzern Ereignisse aus der Erfassung der Zahlungsmethode anzuzeigen. Diese Ereignisse helfen Nutzerinnen und Nutzern, Zahlungen erfolgreich einzuziehen (beispielsweise beim erneuten Versuch einer Karte, bei der Verwendung einer anderen Lesemethode). Wenn eine Transaktion startet, übergibt das SDK einen `ReaderInputOptions`-Wert an den Bildschirm-Handler des Lesegeräts Ihrer App, wobei die akzeptierten Eingabetypen (beispielsweise `Swipe`, `Insert`, oder `Tap`) angezeigt werden. Fordern Sie die Nutzerinnen und Nutzer über die Nutzeroberfläche des Bezahlvorgangs Ihrer App auf, die Karte unter Verwendung einer dieser Optionen vorzulegen. Während der Transaktion kann das SDK unter Umständen Ihre App auffordern, Ihren Nutzerinnen und Nutzern zusätzliche Anweisungen anzuzeigen (beispielsweise `Retry Card`). Dazu wird ein Wert `ReaderDisplayMessage` an den Handler der Anzeige Ihres Lesegeräts übergeben. Stellen Sie sicher, dass die Nutzeroberfläche Ihres Bezahlvorgangs Ihren Nutzerinnen und Nutzern diese Meldungen anzeigt. #### Kotlin ```kotlin class ReaderActivity : AppCompatActivity(), MobileReaderListener { // ... override fun onRequestReaderInput(options: ReaderInputOptions) { Toast.makeText(activity, options.toString(), Toast.LENGTH_SHORT).show() } override fun onRequestReaderDisplayMessage(message: ReaderDisplayMessage) { Toast.makeText(activity, message.toString(), Toast.LENGTH_SHORT).show() } // ... } ``` ### Ziehen Sie Zahlungen mit Tap to Pay auf Android ein Wenn Ihre Anwendung bereit ist, eine Zahlung einzuziehen, übernimmt das Stripe-Terminal-Android-SDK die Anzeige, um den Einzugsvorgang abzuwickeln. Nach dem Aufruf der [Zahlungsmethode](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment) zur Abwicklung läuft Ihre Anwendung weiter. Das Android-Gerät zeigt dem/der Karteninhaber/in eine Vollbildaufforderung an, die ihn/sie anweist, seine/ihre Karte oder NFC-basierte mobile Wallet vorzulegen. Wenn beim Lesen der Karte ein Fehler auftritt, wird eine Aufforderung zum erneuten Versuch angezeigt. Eine erfolgreiche Vorlage gibt eine Erfolgsmeldung zurück und dann kehrt die Kontrolle zu Ihrer Anwendung zurück. ![Zahlungseinzug mit Tap to Pay auf Android](https://b.stripecdn.com/docs-statics-srv/assets/ttpa-payment-collection.bd48493bc27d1f5ebb076aeeeaa43456.png) Zahlungseinzug ## PaymentIntent bestätigen - [confirmPaymentIntent (Android)](https://stripe.dev/stripe-terminal-android/core/com.stripe.stripeterminal/-terminal/confirm-payment-intent.html) Nachdem eine Zahlungsmethode erfolgreich vom Kunden/von der Kundin erfasst wurde, müssen Sie als Nächstes die Zahlung mit dem SDK verarbeiten. Wenn Sie bereit sind, mit der Zahlung fortzufahren, rufen Sie `confirmPaymentIntent` mit dem aktualisierten `PaymentIntent` aus [Schritt 2](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-inspect-payment-method) auf. - Bei einer manuellen Erfassung von Zahlungen führt ein erfolgreicher Aufruf von `confirmPaymentIntent` zu einem `PaymentIntent` mit dem Status `requires_capture`. - Bei einer automatischen Erfassung von Zahlungen wechselt der `PaymentIntent` zum Status `succeeded`. Bestätigen Sie PaymentIntents immer mit dem Terminal-SDK auf dem Client. Die Server-seitige Bestätigung umgeht wichtige Interaktionen, wie PIN-Aufforderungen, und kann zu fehlgeschlagenen Transaktionen führen. #### Kotlin ```kotlin val cancelable = Terminal.getInstance().confirmPaymentIntent( paymentIntent, object : PaymentIntentCallback { override fun onSuccess(paymentIntent: PaymentIntent) { // Placeholder handling successful operation } override fun onFailure(e: TerminalException) { // Placeholder for handling exception } } ) ``` Sie müssen einen PaymentIntent innerhalb von 2 Tagen manuell erfassen. Andernfalls läuft die Autorisierung ab und die Gelder werden für den Kunden/die Kundin freigegeben. ### Umgang mit Fehlern - [TerminalException (Android)](https://stripe.dev/stripe-terminal-android/external/com.stripe.stripeterminal.external.models/-terminal-exception/index.html) Wenn eine Zahlung fehlschlägt, gibt das SDK einen Fehler zurück, der den aktualisierten `PaymentIntent` beinhaltet. Ihre Anwendung muss den `PaymentIntent` prüfen, um zu entscheiden, wie der Fehler gehandhabt wird. | PaymentIntent-Status | Bedeutung | Lösung | | ------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `requires_payment_method` | Zahlungsmethode abgelehnt | Versuchen Sie, eine andere Zahlungsmethode zu erfassen, indem Sie `collectPaymentMethod` mit demselben `PaymentIntent` erneut aufrufen. | | `requires_confirmation` | Vorübergehendes Verbindungsproblem | Rufen Sie `confirmPaymentIntent` mit demselben `PaymentIntent` erneut auf, um die Anfrage zu wiederholen. | | `PaymentIntent` ist `nil` | Anfrage an Stripe ist abgelaufen, unbekannter Status des `PaymentIntent` | Versuchen Sie erneut, den ursprünglichen `PaymentIntent` zu bestätigen. Erstellen Sie keinen neuen PaymentIntent, da dies zu mehreren Autorisierungen für den/die Karteninhaber/in führen könnte. | Wenn Anfragen mehrmals hintereinander ablaufen, liegt möglicherweise ein Verbindungsproblem vor. Stellen Sie sicher, dass Ihre App mit dem Internet verbunden ist. ### Doppelte Zahlungen vermeiden Das `PaymentIntent`-Objekt ermöglicht Geldbewegungen bei Stripe – verwenden Sie einen einzigen `PaymentIntent`, um eine Transaktion darzustellen. Verwenden Sie denselben `PaymentIntent`, nachdem eine Karte abgelehnt wurde (z. B. wenn sie nicht ausreichend gedeckt ist), damit Ihre Kundin/Ihr Kunde es mit einer anderen Karte erneut versuchen kann. Wenn Sie den `PaymentIntent` bearbeiten, müssen Sie `collectPaymentMethod` aufrufen, um die Zahlungsinformationen auf dem Lesegerät zu aktualisieren. Ein `PaymentIntent` muss sich im Status `requires_payment_method` befinden, bevor Stripe ihn verarbeiten kann. Ein autorisierter, erfasster oder stornierter `PaymentIntent` kann nicht von einem Lesegerät bestätigt werden. ## Zahlung erfassen [Serverseitig] Wenn Sie bei der Erstellung des `PaymentIntent` in [Schritt 1](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment) `capture_method` als `manual` definiert haben, gibt das SDK einen autorisierten, aber nicht erfassten `PaymentIntent` an Ihre Anwendung zurück. Erfahren Sie mehr über den Unterschied zwischen [Autorisierung und Erfassung](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md). Wenn Ihre App einen bestätigten `PaymentIntent` von Ihrem SDK empfängt, stellen Sie sicher, dass Ihr Backend angewiesen wird, die Zahlung zu erfassen. Erstellen Sie einen Endpoint in Ihrem Backend, der eine `PaymentIntent`-ID akzeptiert und eine Anfrage zum Erfassen des `PaymentIntent` an die Stripe-API übermittelt: ```curl curl -X POST https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/capture \ -u "<>:" ``` Eine erfolgreiche `capture` führt zu einem `PaymentIntent` mit dem Status `succeeded`. Um sicherzustellen, dass die erfasste Plattformgebühr für verbundene Konten korrekt ist, überprüfen Sie jeden `PaymentIntent` und ändern Sie die Plattformgebühr bei Bedarf, bevor Sie die Zahlung manuell erfassen. ### Zahlungen abgleichen Um die Zahlungsaktivität Ihres Unternehmens zu überwachen, können Sie am Tagesende PaymentIntents mit Ihrem internen Bestellsystem auf Ihrem Server abgleichen. Ein `PaymentIntent`, der den Status `requires_capture` beibehält, kann eines der folgenden zwei Szenarien darstellen: **Überflüssige Autorisierung auf der Kartenabrechnung Ihrer Kundin/Ihres Kunden** - Ursache: Der/die Nutzer/in hat den Bezahlvorgang Ihrer App während einer Transaktion verlassen. - Lösung: Wenn der nicht erfasste `PaymentIntent` keiner abgeschlossenen Bestellung auf Ihrem Server zugeordnet ist, können Sie ihn [abbrechen](https://docs.stripe.com/api/payment_intents/cancel.md). Sie können einen stornierten `PaymentIntent` nicht zur Durchführung von Zahlungen verwenden. **Unvollständiger Einzug von Geldern von einer Kundin/einem Kunden** - Ursache: Die Anfrage Ihrer App, die Ihr Backend zur Erfassung der Zahlung anweist, ist fehlgeschlagen. - Lösung: Wenn der nicht erfasste `PaymentIntent` einer abgeschlossenen Bestellung auf Ihrem Server zugeordnet ist und keine andere Zahlung (zum Beispiel eine Barzahlung) für die Bestellung angenommen wurde, können Sie ihn [erfassen](https://docs.stripe.com/api/payment_intents/capture.md). ### Trinkgelder einziehen (US only) In den USA können berechtigte Nutzer/innen [beim Erfassen von Zahlungen ein Trinkgeld über den Zahlungsbeleg einziehen](https://docs.stripe.com/terminal/features/collecting-tips/on-receipt.md). # React Native > This is a React Native for when terminal-sdk-platform is react-native. View the full page at https://docs.stripe.com/terminal/payments/collect-card-payment?terminal-sdk-platform=react-native. Sie kennen die Payment Intents API noch nicht? Hier finden Sie einige nützliche Informationen: - [Die Payment Intents API](https://docs.stripe.com/payments/payment-intents.md) - [Das PaymentIntent-Objekt](https://docs.stripe.com/api/payment_intents.md) - [Weitere Zahlungsszenarien](https://docs.stripe.com/payments/more-payment-scenarios.md) Zum Einziehen von Zahlungen mit Stripe Terminal müssen Sie einen Zahlungsablauf in Ihrer Anwendung programmieren. Verwenden Sie das Stripe Terminal SDK, um einen [PaymentIntent](https://docs.stripe.com/api.md#payment_intents) zu erstellen und zu aktualisieren. Bei einem PaymentIntent handelt es sich um ein Objekt, das eine einzelne Zahlungssitzung darstellt. Die fehlerresistente Terminal-Integration teilt den Zahlungsvorgang in mehrere Schritte auf, von denen jeder sicher erneut versucht werden kann: 1. [PaymentIntent erstellen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment). 1. [Abwickeln der Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment). Die Autorisierung der Karte der Kundin/des Kunden erfolgt, wenn das SDK die Zahlung abwickelt. 1. (Optional) [Zahlung erfassen](https://docs.stripe.com/terminal/payments/collect-card-payment.md#capture-payment) ## Erstellen Sie ein PaymentIntent [Clientseitig] [Serverseitig] Der erste Schritt beim Einziehen von Zahlungen ist das Starten des Zahlungsablaufs. Wenn Kundinnen/Kunden den Bestellvorgang abschließen, muss Ihre Anwendung ein `PaymentIntent`-Objekt erstellen. Dies stellt eine neue Zahlungssitzung auf Stripe dar. - [createPaymentIntent (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#createPaymentIntent) Einen `PaymentIntent` können Sie auf dem Client oder auf dem Server erstellen. Verwenden Sie [Test-Beträge](https://docs.stripe.com/terminal/references/testing.md#physical-test-cards), um verschiedene Ergebnisse zu erzielen. Ein Betrag, der auf `00` endet, führt zu einer bestätigten Zahlung. > #### Erstellen Sie PaymentIntents für abgelehnte Karten nicht erneut > > Erstellen Sie einen PaymentIntent nicht neu, wenn eine Karte abgelehnt wird. Verwenden Sie stattdessen denselben PaymentIntent wieder, um [doppelte Abbuchungen zu vermeiden](https://docs.stripe.com/terminal/payments/collect-card-payment.md#avoiding-double-charges). ### Clientseitig Erstellen Sie einen `PaymentIntent` auf Ihrem Client: > Wenn Ihre App mit dem Lesegerät Verifone P400 verbunden ist, können Sie keinen PaymentIntent über das React Native SDK erstellen. Sie müssen stattdessen 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 {error, paymentIntent} = await createPaymentIntent({ amount: 1000, currency: "usd", }); ``` ### Serverseitig Wenn die zum Starten einer Zahlung erforderlichen Informationen in Ihrer App nicht jederzeit verfügbar sind, können Sie den `PaymentIntent` auch auf Ihrem Server erstellen. Das folgende Beispiel zeigt, wie Sie einen `PaymentIntent` auf Ihrem Server erstellen: #### curl ```bash 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" ``` Für Terminal-Zahlungen muss der Parameter `payment_method_types` `card_present` enthalten. Sie können den Zahlungsablauf wie folgt steuern: - Um den Zahlungsablauf für `card_present`-Zahlungen vollständig zu steuern, setzen Sie `capture_method` auf `manual`. So können Sie vor der endgültigen Finalisierung der Zahlung einen Abgleichschritt hinzufügen. - Um Zahlungen in einem Schritt zu autorisieren und zu erfassen, setzen Sie `capture_method` auf `automatic`. Um in Australien Zahlungen zu akzeptieren, müssen Sie `capture_method` auf `automatic` oder `manual_preferred` setzen. Weitere Informationen finden Sie in unserer [Dokumentation zu Australien](https://docs.stripe.com/terminal/payments/regional.md?integration-country=AU). Um Interac-Zahlungen in Kanada zu akzeptieren, müssen Sie auch `interac_present` in `payment_method_types` aufnehmen. Weitere Informationen finden Sie in unserer [Dokumentation zu Kanada](https://docs.stripe.com/terminal/payments/regional.md?integration-country=CA). Der `PaymentIntent` enthält ein [Client-Geheimnis](https://docs.stripe.com/api/payment_intents/object.md#payment_intent_object-client_secret), einen Schlüssel, der für jeden `PaymentIntent` eindeutig ist. Um das Client-Geheimnis zu verwenden, müssen Sie es vom `PaymentIntent` auf Ihrem Server beziehen und [an den Client übergeben](https://docs.stripe.com/payments/payment-intents.md#passing-to-client). #### Ruby ```ruby post '/create_payment_intent' do intent = # ... Create or retrieve the PaymentIntent {client_secret: intent.client_secret}.to_json end ``` - [retrievePaymentIntent (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#retrievePaymentIntent) Um einen `PaymentIntent` abzurufen, rufen Sie mithilfe des Client-Geheimnisses `retrievePaymentIntent` auf. Nachdem Sie den `PaymentIntent` abgerufen haben, verwenden Sie ihn, um `processPaymentIntent` aufzurufen. ```js const { paymentIntent, error } = await retrievePaymentIntent(clientSecret); if (error) { // Placeholder for handling exception return; } // Placeholder for collecting payment method ``` ## Zahlung abwickeln [Clientseitig] Sie können eine Zahlung sofort mit der von einer Kundin/einem Kunden vorgelegten Karte abwickeln oder stattdessen die Kartenangaben überprüfen, bevor Sie mit dem Prozess der Zahlung fortfahren. Für die meisten Use Cases empfehlen wir eine sofortige Verarbeitung, da es sich um eine einfachere Integration mit weniger API-Aufrufen handelt. Wenn Sie jedoch Ihre eigene Geschäftslogik hinzufügen möchten, bevor die Karte autorisiert wird, können Sie den Vorgang zur Erfassung und Bestätigung in zwei Schritten verwenden. #### Sofort verarbeiten Nach Erstellen eines PaymentIntent besteht der nächste Schritt darin, die Zahlung zu verarbeiten. Das Lesegerät fordert den Kunden/die Kundin auf, seine/ihre Karte aufzulegen oder einzuschieben und autorisiert die Zahlung dann. - [processPaymentIntent (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#processpaymentintent) Während der Abwicklung einer Zahlung kann es einige Sekunden dauern, bis die Karteninhaberin oder der Karteninhaber ihre bzw. seine Karte aus der Wallet erhält oder während der Zahlung eine Frage an den Betreiber stellt. ```js const { paymentIntent, error } = await processPaymentIntent({ paymentIntent: paymentIntent, }); if (error) { // Placeholder for handling exception return; } // Notify your backend to capture the PaymentIntent ``` ### Erfassung abbrechen #### Programmgesteuerte Stornierung - [cancelProcessPaymentIntent (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#cancelprocesspaymentintent) Sie können die Verarbeitung eines PaymentIntent abbrechen, indem Sie im React Native SDK die Methode `cancelProcessPaymentIntent` aufrufen. #### Kundenseitig initiierte Stornierung - [customerCancellation (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/types/CustomerCancellation.html) Intelligente Lesegeräte zeigen Kundinnen und Kunden standardmäßig eine Schaltfläche zum Abbrechen an. Sie können dies deaktivieren, indem Sie `customerCancellation` auf `'disableIfAvailable'` festlegen. Durch Tippen auf die Schaltfläche „Abbrechen“ wird die aktive Transaktion abgebrochen. ```js const { paymentIntent, error } = await collectPaymentMethod({ paymentIntent: paymentIntent,customerCancellation: 'disableIfAvailable' }); if (error) { // Placeholder for handling exception } // Placeholder for processing PaymentIntent ``` ### Ereignisse verarbeiten - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) Wenn Sie eine Zahlungsmethode mit einem Lesegerät wie dem [Stripe M2](https://docs.stripe.com/terminal/readers/stripe-m2.md) ohne integriertes Display erfassen, muss Ihre App in der Lage sein, den Nutzerinnen und Nutzern Ereignisse aus der Erfassung der Zahlungsmethode anzuzeigen. Diese Ereignisse helfen Nutzerinnen und Nutzern, Zahlungen erfolgreich einzuziehen (beispielsweise beim erneuten Versuch einer Karte, bei der Verwendung einer anderen Lesemethode). Wenn eine Transaktion startet, übergibt das SDK einen `ReaderInputOptions`-Wert an den Bildschirm-Handler des Lesegeräts Ihrer App, wobei die akzeptierten Eingabetypen (beispielsweise `Swipe`, `Insert`, oder `Tap`) angezeigt werden. Fordern Sie die Nutzerinnen und Nutzer über die Nutzeroberfläche des Bezahlvorgangs Ihrer App auf, die Karte unter Verwendung einer dieser Optionen vorzulegen. Während der Transaktion kann das SDK unter Umständen Ihre App auffordern, Ihren Nutzerinnen und Nutzern zusätzliche Anweisungen anzuzeigen (beispielsweise `Retry Card`). Dazu wird ein Wert `ReaderDisplayMessage` an den Handler der Anzeige Ihres Lesegeräts übergeben. Stellen Sie sicher, dass die Nutzeroberfläche Ihres Bezahlvorgangs Ihren Nutzerinnen und Nutzern diese Meldungen anzeigt. ```js useStripeTerminal({ onDidRequestReaderInput: (options) => { // Placeholder for updating your app's checkout UI Alert.alert(options.join('/')); }, onDidRequestReaderDisplayMessage: (message) => { Alert.alert(message); }, }); ``` - Bei einer manuellen Erfassung von Zahlungen führt ein erfolgreicher Aufruf von `processPaymentIntent` zu einem `PaymentIntent` mit dem Status `requires_capture`. - Bei einer automatischen Erfassung von Zahlungen wechselt der `PaymentIntent` zum Status `succeeded`. Sie müssen einen PaymentIntent innerhalb von 2 Tagen manuell erfassen. Andernfalls läuft die Autorisierung ab und die Gelder werden für den Kunden/die Kundin freigegeben. ### Umgang mit Fehlern - [StripeError (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeError.html) Wenn eine Zahlung fehlschlägt, gibt das SDK einen Fehler zurück, der den aktualisierten `PaymentIntent` beinhaltet, wenn sie von Stripe abgelehnt wurde. Ihre Anwendung muss den `PaymentIntent` prüfen, um zu entscheiden, wie der Fehler gehandhabt wird. | PaymentIntent-Status | Bedeutung | Lösung | | ------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | `requires_payment_method` | Zahlungsmethode abgelehnt | Versuchen Sie, eine andere Zahlungsmethode zu erfassen, indem Sie `processPaymentIntent` mit demselben `PaymentIntent` erneut aufrufen. | | `requires_confirmation` | Vorübergehendes Verbindungsproblem | Rufen Sie `processPaymentIntent` mit demselben `PaymentIntent` erneut auf, um die Anfrage zu wiederholen. | | `PaymentIntent` ist `nil` | Anfrage an Stripe ist abgelaufen, unbekannter Status des `PaymentIntent` | Verarbeiten Sie den ursprünglichen `PaymentIntent` erneut. Erstellen Sie keinen neuen PaymentIntent, da dies zu mehreren Autorisierungen für den/die Karteninhaber/in führen könnte. | Wenn Anfragen mehrmals hintereinander ablaufen, liegt möglicherweise ein Verbindungsproblem vor. Stellen Sie sicher, dass Ihre App mit dem Internet verbunden ist. ### Doppelte Zahlungen vermeiden Das `PaymentIntent`-Objekt ermöglicht Geldbewegungen bei Stripe – verwenden Sie einen einzigen `PaymentIntent`, um eine Transaktion darzustellen. Verwenden Sie denselben `PaymentIntent`, nachdem eine Karte abgelehnt wurde (z. B. wenn sie nicht ausreichend gedeckt ist), damit Ihre Kundin/Ihr Kunde es mit einer anderen Karte erneut versuchen kann. Wenn Sie den `PaymentIntent` bearbeiten, müssen Sie `processPaymentIntent` aufrufen, um die Zahlungsinformationen auf dem Lesegerät zu aktualisieren. Ein `PaymentIntent` muss sich im Status `requires_payment_method` befinden, bevor Stripe ihn verarbeiten kann. Ein autorisierter, erfasster oder stornierter `PaymentIntent` kann nicht von einem Lesegerät verarbeitet werden. #### Einziehen, prüfen und bestätigen Nach Erstellen eines PaymentIntent besteht der nächste Schritt darin, die Zahlung zu verarbeiten. Das Lesegerät fordert Kundinnen und Kunden auf, ihre Karte einzuführen oder aufzulegen und erstellt dann eine PaymentMethod. ## Eine PaymentMethod erfassen - [collectPaymentMethod (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#collectpaymentmethod) Nachdem Sie einen `PaymentIntent` erstellt haben, erfassen Sie als Nächstes eine Zahlungsmethode mit dem SDK. Um eine Zahlungsmethode zu erfassen, muss Ihre App mit einem Lesegerät verbunden sein. Nach dem Aufruf von `collectPaymentMethod` durch Ihre App wartet das verbundene Lesegerät darauf, dass eine Karte vorgezeigt wird. ```js const { paymentIntent, error } = await collectPaymentMethod({ paymentIntent: paymentIntent }); if (error) { // Placeholder for handling exception } // Placeholder for processing PaymentIntent ``` Diese Methode erfasst die verschlüsselten Daten einer Zahlungsmethode mithilfe des verbundenen Lesegeräts und ordnet die verschlüsselten Daten dem lokalen `PaymentIntent` zu. ### Optionale Prüfung der Angaben zur Zahlungsmethode - [CollectPaymentMethodParams (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/types/CollectPaymentMethodParams.html) - [CardPresentDetails (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/types/CardPresentDetails.html) Für erweiterte Use cases können Sie die Details der Zahlungsmethode der vorgelegten Karte prüfen und Ihre eigene Geschäftslogik vor der Autorisierung ausführen. Verwenden Sie den Parameter `updatePaymentIntent` in `CollectPaymentIntentConfiguration`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort `collectPaymentMethod` zurückgegeben. Verwenden Sie den Parameter `updatePaymentIntent`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort von `collectPaymentMethod` zurückgegeben. Verwenden Sie die Methode `updatePaymentIntent` in `CollectPaymentIntentConfiguration`, um eine `PaymentMethod` an den serverseitigen `PaymentIntent` anzuhängen. Diese Daten werden in der Antwort von `collectPaymentMethod` zurückgegeben. ```js const { paymentIntent, error } = await collectPaymentMethod({ paymentIntent: paymentIntent, updatePaymentIntent: true, }); if (error) { // Placeholder for handling exception } // Placeholder for processing PaymentIntent ``` Diese Methode fügt die erfassten verschlüsselten Zahlungsmethodendaten mit einer Aktualisierung an das `PaymentIntent`-Objekt an. Eine Autorisierung ist erst erforderlich, wenn Sie die Zahlung bestätigen. Dieser erweiterte Anwendungsfall wird auf dem Verifone P400 nicht unterstützt. Nach der Erfassung der Zahlungsmethode müssen Sie die Zahlung innerhalb von 30 Sekunden autorisieren oder stornieren. Wenn das SDK [offline ist](https://docs.stripe.com/terminal/features/operate-offline/collect-card-payments.md), ist das Feld `paymentMethod` im `PaymentIntent`-Objekt nicht vorhanden. Sie können an dieser Stelle auf Attribute wie Kartenmarke, Finanzierung und andere nützliche Daten zugreifen. Stripe versucht zu erkennen, ob eine mobile Wallet bei einer Transaktion verwendet wird, wie im Attribut `wallet.type` gezeigt. Das Attribut wird jedoch nicht ausgefüllt, wenn die Karten-ausstellende Bank die lesegerätgestützte Identifizierung einer mobilen Wallet nicht unterstützt, sodass eine genaue Erkennung nicht garantiert werden kann. Nach der Autorisierung und beim [Abwickeln der Zahlung](https://docs.stripe.com/terminal/payments/collect-card-payment.md#process-payment) erhält Stripe aktuelle Informationen von den Netzwerken und aktualisiert `wallet.type`. ### Erfassung abbrechen #### Programmgesteuerte Stornierung - [cancelCollectPaymentMethod (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#cancelcollectpaymentmethod) Sie können den Einzug der Zahlungsmethode abbrechen, indem Sie im React Native SDK die Methode [cancelCollectPaymentMethod](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#cancelcollectpaymentmethod) aufrufen. #### Kundenseitig initiierte Stornierung - [customerCancellation (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/types/CustomerCancellation.html) Intelligente Lesegeräte zeigen Kundinnen und Kunden standardmäßig eine Schaltfläche zum Abbrechen an. Sie können dies deaktivieren, indem Sie `customerCancellation` auf `'disableIfAvailable'` festlegen. Durch Tippen auf die Schaltfläche „Abbrechen“ wird die aktive Transaktion abgebrochen. ```js const { paymentIntent, error } = await collectPaymentMethod({ paymentIntent: paymentIntent,customerCancellation: 'disableIfAvailable' }); if (error) { // Placeholder for handling exception } // Placeholder for processing PaymentIntent ``` ### Ereignisse verarbeiten - [UserCallbacks (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/index.html#UserCallbacks) Wenn Sie eine Zahlungsmethode mit einem Lesegerät wie dem [Stripe M2](https://docs.stripe.com/terminal/readers/stripe-m2.md) ohne integriertes Display erfassen, muss Ihre App in der Lage sein, den Nutzerinnen und Nutzern Ereignisse aus der Erfassung der Zahlungsmethode anzuzeigen. Diese Ereignisse helfen Nutzerinnen und Nutzern, Zahlungen erfolgreich einzuziehen (beispielsweise beim erneuten Versuch einer Karte, bei der Verwendung einer anderen Lesemethode). Wenn eine Transaktion startet, übergibt das SDK einen `ReaderInputOptions`-Wert an den Bildschirm-Handler des Lesegeräts Ihrer App, wobei die akzeptierten Eingabetypen (beispielsweise `Swipe`, `Insert`, oder `Tap`) angezeigt werden. Fordern Sie die Nutzerinnen und Nutzer über die Nutzeroberfläche des Bezahlvorgangs Ihrer App auf, die Karte unter Verwendung einer dieser Optionen vorzulegen. Während der Transaktion kann das SDK unter Umständen Ihre App auffordern, Ihren Nutzerinnen und Nutzern zusätzliche Anweisungen anzuzeigen (beispielsweise `Retry Card`). Dazu wird ein Wert `ReaderDisplayMessage` an den Handler der Anzeige Ihres Lesegeräts übergeben. Stellen Sie sicher, dass die Nutzeroberfläche Ihres Bezahlvorgangs Ihren Nutzerinnen und Nutzern diese Meldungen anzeigt. ```js useStripeTerminal({ onDidRequestReaderInput: (options) => { // Placeholder for updating your app's checkout UI Alert.alert(options.join('/')); }, onDidRequestReaderDisplayMessage: (message) => { Alert.alert(message); }, }); ``` ## PaymentIntent bestätigen - [confirmPaymentIntent (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeTerminalSdkType.html#confirmpaymentintent) Nachdem eine Zahlungsmethode erfolgreich vom Kunden/von der Kundin erfasst wurde, müssen Sie als Nächstes die Zahlung mit dem SDK verarbeiten. Wenn Sie bereit sind, mit der Zahlung fortzufahren, rufen Sie `confirmPaymentIntent` mit dem aktualisierten `PaymentIntent` aus [Schritt 2](https://docs.stripe.com/terminal/payments/collect-card-payment.md#collect-inspect-payment-method) auf. - Bei einer manuellen Erfassung von Zahlungen führt ein erfolgreicher Aufruf von `confirmPaymentIntent` zu einem `PaymentIntent` mit dem Status `requires_capture`. - Bei einer automatischen Erfassung von Zahlungen wechselt der `PaymentIntent` zum Status `succeeded`. Bestätigen Sie PaymentIntents immer mit dem Terminal-SDK auf dem Client. Die Server-seitige Bestätigung umgeht wichtige Interaktionen, wie PIN-Aufforderungen, und kann zu fehlgeschlagenen Transaktionen führen. ```js const { paymentIntent, error } = await confirmPaymentIntent({ paymentIntent: paymentIntent }); if (error) { // Placeholder for handling exception return; } // Placeholder for notifying your backend to capture paymentIntent.id ``` Sie müssen einen PaymentIntent innerhalb von 2 Tagen manuell erfassen. Andernfalls läuft die Autorisierung ab und die Gelder werden für den Kunden/die Kundin freigegeben. ### Umgang mit Fehlern - [StripeError (React Native)](https://stripe.dev/stripe-terminal-react-native/api-reference/interfaces/StripeError.html) Wenn eine Zahlung fehlschlägt, gibt das SDK einen Fehler zurück, der den aktualisierten `PaymentIntent` beinhaltet. Ihre Anwendung muss den `PaymentIntent` prüfen, um zu entscheiden, wie der Fehler gehandhabt wird. | PaymentIntent-Status | Bedeutung | Lösung | | ------------------------- | ------------------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `requires_payment_method` | Zahlungsmethode abgelehnt | Versuchen Sie, eine andere Zahlungsmethode zu erfassen, indem Sie `collectPaymentMethod` mit demselben `PaymentIntent` erneut aufrufen. | | `requires_confirmation` | Vorübergehendes Verbindungsproblem | Rufen Sie `confirmPaymentIntent` mit demselben `PaymentIntent` erneut auf, um die Anfrage zu wiederholen. | | `PaymentIntent` ist `nil` | Anfrage an Stripe ist abgelaufen, unbekannter Status des `PaymentIntent` | Versuchen Sie erneut, den ursprünglichen `PaymentIntent` zu bestätigen. Erstellen Sie keinen neuen PaymentIntent, da dies zu mehreren Autorisierungen für den/die Karteninhaber/in führen könnte. | Wenn Anfragen mehrmals hintereinander ablaufen, liegt möglicherweise ein Verbindungsproblem vor. Stellen Sie sicher, dass Ihre App mit dem Internet verbunden ist. ### Doppelte Zahlungen vermeiden Das `PaymentIntent`-Objekt ermöglicht Geldbewegungen bei Stripe – verwenden Sie einen einzigen `PaymentIntent`, um eine Transaktion darzustellen. Verwenden Sie denselben `PaymentIntent`, nachdem eine Karte abgelehnt wurde (z. B. wenn sie nicht ausreichend gedeckt ist), damit Ihre Kundin/Ihr Kunde es mit einer anderen Karte erneut versuchen kann. Wenn Sie den `PaymentIntent` bearbeiten, müssen Sie `collectPaymentMethod` aufrufen, um die Zahlungsinformationen auf dem Lesegerät zu aktualisieren. Ein `PaymentIntent` muss sich im Status `requires_payment_method` befinden, bevor Stripe ihn verarbeiten kann. Ein autorisierter, erfasster oder stornierter `PaymentIntent` kann nicht von einem Lesegerät bestätigt werden. ## Zahlung erfassen [Serverseitig] Wenn Sie bei der Erstellung des `PaymentIntent` in [Schritt 1](https://docs.stripe.com/terminal/payments/collect-card-payment.md#create-payment) `capture_method` als `manual` definiert haben, gibt das SDK einen autorisierten, aber nicht erfassten `PaymentIntent` an Ihre Anwendung zurück. Erfahren Sie mehr über den Unterschied zwischen [Autorisierung und Erfassung](https://docs.stripe.com/payments/place-a-hold-on-a-payment-method.md). Wenn Ihre App einen bestätigten `PaymentIntent` von Ihrem SDK empfängt, stellen Sie sicher, dass Ihr Backend angewiesen wird, die Zahlung zu erfassen. Erstellen Sie einen Endpoint in Ihrem Backend, der eine `PaymentIntent`-ID akzeptiert und eine Anfrage zum Erfassen des `PaymentIntent` an die Stripe-API übermittelt: ```curl curl -X POST https://api.stripe.com/v1/payment_intents/{{PAYMENT_INTENT_ID}}/capture \ -u "<>:" ``` Eine erfolgreiche `capture` führt zu einem `PaymentIntent` mit dem Status `succeeded`. Um sicherzustellen, dass die erfasste Plattformgebühr für verbundene Konten korrekt ist, überprüfen Sie jeden `PaymentIntent` und ändern Sie die Plattformgebühr bei Bedarf, bevor Sie die Zahlung manuell erfassen. ### Zahlungen abgleichen Um die Zahlungsaktivität Ihres Unternehmens zu überwachen, können Sie am Tagesende PaymentIntents mit Ihrem internen Bestellsystem auf Ihrem Server abgleichen. Ein `PaymentIntent`, der den Status `requires_capture` beibehält, kann eines der folgenden zwei Szenarien darstellen: **Überflüssige Autorisierung auf der Kartenabrechnung Ihrer Kundin/Ihres Kunden** - Ursache: Der/die Nutzer/in hat den Bezahlvorgang Ihrer App während einer Transaktion verlassen. - Lösung: Wenn der nicht erfasste `PaymentIntent` keiner abgeschlossenen Bestellung auf Ihrem Server zugeordnet ist, können Sie ihn [abbrechen](https://docs.stripe.com/api/payment_intents/cancel.md). Sie können einen stornierten `PaymentIntent` nicht zur Durchführung von Zahlungen verwenden. **Unvollständiger Einzug von Geldern von einer Kundin/einem Kunden** - Ursache: Die Anfrage Ihrer App, die Ihr Backend zur Erfassung der Zahlung anweist, ist fehlgeschlagen. - Lösung: Wenn der nicht erfasste `PaymentIntent` einer abgeschlossenen Bestellung auf Ihrem Server zugeordnet ist und keine andere Zahlung (zum Beispiel eine Barzahlung) für die Bestellung angenommen wurde, können Sie ihn [erfassen](https://docs.stripe.com/api/payment_intents/capture.md). ### Trinkgelder einziehen (US only) In den USA können berechtigte Nutzer/innen [beim Erfassen von Zahlungen ein Trinkgeld über den Zahlungsbeleg einziehen](https://docs.stripe.com/terminal/features/collecting-tips/on-receipt.md).