Subscriptions and in-app purchases in a mobile app — what to check when taking over and maintaining it

In-app purchases break without crashing: paying users without access, access without payment, automatic Google Play refunds. What to check in a taken-over app, which Billing Library and store API deadlines apply in 2026–2027, and what fixing it costs.

Zespół Mobilesoft· Engineering team· 21 listopada 2026· 10 min czytania

"I paid for premium and the app still shows the free version." "I cancelled my subscription six months ago and everything still works." "Google refunded me, even though I never asked." Reports like these rarely show up in crash reports, because the app doesn't crash. Yet they mean real losses: either a customer pays and doesn't get the service, or gets the service and doesn't pay.

In-app purchases and subscriptions are the part of a taken-over project that breaks most quietly. Several parties are involved at once: the app, the store, the backend and the notifications the store sends. A fault in one place doesn't cause a crash — it causes a mismatch between what the store knows about payments and what the app gives the user. In this article we describe what to check in an existing app that sells through the stores, which deprecation deadlines apply in 2026 and 2027, and how much it costs to put this part in order.

The article covers the stores' own mechanisms — Apple In-App Purchase and Google Play Billing — used to sell digital content and features. When they are mandatory and when you can plug in BLIK or another payment gateway is covered in our article on payments in a mobile app.

What a correct purchase flow looks like

To judge what's broken, it helps to know what the reference version looks like:

  1. The app starts the purchase through the Google Play Billing Library or StoreKit.
  2. The store returns proof of the transaction — a purchase token in Google Play, a signed JWS transaction in StoreKit 2.
  3. The app sends it to the backend, which verifies the purchase with the store: through the Google Play Developer API or the App Store Server API (a signed StoreKit 2 transaction can also be verified locally by checking its signature).
  4. The backend grants access and — in Google Play — acknowledges the purchase.
  5. The store sends notifications about renewals, failed payments, cancellations and refunds: Google through Real-time developer notifications (RTDN, via Google Cloud Pub/Sub), Apple through App Store Server Notifications. The backend updates access based on them.
  6. The app can restore purchases on a new phone or after reinstalling.

Apps without their own backend do steps 3–5 on the device only. That's workable for cheap one-time purchases, but with subscriptions it means the app won't learn about a refund or cancellation until the user opens it, and on-device verification is easier to bypass.

What we most often find in taken-over apps

Symptom Typical cause Effect User paid but has no access Verification error, no purchase restore, backend didn't store the token Bad ratings, refunds, support workload Google Play refunds purchases on its own Purchase not acknowledged within 3 days Lost revenue, usually unnoticed Access still works after cancellation or refund Backend checks status only at purchase time, ignores notifications Free service for some users Can't release an update with payments Unsupported Google Play Billing Library version Release block, including urgent fixes Notifications don't arrive The URL in App Store Connect or the Pub/Sub topic points to the previous vendor's server Subscription statuses stop updating Nobody has the keys Store API keys and the Google Cloud service account created on the former developer's private account Verification can't be changed without recovering access first

The second row is particularly treacherous. Google requires every purchase to be acknowledged within three days — otherwise it is automatically refunded and the entitlement revoked. If acknowledgement stopped working after a library update or a backend change, revenue disappears without any error in the app. You only see it in the financial reports in Play Console.

Rows five and six are a typical result of parting ways with a vendor. We cover recovering access in more detail in the developer disappeared — what to do with your app.

Deprecation deadlines worth knowing

As of November 2026:

Item Status Deadline What happens Google Play Billing Library 7 and older deprecated 31 Aug 2026, extension to 1 Nov 2026 — passed A new app version with payments won't be accepted Google Play Billing Library 8 supported until 31 Aug 2027 (extension to 1 Nov 2027) Same as above, a year later Play Developer API: subscriptions.get, refund, revoke (v1) deprecated since May 2025 shutdown 31 Aug 2027 (extension to 1 Nov 2027) The backend can no longer read subscription status; the replacement is subscriptionsv2 Play Developer API: subscriptions.cancel, defer deprecated since May 2026 shutdown 31 Aug 2028 Same as above Apple verifyReceipt and App Store Server Notifications V1 deprecated since 2023 no shutdown date announced Still work, but get no new features; App Store Server API and V2 notifications recommended Original StoreKit API (StoreKit 1) deprecated since 2024 no shutdown date Works, but new capabilities only come to StoreKit 2 On-device receipt validation without SHA-256 — since 24 Jan 2025 Validation fails, and the app may revoke access from paying users

The Billing Library has a fixed two-year cycle: each version is supported for roughly two years after release, and Google publishes the deadline table in advance. It's usually not just a version bump — the API changes between major versions and part of the code has to be rewritten. We write more about tracking such deadlines in our article on deprecated SDKs and APIs.

On Apple's side things are calmer, because the old API still works. Still, it's not worth building anything new on it: at the first bigger change to purchases, it's better to move straight to StoreKit 2 and the App Store Server API.

