In-App Purchase (IAP) in iOS: Subscriptions, Consumables & One-Time Purchases

Introduction to Real-Time IAP Integration for iOS Applications

Challenges Identified

The client needed a secure and scalable In App Purchase (IAP) system tailored to support subscriptions, purchases, and feature gating. Key implementation areas were:

 Addressing Key Implementation Hurdles

1. Smooth IAP Integration During User Onboarding

• During registration, users are prompted to choose a subscription plan (Monthly, 6-Month, or Annual).
• Upon selection, users are directly guided into the IAP purchase flow using StoreKit-2.
• After successful payment, transaction data is stored securely through backend API integration.
• Real-time receipt validation and WebHook-based updates ensure users instantly receive access to their subscribed features.

2. Optimized Purchase Validation and System Performance

• Designed efficient transaction workflows for quick handling of purchases, renewals, and refunds.
• Used a combination of StoreKit-2 and server-side verification to validate each purchase.
• Enabled background processing for subscription updates using WebHooks, keeping user involvement minimal.

3. Adaptive Subscription Tier Management

• Developed support for dynamic plan changes (upgrade, downgrade) and cross-platform subscription recognition.
• Implemented a restore mechanism for users who reinstall the app, ensuring they regain access without hassle.
• Enabled background execution for all subscription operations to minimize user friction.

1. API & Webhook Integration for Real-Time Subscription Management

• Connected the app to the App Store via WebHook integration, receiving immediate updates on purchase-related events.
• Once a transaction completes, all related data (in JSON format) is saved in the backend using secured API calls.
• Optimized the IAP flow to handle all API interactions within one streamlined process, reducing response times and boosting performance.

2. Automated Subscription Checks & Dynamic Navigation

• Integrated real-time subscription status checks whenever the app is launched.
• Based on the user’s active status, they are automatically redirected to either the premium content or the subscription upgrade screen.
• Seamlessly handled transitions for expired, canceled, or new subscriptions with no manual input required.

3. Handling Renewals and Cancellations

• Built a dedicated renewAPI endpoint allowing users to renew subscriptions directly from the app interface.
• Cancellation options were also made available, with changes immediately reflected through WebHook updates.
• Re-subscribing users automatically regain access to all premium features without delay.

A) Make the subscription as unique using different IDs:

private let productIDs = [SubscriptionProduct.subscriptionIDMonthly, SubscriptionProduct.subscriptionIDHalfYearly,
SubscriptionProduct.subscriptionIDYearly]
public func getProducts(block: @escaping ([Product]?) -> Void){
if let products = localProducts, products.count > 0 ‹
block (products)
Return
do ‹
let products = try await Product.products(for: productIDs)
localProducts = products
block (products)
} catch {
print (error)
block (nil) } } }

This comprehensive iOS Swift/Objective C solution ensures that In App Purchase (IAP) flows are smooth, secure, and user-centric, while StoreKit-2 and WebHook integration enable real-time responsiveness, optimized access control, and seamless subscription management.

B) Handle the IAP processing flow with receipt verification:

private func handle(updatedTransaction verificationResult: VerificationResult<Transaction>) {

guard case verified(let transaction) = verificationResult else {
// Ignore unverified transactions.
Return
}
if let _ = transaction.revocationDate ‹
self.purchasedProductIDs.remove (transaction.productID)
} else if let expirationDate = transaction.expirationDate,
expirationDate ‹ Date() ‹
// Do nothing, this subscription is expired.
return
} else if transaction.isUpgraded ‹
// Do nothing, there is an active transaction
// for a higher level of service.
Return
} else {
self.purchasedProductIDs.insert(transaction.productID)
}
}

C)  Get the desired subscriptions:

private func getMonthlyProduct() -> Product? 1
let monthlyProduct = products.first(where: { (product) -> Bool in
product.id = SubscriptionProduct.subscriptionIDMonthly
})
return monthlyProduct
}
private func getHalfYearlyProduct() -> Product? {
let yearlyProduct = products.first(where: i (product) -> Bool in
product.id == SubscriptionProduct.subscriptionIDHalfYearly
return yearlyProduct
private func getYearlyProduct) →> Product? 1
let yearlyProduct = products.first(where: { (product) -> Bool in
product.id = SubscriptionProduct.subscriptionIDYearly
})
return yearlyProduct
}

D) Handle the failure case and subscription tracking based on certain events:

public func updatePurchasedProducts() async {
await withCheckedContinuation({ continuation in
FirebaseManager.shared.isFreeUser { [self] isFree in
isFreeUser = isFree
continuation.resume ()
})
for await result in Transaction.currentEntitlements {
guard case verified(let transaction) = result else {
Continue
}
if transaction.revocationDate == nil {
self.purchasedProductIDs.insert(transaction.productID)
} else &
self.purchasedProductIDs.remove(transaction.productID)
}
}
}
Private
func observeTransactionUpdates () → Task<Void, Never> {
Task(priority: background) { [unowned selfl in for await verificationResult in Transaction.updates ‹
handle (updatedTransaction: verificationResult)
}

E) Real-time IAP view in iOS.

IAP integration example

• Implemented logic to set the unique identifiers or ids for available subscriptions.
• Managed the in-app purchase flow with required validation and different navigation.
• Managed the selected subscription and available identifiers.
• Managed the failure case and subscription tracking.
• Real-time IAP process in iOS devices.

Scalability and Performance Best Practices

1. Webhook & API Rate Optimization for Subscription Handling

• Implemented load balancing across multiple API endpoints to distribute requests evenly and prevent service bottlenecks.
• Used API request batching and lazy data fetching to avoid excessive network usage, ensuring efficient webhook handling and subscription validation.

2. Optimized Subscription Validation & User Navigation

• Utilized automated subscription verification to ensure smooth user access without unnecessary API calls.
• Implemented progressive data retrieval for real-time subscription checks, minimizing app startup latency.
• Optimized navigation redirection based on subscription status, ensuring users are taken to the appropriate screen dynamically.

3. Efficient Subscription Renewal & Cancellation Processing

• Leveraged background transaction processing to reduce performance impact during renewals and cancellations.
• Used localized subscription validation to offload certain checks to the device when possible, reducing API dependency.
• Ensured seamless user experience by integrating automated revalidation mechanisms after a subscription is renewed or canceled.

These best practices ensure scalability, performance optimization, and minimal latency, providing a seamless and efficient IAP experience.