Mobile App Monetization and In-App Purchases Cheat Sheet

Updated 2026-05-16

Next Topic: Mobile App Navigation Patterns Cheat Sheet

🧠Study flashcards on this topic85 cards · spaced repetition→

Mobile app monetization encompasses the complete revenue infrastructure for apps—from in-app purchases and subscriptions managed through StoreKit 2 (iOS) and Google Play Billing Library (Android) to ad-based models and hybrid strategies. Unlike web commerce, mobile monetization requires navigating platform-specific billing APIs, server-side validation protocols, and complex lifecycle states (grace periods, billing retry, account hold). The shift toward subscriptions as the dominant model demands expertise in paywall design, cohort retention analysis, and continuous A/B testing of pricing tiers, while ad-integrated apps layer rewarded video, interstitial, and native formats atop purchase flows. A key insight: server-side receipt validation is non-negotiable—client-only verification invites fraud that can collapse revenue overnight, while real-time webhook notifications from App Store Server Notifications V2 and Google Play RTDN enable instant entitlement updates that prevent unauthorized access and improve user experience.

What This Cheat Sheet Covers

This topic spans 13 focused tables and 87 indexed concepts, 85 flashcards. Below is a complete table-by-table outline of this topic, spanning foundational concepts through advanced details.

Table 1: StoreKit 2 Core Components (iOS)Table 2: Google Play Billing Library Core Methods (Android)Table 3: In-App Purchase Product TypesTable 4: Subscription Lifecycle StatesTable 5: Server-Side Receipt Validation PatternsTable 6: Paywall Design PatternsTable 7: Promotional Offers and DiscountsTable 8: Subscription Metrics and AnalyticsTable 9: Ad Monetization FormatsTable 10: Ad Mediation StrategiesTable 11: Platform Commission FeesTable 12: Testing and DebuggingTable 13: Subscription Management Features

Quick IndexSubscribe to unlock

A jump-to index of every table row in this cheat sheet.

Mind MapSubscribe to unlock

An interactive map of every table and concept in this topic.

Table 1: StoreKit 2 Core Components (iOS)

StoreKit 2 is Apple's modern async/await purchase API, and these are the pieces you reach for constantly—loading a Product, processing a cryptographically signed Transaction, and reading currentEntitlements to decide what to unlock. The thread running through every row is trust: only act on .verified results, and always finish() a transaction so the store stops re-delivering it.

Component	Example	Description
Product	`let products = try await Product.products(for: ["com.app.monthly"])` `let product = products.first`	• Represents an in-app purchase or subscription • loaded from App Store Connect via product IDs • includes localized title, description, and price
Transaction	`for await result in Transaction.updates {` `if case .verified(let transaction) = result {` `await transaction.finish()` `}` `}`	• Cryptographically signed record of a purchase or subscription event • must call `finish()` after processing to acknowledge receipt • monitor `Transaction.updates` for real-time changes
Purchase	`let result = try await product.purchase()` `switch result {` `case .success(let verification): ...` `case .userCancelled: ...` `case .pending: ...` `}`	• Initiates the App Store purchase flow • returns a `PurchaseResult` enum indicating success, cancellation, or pending approval (e.g., Ask to Buy).
Product.SubscriptionInfo	`if let info = product.subscription {` `let group = info.subscriptionGroupID` `let period = info.subscriptionPeriod` `}`	• Metadata for auto-renewable subscriptions • provides subscription group ID, period (weekly/monthly/yearly), and introductory offer eligibility
currentEntitlements	`for await result in Transaction.currentEntitlements {` `if case .verified(let tx) = result {` `// Grant access` `}` `}`	• Asynchronous sequence of active, verified transactions • use at app launch to restore purchases and determine which content to unlock • filters out expired or revoked transactions
VerificationResult	`if case .verified(let transaction) = result {` `// Safe to trust` `} else {` `// Jailbroken device or tampered data` `}`	• Wraps transactions with cryptographic validation • only process `.verified` cases to prevent fraud • `.unverified` indicates potential device compromise
AppStore.sync()	`try await AppStore.sync()`	• Force-syncs the local receipt with the App Store • useful after account changes, but most apps should rely on automatic syncing via `Transaction.updates` instead
StoreView	`StoreView(ids: ["com.app.monthly", "com.app.yearly"])` `.storeButton(.visible, for: .redeemCode)`	• SwiftUI view that displays products with native App Store UI • minimal customization but zero implementation effort • ideal for simple paywalls
SubscriptionStoreView	`SubscriptionStoreView(groupID: "ABC123") {` `Text("Example Content")` `}` `.subscriptionStoreControlStyle(.prominentPicker)`	• SwiftUI view for subscription-specific paywalls • auto-generates UI for all products in a subscription group • supports introductory offer badges and legal text rendering without manual coding

Table 2: Google Play Billing Library Core Methods (Android)

Android's purchase flow is a state machine you drive method by method: connect the BillingClient, query product details, launch the billing flow, then acknowledge or consume whatever comes back. Two pitfalls dominate this table—you must acknowledgePurchase within three days or Google auto-refunds, and you must check isReady before any call since the connection can silently drop mid-session.

