# Zahlungen akzeptieren für digitale Produkte auf iOS mit Stripe als eingetragener Händler Öffnen Sie Stripe Checkout mit Managed Payments in einem Browser, um In-App-Digitalprodukte oder Abos zu verkaufen. > #### Allgemeine Geschäftsbedingungen erforderlich > > Sie müssen die [Allgemeinen Geschäftsbedingungen von Managed Payments](https://stripe.com/legal/managed-payments) im [Dashboard](https://dashboard.stripe.com/settings/managed-payments) akzeptieren, bevor Sie Managed Payments nutzen können. In [einigen Ländern](https://support.stripe.com/questions/changes-to-ios-app-store-guidelines) können Sie auf eine externe Website verlinken, um Zahlungen mit Managed Payments auf iOS zu akzeptieren. Sie verwenden [Stripe Checkout](https://docs.stripe.com/payments/checkout.md), um Ihre Kundinnen und Kunden auf eine von Stripe gehostete Zahlungsseite weiterzuleiten. Dieses Beispiel zeigt, wie digitale Guthaben für die Nutzung in Ihrer App verkauft werden können. Sie können sowohl einmalige Zahlungen als auch Abozahlungen akzeptieren. ![Einmalige Zahlung](https://b.stripecdn.com/docs-statics-srv/assets/one-time-hero.36361064aef1a09b8192ef17b0b557de.png) Nutzeroberfläche, die Kundinnen und Kunden bei einmaligen Zahlungen mit Managed Payments sehen ![Wiederkehrende Zahlung](https://b.stripecdn.com/docs-statics-srv/assets/recurring-hero.00968928fbe5564c9964922965c8b3c1.png) Nutzeroberfläche, die Kundinnen und Kunden bei Abozahlungen mit Managed Payments sehen ## So funktioniert es Das folgende Diagramm zeigt den gesamten Zahlungsablauf von der App zum Web in groben Zügen: Allgemeiner Ablauf des Bezahlvorgangs von der App zum Web bei In-App-Käufen (See full diagram at https://docs.stripe.com/payments/managed-payments/set-up-mobile) ## Beschränkungen Dieser Leitfaden behandelt nicht die folgenden Themen: - Benutzerauthentifizierung. Falls Sie noch keinen Authentifizierungsanbieter haben, können Sie einen Drittanbieter wie [Sign in with Apple](https://developer.apple.com/sign-in-with-apple/) oder [Firebase Authentication](https://firebase.google.com/docs/auth) verwenden. - Native In-App-Käufe. Um In-App-Käufe mit StoreKit umzusetzen, besuchen Sie [den Leitfaden zu In-App-Käufen von Apple](https://developer.apple.com/in-app-purchase/). Dieser Leitfaden beschreibt nur den Prozess für den Verkauf von In-App-Digitalprodukten, die diese [Anforderungen](https://docs.stripe.com/payments/managed-payments/eligibility.md) erfüllen. Wenn Ihre digitalen Produkte diese Kriterien nicht erfüllen, finden Sie weitere Informationen unter [Zahlungen für digitale Güter auf iOS akzeptieren](https://docs.stripe.com/mobile/digital-goods/checkout.md). Wenn Sie physische Produkte verkaufen, siehe [In-App-Zahlungen mit Stripe](https://docs.stripe.com/payments/mobile.md). ## Before you begin - Stellen Sie sicher, dass Ihre Produkte die [Anforderungen](https://docs.stripe.com/payments/managed-payments/eligibility.md) für Managed Payments erfüllen. Um eine Zahlung mit Managed Payments abzuwickeln, müssen alle Produkte, die der Kunde/die Kundin kauft, die Anforderungen erfüllen. - Aktivieren Sie Managed Payments in Ihrem [Dashboard](https://dashboard.stripe.com/settings/managed-payments). - [Entwicklungsumgebung einrichten](https://docs.stripe.com/get-started/development-environment.md). - Verwenden Sie die API-Version `2025-03-31.basil` oder [höher](https://docs.stripe.com/changelog.md). ## Produkte und Preise erstellen Erstellen Sie Ihre *Produkte* (Products represent items your customer can subscribe to with a Subscription. An associated Price object describes the pricing and other terms of the subscription) und deren *Preise* (Prices define how much and how often to charge for products. This includes how much the product costs, what currency to use, and the interval if the price is for subscriptions) im Dashboard oder über die Stripe CLI. Sie können digitale Produkte mit einmaligen Preisen sowie Abonnements mit wiederkehrenden Preisen hinzufügen. Sie können Ihren Kundinnen und Kunden auch die Wahl lassen, wie viel sie bezahlen möchten (z. B. um selbst zu entscheiden, wie viel Guthaben sie kaufen), indem Sie **Kundinnen und Kunden wählen, was sie bezahlen ** auswählen. Wenn Sie Ihr Produkt erstellen, muss der von Ihnen ausgewählte Steuercode [für Managed Payments zugelassen](https://docs.stripe.com/payments/managed-payments/eligibility.md#eligible-tax-codes) sein. Zugelassene Steuercodes sind mit `Für Managed Payments zugelassen` gekennzeichnet. Dieses Beispiel verwendet ein einzelnes *Produkt* und einen *Preis*, um ein 100-Coin-Bundle zu repräsentieren, das 10 USD kostet. #### Dashboard Gehen Sie zur Seite [Produkt hinzufügen](https://dashboard.stripe.com/test/products/create) und erstellen Sie das Coin-Paket. Fügen Sie einen einmaligen Preis von 10 USD hinzu. Wählen Sie `txcd_10201000` als Steuercode für `Video Games - downloaded - non subscription - with permanent rights tax code`. - 100 Münzen: Bundle mit 100 In-App-Münzen - Preis: Standard-Modell | 10 USD | Einmalig | txcd_10201000 Zeichnen Sie nach Erstellung des Preises die Preis-ID auf, sodass diese in nachfolgenden Schritten verwendet werden kann. Preis-IDs sehen in etwa wie folgt aus: `price_G0FvDp6vZvdwRZ`. Wenn Sie bereit sind, klicken Sie auf **In Live-Modus kopieren**, um Ihr Produkt von einer [Testumgebung in den Live-Modus](https://docs.stripe.com/keys.md#test-live-modes) zu kopieren. #### Stripe-CLI Erstellen Sie als Nächstes die Produkt-Objekte: ```bash stripe products create \ --name="100 coins" \ --description="Bundle of 100 in-app coins" \ --tax-code="txcd_10201000" ``` Das Stripe-CLI gibt die Produktdetails aus, einschließlich der Produkt-ID. ```json { "id": "prod_H94k5odtwJXMtQ", "object": "product", "active": true, "attributes": [ ], "created": 1587577341, "description": "Bundle of 100 in-app coins", "images": [ ], "livemode": false, "metadata": { }, "name": "100 coins", "statement_descriptor": null, "tax_code": "txcd_10201000", "type": "service", "unit_label": null, "updated": 1587577341 } ``` Erstellen Sie anhand der Produkt-IDs jeweils einen Preis. Die Zahl `unit_amount` wird in Cent angegeben, z. B. `1000` = 10 USD. ```bash stripe prices create \ -d product=prod_H94k5odtwJXMtQ \ -d unit_amount=1000 \ -d currency=usd ``` Speichern Sie die Preis-ID für jeden Preis, damit Sie sie in den folgenden Schritten verwenden können. Sie sieht ungefähr so aus: ```json { "id": "price_1Jh0tjEmNk5jCjFGCkLnNYGO", "object": "price", "active": true, "billing_scheme": "per_unit", "created": 1633391323, "currency": "usd", "livemode": false, "lookup_key": null, "metadata": { }, "nickname": null, "product": "prod_H94k5odtwJXMtQ", "recurring": null, "tax_behavior": "unspecified", "tiers_mode": null, "transform_quantity": null, "type": "one_time", "unit_amount": 1000, "unit_amount_decimal": "1000" } ``` ## Kundinnen/Kunden erstellen [Serverseitig] Erstellen Sie jedes Mal, wenn Sie eine Checkout-Sitzung erstellen auch ein *Kunden* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments)Objekt für Ihre/n Nutzer/in, sofern noch keines besteht. #### Node.js ```javascript // Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. // Find your keys at https://dashboard.stripe.com/apikeys. const stripe = require('stripe')('<>'); // This assumes your app has an existing user database, which we'll call `myUserDB`. const user = myUserDB.getUser("jennyrosen"); if (!user.stripeCustomerID) { const customer = await stripe.customers.create({ name: user.name, email: user.email, }); // Set the user's Stripe Customer ID for later retrieval. user.stripeCustomerID = customer.id; } ``` > Speichern Sie eine Zuweisung auf Ihrem Server zwischen dem Benutzerkonto und der Stripe-Kunden-ID. Ohne eine solche Verbindung zur Zuordnung einer/s Kund/in zu einem Kauf, können Ihre Kund/innen ihre Käufe nicht erhalten. > > Besteht für Ihre App kein Authentifizierungsanbieter, können Sie [Mit Apple registrieren](https://developer.apple.com/sign-in-with-apple/) verwenden. Verwenden Sie das Argument [customer](https://docs.stripe.com/api/checkout/sessions/create.md#create_checkout_session-customer), um die Kunden/Kundin beim Erstellen einer Checkout-Sitzung zu übergeben. Dadurch wird sichergestellt, dass alle während der Sitzung erstellten Objekte dem richtigen `Customer`-Objekt zugeordnet werden. ## Universelle Links einrichten [Clientseitig] [Serverseitig] *Universelle Links* (Use Universal links on iOS and macOS to link directly to in-app content. They're standard HTTPS links, so the same URL works for your website and your app) ermöglichen es Checkout, Deep Links zu Ihrer App zu erstellen. So konfigurieren Sie einen universellen Link: 1. Fügen Sie Ihrer Domain eine `apple-app-site-association`-Datei hinzu. 1. Fügen Sie Ihrer App eine Berechtigung für die zugewiesenen Domains hinzu. 1. Fügen Sie eine Fallbackseite für Ihre Checkout-Umleitungs-URL hinzu. #### Definieren Sie die zugewiesenen Domains Fügen Sie Ihrer Domain eine Datei unter **.well-known/apple-app-site-association** hinzu, um die URLs zu definieren, die Ihre App verarbeitet. Stellen Sie Ihrer App-ID die Team-ID voran, die Sie auf der [Mitgliedschafts-Seite des Apple Developer Portals](https://developer.apple.com/account) finden. ```json { "applinks": { "apps": [], "details": [ { "appIDs": [ "A28BC3DEF9.com.example.MyApp1", "A28BC3DEF9.com.example.MyApp1-Debug" ], "components": [ { "/": "/checkout_redirect*", "comment": "Matches any URL whose path starts with /checkout_redirect" } ] } ] } } ``` Sie müssen der Datei den MIME-Typ `application/json` hinzufügen. Mit `curl -I` bestätigen Sie den Inhaltstyp. ```bash curl -I https://example.com/.well-known/apple-app-site-association ``` Auf der Seite [Zugewiesene Domains unterstützen](https://developer.apple.com/documentation/xcode/supporting-associated-domains) von Apple finden Sie weitere Einzelheiten hierzu. #### Fügen Sie Ihrer App eine Berechtigung für die zugewiesenen Domains (“Associated Domains”) hinzu. 1. Öffnen Sie den Bereich **Signierung & Kapazitäten** der Zielanwendung Ihrer App. 1. Klicken Sie auf **+ Funktion** und wählen Sie dann **Zugewiesene Domains** aus. 1. Fügen Sie einen Eintrag für `applinks:example.com` zur Liste der **Zugewiesenen Domains** hinzu. Weitere Informationen zu universellen Links finden Sie auf der Seite [Universelle Links für Entwickler](https://developer.apple.com/ios/universal-links/) von Apple. Obgleich iOS Links an die in Ihrer `apple-app-site-association`-Datei definierten URLs abruft, kann es zu Situationen kommen, in denen die Umleitung Ihre App nicht öffnen kann. Erstellen Sie unbedingt eine [Fallback-Seite](https://docs.stripe.com/payments/checkout/custom-success-page.md?payment-ui=stripe-hosted) unter Ihrer `success_url`. Sie können beispielsweise ein [benutzerdefiniertes URL-Schema für Ihre App definieren](https://developer.apple.com/documentation/xcode/defining-a-custom-url-scheme-for-your-app) und dieses für einen Link zurück verwenden, falls der universelle Link fehlschlägt. ## Checkout-Sitzung erstellen [Serverseitig] Eine [Checkout-Sitzung](https://docs.stripe.com/api/checkout/sessions/create.md) ist eine programmgesteuerte Darstellung dessen, was Ihren Kundinnen/Kunden bei der Weiterleitung zum Zahlungsformular angezeigt wird. Checkout-Sitzungen laufen 24 Stunden nach Erstellung ab. Konfigurieren Sie es mit: - Die Kunden-ID - Die Produkt-ID (entweder für eine einmalige Zahlung oder ein Abo) - Ein `origin_context`, der auf `mobile_app` gesetzt ist, um eine Nutzeroberfläche zu aktivieren, die für App-to-Web-Käufe optimiert ist. - Der Parameter `managed_payments[enabled]` ist `true` - Eine `success_url`, ein *universeller Link* (Use Universal links on iOS and macOS to link directly to in-app content. They're standard HTTPS links, so the same URL works for your website and your app), der Ihre Kund/innen an Ihre App weiterleitet, um die Zahlung abzuschließen. Geben Sie die [URL](https://docs.stripe.com/api/checkout/sessions/object.md#checkout_session_object-url) aus der Antwort an Ihre App zurück, nachdem Sie eine Checkout-Sitzung erstellt haben. #### Einmalige Zahlung #### Node.js ```javascript // This example sets up an endpoint using the Express framework. const express = require('express'); const app = express(); // Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. const stripe = require('stripe')('<>'); app.post('/create-checkout-session', async (req, res) => { // Fetch the Stripe customer ID for the customer associated with this request. // This assumes your app has an existing user database, which we'll call `myUserDB`. const user = myUserDB.getUserFromToken(req.query.token); const customerId = user.stripeCustomerID; // The price ID from the previous step const priceId = '{{PRICE_ID}}'; const session = await stripe.checkout.sessions.create({ line_items: [ { price: priceId, quantity: 1, }, ], mode: 'payment', managed_payments: {enabled: true}, origin_context: 'mobile_app', customer: customerId, success_url: 'https://example.com/checkout_redirect/success', }); res.json({url: session.url}); }); app.post('/login', async (req, res) => { // This assumes your app has an existing user database, which we'll call `myUserDB`. const token = myUserDB.login(req.body.login_details) res.json({token: token}) }); app.listen(4242, () => console.log(`Listening on port ${4242}!`)); ``` #### Abonnement #### Node.js ```javascript // This example sets up an endpoint using the Express framework. const express = require('express'); const app = express(); // Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. const stripe = require('stripe')('<>'); app.post('/create-checkout-session', async (req, res) => {// Fetch the Stripe customer ID for the customer associated with this request. // This assumes your app has an existing user database, which we'll call `myUserDB`. const user = myUserDB.getUserFromToken(req.query.token); const customerId = user.stripeCustomerID; // The price ID from the previous step const priceId = '{{SUBSCRIPTION_PRICE_ID}}'; const session = await stripe.checkout.sessions.create({ line_items: [ { price: priceId, quantity: 1, }, ], mode: 'subscription', managed_payments: {enabled: true}, origin_context: 'mobile_app', customer: customerId, success_url: 'https://example.com/checkout_redirect/success', }); res.json({url: session.url}); }); app.post('/login', async (req, res) => { // This assumes your app has an existing user database, which we'll call `myUserDB`. const token = myUserDB.login(req.body.login_details) res.json({token: token}) }); app.listen(4242, () => console.log(`Listening on port ${4242}!`)); ``` ## Checkout in Safari öffnen [Clientseitig] Fügen Sie Ihrer App eine Checkout-Schaltfläche hinzu. Diese Schaltfläche: 1. Ruft einen serverseitigen Endpoint auf, der die Checkout-Sitzung erstellt. 1. Gibt die Checkout-Sitzung an den Client zurück. 1. Öffnet die Sitzungs-URL in Safari. ```swift import Foundation import SwiftUI import StoreKit struct BuyCoinsView: View { @EnvironmentObject var myBackend: MyServer @State var paymentComplete = false var body: some View { // Check if payments are blocked by Parental Controls on this device. if !SKPaymentQueue.canMakePayments() { Text("Payments are disabled on this device.") } else { if paymentComplete { Text("Payment complete!") } else { Button { myBackend.createCheckoutSession { url in UIApplication.shared.open(url, options: [:], completionHandler: nil) } } label: { Text("Buy 100 coins") }.onOpenURL { url in // Handle the universal link from Checkout. if url.absoluteString.contains("success") { // The payment was completed. Show a success // page and fetch the latest customer entitlements // from your server. paymentComplete = true } } } } } } ``` ### Die Checkout-URL auf dem Client abrufen Verwenden Sie Ihren Server-Endpoint, um die Checkout-Sitzung aufzurufen. ```swift class MyServer: ObservableObject { // The cached login token var token: String? func createCheckoutSession(completion: @escaping (URL) -> Void) { // Send the login token to the `/create_checkout_session` endpoint let request = URLRequest(url: URL(string: "https://example.com/create-checkout-session?token=\(self.token)")!) let task = URLSession.shared.dataTask(with: request, completionHandler: { (data, response, error) in guard let unwrappedData = data, let json = try? JSONSerialization.jsonObject(with: unwrappedData, options: []) as? [String : Any], let urlString = json["url"] as? String, let url = URL(string: urlString) else { // Handle error return } DispatchQueue.main.async { // Call the completion block with the Checkout session URL returned from the backend completion(url) } }) task.resume() } func login() { // Login using the server and set the login token. let request = URLRequest(url: URL(string: "https://example.com/login")!) let task = URLSession.shared.dataTask(with: request, completionHandler: { (data, response, error) in guard let unwrappedData = data, let json = try? JSONSerialization.jsonObject(with: unwrappedData, options: []) as? [String : Any], let token = json["token"] as? String else { // Handle error return } self.token = token }) task.resume() } } ``` ## Umgang mit Bestellabwicklung [Serverseitig] Nach erfolgreicher Kaufabwicklung sendet Stripe Ihnen den *Webhook* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests) `checkout.session.completed`. Wenn Sie das Ereignis empfangen, können Sie der Kundin/dem Kunden die Münzen auf Ihrem Server zuweisen. Checkout leitet Ihre Kundinnen und Kunden an die `success_url` weiter, wenn Sie [bestätigen, dass Sie das Ereignis erhalten haben](https://docs.stripe.com/webhooks.md#acknowledge-events-immediately). In Szenarien, in denen Ihr Endpoint nicht funktionsfähig ist oder das Ereignis nicht ordnungsgemäß bestätigt wurde, leitet Checkout den Kunden/die Kundin 10 Sekunden nach einer erfolgreichen Zahlung an die `success_url` weiter. Zu Testzwecken können Sie Ereignisse im [Dashboard](https://dashboard.stripe.com/events) überwachen oder die [Stripe-CLI](https://docs.stripe.com/webhooks.md#test-webhook) verwenden. Für die Produktion richten Sie einen Webhook-Endpoint ein und abonnieren Sie die entsprechenden Ereignistypen. Wenn Sie Ihren `STRIPE_WEBHOOK_SECRET`-Schlüssel nicht kennen, klicken Sie im Dashboard auf den [Webhook](https://dashboard.stripe.com/webhooks), um ihn anzuzeigen. #### Node.js ```javascript // Don't put any keys in code. See https://docs.stripe.com/keys-best-practices. // Find your keys at https://dashboard.stripe.com/apikeys. const stripe = require('stripe')('<>'); app.post("/webhook", async (req, res) => { let data; let eventType; // Check if webhook signing is configured. const webhookSecret = "{{STRIPE_WEBHOOK_SECRET}}" // Beispiel: whsec_c7681Dm if (webhookSecret) { // Retrieve the event by verifying the signature using the raw body and secret. let event; let signature = req.headers["stripe-signature"]; try { event = stripe.webhooks.constructEvent( req.body, signature, webhookSecret ); } catch (err) { console.log(`⚠️ Webhook signature verification failed.`); return res.sendStatus(400); } // Extract the object from the event. data = event.data; eventType = event.type; } else { // Webhook signing is recommended, but if the secret is not configured in `config.js`, // retrieve the event data directly from the request body. data = req.body.data; eventType = req.body.type; } switch (eventType) { case 'checkout.session.completed': const session = event.data.object; // Payment is successful. // Update the customer in your database to reflect this purchase. const user = myUserDB.userForStripeCustomerID(session.customer); user.addCoinsTransaction(100, session.id); break; default: // Unhandled event type } res.sendStatus(200); }); ``` ### Testen Testen Sie Ihre Checkout-Schaltfläche, die Ihre Kundin/Ihren Kunden zu Stripe Checkout weiterleitet. 1. Klicken Sie auf die Schaltfläche Bezahlvorgang, die Sie dann zum Checkout-Zahlungsformular von Stripe weiterleitet. 1. Geben Sie die Testnummer 4242 4242 4242 4242, einen dreistelligen CVC, ein Ablaufdatum und eine gültige Postleitzahl. 1. Tippen Sie auf **Bezahlen**. 1. Der Webhook `checkout.session.completed` wird ausgelöst und Stripe benachrichtigt Ihren Server über die Transaktion. 1. Sie werden zu Ihrer App zurückgeleitet. Wenn Ihre Integration nicht funktioniert, lesen Sie bitte im Abschnitt [Zusätzliche Testressourcen](https://docs.stripe.com/payments/managed-payments/set-up-mobile.md#additional-testing-resources) weiter unten nach. ### Zahlungsdaten #### Item 1 1. Nachdem Sie die Testzahlung bestätigt haben, gehen Sie zum **Dashboard** > [Transaktionen](https://dashboard.stripe.com/test/payments). 1. Klicken Sie auf Ihre Testzahlung, um die Zahlungsdetails anzuzeigen. Auf dieser Seite werden folgende Informationen angezeigt: - Erworbenes Produkt - Eingerichtetes [Abo](https://docs.stripe.com/api/subscriptions.md) - Erstellte [Rechnung](https://docs.stripe.com/api/invoices.md) - Über Managed Payments berechneter und einbehaltener Steuerbetrag - Zahlungsbeschreibung in der Abrechnung, die auf den Kontoauszügen Ihrer Kundinnen und Kunden angezeigt wird > #### Kundengenehmigung > > Wenn Kundinnen und Kunden ein Abonnement über Managed Payments kaufen, autorisieren sie nur die Belastung ihrer Zahlungsmethode durch Managed Payments. Um diese Zahlungsmethode für Transaktionen außerhalb von Managed Payments belasten zu können, müssen Sie die entsprechende Einwilligung Ihrer Kundinnen und Kunden einholen. #### Item 2 1. Nachdem Sie die Testzahlung bestätigt haben, gehen Sie zum **Dashboard** > [Transaktionen](https://dashboard.stripe.com/test/payments). 1. Klicken Sie auf Ihre Testzahlung, um die Zahlungsdetails anzuzeigen. Auf dieser Seite werden folgende Informationen angezeigt: - Erworbenes Produkt - Eingerichtetes [Abonnement](https://docs.stripe.com/api/subscriptions.md) (falls erworben) - Erstellte [Rechnung](https://docs.stripe.com/api/invoices.md) - Über Managed Payments berechneter und einbehaltener Steuerbetrag - Zahlungsbeschreibung in der Abrechnung, die auf den Kontoauszügen Ihrer Kundinnen und Kunden angezeigt wird #### Vorschau des Zahlungsbelegs 1. Klicken Sie unter **Zahlungsbelegsverlauf** auf **Zahlungsbeleg anzeigen**. 1. Klicken Sie auf **Zahlungsbeleg senden**, um eine Vorschau der Zahlungsbeleg-E-Mail an Ihre Kundin oder Ihren Kunden anzuzeigen. > Im Sandbox-Modus erhalten Sie nach einem Kauf keine Zahlungsbelege per E-Mail. Bitte senden Sie diese manuell gemäß den Anweisungen im vorherigen Abschnitt. ### Link [Link](https://docs.stripe.com/payments/link.md) fungiert beim Bezahlvorgang als eingetragener Händler und unterstützt auf der Website von [Link](https://link.com) die Verwaltung von Abonnements und den Support von Transaktionen. Sie können testen, wie Link während des Bezahlvorgangs funktioniert, indem Sie während einer ersten Checkout-Sitzung ein Konto Link erstellen. Nachdem Sie das Konto Link erstellt haben, versuchen Sie eine weitere Sitzung mit derselben E-Mail-Adresse. Zum Authentifizieren verwenden Sie bitte den Testpasscode `000000`. Testkäufe werden in der Link-App nicht angezeigt. Sie können die Tools zur Verwaltung von Bestellungen in der Link-App testen, indem Sie während einer Checkout-Session im Live-Modus ein Link-Konto erstellen. ## Optional: Zusätzliche Testressourcen Sie können mehrere Testkarten verwenden, um sicherzustellen, dass Ihre Integration bereit für den Einsatz in einer Produktionsumgebung ist. Verwenden Sie sie mit einer beliebigen Prüfziffer (CVC), einer Postleitzahl und einem Ablaufdatum in der Zukunft. | Nummer | Beschreibung | | ------------------- | ---------------------------------------------------------------------------------------------- | | 4242 4242 4242 4242 | Zahlung ist erfolgreich und wird sofort verarbeitet. | | 4000 0000 0000 3220 | Für eine erfolgreiche Zahlung muss die 3D Secure 2-Authentifizierung durchgeführt werden. | | 4000 0000 0000 9995 | Zahlung schlägt immer mit dem Ablehnungscode `insufficient_funds` fehl. | Eine vollständige Liste der Testkarten finden Sie im Leitfaden [Testbetrieb](https://docs.stripe.com/testing.md). ### Universelle Links testen Wenn Ihr universeller Link nicht von Checkout auf Ihre App weiterleitet, prüfen Sie die `SharedWebCredentials`-Logs auf Fehler. 1. Fügen Sie der Zugewiesenen Domain einen Debugging-Parameter hinzu. - Öffnen Sie den Bereich **Signierung & Kapazitäten** der Zielanwendung Ihrer App. - Fügen Sie dem Eintrag für Ihre zugewiesene Domain die Kennzeichnung `?mode=developer` hinzu. *(Example: `applinks:example.com?mode=developer`)* 1. Wechseln Sie in den Entwicklermodus. - Führen Sie eine App aus Xcode auf Ihrem Gerät aus und aktivieren Sie das Entwicklermenü. - Öffnen Sie auf Ihrem iPhone die **Einstellungen**, tippen Sie auf **Entwickler** und aktivieren Sie **Entwicklung Zugewiesene Domains**. 1. Löschen Sie Ihre App und installieren Sie sie neu. Dadurch wird iOS die Datei apple-app-site-association erneut herunterladen. 1. Schließen Sie den Bezahlvorgang in Ihrer App ab. 1. Checkout leitet Sie an Ihre App weiter. Falls nicht, führen Sie eine Systemdiagnose durch. 1. Drücken Sie gleichzeitig die Volumentasten (+ und -) und die Einschalttaste für 1 Sekunde, danach loslassen. Sie fühlen eine kurze Vibration, es wird aber kein visuelles Signal angezeigt. 1. Warten Sie 5 Minuten, gehen Sie dann auf **Einstellungen** > **Datenschutz** > **Analyse und Verbesserungen** > **Analysedaten** und scrollen Sie zur letzten Systemdiagnosedatei in der Liste. 1. Tippen Sie die Taste Teilen, um per AirDrop die Datei auf Ihrem Computer zu speichern. 1. Öffnen Sie das Systemdiagnosearchiv und dann `swcutil_show.txt`. 1. Durchsuchen Sie diese Datei nach der ID Ihrer App. Sie sehen einen Bereich mit Debugging-Informationen für Ihre App, einschließlich etwaiger Fehlermeldungen. ``` Service: applinks App ID: Y28TH9SHX7.com.stripe.FruitStore App Version: 1.0 App PI: { v = 0, t = 0x8, u = 0xc98, db = E335D78F-D49E-4F19-A150-F657E50DEDAE, {length = 8, bytes = 0x980c000000000000} } Domain: example.com?mode=developer User Approval: unspecified Site/Fmwk Approval: unspecified Flags: developer Last Checked: 2021-09-23 18:16:58 +0000 Next Check: 2021-09-23 21:21:34 +0000 Error: Error Domain=NSCocoaErrorDomain Code=3840 "JSON text did not start with array or object and option to allow fragments not set. around line 1, column 0." UserInfo={NSDebugDescription=JSON text did not start with array or object and option to allow fragments not set. around line 1, column 0., NSJSONSerializationErrorIndex=0} Retries: 1 ``` ## See also - [Rabatte hinzufügen](https://docs.stripe.com/payments/checkout/discounts.md) - [Ihr Branding anpassen](https://docs.stripe.com/payments/checkout/customization.md) - [Bestätigungsseite anpassen](https://docs.stripe.com/payments/checkout/custom-success-page.md)