Accept payments for digital products on iOS with Stripe as your merchant of record
Open Stripe Checkout with Managed Payments in a browser to sell in-app digital products or subscriptions.
Terms of service required
You must accept the Managed Payments terms of service in the Dashboard before you can use Managed Payments.
In some countries, you can link to an external website to accept payments using Managed Payments on iOS. You use Stripe Checkout to redirect your customers to a Stripe-hosted payment page. As an example, this guide describes how to sell digital credits for use in your app. You can accept both one-time or subscription payments.
The UI customers see for one-time payments with Managed Payments
The UI customers see for subscription payments with Managed Payments
How it works
The following diagram shows the full app-to-web payment flow at a high level:
Limitations
This guide doesn’t cover:
- User authentication. If you don’t have an existing authentication provider, you can use a third-party provider, such as Sign in with Apple or Firebase Authentication .
- Native in-app purchases. To implement in-app purchases using StoreKit, visit Apple’s in-app purchase guide .
This guide only describes the process for selling in-app digital products that follow this eligibility criteria. If your digital products don’t match this criteria, see Accept payments for digital goods on iOS. If you sell physical products, see Stripe in-app payments.
Before you begin
- Make sure your products meet the eligibility requirements for Managed Payments. To process a payment with Managed Payments, all of the products the customer is purchasing must be eligible.
- Activate Managed Payments in your Dashboard .
- Set up your development environment .
- Use an API version of 2025-03-31. basil or later .
Create products and prices
Create your products and their prices in the Dashboard or with the Stripe CLI. You can add digital products with one-off prices and subscriptions using recurring prices. You can also let your customer pay what they want (for example, to decide how many credits to buy), by selecting Customers choose what to pay. When you create your Product, the tax code you select must be eligible for Managed Payments. Eligible tax codes are labelled Eligible for Managed Payments.
This example uses a single product and price to represent a 100 coin bundle that costs 10 USD.
Go to the Add a product page and create the coin bundle. Add a one-time price of US$10. Select txcd_10201000 for the tax code Video Games - downloaded - non subscription - with permanent rights tax code.
- 100 coins: Bundle of 100 in-app coins
- Price: Standard model | 10 USD | One-time | txcd_10201000
After you create the price, record the price ID so you can use it in subsequent steps. Price IDs look like this: price_G0FvDp6vZvdwRZ.
When you’re ready, click Copy to live mode to clone your product from a testing environment to live mode.
Create customers Server-side
Each time you create a Checkout session, create a Customer object for your user if one doesn’t already exist.
Node.js
// 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')('sk_test_Ou1w6LVt3zmVipDVJsvMeQsc');
// 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;
}
Warning
Make sure to store an association on your server between the user account and the Stripe customer ID. Without a way to associate a customer with a purchase, your customers can’t recover their purchases.
If your app doesn’t have an existing authentication provider, you can use Sign in with Apple.
Use the customer argument to pass their Customer ID when creating a Checkout Session. This ensures that all objects created during the session associate with the correct Customer object.
Set up universal links Client-side Server-side
Universal links allow Checkout to deep link into your app. To configure a universal link:
- Add an apple-app-site-association file to your domain.
- Add an Associated Domains Entitlement to your app.
- Add a fallback page for your Checkout redirect URLs.
Define the associated domains
Add a file to your domain at .well-known/apple-app-site-association to define the URLs your app handles. Prepend your App ID with your Team ID, which you can find on the Membership page of the Apple Developer Portal.
.well-known/apple-app-site-association
{
"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"
}
]
}
]
}
}
You must serve the file with the related setting type application/json. Use curl -I to confirm the content type.
Command Line
See Apple’s page on supporting associated domains for more details.
Add an Associated Domains entitlement to your app
- Open the Signing & Capabilities pane of your app’s target.
- Click + Capability , then select Associated Domains .
- Add an entry for applinks:example. com to the Associated Domains list.
For more information on universal links, see Apple’s Universal Links for Developers page.
Although iOS intercepts links to the URLs defined in your apple-app-site-association file, you might encounter situations where the redirect fails to open your app.
Make sure to create a fallback page at your success_url. For example, you can define a custom URL scheme for your app and use it to link back in case the universal link fails.
Create a Checkout session Server-side
A Checkout Session is the programmatic representation of what your customer sees when they’re redirected to the payment form. Checkout Sessions expire 24 hours after creation. Configure it with:
- The customer ID
- The product ID (either a one-time payment or subscription)
- An origin _ context set to mobile _ app to opt in to a UI that’s optimised for app-to-web purchases.
- The managed _ payments[enabled] parameter to true
- A success _ url , a universal link to redirect your customer to your app after they complete the payment.
After creating a Checkout Session, return the URL from the response to your app.
Node.js
Open Checkout in Safari Client-side
Add a checkout button to your app. This button:
- Calls your server-side endpoint to create a Checkout session.
- Returns the Checkout session to the client.
- Opens the session URL in Safari.
CheckoutView.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
}
}
}
}
}
}
Fetch the Checkout URL on the client
Use your server endpoint to fetch the checkout session.
CheckoutView.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()
}
}
Handle order fulfilment Server-side
After the purchase succeeds, Stripe sends you a checkout.session.completed webhook. When you receive this event, you can add the coins to the customer on your server.
Checkout redirects your customer to the success_url when you acknowledge you received the event. In scenarios where your endpoint is down or the event isn’t acknowledged properly, Checkout redirects the customer to the success_url 10 seconds after a successful payment.
For testing purposes, you can monitor events in the Dashboard or using the Stripe CLI. For production, set up a webhook endpoint and subscribe to appropriate event types. If you don’t know your the related setting key, click the webhook in the Dashboard to view it.
server.js
Node.js
// 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')('sk_test_Ou1w6LVt3zmVipDVJsvMeQsc');
app.post("/webhook", async (req, res) => {
let data;
let eventType;
// Check if webhook signing is configured.
const webhookSecret = "{{STRIPE_WEBHOOK_SECRET}}"
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);
});
Testing
Test your checkout button that redirects your customer to Stripe Checkout.
- Click the checkout button, which redirects you to the Stripe Checkout payment form.
- Enter the test number , a three-digit CVC, a future expiry date, and any valid postal code.
- Tap Pay .
- The checkout. session. completed webhook fires, and Stripe notifies your server about the transaction.
- You’re redirected back to your app.
If your integration isn’t working, see the additional testing resources section below.
Payment details
- After you confirm the test payment, go to the Dashboard > Transactions
- Click your test payment to view the payment details. This page shows the:
- Product that was purchased
- Subscription that was created
- Invoice that was created
- Amount of tax calculated and withheld through Managed Payments
- Statement descriptor that displays on your customer’s statements
Customer authorisation
When a customer purchases a subscription through Managed Payments, it only authorises their payment method to be charged by Managed Payments. Make sure you obtain the appropriate consent from your customer to charge this payment method for any transactions outside of Managed Payments.
Preview the receipt
- Under Receipt history , click View receipt .
- Click Send receipt to preview the receipt email sent to your customer.
Note
In sandbox mode, you won’t receive email receipts automatically after a purchase. Send them manually using the instructions above.
Link
Link acts as the merchant of record at checkout and provides subscription management and transaction support on the Link website.
You can test how Link works during checkout by creating a Link account during an initial Checkout Session. After you create the Link account, attempt another session using the same email address. To authenticate, use the test passcode 000000.
Test purchases won’t appear in the Link app. You can test the order management tools in the Link app by creating a Link account during a live mode Checkout Session.