Method	Example	Description
startConnection	`billingClient.startConnection(object : BillingClientStateListener {` `override fun onBillingSetupFinished(result: BillingResult) {` `if (result.responseCode == BillingResponseCode.OK) { ... }` `}` `})`	• Establishes connection to Google Play Billing • must complete successfully before querying products or launching purchases • retry on failure with exponential backoff

The rest of this section is part of the full cheat sheet

Table 3: In-App Purchase Product Types

Every IAP you ship falls into one of these four buckets, and picking the right one shapes everything downstream—how you grant the benefit, whether the user can buy again, and how the stores handle it. Consumables deplete and can be repurchased, non-consumables are owned forever, and auto-renewable subscriptions now drive the majority of revenue while their non-renewing legacy cousin has all but disappeared.

Type	Example	Description
Consumable	In-game currency pack: `let result = try await product.purchase()` `// After granting currency:` `await transaction.finish()`	• Depletes with use and can be purchased repeatedly • user consumes the benefit (e.g., 100 coins) then can buy again • requires server-side tracking to prevent duplication fraud

The rest of this section is part of the full cheat sheet

Table 4: Subscription Lifecycle States

A subscription is never just "on" or "off"—it moves through a sequence of states as payments succeed, fail, and retry, and your app has to grant or revoke access correctly at each one. The states between active and expired (grace period, billing retry, account hold, paused) are where most involuntary churn hides, so understanding who still has access during each phase is what separates a clean integration from a leaky one.

State	Example	Description
Active	User subscribed, payment succeeded: `if purchase.purchaseState == PurchaseState.PURCHASED {` `grantAccess()` `}`	• Subscription is paid and user has full access • both iOS and Android update entitlements immediately • remains active until expiration or cancellation

The rest of this section is part of the full cheat sheet

Table 1: StoreKit 2 Core Components (iOS)

Component	Example	Description
Product	`let products = try await Product.products(for: ["com.app.monthly"])` `let product = products.first`	• Represents an in-app purchase or subscription • loaded from App Store Connect via product IDs • includes localized title, description, and price
Transaction	`for await result in Transaction.updates {` `if case .verified(let transaction) = result {` `await transaction.finish()` `}` `}`	• Cryptographically signed record of a purchase or subscription event • must call `finish()` after processing to acknowledge receipt • monitor `Transaction.updates` for real-time changes
Purchase	`let result = try await product.purchase()` `switch result {` `case .success(let verification): ...` `case .userCancelled: ...` `case .pending: ...` `}`	• Initiates the App Store purchase flow • returns a `PurchaseResult` enum indicating success, cancellation, or pending approval (e.g., Ask to Buy).
Product.SubscriptionInfo	`if let info = product.subscription {` `let group = info.subscriptionGroupID` `let period = info.subscriptionPeriod` `}`	• Metadata for auto-renewable subscriptions • provides subscription group ID, period (weekly/monthly/yearly), and introductory offer eligibility
currentEntitlements	`for await result in Transaction.currentEntitlements {` `if case .verified(let tx) = result {` `// Grant access` `}` `}`	• Asynchronous sequence of active, verified transactions • use at app launch to restore purchases and determine which content to unlock • filters out expired or revoked transactions
VerificationResult	`if case .verified(let transaction) = result {` `// Safe to trust` `} else {` `// Jailbroken device or tampered data` `}`	• Wraps transactions with cryptographic validation • only process `.verified` cases to prevent fraud • `.unverified` indicates potential device compromise
AppStore.sync()	`try await AppStore.sync()`	• Force-syncs the local receipt with the App Store • useful after account changes, but most apps should rely on automatic syncing via `Transaction.updates` instead
StoreView	`StoreView(ids: ["com.app.monthly", "com.app.yearly"])` `.storeButton(.visible, for: .redeemCode)`	• SwiftUI view that displays products with native App Store UI • minimal customization but zero implementation effort • ideal for simple paywalls
SubscriptionStoreView	`SubscriptionStoreView(groupID: "ABC123") {` `Text("Example Content")` `}` `.subscriptionStoreControlStyle(.prominentPicker)`	• SwiftUI view for subscription-specific paywalls • auto-generates UI for all products in a subscription group • supports introductory offer badges and legal text rendering without manual coding

Table 2: Google Play Billing Library Core Methods (Android)

Method	Example	Description
startConnection	`billingClient.startConnection(object : BillingClientStateListener {` `override fun onBillingSetupFinished(result: BillingResult) {` `if (result.responseCode == BillingResponseCode.OK) { ... }` `}` `})`	• Establishes connection to Google Play Billing • must complete successfully before querying products or launching purchases • retry on failure with exponential backoff

Table 3: In-App Purchase Product Types

Type	Example	Description
Consumable	In-game currency pack: `let result = try await product.purchase()` `// After granting currency:` `await transaction.finish()`	• Depletes with use and can be purchased repeatedly • user consumes the benefit (e.g., 100 coins) then can buy again • requires server-side tracking to prevent duplication fraud

Table 4: Subscription Lifecycle States

State	Example	Description
Active	User subscribed, payment succeeded: `if purchase.purchaseState == PurchaseState.PURCHASED {` `grantAccess()` `}`	• Subscription is paid and user has full access • both iOS and Android update entitlements immediately • remains active until expiration or cancellation