# In-App-Zahlungen annehmen Erstellen Sie mithilfe des Payment Sheet eine benutzerdefinierte Zahlungsintegration in Ihrer iOS-, Android- oder React Native-App. Das Payment Sheet ist eine anpassbare Komponente, die eine Liste von Zahlungsmethoden anzeigt und Zahlungsdetails in Ihrer App mithilfe eines unteren Blatts erfasst. > #### Support für die Accounts v2 API > > Das Payment Sheet unterstützt *von Kund/innen konfigurierte Konten* nicht. Es unterstützt nur `Kund/innen`-Objekte. # Zahlungsmethode erfassen und speichern Mit einem SetupIntent-Ablauf können Sie Zahlungsmethoden erfassen und für zukünftige Zahlungen speichern, ohne eine Abbuchung erstellen zu müssen. Bei dieser Integration rendern Sie das Payment Sheet, erstellen einen *SetupIntent* (The Setup Intents API lets you build dynamic flows for collecting payment method details for future payments. It tracks the lifecycle of a payment setup flow and can trigger additional authentication steps if required by law or by the payment method) und speichern die Zahlungsmethode in Ihrer App. ## Stripe einrichten [Serverseitig] [Clientseitig] ### Serverseitig Diese Integration erfordert Endpoints auf Ihrem Server, die mit der Stripe-API kommunizieren können. Nutzen Sie unsere offiziellen Bibliotheken für den Zugriff auf die Stripe-API von Ihrem Server aus: #### Ruby ```bash # Available as a gem sudo gem install stripe ``` ```ruby # If you use bundler, you can add this line to your Gemfile gem 'stripe' ``` ### Client-seitig Das [Stripe iOS SDK](https://github.com/stripe/stripe-ios) ist Open Source, [vollständig dokumentiert](https://stripe.dev/stripe-ios/index.html) und kompatibel mit Apps, die iOS 13 oder höher unterstützen. #### Swift Package Manager Führen Sie zur Installation des SDK die folgenden Schritte aus: 1. Wählen Sie in Xcode **Datei** > **Add Package Dependencies** (Paketabhängigkeiten hinzufügen) aus und geben Sie als Repository-URL `https://github.com/stripe/stripe-ios-spm` ein. 2. Wählen auf unserer [Veröffentlichungsseite](https://github.com/stripe/stripe-ios/releases) die neueste Version aus. 3. Fügen Sie das Produkt **StripePaymentSheet** zum [Ziel Ihrer App](https://developer.apple.com/documentation/swift_packages/adding_package_dependencies_to_your_app) hinzu. #### CocoaPods 1. Falls noch nicht geschehen, installieren Sie bitte die aktuellste Version von [CocoaPods](https://guides.cocoapods.org/using/getting-started.html). 2. Wenn Sie keine bestehende [Podfile](https://guides.cocoapods.org/syntax/podfile.html) haben, führen Sie folgenden Befehl aus, um eine zu erstellen: ```bash pod init ``` 3. Fügen Sie folgende Zeile in Ihre `Podfile` ein: ```podfile pod 'StripePaymentSheet' ``` 4. Führen Sie folgenden Befehl aus: ```bash pod install ``` 5. Vergessen Sie nicht, ab jetzt in Zukunft anstelle der Datei `.xcodeproj` die Datei `.xcworkspace` zum Öffnen Ihres Projekts in Xcode zu verwenden. 6. Führen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK Folgendes aus: ```bash pod update StripePaymentSheet ``` #### Carthage 1. Falls noch nicht geschehen, installieren Sie bitte die aktuelle Version von [Carthage](https://github.com/Carthage/Carthage#installing-carthage). 2. Fügen Sie folgende Zeile in Ihre `Cartfile` ein: ```cartfile github "stripe/stripe-ios" ``` 3. Befolgen Sie die [Carthage-Installationsanweisungen](https://github.com/Carthage/Carthage#if-youre-building-for-ios-tvos-or-watchos). Vergewissern Sie sich, dass Sie alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentSheet/README.md#manual-linking) aufgeführten erforderlichen Frameworks einbetten. 4. Führen Sie für zukünftige Updates auf die aktuelle Version unseres SDK einfach folgenden Befehl aus: ```bash carthage update stripe-ios --platform ios ``` #### Manuelles Framework 1. Gehen Sie auf unsere [GitHub-Release-Seite](https://github.com/stripe/stripe-ios/releases/latest), laden Sie **Stripe.xcframework.zip** herunter und entpacken Sie die Datei. 2. Ziehen Sie **StripePaymentSheet.xcframework** in den Abschnitt **Embedded Binaries** (Eingebettete Binärdateien) der Einstellungen unter **General** (Allgemeines) Ihres Xcode-Projekts. Aktivieren Sie dabei die Option **Copy items if needed** (Elemente kopieren, falls nötig). 3. Wiederholen Sie Schritt 2 für alle [hier](https://github.com/stripe/stripe-ios/tree/master/StripePaymentSheet/README.md#manual-linking) aufgeführten erforderlichen Frameworks. 4. Wiederholen Sie für zukünftige Updates auf die jeweils aktuelle Version des SDK die Schritte 1–3. > Details zur aktuellen SDK-Version und zu vorherigen Versionen finden Sie auf der Seite [Releases](https://github.com/stripe/stripe-ios/releases) auf GitHub. Um bei Veröffentlichung einer neuen Version eine Benachrichtigung zu erhalten, [achten Sie auf die Releases zum jeweiligen Repository](https://help.github.com/en/articles/watching-and-unwatching-releases-for-a-repository#watching-releases-for-a-repository). Sie müssen auch Ihren [veröffentlichbaren Schlüssel](https://dashboard.stripe.com/apikeys) festlegen, damit das SDK API Aufrufe an Stripe tätigen kann. Zunächst können Sie den veröffentlichbaren Schlüssel während der Integration auf dem Client codieren, aber den veröffentlichbaren Schlüssel von Ihrem Server in der Produktion abrufen. ```swift // Set your publishable key: remember to change this to your live publishable key in production // See your keys here: https://dashboard.stripe.com/apikeys STPAPIClient.shared.publishableKey = "<>" ``` ## Zahlungsmethoden aktivieren Zeigen Sie Ihre [Einstellungen für Zahlungsmethoden](https://dashboard.stripe.com/settings/payment_methods) an und aktivieren Sie die Zahlungsmethoden, die Sie unterstützen möchten. Sie müssen mindestens eine Zahlungsmethode aktiviert haben, um einen *SetupIntent* (The Setup Intents API lets you build dynamic flows for collecting payment method details for future payments. It tracks the lifecycle of a payment setup flow and can trigger additional authentication steps if required by law or by the payment method) zu erstellen. Standardmäßig aktiviert Stripe Karten und andere gängige Zahlungsmethoden, mit denen Sie mehr Kundinnen und Kunden erreichen können. Wir empfehlen jedoch, zusätzliche Zahlungsmethoden zu aktivieren, die für Ihr Unternehmen und Ihre Kundschaft relevant sind. Weitere Informationen zur Unterstützung von Produkten und Zahlungsmethoden finden Sie auf der Seite [Unterstützte Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/payment-method-support.md) und der [Preisseite](https://stripe.com/pricing/local-payment-methods) für Gebühren. ## Rückgabe-URL einrichten [Clientseitig] Der Kunde/Die Kundin verlässt ggf. Ihre App, um sich zu authentifizieren (z. B. in Safari oder einer Banking-App). Damit sie nach der Authentifizierung automatisch zu Ihrer App zurückkehren können, [konfigurieren Sie ein benutzerdefiniertes URL-Schema](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app) und richten Sie Ihren App-Delegate so ein, dass die URL an das SDK weitergeleitet wird. Stripe unterstützt keine [universellen Links](https://developer.apple.com/documentation/xcode/allowing-apps-and-websites-to-link-to-your-content). #### SceneDelegate #### Swift ```swift // This method handles opening custom URL schemes (for example, "your-app://stripe-redirect") func scene(_ scene: UIScene, openURLContexts URLContexts: Set) { guard let url = URLContexts.first?.url else { return } let stripeHandled = StripeAPI.handleURLCallback(with: url) if (!stripeHandled) { // This was not a Stripe url – handle the URL normally as you would } } ``` #### AppDelegate #### Swift ```swift // This method handles opening custom URL schemes (for example, "your-app://stripe-redirect") func application(_ app: UIApplication, open url: URL, options: [UIApplication.OpenURLOptionsKey: Any] = [:]) -> Bool { let stripeHandled = StripeAPI.handleURLCallback(with: url) if (stripeHandled) { return true } else { // This was not a Stripe url – handle the URL normally as you would } return false } ``` #### SwiftUI #### Swift ```swift @main struct MyApp: App { var body: some Scene { WindowGroup { Text("Hello, world!").onOpenURL { incomingURL in let stripeHandled = StripeAPI.handleURLCallback(with: incomingURL) if (!stripeHandled) { // This was not a Stripe url – handle the URL normally as you would } } } } } ``` Legen Sie zusätzlich die [returnURL](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:6Stripe12PaymentSheetC13ConfigurationV9returnURLSSSgvp) in Ihrem [PaymentSheet.Configuration](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html)-Objekt auf die URL für Ihre App fest. ```swift var configuration = PaymentSheet.Configuration() configuration.returnURL = "your-app://stripe-redirect" ``` ## Legen Sie eine Kundin oder einen Kunden an [Serverseitig] Um eine Zahlungsmethode für zukünftige Zahlungen einzurichten, müssen Sie sie einem Objekt zuordnen, das Ihren Kunden/Ihre Kundin repräsentiert. Wenn Ihr Kunde/Ihre Kundin ein Konto erstellt oder die erste Transaktion mit Ihrem Unternehmen durchgeführt hat, erstellen Sie ein [Customer](https://docs.stripe.com/api/customers/create.md)-Objekt. ```curl curl -X POST https://api.stripe.com/v1/customers \ -u "<>:" ``` ## Zahlungsdaten erfassen [Clientseitig] Wir bieten zwei Arten der Integration an. Wählen Sie eine, um fortzufahren. | PaymentSheet | PaymentSheet.FlowController | | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ![PaymentSheet](https://b.stripecdn.com/docs-statics-srv/assets/ios-overview.9e0d68d009dc005f73a6f5df69e00458.png) | ![PaymentSheet.FlowController](https://b.stripecdn.com/docs-statics-srv/assets/ios-multi-step.cd631ea4f1cd8cf3f39b6b9e1e92b6c5.png) | | Zeigt ein Formular an, um die Zahlungsdetails zu erfassen und die Einrichtung abzuschließen. Die Schaltfläche im Formular zeigt **Einrichten** an und richtet die Zahlungsmethode ein. | Zeigt ein Formular an, über das nur Zahlungsdetails erfasst werden. Die Schaltfläche im Formular zeigt **Fortfahren** an und leitet Kundinnen und Kunden zu Ihrer App zurück, in der die Einrichtung mit Ihrer eigenen Schaltfläche abgeschlossen wird. | #### PaymentSheet ### PaymentSheet initialisieren Wenn Sie bereit sind, eine Zahlungsmethode einzurichten (z. B. wenn eine Kundin oder ein Kunde auf die Schaltfläche für den Bezahlvorgang tippt), initialisieren Sie das PaymentSheet mit einer `PaymentSheet.Configuration` und einer [PaymentSheet.IntentConfiguration](https://github.com/stripe/stripe-ios/blob/master/StripePaymentSheet/StripePaymentSheet/Source/PaymentSheet/PaymentSheetIntentConfiguration.swift). Das [Configuration](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/configuration-swift.struct)-Objekt enthält die allgemeine Konfiguration für das PaymentSheet, die sich normalerweise zwischen den Zahlungen nicht ändert, wie z. B. die `returnURL`. Das [IntentConfiguration](https://github.com/stripe/stripe-ios/blob/master/StripePaymentSheet/StripePaymentSheet/Source/PaymentSheet/PaymentSheetIntentConfiguration.swift)-Objekt enthält Details über die spezifische Einrichtung, wie z. B. die Währung, und einen `confirmationTokenConfirmHandler`-Rückruf. Lassen Sie seine Implementierung zunächst leer. ```swift import StripePaymentSheet class MyCheckoutVC: UIViewController { func didTapCheckoutButton() {let intentConfig = PaymentSheet.IntentConfiguration(mode: .setup(currency: "USD")) { [weak self] confirmationToken in try await self?.handleConfirmationToken(confirmationToken) } var configuration = PaymentSheet.Configuration() configuration.returnURL = "your-app://stripe-redirect" // Use the return url you set up in the previous step let paymentSheet = PaymentSheet(intentConfiguration: intentConfig, configuration: configuration) } func handleConfirmationToken(_ confirmationToken: STPConfirmationToken) async throws -> String { // ...explained later } } ``` ### PaymentSheet präsentieren Legen Sie als Nächstes das PaymentSheet vor. Die Methode `present` nimmt einen Abschlussblock auf, der aufgerufen wird, wenn Kundinnen und Kunden mit dem Einrichten Ihrer Zahlungsmethode fertig sind und das Sheet verwerfen. Implementieren Sie den Abschlussblock, um das Ergebnis zu verarbeiten (z. B. durch Anzeige eines Bestätigungsbildschirms im Fall von `.completed`). ```swift class MyCheckoutVC: UIViewController { func didTapCheckoutButton() { // ...paymentSheet.present(from: self) { result in switch result { case .completed: //Setupcompleted - show a confirmation screen. case .failed(let error): print(error) // PaymentSheet encountered an unrecoverable error. You can display the error to the user, log it, and so on case .canceled: // Customer canceled - you should probably do nothing. } } } } ``` ### Details der Zahlung bestätigen Wenn der Kunde im PaymentSheet auf die Schaltfläche Einrichten tippt, wird der Rückruf, den Sie an `PaymentSheet.IntentConfiguration` übergeben haben, mit einem [STPConfirmationToken](https://stripe.dev/stripe-ios/stripepayments/documentation/stripepayments/stpconfirmationtoken) Objekt aufgerufen, das die Zahlungsdetails und -einstellungen der Kundin/des Kunden darstellt. Implementieren Sie diesen Rückruf, um eine Anfrage an Ihren Server zu senden . Ihr Server erstellt einen SetupIntent und gibt sein Client-Geheimnis zurück. Wenn die Anfrage zurückkommt, geben Sie das Client-Geheimnis Ihrer Serverantwort zurück oder geben Sie einen Fehler aus. Das PaymentSheet bestätigt des SetupIntent mithilfe des Client-Geheimnisses aus oder zeigt die lokalisierte Fehlermeldung in seiner Nutzeroberfläche an (entweder [errorDescription](https://developer.apple.com/documentation/foundation/localizederror/2946895-errordescription) oder [localizedDescription](https://developer.apple.com/documentation/foundation/nserror/1414418-localizeddescription)). ```swift class MyCheckoutVC: UIViewController { // ... func handleConfirmationToken(_ confirmationToken: STPConfirmationToken) async throws -> String { // Make a request to your own server. Pass confirmationToken.stripeId if using server-side confirmation. // Return the client secret or throw an error. return try await MyAPIClient.shared.createIntent(confirmationTokenId: confirmationToken.stripeId) } } ``` #### PaymentSheet.FlowController Bei dieser Integration wird davon ausgegangen, dass Ihr Zahlungsbildschirm über zwei Schaltflächen verfügt – die Schaltfläche „**Zahlungsmethode**“, die das PaymentSheet zur Erfassung der Zahlungsdaten aufruft, und die Schaltfläche „**Kaufen**“, mit der Einrichtung abgeschlossen wird. ### PaymentSheet.FlowController initialisieren Wenn Ihr Bezahlvorgang geladen wird, initialisieren Sie `PaymentSheet.FlowController` mit einer `PaymentSheet.Configuration` und einer `PaymentSheet.IntentConfiguration`. Das [Configuration](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/configuration-swift.struct)-Objekt enthält allgemeine Konfigurationen für PaymentSheet, die sich normalerweise zwischen den Zahlungen nicht ändern, wie `returnURL`. Das [IntentConfiguration](https://github.com/stripe/stripe-ios/blob/master/StripePaymentSheet/StripePaymentSheet/Source/PaymentSheet/PaymentSheetIntentConfiguration.swift)-Objekt enthält Details über die spezifische sowie einen `confirmationTokenConfirmHandler`Rückruf. Lassen Sie seine Implementierung vorerst leer. Nachdem `PaymentSheet.FlowController` initialisiert wurde, aktualisieren Sie Ihre Schaltfläche „**Zahlungsmethode**“ mit ihrer `paymentOption`. Diese Eigenschaft enthält ein Bild und ein Label, das die anfangs ausgewählte Standardzahlungsmethode des Kunden/der Kundin darstellt. ```swift class MyCheckoutVC: UIViewController { func loadCheckout() {let intentConfig = PaymentSheet.IntentConfiguration(mode: .setup(currency: "USD")) { [weak self] confirmationToken in try await self?.handleConfirmationToken(confirmationToken) } var configuration = PaymentSheet.Configuration() configuration.returnURL = "your-app://stripe-redirect" // Use the return url you set up in the previous step PaymentSheet.FlowController.create( intentConfiguration: intentConfig, configuration: configuration ) { [weak self] result in switch result { case .failure(let error): print(error) case .success(let paymentSheetFlowController): self?.paymentSheetFlowController = paymentSheetFlowController // Update your UI paymentSheetFlowController.paymentOption.image and paymentSheetFlowController.paymentOption.label } } } func handleConfirmationToken(_ confirmationToken: STPConfirmationToken) async throws -> String { // ...explained later } } ``` ### PaymentSheet anzeigen Wenn Kund/innen auf Ihre Schaltfläche „**Zahlungsmethode**“ tippen, rufen Sie `presentPaymentOptions` auf, um die Zahlungsdetails zu erfassen. Wenn dies abgeschlossen ist, aktualisieren Sie Ihre Benutzeroberfläche erneut mit der Eigenschaft `paymentOption`. ```swift paymentSheetFlowController.presentPaymentOptions(from: self) { // Update your UI using paymentSheetFlowController.paymentOption } ``` ### (Optional) Zahlungsangaben aktualisieren Wenn Kund/innen Aktionen durchführen, anhand derer sich die Zahlungsdetails ändern (z. B. durch Anwendung eines Rabattcodes oder der Bearbeitung des Warenkorbs), aktualisieren Sie die Instanz PaymentSheet.FlowController mit den neuen Werten. Dadurch wird sichergestellt, dass in unserer Benutzeroberfläche die richtigen Werte angezeigt werden (z. B. die Schaltfläche **Bezahlen**, die Apple Pay-Benutzeroberfläche), die entsprechenden Zahlungsmethoden angezeigt werden usw. Indem wir die Instanz aktualisieren, anstatt den PaymentSheet.FlowController neu zu initialisieren, bleiben die Zahlungsdetails der Kundinnen und Kunden erhalten. Rufen Sie die Methode `update` mit dem aktualisierten IntentConfiguration-Objekt auf. Rufen Sie während der Aktualisierung weder `present` noch `confirm` auf dem PaymentSheet.FlowController auf (deaktivieren Sie z. B. Ihre Schaltflächen „**Buy**“ und „**Payment method**“). Wenn die Aktualisierung abgeschlossen ist, aktualisieren Sie Ihre Benutzeroberfläche mit der Eigenschaft `paymentOption` für den Fall, dass die zuvor vom Kunden/von der Kundin ausgewählte Zahlungsmethode nicht mehr verfügbar ist. Versuchen Sie es erneut, wenn die Aktualisierung fehlschlagen sollte. ```swift // Create an updated IntentConfiguration var updatedIntentConfig = oldIntentConfig updatedIntentConfig.amount = 999 // Disable your "Buy" and "Payment method" buttons and call `update` paymentSheetFlowController.update(intentConfiguration: updatedIntentConfig) { [weak self] error in if error != nil { // You must retry - until the update succeeds, the customer can't pay or select a payment method. // For example, you can automatically retry the update with an exponential back-off, or present the user with an alert that retries the update. } else { // Re-enable your "Buy" and "Payment method" buttons // Update your UI using paymentSheetFlowController.paymentOption.image and paymentSheetFlowController.paymentOption.label } } ``` ### Details der Zahlung bestätigen Wenn die Kundin/der Kunde auf Ihre Schaltfläche **Kaufen** tippt, rufen Sie [paymentSheetFlowController.confirm](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/flowcontroller/confirm\(from:completion:\)) auf. Dadurch wird der `confirmationTokenConfirmHandler`-Rückruf ausgelöst, den Sie an `PaymentSheet.IntentConfiguration` mit einem [STPConfirmationToken](https://stripe.dev/stripe-ios/stripepayments/documentation/stripepayments/stpconfirmationtoken)-Objekt übergeben haben, das die Zahlungsdetails und -präferenzen der Kundin oder des Kunden darstellt. Implementieren Sie diesen Rückruf, um eine Anfrage an Ihren Server zu senden . Ihr Server erstellt einen SetupIntent und gibt sein Client-Geheimnis zurück. Wenn die Anfrage zurückkommt, geben Sie das Client-Geheimnis Ihrer Serverantwort zurück oder geben Sie einen Fehler aus . Das PaymentSheetbestätigt den SetupIntent unter Verwendung des Client-Geheimnisses. ```swift class MyCheckoutVC: UIViewController { // ...func didTapBuyButton() { paymentSheetFlowController.confirm(from: self) { paymentResult in switch paymentResult { case .completed: //Setupcompleted - show a confirmation screen. case .failed(let error): // PaymentSheet encountered an unrecoverable error. You can display the error to the user, log it, and so on print(error) case .canceled: // Customer canceled - you should probably do nothing. } } } func handleConfirmationToken(_ confirmationToken: STPConfirmationToken) async throws -> String { // Make a request to your own server. Pass confirmationToken.stripeId if using server-side confirmation. return try await fetchIntentClientSecret(...) } } ``` Der Servercode wird im folgenden Schritt erläutert. ## SetupIntent erstellen [Serverseitig] Erstellen Sie einen *SetupIntent* (The Setup Intents API lets you build dynamic flows for collecting payment method details for future payments. It tracks the lifecycle of a payment setup flow and can trigger additional authentication steps if required by law or by the payment method) auf Ihrem Server. Zahlungsmethoden können Sie über das [Dashboard](https://dashboard.stripe.com/settings/payment_methods) verwalten. Stripe wertet Einschränkungen der Zahlungsmethode und andere Parameter aus, um die Liste der unterstützten Zahlungsmethoden zu ermitteln. Wenn der Aufruf erfolgreich ist, geben Sie den SetupIntent *das Client-Geheimnis* (The client secret is a unique key returned from Stripe as part of a PaymentIntent. This key lets the client access important fields from the PaymentIntent (status, amount, currency) while hiding sensitive ones (metadata, customer)) zurück. Wenn der Aufruf fehlschlägt, [beheben Sie den Fehler](https://docs.stripe.com/error-handling.md) und geben eine Fehlermeldung mit einer kurzen Erklärung an Ihre Kundin/Ihren Kunden zurück. > Überprüfen Sie, ob alle IntentConfiguration-Eigenschaften mit Ihrem SetupIntent (zum Beispiel [Nutzung](https://docs.stripe.com/api/setup_intents/object.md#setup_intent_object-usage)) übereinstimmen. #### Ruby ```ruby require 'stripe' # Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. client = Stripe::StripeClient.new('<>') post '/create-intent' do data = JSON.parse request.body.read params = { customer: ..., # The Customer ID you previously created automatic_payment_methods: {enabled: true}, } begin intent = client.v1.setup_intents.create(params) {client_secret: intent.client_secret}.to_json rescue Stripe::StripeError => e {error: e.error.message}.to_json end end ``` ## Die gespeicherte Zahlungsmethode später belasten [Serverseitig] > `bancontact` und `ideal` sind standardmäßig einmalige Zahlungsmethoden. Wenn sie für die künftige Verwendung eingerichtet werden, erzeugen sie eine wiederverwendbare Art der Zahlungsmethode `sepa_debit`, sodass Sie `sepa_debit` verwenden müssen, um gespeicherte Zahlungsmethoden abzufragen. Um eine Zahlungsmethode zum Belasten zu finden, listen Sie die Zahlungsmethoden auf, die mit Ihrer Kundin/Ihrem Kunden verknüpft sind. In diesem Beispiel sind Karten aufgeführt, Sie können jedoch jeden unterstützten [Typ](https://docs.stripe.com/api/payment_methods/object.md#payment_method_object-type) auflisten. > #### Verwenden Sie die Accounts v2 API zum Darstellen von Kundinnen und Kunden > > Die Accounts v2 API ist allgemein für Connect-Nutzer/innen verfügbar und für andere Stripe-Nutzer/innen in der öffentlichen Vorschau. Wenn Sie an der Accounts v2 Vorschau teilnehmen, müssen Sie eine [Vorschauversion](https://docs.stripe.com/api-v2-overview.md#sdk-and-api-versioning) in Ihrem Code angeben. > > Um Zugriff auf die Accounts v2 Vorschau anzufordern, {% collect-email modal=true modal_link_text=“sign up.” list=“payin-payout-reuse-waitlist@stripe.com” send_direct_email=true intro_text=“Sind Sie am frühzeitigen Zugang zur Vorschau der Accounts v2 API interessiert?" body_text=“Wir sind gerade dabei, die Vorschau von Accounts v2 bereitzustellen. Um Zugang zu beantragen, geben Sie unten Ihre E-Mail-Adresse ein.” form_cta_text=“Registrieren” success_text=“Danke! Wir melden uns bald.” show_email_confirmation=wahr /%} > > Für die meisten Anwendungsfälle empfehlen wir, [Ihre Kundinnen und Kunden als vom Kunden bzw. von der Kundin konfigurierte Account-Objekte abzubilden](https://docs.stripe.com/accounts-v2/use-accounts-as-customers.md), anstatt [Customer](https://docs.stripe.com/api/customers.md)-Objekte zu verwenden. #### Accounts v2 ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d type=card ``` #### Customers v1 ```curl curl -G https://api.stripe.com/v1/payment_methods \ -u "<>:" \ -d "customer={{CUSTOMER_ID}}" \ -d type=card ``` Wenn Sie bereit sind, die Zahlung Ihrer Kundin/Ihres Kunden *off-session* (A payment is described as off-session if it occurs without the direct involvement of the customer, using previously-collected payment information) zu belasten, verwenden Sie die `Kunden`-ID oder das von der Kundin/dem Kunden/Kundin konfigurierte `Konto` und die `PaymentMethod`-ID, um einen `PaymentIntent` mit dem Betrag und der Währungen der Zahlung zu erstellen. Legen Sie einige weitere Parameter fest, um die Off-Session-Zahlung durchzuführen: - Legen Sie [off_session](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-off_session) auf true fest, um anzugeben, dass der Kunde/die Kundin sich während eines Bezahlvorgangs nicht in Ihrem Bezahlvorgang befindet und somit eine Authentifizierungsanfrage eines Partners, wie z. B. eines Kartenausstellers, einer Bank oder eines anderen Zahlungsinstituts, nicht erfüllen kann. Wenn ein Partner während Ihres Bezahlvorgangs eine Authentifizierung anfordert, fordert Stripe Ausnahmen unter Verwendung von Kunden/Kundinnen aus einer vorherigen *On-Session*-Transaktion an. Wenn die Bedingungen für die Ausnahme nicht erfüllt sind, kann der `PaymentIntent` einen Fehler ergeben. - Setzen Sie [„confirm“](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-confirm) auf „true“, um sofort nach Erstellung des `PaymentIntent` eine Bestätigung auszulösen. - Legen Sie [payment_method](https://docs.stripe.com/api.md#create_payment_intent-payment_method) auf die ID der `PaymentMethod` fest. - Je nachdem, wie Sie Kundinnen/Kunden in Ihrer Integration darstellen, legen Sie entweder [customer_account](https://docs.stripe.com/api/payment_intents/create.md#create_payment_intent-customer_account) auf die ID des kundenseitig konfigurierten `Kontos` oder [customer](https://docs.stripe.com/api.md#create_payment_intent-customer) auf die `Kunden`-ID fest. #### Accounts v2 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "automatic_payment_methods[enabled]=true" \ -d "customer_account={{CUSTOMERACCOUNT_ID}}" \ -d payment_method={{PAYMENT_METHOD_ID}} \ --data-urlencode "return_url=https://example.com/order/123/complete" \ -d off_session=true \ -d confirm=true ``` #### Customers v1 ```curl curl https://api.stripe.com/v1/payment_intents \ -u "<>:" \ -d amount=1099 \ -d currency=usd \ -d "automatic_payment_methods[enabled]=true" \ -d "customer={{CUSTOMER_ID}}" \ -d payment_method={{PAYMENT_METHOD_ID}} \ --data-urlencode "return_url=https://example.com/order/123/complete" \ -d off_session=true \ -d confirm=true ``` ## Integration testen #### Karten | Kartennummer | Szenario | So führen Sie den Test durch | | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------- | | 4242424242424242 | Die Kartenzahlung ist erfolgreich und es ist keine Authentifizierung erforderlich. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | | 4000002500003155 | Für die Kartenzahlung ist eine *Authentifizierung* (Strong Customer Authentication (SCA) is a regulatory requirement in effect as of September 14, 2019, that impacts many European online payments. It requires customers to use two-factor authentication like 3D Secure to verify their purchase) erforderlich. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | | 4000000000009995 | Die Karte wird mit einem Ablehnungscode wie `insufficient_funds` abgelehnt. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | | 6205500000000000004 | Die UnionPay-Karte hat eine variable Länge von 13 bis 19 Ziffern. | Füllen Sie das Kreditkartenformular aus und geben Sie die Kreditkartennummer mit beliebiger Gültigkeitsdauer, CVC und Postleitzahl an. | #### Bankumleitungen | Zahlungsmethode | Szenario | So führen Sie den Test durch | | ----------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Bancontact, iDEAL | Ihr/e Kund/in konnte sich auf der iDEAL-Weiterleitungsseite für eine auf Weiterleitung basierende Zahlungsmethode mit sofortiger Benachrichtigung nicht authentifizieren. | Wählen Sie eine beliebige, auf Weiterleitung basierende Zahlungsmethode aus, füllen Sie die erforderlichen Informationen aus und bestätigen Sie die Zahlung. Klicken Sie dann auf der Weiterleitungsseite auf **Testzahlung fehlgeschlagen**. | | Pay by Bank | Ihr Kunde/Ihre Kundin zahlt erfolgreich mit einer auf Weiterleitung basierenden Zahlungsmethode mit [verzögerter Benachrichtigung](https://docs.stripe.com/payments/payment-methods.md#payment-notification). | Wählen Sie die Zahlungsmethode aus, füllen Sie die erforderlichen Informationen aus und bestätigen Sie die Zahlung. Klicken Sie dann auf der Weiterleitungsseite auf **Testzahlung abschließen**. | | Pay by Bank | Ihr/e Kund/in konnte sich auf der iDEAL-Weiterleitungsseite für eine auf Weiterleitung basierende Zahlungsmethode mit verzögerter Benachrichtigung nicht authentifizieren. | Wählen Sie die Zahlungsmethode aus, füllen Sie die erforderlichen Informationen aus und bestätigen Sie die Zahlung. Klicken Sie dann auf der Weiterleitungsseite auf **Testzahlung fehlgeschlagen**. | | BLIK | BLIK-Zahlungen können aus verschiedenen Gründen fehlschlagen. Es gibt sofortige Fehler (der Code ist abgelaufen oder ungültig), verzögerte Fehler (die Bank lehnt ab) oder Zeitüberschreitungen (der/die Kund/in hat nicht rechtzeitig reagiert). | Verwenden Sie E-Mail-Muster, um [die verschiedenen Fehler zu simulieren](https://docs.stripe.com/payments/blik/accept-a-payment.md#simulate-failures) | #### Banklastschriften | Zahlungsmethode | Szenario | So führen Sie den Test durch | | ---------------- | -------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | | SEPA-Lastschrift | Ihr/e Kund/in zahlt erfolgreich mit dem SEPA-Lastschriftverfahren. | Füllen Sie das Formular mit der Kontonummer `AT321904300235473204` aus. Die bestätigte PaymentIntent geht zunächst in den Status „wird verarbeitet“ und dann drei Minuten später in den Status „erfolgreich“ über. | | SEPA-Lastschrift | Der Status der PaymentIntent Ihres/Ihrer Kund/in wechselt von `processing` zu `requires_payment_method`. | Füllen Sie das Formular mit der Kontonummer `AT861904300235473202` aus. | Hier finden Sie weitere Informationen zum [Testen](https://docs.stripe.com/testing.md) Ihrer Integration. ## Kartenscannen aktivieren Um die Unterstützung für das Scannen von Karten für iOS zu aktivieren, setzen Sie `NSCameraUsageDescription` (**Datenschutz – Beschreibung Kameranutzung**) in der `Info.plist` Ihrer Anwendung und geben einen Grund für den Zugriff auf die Kamera an (z. B. „Zum Scannen von Karten“). ## Optional: Karten speichern [Serverseitig] [Clientseitig] `PaymentSheet` kann es Kundinnen und Kunden ermöglichen, ihre Karte zu speichern, und die gespeicherten Karten des Kunden/der Kundin in die verfügbaren Zahlungsmethoden aufnehmen. Der Kunde/Die Kundin muss über ein zugehöriges, vom Kunden/von der Kundin konfiguriertes [Account](https://docs.stripe.com/api/v2/core/accounts/create.md#v2_create_accounts-configuration-customer)-Objekt oder [Customer](https://docs.stripe.com/api/customers/create.md)-Objekt auf Ihrem Server verfügen. Um ein Kontrollkästchen zu aktivieren, mit dem der Kunde/die Kundin seine/ihre Karte speichern kann, erstellen Sie eine [CustomerSession](https://docs.stripe.com/api/customer_sessions.md) mit `enabled` für `payment_method_save`. #### Accounts v2 ```javascript const stripe = require('stripe')('sk_test_your_secret_key'); app.post('/mobile-payment-element', async (req, res) => { // Use an existing Account ID if this is a returning customer. const customer_account = await stripe.v2.core.accounts.create(); const customerSession = await stripe.customerSessions.create({ customer_account: customer_account.id, components: { mobile_payment_element: { enabled: true, features: { payment_method_save: 'enabled', payment_method_redisplay: 'enabled', payment_method_remove: 'enabled' } }, }, }); res.json({ customerSessionClientSecret: customerSession.client_secret, customer_account: customer_account.id, }); }); ``` Konfigurieren Sie als Nächstes PaymentSheet mit der ID des Kunden/der Kundin und dem Client-Geheimnis der CustomerSession. ```swift @_spi(CustomerSessionBetaAccess) import StripePaymentSheet var configuration = PaymentSheet.Configuration() configuration.customer = .init(id: customerAccountId, customerSessionClientSecret: customerSessionClientSecret) self.paymentSheet = PaymentSheet(..., configuration: configuration) ``` #### Customers v1 ```javascript const stripe = require('stripe')('sk_test_your_secret_key'); app.post('/mobile-payment-element', async (req, res) => { // Use an existing Customer ID if this is a returning customer. const customer = await stripe.customers.create(); const customerSession = await stripe.customerSessions.create({ customer: customer.id, components: { mobile_payment_element: { enabled: true, features: { payment_method_save: 'enabled', payment_method_redisplay: 'enabled', payment_method_remove: 'enabled' } }, }, }); res.json({ customerSessionClientSecret: customerSession.client_secret, customer: customer.id, }); }); ``` Konfigurieren Sie als Nächstes PaymentSheet mit der ID des Kunden/der Kundin und dem Client-Geheimnis der CustomerSession. ```swift @_spi(CustomerSessionBetaAccess) import StripePaymentSheet var configuration = PaymentSheet.Configuration() configuration.customer = .init(id: customerId, customerSessionClientSecret: customerSessionClientSecret) self.paymentSheet = PaymentSheet(..., configuration: configuration) ``` ## Optional: Zahlungsmethoden mit Verzögerung zulassen [Clientseitig] *Zahlungsmethoden mit Verzögerung* (A payment method that can't immediately return payment status when a customer attempts a transaction (for example, ACH debits). Businesses commonly hold an order in a pending state until payment is successful with these payment methods) garantieren nicht, dass Sie am Ende des Bezahlvorgangs Gelder von Ihrem Kunden/Ihrer Kundin erhalten, da die Abwicklung eine gewisse Zeit in Anspruch nimmt (z. B. bei US-Bankkonten, SEPA-Lastschrift, iDEAL und Bancontact) oder weil Kundinnen und Kunden aktiv werden müssen, um den Vorgang abzuschließen (z. B. OXXO, Konbini und Boleto). Standardmäßig zeigt PaymentSheet keine Zahlungsmethoden mit Verzögerung an. Um die Funktion zu aktivieren, setzen Sie `allowsDelayedPaymentMethods` in Ihrer `PaymentSheet.Configuration` auf „true“. Durch diesen Schritt allein werden keine bestimmten Zahlungsmethoden aktiviert. Er zeigt vielmehr an, dass Ihre App in der Lage ist, diese zu verarbeiten. Obwohl beispielsweise OXXO von PaymentSheet nicht unterstützt wird, kann Ihre App OXXO als Zahlungsoption ohne zusätzliche Integrationsänderungen anzeigen, wenn es unterstützt wird und Sie auf die neueste SDK-Version aktualisiert haben. ```swift var configuration = PaymentSheet.Configuration() configuration.allowsDelayedPaymentMethods = true self.paymentSheet = PaymentSheet(..., configuration: configuration) ``` Wenn die Kundin/der Kunde erfolgreich eine dieser verzögerten Zahlungsmethoden in PaymentSheet verwendet, lautet das zurückgegebene Zahlungsergebnis `.completed`. ## Optional: Apple Pay aktivieren > Wenn Ihr Zahlungsbildschirm eine spezielle **Apple Pay**-Schaltfläche enthält, folgen Sie dem [Apple Pay-Leitfaden](https://docs.stripe.com/apple-pay.md#present-payment-sheet) und verwenden Sie `ApplePayContext`, um Zahlungen über Ihre **Apple Pay**-Schaltfläche einzuziehen. Sie können `PaymentSheet` verwenden, um andere Arten von Zahlungsmethoden zu handhaben. ### Für eine Apple-Händler-ID registrieren Beantragen Sie eine Apple-Händler-ID, indem Sie sich auf der Apple Developer-Website [für eine neue Kennung registrieren](https://developer.apple.com/account/resources/identifiers/add/merchant). Tragen Sie eine Beschreibung und eine Kennung in das Formular ein. Die Beschreibung ist nur für Ihre internen Zwecke bestimmt und kann später geändert werden. Stripe empfiehlt, dass Sie den Namen Ihrer App als Kennung verwenden, zum Beispiel `merchant.com.{{YOUR_APP_NAME}}`. ### Neues Apple Pay-Zertifikat erstellen Erstellen Sie ein Zertifikat für Ihre App, um Zahlungsdaten zu verschlüsseln. Gehen Sie zu den [iOS-Zertifikateinstellungen](https://dashboard.stripe.com/settings/ios_certificates) im Dashboard, klicken Sie auf **Neue Anwendung hinzufügen** und befolgen Sie die Anleitung. Laden Sie eine Certificate Signing Request (CSR)-Datei herunter, um ein sicheres Zertifikat von Apple zu erhalten, mit dem Sie Apple Pay verwenden können. Eine CSR-Datei muss verwendet werden, um genau ein Zertifikat auszustellen. Wenn Sie Ihre Apple-Händler-ID wechseln, müssen Sie zu den [iOS-Zertifikateinstellungen](https://dashboard.stripe.com/settings/ios_certificates) im Dashboard gehen, um eine neue CSR und ein Zertifikat zu erhalten. ### Mit Xcode integrieren Fügen Sie Ihrer App die **Apple Pay**-Funktion hinzu. Öffnen Sie in Xcode Ihre Projekteinstellungen, klicken Sie auf die Registerkarte **Signing & Capabilities** (Anmeldung und Funktionen) und fügen Sie die **Apple Pay**-Funktion hinzu. Möglicherweise werden Sie an dieser Stelle aufgefordert, sich bei Ihrem Entwicklerkonto anzumelden. Wählen Sie die zuvor erstellte Händler-ID aus. Ihre App sollte nun Apple Pay unterstützen. ![](https://b.stripecdn.com/docs-statics-srv/assets/xcode.a701d4c1922d19985e9c614a6f105bf1.png) Apple Pay-Funktion in Xcode aktivieren ### Apple Pay hinzufügen #### Einmalige Zahlung Um Apple Pay zum PaymentSheet hinzuzufügen, setzen Sie [applePay](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:6Stripe12PaymentSheetC13ConfigurationV8applePayAC05ApplefD0VSgvp), nachdem Sie `PaymentSheet.Configuration` mit Ihrer Apple-Händler-ID und dem [Ländercode Ihres Unternehmens](https://dashboard.stripe.com/settings/account) initialisiert haben. #### iOS (Swift) ```swift var configuration = PaymentSheet.Configuration() configuration.applePay = .init( merchantId: "merchant.com.your_app_name", merchantCountryCode: "US" ) ``` #### Wiederkehrende Zahlungen Um Apple Pay zum PaymentSheet hinzuzufügen, setzen Sie [applePay](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:6Stripe12PaymentSheetC13ConfigurationV8applePayAC05ApplefD0VSgvp), nachdem Sie `PaymentSheet.Configuration` mit Ihrer Apple-Händler-ID und dem [Ländercode Ihres Unternehmens](https://dashboard.stripe.com/settings/account) initialisiert haben. Gemäß den [Apple-Richtlinien](https://developer.apple.com/design/human-interface-guidelines/apple-pay#Supporting-subscriptions) für wiederkehrende Zahlungen müssen Sie auch zusätzliche Attribute für `PKPaymentRequest` festlegen. Fügen Sie in [ApplePayConfiguration.paymentRequestHandlers](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/applepayconfiguration/handlers/paymentrequesthandler) einen Handler hinzu, um die [PKPaymentRequest.paymentSummaryItems](https://developer.apple.com/documentation/passkit/pkpaymentrequest/1619231-paymentsummaryitems) mit dem Betrag zu konfigurieren, den Sie berechnen möchten (z. B. 9,95 USD pro Monat). Sie können auch [Händler-Token](https://developer.apple.com/apple-pay/merchant-tokens/) übernehmen, indem Sie die Eigenschaften `recurringPaymentRequest` oder `automaticReloadPaymentRequest` für `PKPaymentRequest` festlegen. Weitere Informationen zur Verwendung wiederkehrender Zahlungen mit Apple Pay finden Sie in der [PassKit-Dokumentation von Apple](https://developer.apple.com/documentation/passkit/pkpaymentrequest). #### iOS (Swift) ```swift let customHandlers = PaymentSheet.ApplePayConfiguration.Handlers( paymentRequestHandler: { request in // PKRecurringPaymentSummaryItem is available on iOS 15 or later if #available(iOS 15.0, *) { let billing = PKRecurringPaymentSummaryItem(label: "My Subscription", amount: NSDecimalNumber(string: "59.99")) // Payment starts today billing.startDate = Date() // Payment ends in one year billing.endDate = Date().addingTimeInterval(60 * 60 * 24 * 365) // Pay once a month. billing.intervalUnit = .month billing.intervalCount = 1 // recurringPaymentRequest is only available on iOS 16 or later if #available(iOS 16.0, *) { request.recurringPaymentRequest = PKRecurringPaymentRequest(paymentDescription: "Recurring", regularBilling: billing, managementURL: URL(string: "https://my-backend.example.com/customer-portal")!) request.recurringPaymentRequest?.billingAgreement = "You'll be billed $59.99 every month for the next 12 months. To cancel at any time, go to Account and click 'Cancel Membership.'" } request.paymentSummaryItems = [billing] request.currencyCode = "USD" } else { // On older iOS versions, set alternative summary items. request.paymentSummaryItems = [PKPaymentSummaryItem(label: "Monthly plan starting July 1, 2022", amount: NSDecimalNumber(string: "59.99"), type: .final)] } return request } ) var configuration = PaymentSheet.Configuration() configuration.applePay = .init(merchantId: "merchant.com.your_app_name", merchantCountryCode: "US", customHandlers: customHandlers) ``` ### Bestellverfolgung Um Informationen zur [Bestellverfolgung](https://developer.apple.com/design/human-interface-guidelines/technologies/wallet/designing-order-tracking) in iOS 16 oder höher hinzuzufügen, konfigurieren Sie einen [authorizationResultHandler](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/applepayconfiguration/handlers/authorizationresulthandler) in Ihren `PaymentSheet.ApplePayConfiguration.Handlers`. Stripe ruft Ihre Implementierung auf, nachdem die Zahlung durchgeführt wurde, aber bevor iOS das Apple Pay-Formular schließt. Rufen Sie in Ihrer Implementierung von `authorizationResultHandler` die Bestelldetails für die abgeschlossene Bestellung von Ihrem Server ab. Fügen Sie die Details dem bereitgestellten [PKPaymentAuthorizationResult](https://developer.apple.com/documentation/passkit/pkpaymentauthorizationresult) hinzu und geben Sie das geänderte Ergebnis zurück. Weitere Informationen zur Bestellverfolgung finden Sie in der [Dokumentation zu Wallet-Bestellungen von Apple](https://developer.apple.com/documentation/walletorders). #### iOS (Swift) ```swift let customHandlers = PaymentSheet.ApplePayConfiguration.Handlers( authorizationResultHandler: { result in do { // Fetch the order details from your service let myOrderDetails = try await MyAPIClient.shared.fetchOrderDetails(orderID: orderID) result.orderDetails = PKPaymentOrderDetails( orderTypeIdentifier: myOrderDetails.orderTypeIdentifier, // "com.myapp.order" orderIdentifier: myOrderDetails.orderIdentifier, // "ABC123-AAAA-1111" webServiceURL: myOrderDetails.webServiceURL, // "https://my-backend.example.com/apple-order-tracking-backend" authenticationToken: myOrderDetails.authenticationToken) // "abc123" // Return your modified PKPaymentAuthorizationResult return result } catch { return PKPaymentAuthorizationResult(status: .failure, errors: [error]) } } ) var configuration = PaymentSheet.Configuration() configuration.applePay = .init(merchantId: "merchant.com.your_app_name", merchantCountryCode: "US", customHandlers: customHandlers) ``` ## Optional: Passen Sie das Tabellenblatt an Alle Anpassungen werden mithilfe des [PaymentSheet.Configuration](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html)-Objekts konfiguriert. ### Erscheinungsbild Passen Sie mit der [Appearance API](https://docs.stripe.com/elements/appearance-api/mobile.md?platform=ios) Farben, Schriftarten und mehr an das Erscheinungsbild Ihrer App an. ### Layout der Zahlungsmethode Konfigurieren Sie das Layout der Zahlungsmethoden im Formular mit [paymentMethodLayout](https://stripe.dev/stripe-ios/stripepaymentsheet/documentation/stripepaymentsheet/paymentsheet/configuration-swift.struct/paymentmethodlayout). Sie können sie horizontal oder vertikal anzeigen oder das Layout von Stripe automatisch optimieren lassen. ![](https://b.stripecdn.com/docs-statics-srv/assets/ios-mpe-payment-method-layouts.9d0513e2fcec5660378ba1824d952054.png) #### Swift ```swift var configuration = PaymentSheet.Configuration() configuration.paymentMethodLayout = .automatic ``` ### Adressen der Nutzer/innen erfassen Erfassen Sie lokale und internationale Versand- und Rechnungsadressen von Ihren Kundinnen und Kunden mithilfe des [Address Element](https://docs.stripe.com/elements/address-element.md?platform=ios). ### Anzeigename des Händlers Geben Sie einen kundenorientierten Unternehmensnamen an, indem Sie [merchantDisplayName](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:18StripePaymentSheet0bC0C13ConfigurationV19merchantDisplayNameSSvp) festlegen. Standardmäßig handelt es sich dabei um den Namen Ihrer App. #### Swift ```swift var configuration = PaymentSheet.Configuration() configuration.merchantDisplayName = "My app, Inc." ``` ### Dunkelmodus `PaymentSheet` passt sich automatisch an die systemweiten Erscheinungsbildeinstellungen des Nutzers/der Nutzerin an (heller und dunkler Modus). Wenn Ihre App den Dunkelmodus nicht unterstützt, können Sie den [Stil](https://stripe.dev/stripe-ios/stripe-paymentsheet/Classes/PaymentSheet/Configuration.html#/s:18StripePaymentSheet0bC0C13ConfigurationV5styleAC18UserInterfaceStyleOvp) auf den Modus `alwaysLight` oder `alwaysDark` einstellen. ```swift var configuration = PaymentSheet.Configuration() configuration.style = .alwaysLight ``` ### Standardabrechnungsdetails Um Standardwerte für die im Zahlungsformular erfassten Rechnungsdetails festzulegen, konfigurieren Sie die Eigenschaft `defaultBillingDetails`. Die Felder von `PaymentSheet` werden vorab mit den von Ihnen angegebenen Werten ausgefüllt. ```swift var configuration = PaymentSheet.Configuration() configuration.defaultBillingDetails.address.country = "US" configuration.defaultBillingDetails.email = "foo@bar.com" ``` ### Erfassung der Rechnungsdetails Verwenden Sie `billingDetailsCollectionConfiguration`, um anzugeben, wie Sie Rechnungsdetails im Zahlungsformular erfassen möchten. Sie können den Namen, die E-Mail-Adresse, die Telefonnummer und die Adresse Ihrer Kundinnen und Kunden erfassen. Wenn Sie nur die für die Zahlungsmethode erforderlichen Rechnungsdetails angeben möchten, legen Sie `billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod` auf „true“ fest. In diesem Fall werden `PaymentSheet.Configuration.defaultBillingDetails` als [Abrechnungsdetails](https://docs.stripe.com/api/payment_methods/object.md?lang=node#payment_method_object-billing_details) der Zahlungsmethode festgelegt. Wenn Sie zusätzliche Rechnungsdetails erfassen möchten, die für die Zahlungsmethode nicht unbedingt erforderlich sind, legen Sie `billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod` auf „false“ fest. In diesem Fall werden die über das `PaymentSheet` erfassten Rechnungsdetails als Rechnungsdetails der Zahlungsmethode festgelegt. ```swift var configuration = PaymentSheet.Configuration() configuration.defaultBillingDetails.email = "foo@bar.com" configuration.billingDetailsCollectionConfiguration.name = .always configuration.billingDetailsCollectionConfiguration.email = .never configuration.billingDetailsCollectionConfiguration.address = .full configuration.billingDetailsCollectionConfiguration.attachDefaultsToPaymentMethod = true ``` > Wenden Sie sich an Ihren Rechtsbeistand bezüglich der Gesetze, die für das Erfassen von Informationen gelten. Erfassen Sie Telefonnummern nur, wenn Sie sie für die Transaktion benötigen.