# Akzeptieren Sie Zahlungen für digitale Waren in iOS mit einer vorgefertigten Zahlungsseite Öffnen Sie Stripe Checkout in einem Browser, um in der App digitale Waren oder Abonnements zu verkaufen. > [Erfahren Sie, wie Sie eine ähnliche Integration erstellen, die Managed Payments verwendet](https://docs.stripe.com/payments/managed-payments/set-up-mobile.md), die Stripe-Lösung für *eingetragene Händler/innen* (The legal entity responsible for facilitating the sale of products to a customer that handles any applicable regulations and liabilities, including sales taxes. In a Connect integration, it can be the platform or a connected account). Für iOS-Apps, die in den USA digitale Produkte, Inhalte und Abonnements verkaufen, können Sie Kundinnen und Kunden auf eine externe Bezahlseite weiterleiten, um Zahlungen über [Stripe Checkout](https://docs.stripe.com/payments/checkout.md) abzuwickeln. Verwenden Sie die [Storefront-Eigenschaft von StoreKit](https://developer.apple.com/documentation/storekit/storefront), um festzustellen, von welchem Store Ihre App heruntergeladen wurde. In dieser Anleitung wird beschrieben, wie Sie Zahlungen für den Kauf von Guthaben in Ihrer iOS-App abwickeln können, indem Sie Kundinnen und Kunden auf eine von [Stripe gehostete Zahlungsseite](https://docs.stripe.com/checkout/quickstart.md) weiterleiten. Android-Entwickler/innen in den USA können Zahlungen direkt in der App mit einem Drittpartei-Zahlungsabwickler verarbeiten. Informationen dazu, wie Sie Zahlungen direkt in der App mit Stripe akzeptieren, finden Sie unter [In-App-Zahlungen](https://docs.stripe.com/payments/mobile.md). In diesem Leitfaden wird nur der Prozess für iOS-Entwickler/innen beschrieben, die in der App digitale Waren verkaufen. Verwenden Sie den Leitfaden für [native App-Zahlungen](https://docs.stripe.com/payments/mobile.md), wenn Sie Folgendes verkaufen: - Physische Waren - Waren und Dienste zum Verbrauch außerhalb Ihrer App - Persönliche Dienstleistungen in Echtzeit zwischen zwei Individuen Dieser Leitfaden bietet Informationen zu den folgenden Vorgehensweisen: - Erfassen Sie Zahlungsinformationen mit Checkout. - Erstellen Sie Ihre Guthabenpakete mit *Produkten* (Products represent what your business sells—whether that's a good or a service), *Preisen* (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) und *Kund/innen* (Customer objects represent customers of your business. They let you reuse payment methods and give you the ability to track multiple payments). - Verwenden Sie *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), um von Checkout direkt an Ihre App weiterzuleiten. - Überwachen Sie *Webhooks* (A webhook is a real-time push notification sent to your application as a JSON payload through HTTPS requests), um das In-App-Guthaben Ihrer Kund/innen zu aktualisieren. ![Einmalige Zahlung](https://b.stripecdn.com/docs-statics-srv/assets/one_time_hero.e9d6a86d35345553ed008f0bd442c6b2.png) Externer Link für einmalige Zahlungen ![Wiederkehrende Zahlung](https://b.stripecdn.com/docs-statics-srv/assets/recurring_hero.6dff3f5076ca832cde57ac0757110291.png) Externer Link für wiederkehrende Zahlungen oder Abonnements ## 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/mobile/digital-goods/checkout) ## Folgendes wird nicht abgedeckt Dieser Leitfaden erläutert, wie Sie Stripe Checkout neben Ihrem bestehenden In-App-Kaufsystem einrichten. Nicht behandelt wird: - Benutzerauthentifizierung. Falls Sie noch keinen Authentifizierungsanbieter haben, können Sie einen Drittanbieter wie [Registrieren bei Apple](https://developer.apple.com/sign-in-with-apple/) oder [Firebase-Authentifizierung](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/). ## Stripe einrichten [Serverseitig] [Registrieren Sie sich](https://dashboard.stripe.com/register) zunächst für ein Stripe-Konto. Fügen Sie dann die Stripe API-Bibliothek Ihrem Backend hinzu: #### 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' ``` Installieren Sie als Nächstes die Stripe-CLI. Mit der CLI können Sie die erforderlichen [Webhook](https://docs.stripe.com/webhooks.md#test-webhook)-Tests durchführen und Ihre Produkte und Preise erstellen. Weitere Installationsoptionen finden Sie unter [Mit der Stripe-CLI loslegen](https://docs.stripe.com/stripe-cli.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 die zugehörigen *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 mit der Stripe-CLI. Sie können digitale Produkte mit einmaligen Preisen und Abonnements mit wiederkehrenden Preisen modellieren. Sie können Ihre Kundinnen und Kunden auch so viel bezahlen lassen, wie sie möchten (z. B. um zu entscheiden, wie viele Credits sie kaufen möchten), indem Sie **Kundinnen/Kunden entscheiden, was sie bezahlen möchten** auswählen. In diesem Beispiel wird ein einzelnes *Produkt* und ein einzelner *Preis* verwendet, um ein Bundle mit 100 Münzen darzustellen. #### Dashboard Gehen Sie zur Seite [Ein Produkt hinzufügen](https://dashboard.stripe.com/test/products/create) und erstellen Sie das Münzbündel. Fügen Sie einen einmaligen Preis von 10 USD hinzu. - 100 Münzen: Bundle mit 100 In-App-Münzen - Preis: Standard-Modell | 10 USD | Einmal Zeichnen Sie nach Erstellung der Preise 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, verwenden Sie die Schaltfläche **In Live-Modus kopieren** oben rechts auf der Seite, um Ihr Produkt aus dem [Test- in den Live-Modus zu kopieren](https://docs.stripe.com/keys.md#test-live-modes). #### Stripe-CLI Erstellen Sie als Nächstes die Produkt-Objekte: ```bash stripe products create \ --name="100 coins" \ --description="Bundle of 100 in-app coins" ``` 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, "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 ``` Zeichnen Sie Preis-ID für jeden Preis auf, sodass diese in nachfolgenden Schritten verwendet werden können. Die Preis-IDs sehen in etwa wie folgt 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" } ``` ## Kund/innen 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. Sie können [Angaben zur Zahlungsmethode speichern](https://docs.stripe.com/payments/save-during-payment.md?platform=checkout), damit Checkout die Zahlungsmethode automatisch den Kundinnen/Kunden zur zukünftigen Verwendung zuordnet. ## 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 (“Associated 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. ## Erstellen Sie eine Checkout-Sitzung [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 eine einmalige Zahlung oder ein Abonnement) - Ein `origin_context`, der auf `mobile_app` festgelegt ist, um sich für eine Nutzeroberfläche zu entscheiden, die für App-to-Web-Käufe optimiert ist. - 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. > Erstellen Sie die Checkout-Sitzung mit `origin_context: "mobile_app"`, um sich für eine Nutzeroberfläche zu entscheiden, die für App-to-Web-Käufe optimiert ist. 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. #### Einmalzahlung #### Node.js ```javascript // This example sets up an endpoint using the Express framework. const express = require('express'); const app = express(); 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', 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}!`)); ``` #### Subscription #### Node.js ```javascript // This example sets up an endpoint using the Express framework. const express = require('express'); const app = express(); 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', 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}!`)); ``` > [Apple Pay ist standardmäßig aktiviert](https://dashboard.stripe.com/settings/checkout) und wird automatisch in Checkout angezeigt, wenn ein Kunde/eine Kundin ein unterstütztes Gerät verwendet. Sie können zusätzliche Zahlungsmethoden akzeptieren, indem Sie [dynamische Zahlungsmethoden](https://docs.stripe.com/payments/payment-methods/dynamic-payment-methods.md) verwenden. ## 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/mobile/digital-goods/checkout.md#additional-testing-resources) weiter unten nach. ## 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 ``` ## Optional: In-App-Käufe mit Managed Payments Akzeptieren Sie Zahlungen mit Managed Payments, das viele Unternehmensfunktionen (wie Steuern und Zahlungsanfechtungen) in Ihrem Namen abwickeln kann. Erfahren Sie mehr darüber, wie Sie die Stripe-Lösung für eingetragene Händler/innen [Managed Payments verwenden](https://docs.stripe.com/payments/managed-payments/set-up-mobile.md). ## See also - [Rabatte hinzufügen](https://docs.stripe.com/payments/checkout/discounts.md) - [Steuern einziehen](https://docs.stripe.com/payments/checkout/taxes.md) - [Steuer-IDs erfassen](https://docs.stripe.com/tax/checkout/tax-ids.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)