StoreKit 2 Production Guide: Modern IAP with Async/Await

1import StoreKit
2 
3@Observable
4final class StoreVM {
5    var products: [Product] = []
6    var purchasedProductIDs: Set<String> = []
7 
8    func loadProducts() async throws {
9        let ids = ["com.myapp.pro.monthly", "com.myapp.pro.yearly", "com.myapp.coin.100"]
10        products = try await Product.products(for: ids)
11    }
12}

1struct Product {
2    let id: String
3    let displayName: String
4    let description: String
5    let price: Decimal
6    let displayPrice: String  // "$9.99" localized
7    let type: ProductType     // .consumable, .nonConsumable, .nonRenewable, .autoRenewable
8    let subscription: SubscriptionInfo?
9}

1extension StoreVM {
2    func purchase(_ product: Product) async throws {
3        let result = try await product.purchase()
4 
5        switch result {
6        case .success(let verification):
7            let transaction = try checkVerified(verification)
8            await handleTransactionCompletion(transaction)
9            await transaction.finish()
10 
11        case .pending:
12            // Waiting for family approval or Apple ID verification
13            break
14 
15        case .userCancelled:
16            break
17 
18        @unknown default:
19            break
20        }
21    }
22 
23    func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
24        switch result {
25        case .unverified(_, let error):
26            throw error
27        case .verified(let safe):
28            return safe
29        }
30    }
31}

1Task.detached {
2    for await update in Transaction.updates {
3        if case .verified(let transaction) = update {
4            await handleTransactionCompletion(transaction)
5            await transaction.finish()
6        }
7    }
8}

1// Node.js server
2import jwt from 'jsonwebtoken';
3import { X509Certificate } from 'node:crypto';
4 
5async function verifyJWS(signedPayload: string): Promise<TransactionInfo> {
6    const [headerB64] = signedPayload.split('.');
7    const header = JSON.parse(Buffer.from(headerB64, 'base64url').toString());
8 
9    // 1. Get Apple public keys from x5c chain
10    const certChain = header.x5c.map(c => new X509Certificate(Buffer.from(c, 'base64')));
11 
12    // 2. Verify chain against Apple Root CA (G3)
13    await verifyCertChain(certChain, APPLE_ROOT_CA_G3);
14 
15    // 3. Verify signature
16    const leafCert = certChain[0];
17    const publicKey = leafCert.publicKey;
18    const decoded = jwt.verify(signedPayload, publicKey, { algorithms: ['ES256'] });
19 
20    return decoded as TransactionInfo;
21}

1const response = await fetch(
2    `https://api.storekit.itunes.apple.com/inApps/v1/transactions/${transactionId}`,
3    {
4        headers: {
5            'Authorization': `Bearer ${generateJWT(APP_STORE_KEY_ID, ISSUER_ID)}`,
6        },
7    }
8);
9const { signedTransactionInfo } = await response.json();
10const transaction = await verifyJWS(signedTransactionInfo);

1let offer = product.subscription?.introductoryOffer
2 
3if let offer {
4    print("First (offer.period.formatted): (offer.displayPrice)")
5    // Show in UI: "First 7 days free, then $9.99/month"
6}

1// 1. Generate signature on server (offer defined in App Store Connect)
2let signedOffer = await myServer.signPromoOffer(
3    offerID: "winter_discount",
4    userUUID: currentUser.id
5)
6 
7// 2. Purchase with offer
8let result = try await product.purchase(options: [
9    .promotionalOffer(
10        offerID: signedOffer.id,
11        keyID: signedOffer.keyID,
12        nonce: signedOffer.nonce,
13        signature: signedOffer.signature,
14        timestamp: signedOffer.timestamp
15    )
16])

1let winbackOffers = product.subscription?.winBackOffers ?? []
2if let firstOffer = winbackOffers.first {
3    try await product.purchase(options: [.winBackOfferID(firstOffer.id)])
4}

1// Express webhook handler
2app.post('/apple/webhook', async (req, res) => {
3    const { signedPayload } = req.body;
4    const notification = await verifyJWS(signedPayload);
5 
6    switch (notification.notificationType) {
7        case 'SUBSCRIBED':
8            await grantEntitlement(notification);
9            break;
10        case 'DID_RENEW':
11            await extendEntitlement(notification);
12            break;
13        case 'DID_FAIL_TO_RENEW':
14            await warnUser(notification);
15            break;
16        case 'EXPIRED':
17            await revokeEntitlement(notification);
18            break;
19        case 'REFUND':
20            await processRefund(notification);
21            break;
22        case 'GRACE_PERIOD_EXPIRED':
23            await downgradeUser(notification);
24            break;
25    }
26 
27    res.status(200).send('OK');
28});

1let purchases = Transaction.currentEntitlements
2for await entitlement in purchases {
3    if case .verified(let transaction) = entitlement {
4        if transaction.ownershipType == .familyShared {
5            print("This purchase came via family sharing")
6        } else {
7            print("User purchased it themselves")
8        }
9    }
10}

1// iOS 15+ official Apple refund UI
2@Environment(\.requestReview) var requestReview
3@Environment(\.openURL) var openURL
4 
5// Refund request
6if let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene {
7    let result = try await Transaction.beginRefundRequest(
8        for: transactionID,
9        in: windowScene
10    )
11}

1case 'REFUND':
2    // notification.data.signedRenewalInfo → revoked
3    await db.transaction(async (tx) => {
4        await tx.update('entitlements', { status: 'refunded' });
5        await tx.insert('refund_log', { ... });
6    });
7    break;

1{
2    "products": [{
3        "id": "com.myapp.pro.monthly",
4        "type": "auto_renewable_subscription",
5        "displayPrice": "9.99",
6        "subscriptionGroupID": "pro_group"
7    }]
8}

1struct PaywallView: View {
2    @Environment(StoreVM.self) private var store
3    @State private var selectedProduct: Product?
4 
5    var body: some View {
6        VStack(spacing: 16) {
7            Text("Upgrade to Pro")
8                .font(.largeTitle)
9 
10            ForEach(store.products) { product in
11                ProductCard(
12                    product: product,
13                    isSelected: selectedProduct?.id == product.id
14                )
15                .onTapGesture { selectedProduct = product }
16            }
17 
18            Button {
19                Task {
20                    guard let product = selectedProduct else { return }
21                    try await store.purchase(product)
22                }
23            } label: {
24                Text("Purchase")
25                    .frame(maxWidth: .infinity)
26                    .padding()
27            }
28            .buttonStyle(.borderedProminent)
29 
30            Text("Cancel anytime")
31                .font(.caption)
32                .foregroundStyle(.secondary)
33        }
34        .padding()
35        .task { try? await store.loadProducts() }
36    }
37}