Auditing purchases in a taken-over app — checklist

If the app earns money from subscriptions, this review is worth doing in the first weeks of maintenance, alongside the items in the project takeover checklist:

  • Products. The list of product IDs in App Store Connect and Play Console matches the code. There are no "dead" products someone can still buy.
  • Library versions. Which Google Play Billing Library version, which StoreKit API, whether the app uses a third-party SDK (e.g. RevenueCat, Adapty) and which version.
  • Where verification happens. On the device, on the backend, or at a third-party provider.
  • Notifications. Where the App Store Server Notifications URL and the RTDN Pub/Sub topic point. Whether that server exists, whether it's yours and whether it actually processes events.
  • Keys and accounts. In-App Purchase / App Store Server API keys, the shared secret, the Google Cloud service account with Play Console access, the SDK provider account — whose account they're on and who has access.
  • Acknowledging purchases in Google Play. Whether every purchase is acknowledged and what happens when the backend is temporarily unavailable.
  • Subscription states. Handling of the grace period, account hold, pause, refund and plan change.
  • Restoring purchases. Works on a new device and after signing in to a different account in the app.
  • Matching numbers. The number of active subscriptions in the backend matches the store reports. A gap of more than a few percent signals that some events are getting lost.

The last item is the cheapest and tells you the most. If the numbers match, the rest usually works. If they don't, you know where to look.

How to change payment code safely

Changes to purchases are an area where a mistake costs money directly. A few rules we follow:

  • A separate release. A Billing Library update or a move to StoreKit 2 ships in a version with no other changes, so the cause of any problem is easy to pinpoint.
  • Backward compatibility on the backend. Old app versions will keep sending data in the old format for months, e.g. receipts instead of JWS transactions. The backend has to support both during the transition — we describe the rules in our article on API changes and old app versions.
  • Testing in the stores' test environments. Apple Sandbox and StoreKit Testing in Xcode; licence testers in Google Play. In both stores test subscriptions renew at an accelerated pace (a monthly one every few minutes), so you can go through a renewal, a failed payment and an expiry in one afternoon. How to set up tests in an old app is covered in our article on testing an old mobile app.
  • Staged release and observation. The new version goes to some users first, while you compare the number of purchases, renewals and verification errors with the previous one. This requires crash monitoring and logging of purchase events on the backend.
  • Reconciliation after release. A few days after release, compare the backend and store numbers again.

Your own integration or a third-party provider

Some apps use services that take over verification, notification handling and subscription analytics, e.g. RevenueCat or Adapty. When taking over an app, it's worth deciding deliberately whether to keep this or change it.

Own integration Third-party provider Upfront cost Higher: backend, notifications, state handling Lower: SDK and configuration Ongoing cost Code maintenance and reacting to store API changes A fee, usually based on revenue above a threshold Store API changes Your responsibility Mostly the provider's, but the SDK still needs updating Data With you With the provider, with export and webhooks Risk Bugs in your own code Dependence on the provider and its pricing

For a small app with a single subscription, a third-party provider is often cheaper. With high revenue or unusual access rules (e.g. company subscriptions assigned to accounts from an admin panel), your own backend pays off — we write about maintaining one in mobile app backend: what breaks. Whatever you choose, the provider account should belong to your company, not to the vendor.

How much it costs

Scope Estimated effort At PLN 180 net per hour Purchases and subscriptions audit (code, store configuration, keys, notifications, number reconciliation) 8–16 h approx. PLN 1.4k–2.9k Updating Google Play Billing Library by one or two versions 16–40 h approx. PLN 2.9k–7.2k Moving the backend to subscriptionsv2 16–40 h approx. PLN 2.9k–7.2k Migrating to StoreKit 2 and the App Store Server API 40–100 h approx. PLN 7.2k–18k Server-side verification and notification handling from scratch, both platforms 60–160 h approx. PLN 10.8k–28.8k

The figures are estimates and depend on the number of products, subscription types and the state of the code. The rate is an example — we set the actual cost after reviewing the project. For comparison: if purchase acknowledgement in Google Play stops working, the store will refund every new subscription. With 200 new subscriptions a month at PLN 30, that's PLN 6k a month — lost until someone looks at the reports.

Summary

In-app purchases break without crashing, so you have to check them deliberately. Start by comparing the number of active subscriptions in the backend and in the stores, then check the Billing Library version, where verification happens, the notification URLs and whose accounts hold the keys. If the app uses Billing Library 7 or older, you can no longer release an update with payments on Google Play — that's the first thing to fix. The next deadlines, version 8 and Google's old subscription APIs, fall in August 2027, so it's best to plan them now rather than in the middle of summer.

We put payments in order in taken-over apps as part of our mobile app takeover and mobile app maintenance services, and handle server-side verification and notifications as part of our backend and API service. If you want to check whether your app uses up-to-date libraries and SDKs, including the Billing Library, order a free app analysis or contact us.