Offline Entitlements: Keeping In-App Purchases Working When Servers Are Down
A purchase flow that depends on a remote validation call has a single point of failure: the remote call. Offline entitlements address that dependency for subscription purchases: the SDK grants access on the device when the backend cannot be reached and reconciles with the dashboard once connectivity returns. This guide explains what the feature covers, how the SDK decides what a user owns without a server, and where the boundaries sit so you can judge whether your product's purchase mix fits. Capability details below describe the offline entitlements behavior as documented; confirm current behavior against your SDK documentation before relying on it.
Why a purchase flow needs an offline path
Normally the backend sits between the store and the app: it confirms what the user bought and which entitlements that unlocks. That design is correct for accuracy, but it also means a backend outage can stall checkout and renewal handling at the exact moment a user is trying to pay. Offline entitlements keep the purchase moving when the primary and backup servers are unreachable, with the SDK syncing the record automatically once service returns so the dashboard reflects the transaction. Earlier SDK versions already cached data to survive outages; the gap this feature closes is completing purchases and renewals while the outage is in progress.
How the SDK decides entitlements without a server
Two responsibilities used to live entirely on the backend: identifying which products a user has purchased (by talking to Apple and Google) and mapping those products to entitlements. The newer SDKs carry a full product-to-entitlement mapping locally, so they can resolve what a user has unlocked on-device. Security comes from the store SDKs rather than from trusting local receipts: on Apple platforms the SDK reads current subscriptions through StoreKit 2, which resists the receipt tampering that StoreKit 1 receipts were more exposed to; on Android it uses Google Play BillingClient, the Amazon Appstore SDK, or another supported store SDK. Offerings are also cached, which is what allows a paywall to render during an outage even though Offerings normally have a short cache lifetime because they can change at any time.
What the test coverage has to prove
Adding an offline path increases SDK complexity, so the test strategy matters as much as the feature. Coverage combines unit tests, integration tests, and manual testing, plus extended end-to-end infrastructure that simulates the API being down, up, or flipping state mid-session. The integration test in the accompanying code module walks a single scenario end to end: purchase while the server is down, bring the server back, request customer info, confirm the transaction is finished, restart the app with a clean cache, and confirm the receipt was posted and the entitlement still resolves. That sequence is a useful template for your own regression suite, because it checks both the offline grant and the later reconciliation.
Where offline entitlements stop
Four boundaries determine whether the feature applies to a given user:
- Platform versions. On Apple platforms the feature needs iOS 15.0+, tvOS 15.0+, watchOS 8.0+, or macOS 12.0+, because it depends on StoreKit 2 for secure entitlement resolution.
- Cross-platform purchases. A subscription bought on one platform does not activate on another during an outage. An Android purchase will not be active on iOS while the servers are unreachable.
- Fresh installs. The app must have launched at least once with the servers online so the SDK can download the mapping it needs. A brand-new install during an outage has nothing to work from.
- One-time purchases. Consumables and non-consumables are not supported offline, because verifying them correctly requires server validation. The platform nuance matters here: on iOS only consumables are blocked, and non-consumables plus non-renewing subscriptions are supported offline through StoreKit 2; on Android all in-app product types are blocked.
Paywall behavior during an outage
If you render paywalls from your Offerings configuration, three observable behaviors apply during an outage. Cached Offerings are shown immediately, since the SDK keeps them in memory and on disk and falls back to the disk copy when the server is unreachable, so the paywall still renders fully. A purchase that fails because of a server error is granted on-device through offline entitlements and synced automatically when connectivity returns, typically on the next foreground. If the purchase attempt itself errors, the paywall stays visible and an inline error dialog lets the user retry without losing their place. Verify the automatic-sync timing against your SDK documentation for your SDK version.
A checklist before you rely on it
Use this to decide whether your purchase mix is covered by offline entitlements. Work through each question and note the answer for your app; a worked example follows the list to show how the answers combine into a decision. The questions are evaluation prompts, not a live checklist with stored results on this page, so record your own answers in a worksheet or design doc as you go. A worked example: a team sells a monthly subscription on both iOS and Android, supports iOS 15 and up, and has no consumables. Their answers are: subscriptions only (yes), no Android non-consumables (no), minimum OS meets the StoreKit 2 floor (yes), same subscription on both platforms (yes, so no cross-platform carryover during an outage), new users can reach a paywall before any online launch (no), and dashboard reconciliation depends on the next foreground (yes, so support messaging must explain a short delay). Because the cross-platform and reconciliation answers introduce known gaps, the team treats those paths as documented limitations rather than edge cases and writes paywall copy that does not promise instant cross-platform access. If every answer lines up for your app, the feature applies with no code changes on your side; confirm that against your SDK documentation for your SDK version. If any answer does not, treat that path as a known gap rather than an edge case.
Frequently asked questions
Do I need to change my code to get offline entitlements?
The feature ships in the SDK and applies automatically once you are on a version that includes it, with no code changes needed. Your existing purchase calls continue to work; the difference is what happens when the backend cannot be reached. Confirm this for your SDK version before relying on it.
What happens to a purchase made while the servers are down?
The SDK grants the entitlement on the device so the user is not blocked. When connectivity returns, the purchase is synced to the backend, typically on the next app foreground, and then appears in the dashboard.
Why are one-time purchases excluded?
Subscription status can be verified securely through the store SDK, but one-time purchases need server validation to guarantee correctness. That is why the offline path covers subscriptions and not consumables or non-consumables, with the iOS non-consumable exception noted above.
Does an offline purchase on Android unlock the same subscription on iOS?
No. During an outage, a purchase made on one platform does not carry over to another. The subscription becomes visible across platforms once the servers are reachable again and the record syncs.