Skip to content
← All articlesMobile Apps

In-App Purchases and Subscriptions: A Mobile App Guide

How to plan in-app purchases and subscriptions for iOS and Android: billing rules, server-side validation, entitlements, testing and what to brief your developers.

Adding a paywall looks simple on a roadmap: one screen, one button, one price. In practice, in-app purchases and subscriptions touch the app, your backend, two store platforms, your analytics and your support process. Teams that treat billing as “just a screen” usually ship late, then spend months fixing edge cases such as missing access after a renewal or users charged twice.

This guide is for founders, product managers and CTOs who are planning monetisation for an iOS and Android app, or briefing an outsourced team to build it.

Start with the rules, not the code

If your app sells digital goods or features that are consumed inside the app, Apple and Google generally require you to use their own billing systems (Apple’s StoreKit and Google Play Billing). Physical goods and real-world services, such as a delivery or a taxi ride, are normally handled with a normal payment gateway instead. Rules differ by region and change over time, so check the current App Store Review Guidelines and Google Play policies before you design the flow.

Our guide to App Store review guidelines covers the common rejection reasons, and billing mistakes are on that list. If you also take card payments for non-digital goods, see our payment gateway integration guide.

Choose the right product type

Both stores offer a similar set of product types. Pick the one that matches how the user receives value.

Product type What the user gets Typical use
Consumable Something used up and bought again Credits, coins, boosts
Non-consumable A one-time permanent unlock Remove ads, premium feature
Auto-renewing subscription Ongoing access, billed on a cycle SaaS-style apps, content, fitness
Non-renewing subscription Fixed-period access with no automatic renewal Seasonal passes (mainly iOS)

Subscriptions bring recurring revenue but also recurring obligations: renewals, cancellations, grace periods, refunds and clear communication with the user. Do not choose a subscription just because it is fashionable. Choose it when the user genuinely receives value continuously.

Architecture: the server is the source of truth

The most common design mistake is trusting the app alone to decide whether a user has paid. A modified or jailbroken device can fake a purchase result. A reliable design works like this:

  1. The app starts the purchase through StoreKit or Play Billing.
  2. The store returns a purchase token or signed transaction.
  3. The app sends it to your backend.
  4. Your backend verifies it with the store’s server API.
  5. The backend records an entitlement (what the user is allowed to access) against the user’s account.
  6. The app reads entitlements from your backend, not from local state alone.

Then keep the entitlement current using server notifications. Apple offers App Store Server Notifications and Google offers Real-time developer notifications. They tell your backend about renewals, expirations, refunds and billing problems even when the user never opens the app.

You can build all of this yourself, or use a third-party subscription management service to reduce the work. That is a build-versus-buy question; our build vs buy decision guide gives a framework. If you buy, check pricing, data ownership and exit options before you commit.

Edge cases to plan for from day one

Most billing bugs are not in the happy path. Put these in the requirements document:

  • Restore purchases. Users who reinstall or change phones must be able to recover access. Apple expects a visible restore option for relevant products.
  • Cross-platform accounts. A user who subscribes on iOS and logs in on Android should have access if your product promises it. That requires your own account system and entitlement store.
  • Grace periods and billing retry. When a card fails, the stores retry for a time. Decide whether the user keeps access meanwhile.
  • Refunds and revocations. Your backend should remove access when it receives a refund notification.
  • Pending purchases. Some payment methods complete later; the app must not unlock too early or lose the purchase.
  • Price changes, upgrades and downgrades. Define proration and which plan wins if a user holds two.
  • Free trials and introductory offers. Make sure eligibility checks are enforced by the store, and your analytics can tell trial users from paying ones.
  • Family sharing and regional pricing. Decide whether you support them, rather than finding out from reviews.

Design the paywall honestly

Store reviewers and users both react badly to unclear pricing. As a rule, show the price, the billing period, the renewal terms and how to cancel before the user confirms. Link to your terms and privacy policy. Do not hide the close button, and do not make the free tier unusable just to push a sale. Good UX here is also good compliance. For a structured review, our UX audit checklist is a useful starting point.

Test billing properly

Billing is hard to test because real money is involved, so use the sandbox tools the stores provide: sandbox accounts and StoreKit testing on iOS, and licence testers and internal test tracks on Android. Your test plan should cover:

  • successful purchase, cancellation mid-flow and failed payment;
  • restore on a clean install;
  • renewal, expiry and refund notifications reaching the backend;
  • loss of network between payment and entitlement update;
  • the same account on two devices.

Automate the backend notification handling, since it is the part that quietly breaks. Our mobile device testing strategy explains how to choose the real devices to cover.

Measure what matters

Track events through the funnel: paywall viewed, purchase started, purchase completed, trial started, renewal, cancellation and refund. Agree the definitions in a tracking plan before development, so product and engineering read the numbers the same way. Pair this with crash reporting, so a billing failure is visible quickly rather than found via one-star reviews.

A short briefing checklist for your developers

  • Which products and plans exist, and on which platforms?
  • Where is the entitlement stored, and who owns that service?
  • Which store notifications must the backend handle?
  • What happens on failure, refund, restore and plan change?
  • How will support staff look up a user’s subscription status?
  • What is the test plan, and who signs off the sandbox results?

Working with AkMo

Billing is an area where an experienced mobile team saves months of rework. AkMo Technologies builds iOS and Android apps for international clients from Chennai, including backend entitlement services and store submission support. Explore our mobile app development services, or contact us to discuss your monetisation plan.

Let’s build what’s next.

Tell us about your platform, your product idea or the systems you want to modernise. Someone from our Chennai engineering team will get back to you personally.