Managing In-App Purchases in your apps
Discover the possible ways to monetize your app with the native tools provides by Apple with StoreKit 2.
It starts with an idea. Then sketch, design, and code it to bring it to life. You test it, validate it, make sure it solves a real problem or is fun to use, and then you publish it on the store. Even though that’s an oversimplification of the process, that kind of describes how an app might come into existence. Once an application is on the store and people are downloading and using it, the next phase of an app’s lifecycle begins: Maintaining and evolving it.
Users start giving feedback on how it could be better, or new features that would make it even more powerful. Bugs and crashes start popping up here and there and need to be addressed. Every year, new updates to the operational system are announced, bringing new technologies and frameworks enabling possibilities that weren’t possible when you envisioned the app in the first place.
As a developer, monetizing an application enables its continuous development and sustains the app’s long-term evolution. Some apps can survive as a free app on the store, but if you plan to continue working on the app, you need to be able to pay your bills, or at least the developer membership annual fee.
The App Store supports different In-App purchase models, and there are proper ways to implement them in your app. Let’s explore the options Apple offers developers for monetizing their applications.
In-App-Purchases
Most of the apps considered successful on the App Store use a freemium business model, meaning they are free to download, but users must pay within the app to access some features. There are two different categories of in-app purchases:
- One-Time-Purchases
- Subscriptions
To configure your In-App purchases, no coding is required to get started. You can head over to App Store Connect, select one of your apps and click on the section called "In-App-Purchases". Here you can configure your On-Time-Purchases. Subscriptions are configured in the “Subscriptions” section.
One-Time-Purchases can be split into subcategories: Non-Consumable In-App-Purchases and Consumable In-App-Purchases.
Non-Consumable In-App-Purchases
A user buys a feature or set of features inside an app, pays for it one time and can use this feature throughout the lifecycle of the app. This type of purchase gives users the flexibility to choose which features they actually need.
Let’s say you are building a photo editing app and the user can use all the features to edit the photo for free. At the end, when he wants to export the photo, the app puts a small watermark in the corner. Here, the developer could implement a Non-Consumable In-App-Purchase to let the user remove the watermark on all future exports.
Another use case is offering a lifetime “subscription” for people who don’t like subscriptions. Developers typically charge 2-3 times the annual subscription price, and users can then unlock all features for the lifetime of the app.
Consumable In-App-Purchases
The user buys an item that can be used once and must be purchased again after it runs out. The most popular use cases are power-ups or coins in games or gamified apps.
For example, in Duolingo, users consume energy each time they complete a lesson. When the energy reaches zero, the user has two options: either wait for it to refill over time or spend a premium currency (“gems”) to refill it. These gems are purchased as Consumable In-App Purchases in various quantities. Users can then spend this currency to refill energy as needed.
Subscriptions
From a business perspective, the problem with one-time purchases is their lack of reliable Monthly Recurring Revenue (MRR). The developer must rely on unpredictable one-time sales, which makes revenue less stable and risky. That’s why many developers usually choose to monetize their apps through subscriptions.
Subscriptions can be split into two sub-categories:
- Non-renewing subscriptions
- Auto-renewable subscriptions
Non-renewing subscriptions
The Non-renewing subscription type is a good way to give users a first impression of what your app offers before committing to a long-term subscription.
For example, imagine you build a habit-tracking application and want to give your users a way to understand whether the methods you use actually help them build a habit. To nudge them into making their first purchase, you could offer a monthly Non-renewing subscription for a slightly higher price, to balance the flexibility they get with the absence of automatic renewal.
Let’s say a user is convinced, and your app helped them build a healthy reading habit. Now you can introduce an auto-renewal subscription to convert them into a recurring revenue user.
Auto-renewable subscriptions
Most apps split their Auto-renewable subscriptions into monthly and yearly plans. If we stay with our habit tracker app example from before, you could now offer the user an upgrade. For example, you might offer an Auto-renewable Monthly Subscription that is priced 20% lower than the non-renewing version.
Alongside this, you could offer a yearly auto-renewable plan with a larger discount, often around 30% compared to the monthly Non-renewing price, to encourage long-term commitment.
This pricing structure benefits both sides: users get a better deal, while the developer benefits from predictable, stable long-term revenue.
Each type of In-App Purchase serves a different purpose, and choosing the right model depends on your app’s features, your business goals, and how your users gain value from your product. Non-Consumables are ideal for permanent unlocks, Consumables work well for repeatable actions, and subscriptions offer the most predictable long-term revenue.
Understanding these models provides the foundation for later implementing your In-App purchases with StoreKit 2 inside the app, designing upgrade flows, and crafting a sustainable monetization strategy.
The session Meet StoreKit for SwiftUI from WWDC 2023 gives an excellent overview of the implementation of merchandising in-app purchases within a SwiftUI application and the session What’s new in StoreKit and In-App Purchase from WWDC 2024 introduces the latest features StoreKit 2 has to offer.