Adding In-App Purchases: A Step-by-Step Guide to Implementation in Mobile Apps

Introduction

In-app purchases (IAPs) are a powerful way to monetize mobile applications. Whether you’re selling digital content, unlocking premium features, or offering subscriptions, in-app purchases provide a seamless and scalable method for generating revenue. But implementing IAPs involves more than just dropping a button into your UI—it requires careful integration with platform-specific APIs, proper product setup, and strict compliance with store guidelines.

In this comprehensive guide, you’ll learn how to implement in-app purchases step by step for iOS and Android. We’ll cover types of purchases, best practices, and the key steps for setting up a smooth, secure purchase flow in your mobile app.

What Are In-App Purchases?

In-app purchases (IAPs) allow users to buy digital goods or services directly within your mobile application. These purchases are handled by the respective app store’s billing system:

• Apple’s In-App Purchase (StoreKit)
• Google Play Billing

Types of In-App Purchases:

1. Consumables – One-time use (e.g., coins, tokens)
2. Non-Consumables – Permanent unlocks (e.g., remove ads, premium themes)
3. Subscriptions – Recurring charges (e.g., monthly plans, annual memberships)

Step 1: Plan Your Monetization Strategy

Before implementing IAPs, define what you’re selling and how it fits into your user experience.

Key Considerations:

• Is it a one-time purchase or subscription?
• Will users need to restore purchases later?
• Are you targeting both iOS and Android?

Clearly identify SKUs (product identifiers), pricing tiers, and purchase flows.

Step 2: Set Up Products in the App Stores

For iOS (App Store Connect):

1. Log in to App Store Connect
2. Select My Apps > Your App
3. Go to Features > In-App Purchases
4. Click + and choose a purchase type
5. Enter the required information:
   • Reference name
   • Product ID (used in your code)
   • Pricing
   • Description
6. Submit for review (IAPs must be reviewed like apps)

For Android (Google Play Console):

1. Go to Google Play Console
2. Select your app > Monetize > Products
3. Click In-app Products
4. Add a new product with:
   • Product ID
   • Title & description
   • Pricing
5. Save and activate the product

Step 3: Integrate the SDK

You’ll need to use the platform’s SDK or a cross-platform solution.

iOS – StoreKit (Swift)

swiftCopyEditimport StoreKit

func fetchProducts() {
    let request = SKProductsRequest(productIdentifiers: ["com.yourapp.premium"])
    request.delegate = self
    request.start()
}

Android – Google Play Billing Library (Kotlin)

kotlinCopyEditval billingClient = BillingClient.newBuilder(this)
    .enablePendingPurchases()
    .setListener(purchasesUpdatedListener)
    .build()

Cross-Platform Options:

• React Native: react-native-iap
• Flutter: in_app_purchase
• Unity: Unity IAP

These libraries provide a unified API for iOS and Android.

Step 4: Display Products in Your App

Fetch product metadata (like title and price) from the app store and show it in your UI.

Example (React Native):

javascriptCopyEditconst items = await RNIap.getProducts(['com.yourapp.premium']);

Display the product list in a modal or settings screen with a purchase button.

Step 5: Handle the Purchase Process

Initiate the transaction when the user taps the purchase button.

iOS (Swift):

swiftCopyEditlet payment = SKPayment(product: selectedProduct)
SKPaymentQueue.default().add(payment)

Android (Kotlin):

kotlinCopyEditval flowParams = BillingFlowParams.newBuilder()
    .setSkuDetails(skuDetails)
    .build()
billingClient.launchBillingFlow(this, flowParams)

Handle purchase responses, update UI, and unlock features accordingly.

Step 6: Validate and Acknowledge Purchases

Always verify purchases server-side to prevent fraud.

iOS:

• Use Apple’s receipt validation endpoint
• Include the receipt data from Bundle.main.appStoreReceiptURL

Android:

• Acknowledge purchases using the Google Play Developer API
• Unacknowledged purchases may be refunded automatically

Step 7: Restore Purchases (for Non-Consumables)

Users may delete and reinstall your app. Allow them to restore purchases.

iOS:

swiftCopyEditSKPaymentQueue.default().restoreCompletedTransactions()

Android:

Use BillingClient.queryPurchasesAsync() to fetch previously owned items.

Step 8: Test In-App Purchases

iOS:

• Use Sandbox Testers from App Store Connect
• Log in on a test device with a sandbox Apple ID

Android:

• Upload your app to internal testing track
• Use a license tester Google account

Always test each scenario:

• First-time purchase
• Cancelled transaction
• Invalid payment
• Restore flow

Best Practices for IAP Implementation

• Clearly communicate pricing and benefits
• Use localized pricing when displaying product info
• Secure communication between your app and backend
• Handle edge cases: payment failure, interrupted transactions
• Respect platform rules—don’t try to bypass in-app billing for digital goods

Real-World Use Case: Unlocking a Premium Feature

You offer a “Pro Mode” that removes ads and unlocks advanced tools.

1. Create a non-consumable product: com.yourapp.pro
2. Display a “Go Pro” button in the app
3. On purchase, store the entitlement (e.g., in UserDefaults or SharedPreferences)
4. Remove ads and unlock features
5. Restore on reinstall/login

Conclusion

In-app purchases provide a flexible and powerful monetization path for mobile apps. With the right setup and careful testing, you can deliver a seamless purchase experience that increases revenue while respecting user trust and platform guidelines.

Whether you’re offering consumables, lifetime unlocks, or subscription-based content, the steps outlined here will help you confidently implement IAPs and optimize your app’s revenue model.