Cross-Platform Subscription State: Sharing Entitlements Between Android and iOS
A subscriber who pays on an iPhone and then installs the Android build expects the same access. The two storefronts, however, keep separate records and expose them through incompatible APIs. This guide explains where the gap comes from, outlines the four components a self-built sync layer needs, and shows how a shared app user ID and a single entitlement object reduce the client-side check to one property.
Why one subscriber becomes two disconnected records
Each storefront only reports purchases made through its own billing system. Google Play Billing knows nothing about an App Store transaction, and StoreKit knows nothing about a Play purchase. When the same person signs in on the other platform, the client queries its own store, finds no purchase, and shows a paywall to someone who is already paying.
This is expected behavior rather than a defect. Neither platform ships a bridge to the other, so any shared view of entitlement has to be assembled outside both stores.
Where the two billing systems diverge
The split runs deeper than surface API naming. It reaches into how a purchase is proven, how renewals are announced, and how products are defined.
Purchase proof and verification. Google Play hands your app an opaque purchase token, and your server trades that token for current state through the Play Developer API. Apple hands you a signed transaction; under StoreKit 2 the payload is a JSON Web Signature your server checks against Apple's public key. Put simply, one store wants you to ask its server, the other wants you to validate a signature yourself. The receipt and verification comparison table below lines up the two approaches.
Renewal notifications. Google routes events through Cloud Pub/Sub, so you own a subscription and a processing service. Apple posts HTTPS requests to a URL you register. The event names, payload shapes, and identifying field in each notification all differ, which means each platform needs its own parsing and state logic.
Product structure. Google Play's base plan and offer hierarchy lets one subscription product carry multiple plans and pricing phases. Apple's model is flatter: a product ID maps to one duration, and monthly and annual options are separate IDs grouped together. There is no one-to-one mapping, so a translation layer from platform product identifiers to a shared entitlement concept is unavoidable.
The four pieces of a self-built sync layer
Bridging the stores yourself comes down to four capabilities, each of which depends on the one before it.
- A cross-platform user identity. Both clients must report purchases against the same server-side account. Without a shared identifier, a Play purchase and an App Store purchase can never be attributed to one person.
- Verification against both APIs. Your backend needs Google service-account credentials for the Play Developer API and a JWT signed with an App Store Connect key for the App Store Server API. Authentication, error handling, and response parsing are separate for each path.
- A platform-neutral entitlement store. Products from both stores map into a shared entitlement record that tracks active state, source platform, the platform product ID, the platform purchase proof, expiry, and when the record was last verified.
- Two notification pipelines. Renewals, cancellations, expiries, and revocations arrive in different formats and must be translated into the same entitlement state machine. Grace periods and refunds also behave differently between the platforms.
Beyond the initial build, both stores revise their billing systems periodically. Google's 2022 base plan and offer model and Apple's StoreKit 2 transaction model each forced backend changes, and future revisions will do the same.
Build-or-buy checklist
Use these questions to decide whether a self-built layer is realistic for your team. They are evaluation prompts, not a scorecard with fixed weights — the right answer depends on your team's size, existing backend experience, and how much of the work you can absorb without slowing releases. A worked worksheet follows the questions so you can apply them to your own situation rather than to a specific vendor's claims about effort saved or support provided; any such figures would need to come from your own estimates or a vendor's current published terms, which this page does not assert on anyone's behalf. For each question, record a short answer and the evidence behind it (who owns the work today, what breaks when a store changes its API, what monitoring already exists). Where an answer is uncertain, treat it as a gap to close before committing to a self-built path, and note the cost of closing it. If most answers are no, a managed identity and entitlement service is worth evaluating against your own requirements and current pricing; the effort it saves depends on your team's baseline, so compare it with your own self-build estimate rather than a generic figure. If most are yes, the four-stage plan above is the minimum scope, and the worksheet should also capture who owns each stage and how platform API changes will be absorbed.
How a shared app user ID changes the client check
Configure the SDK on each platform with the same app user ID, and the four stages collapse into one identifier and one object. A managed service of this kind verifies receipts with each store, records entitlements against that ID, and subscribes to renewal notifications on your behalf; whether a given provider does so, and under what terms, is something to confirm against its current documentation and agreement rather than assume. When either client requests customer info, it receives the full entitlement state, including purchases made on the other platform, provided the shared identity is configured consistently on both sides and the backend has verified the originating purchase. If either condition is missing, the client will only see its own store's records, so treat the shared ID as a prerequisite rather than an optional convenience. The client-side decision then collapses to a single property. The entitlement object exposes isActive, plus store, expirationDate, and willRenew for display or diagnostics. Access does not depend on which store the subscription came from, so the Android build never needs to understand Apple receipts and the iOS build never needs to understand Play purchase tokens. For users who subscribe before creating an account, the service assigns an anonymous ID. Calling logIn with the real user ID later transfers those purchases to the identified account and merges any history already attached to it. The created flag in the login result tells you whether the account was new.
Worked example: the fitness app subscriber
A user buys Premium on an iPhone. A week later they install the Android build and sign in with the same account.
- Without a sync layer: the Android client queries Play Billing, receives an empty purchase list, and shows the paywall. The subscription is active but invisible to that platform.
- With a shared identity: the Android client requests customer info using the same app user ID. The response marks the Premium entitlement active, with
storeindicating the App Store as the origin. The app grants access without any Apple-specific code.
Renewals, grace periods, cancellations, and expirations continue to be tracked on the server, so both platforms see the same current state on the next request.
Failure-mode distinctions
Not every paywall shown to a paying subscriber has the same cause. Separating them shortens debugging.
- Paywall despite an active subscription on the other platform. No shared identity or no cross-platform entitlement lookup exists. The client only sees its own store.
- Entitlement reported inactive after a renewal. A notification was missed or not processed, so the stored expiry is stale. Re-verifying against the store API resolves it.
- Access granted after cancellation. The entitlement record still shows active because the cancellation event was not translated into the shared state machine.
- User cannot find the subscription to cancel. The management link points to the wrong store. The entitlement's management URL should route to the store where the purchase originated.
Field map for the entitlement object
When reading a customer info response, these properties carry the decisions:
entitlements["premium"].isActive— the access gate; true regardless of originating store.entitlements["premium"].store— origin platform, useful for support and analytics, not required for access.entitlements["premium"].expirationDate— when the current period ends.entitlements["premium"].willRenew— whether auto-renewal is on.managementURL— the correct store's subscription settings page for that user.
| Aspect | Google Play Billing | Apple StoreKit |
|---|---|---|
| Purchase proof | Purchase token (opaque string) | Signed receipt (JWS in StoreKit 2) |
| Verification endpoint | purchases.subscriptionsv2.get REST API | App Store Server API ( /inApps/v1/subscriptions ) |
| Authentication | Google service account with JSON key | JWT signed with App Store Connect private key |
| Response format | SubscriptionPurchaseV2 JSON object | JWSTransactionDecodedPayload (signed JSON) |
| Subscription ID format | productId:basePlanId | Simple productId string |
| Renewal tracking | expiryTime field on subscription resource | expiresDate in transaction info |
Platform API details reflect the captured article's reference period; verify current API contracts with each store before implementation.
| Aspect | Google Play RTDN | Apple Server Notifications V2 |
|---|---|---|
| Delivery mechanism | Google Cloud Pub/Sub | HTTPS POST to your endpoint |
| Notification format | DeveloperNotification with type enum | signedPayload (JWS) with notificationType |
| Event types | SUBSCRIPTION_RENEWED , SUBSCRIPTION_CANCELED , etc. | DID_RENEW , DID_CHANGE_RENEWAL_STATUS , etc. |
| User identification | purchaseToken in notification | originalTransactionId in signed payload |
| Setup | Configure Pub/Sub topic in Play Console | Register URL in App Store Connect |
Event names and payload structures reflect the captured article's reference period; confirm against current store documentation.
Frequently asked questions
Can a Google Play subscription unlock features in an iOS app?
Not through the stores alone. Play Billing only reports Play purchases and StoreKit only reports App Store purchases. A shared backend that verifies both and stores entitlement against one user ID is required to grant access across platforms.
What is the minimum a self-built sync layer needs?
Four components: a cross-platform user identity, verification against both the Play Developer API and the App Store Server API, a platform-neutral entitlement store that maps product IDs to entitlements, and two notification pipelines that translate renewals, cancellations, expiries, and revocations into one state machine.
How does a shared app user ID handle users who subscribe before signing up?
The service assigns an anonymous ID and attaches the purchase to it. When the user later logs in with a real user ID, the login call transfers those purchases to the identified account and merges any existing history. The created flag indicates whether the account was new.
Which entitlement property should gate access?
isActive on the entitlement. The store property tells you where the subscription originated, which is useful for support and analytics, but access should not depend on it.
How should subscription management links be routed?
Use the management URL returned with customer info. It points to the store where the user subscribed, so an App Store subscriber is sent to Apple's subscription settings rather than Google Play.