In-App Purchases

Introduction to StoreKit 2

StoreKit 2 is Apple's modern framework for in-app purchases, introduced in iOS 15. It provides a simpler, more reliable API compared to the original StoreKit framework.

Product Types

Apple supports four product types:

Setting Up Products in App Store Connect

1. Navigate to your app in App Store Connect
2. Go to In-App Purchases section
3. Click the plus button to create a new product
4. Choose the product type
5. Set a unique Product ID (e.g., com.yourapp.coins100)
6. Set pricing and metadata

Basic StoreKit 2 Implementation

import StoreKit

@Observable
class StoreManager {
    var products: [Product] = []
    var purchasedProductIDs: Set<String> = []
    
    let productIDs: Set<String> = [
        "com.yourapp.coins100",
        "com.yourapp.pro",
        "com.yourapp.removeads"
    ]
    
    func loadProducts() async {
        do {
            products = try await Product.products(for: productIDs)
                .sorted(by: { $0.price < $1.price })
        } catch {
            print("Failed to load products: \(error)")
        }
    }
    
    func purchase(_ product: Product) async throws -> Transaction? {
        let result = try await product.purchase()
        
        switch result {
        case .success(let verification):
            let transaction = try checkVerified(verification)
            await updatePurchasedProducts()
            return transaction
        case .userCancelled:
            return nil
        case .pending:
            return nil
        @unknown default:
            return nil
        }
    }
}

Verifying Transactions

StoreKit 2 uses Swift result types to verify transactions:

func checkVerified<T>(_ result: VerificationResult<T>) throws -> T {
    switch result {
    case .unverified(_, let error):
        throw StoreError.failedVerification(error)
    case .verified(let value):
        return value
    }
}

Listening for Transaction Updates

func listenForTransactions() -> Task<Void, Error> {
    return Task.detached {
        for await result in Transaction.updates {
            do {
                let transaction = try self.checkVerified(result)
                await self.updatePurchasedProducts()
                await transaction.finish()
            } catch {
                print("Transaction failed verification: \(error)")
            }
        }
    }
}

Complete Purchase Flow

A robust purchase flow handles success, failure, and edge cases:

@Observable
class PurchaseManager {
    var isLoading = false
    var purchaseError: String?
    var showPurchaseAlert = false
    
    func purchaseProduct(_ product: Product) async {
        isLoading = true
        defer { isLoading = false }
        
        do {
            let result = try await product.purchase()
            
            switch result {
            case .success(let verification):
                let transaction = try checkVerified(verification)
                await handleSuccessfulPurchase(transaction)
                await transaction.finish()
                
            case .userCancelled:
                break
                
            case .pending:
                purchaseError = "Purchase is pending. Check back later."
                showPurchaseAlert = true
                
            @unknown default:
                break
            }
        } catch {
            purchaseError = error.localizedDescription
            showPurchaseAlert = true
        }
    }
    
    private func handleSuccessfulPurchase(_ transaction: Transaction) async {
        switch transaction.productType {
        case .consumable:
            await addConsumableBalance(transaction)
        case .nonConsumable:
            await unlockFeature(transaction.productID)
        case .autoRenewable:
            await activateSubscription(transaction)
        default:
            break
        }
    }
}

Consumable Purchases

Consumable products are used up and can be repurchased:

func addConsumableBalance(_ transaction: Transaction) async {
    let productID = transaction.productID
    let amounts: [String: Int] = [
        "com.yourapp.coins100": 100,
        "com.yourapp.coins500": 500,
        "com.yourapp.coins1000": 1000
    ]
    if let amount = amounts[productID] {
        await gameState.addCoins(amount)
    }
}

Restoring Purchases

Users can restore previous purchases on new devices:

func restorePurchases() async {
    for await result in Transaction.currentEntitlements {
        if case .verified(let transaction) = result {
            await handleSuccessfulPurchase(transaction)
            await transaction.finish()
        }
    }
}

Handling Pending Transactions

Some purchases require parental approval:

func checkPendingTransactions() async {
    for await result in Transaction.pendingEntitlements {
        if case .verified(let transaction) = result {
            notificationManager.showPendingPurchase(transaction.productID)
        }
    }
}

Why Validate Receipts?

Receipt validation ensures that purchases are legitimate and prevents fraud. Apple recommends server-side validation for security.

Server-Side Validation

For production apps, validate receipts on your server:

struct ReceiptValidator {
    let serverURL: URL
    
    func validate(_ receipt: String) async throws -> ReceiptStatus {
        var request = URLRequest(url: serverURL)
        request.httpMethod = "POST"
        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
        
        let body = [
            "receipt": receipt,
            "password": "your-shared-secret"
        ]
        request.httpBody = try JSONSerialization.data(withJSONObject: body)
        
        let (data, _) = try await URLSession.shared.data(for: request)
        let response = try JSONDecoder().decode(ReceiptResponse.self, from: data)
        
        return response.status == 0 ? .valid : .invalid
    }
}

enum ReceiptStatus {
    case valid
    case invalid
    case expired
}

Shared Secret

The shared secret is used for auto-renewable subscription validation:

1. Go to App Store Connect > App > App Information
2. Find the Shared Secret section
3. Generate or view the shared secret
4. Use it in server-side validation requests

Common Validation Errors

Best Practices

• Always validate receipts server-side in production
• Use the shared secret for subscription validation
• Handle network failures gracefully
• Cache validation results locally
• Implement retry logic for transient errors