Skip to content
AppDues
Log in
Contact salesSign up

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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 store indicating 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.
Receipt formats and verification: Google Play Billing vs Apple StoreKit
AspectGoogle Play BillingApple StoreKit
Purchase proofPurchase token (opaque string)Signed receipt (JWS in StoreKit 2)
Verification endpointpurchases.subscriptionsv2.get REST APIApp Store Server API ( /inApps/v1/subscriptions )
AuthenticationGoogle service account with JSON keyJWT signed with App Store Connect private key
Response formatSubscriptionPurchaseV2 JSON objectJWSTransactionDecodedPayload (signed JSON)
Subscription ID formatproductId:basePlanIdSimple productId string
Renewal trackingexpiryTime field on subscription resourceexpiresDate in transaction info

Platform API details reflect the captured article's reference period; verify current API contracts with each store before implementation.

Real-time notifications: Google Play RTDN vs Apple Server Notifications V2
AspectGoogle Play RTDNApple Server Notifications V2
Delivery mechanismGoogle Cloud Pub/SubHTTPS POST to your endpoint
Notification formatDeveloperNotification with type enumsignedPayload (JWS) with notificationType
Event typesSUBSCRIPTION_RENEWED , SUBSCRIPTION_CANCELED , etc.DID_RENEW , DID_CHANGE_RENEWAL_STATUS , etc.
User identificationpurchaseToken in notificationoriginalTransactionId in signed payload
SetupConfigure Pub/Sub topic in Play ConsoleRegister 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.