The Challenge

Modern users expect seamless experiences across all their devices. They might start their day on an iPad, switch to an Android phone during their commute, and finish work on a web browser. For subscription-based applications, this creates a complex problem: how do you manage subscriptions across iOS, Android, and web platforms without double-charging users or creating fragmented access?

The Multi-Platform Subscription Dilemma

In-app purchases are the standard-and often mandatory-way to handle subscriptions on mobile platforms. Both Apple’s App Store and Google’s Play Store have their own payment systems, APIs, and management interfaces. Typically, mobile developers implement these separately, with each platform managing its own subscription state.

This works fine until you introduce a third platform: the web.

The Problems We Faced

Platform Silos – A user who subscribes on iOS expects to access premium features on Android and web, but each platform’s native subscription system only knows about its own transactions.

Risk of Double Charging – Without a unified system, a user might accidentally purchase subscriptions on multiple platforms, leading to frustrated customers and support headaches.

No Single Source of Truth – With subscriptions managed independently on each platform, there’s no authoritative answer to the question: “Is this user currently subscribed?”

Web Platform Complexity – While mobile platforms have built-in subscription infrastructure, web applications typically use different payment processors like Stripe, adding another layer of complexity.

Our Solution: Webhook-Based Unified Subscription Management

We built a centralized subscription management system powered by webhooks, creating a single source of truth for subscription status across all platforms.

Why Webhooks?

Both Apple and Google provide robust webhook systems that notify your backend about all subscription events:

• New purchases
• Renewals
• Cancellations
• Refunds
• Billing issues
• Grace periods

By listening to these webhooks, we could capture every subscription event in real-time and maintain an authoritative record in our own database.

Architecture Overview

Our Node.js backend acts as the central subscription authority:

All subscription events from all platforms flow into our backend, where they update a single, unified subscription record for each user.

Implementation Details

1. Webhook Endpoints

We created secure webhook endpoints for each platform:

• /webhooks/apple – App Store Server Notifications
• /webhooks/google – Google Play Developer Notifications
• /webhooks/stripe – Stripe subscription events

Each endpoint validates the incoming webhook signature to ensure authenticity and prevent tampering.

2. Unified Subscription Model

Instead of maintaining separate subscription states per platform, we created a unified user subscription record:

{

  userId: “user_123”,

  subscriptionStatus: “active”,

  platform: “ios”, // Platform of original purchase

  expiresAt: “2024-12-31T23:59:59Z”,

  originalTransactionId: “apple_tx_456”,

  lastUpdated: “2024-11-19T10:30:00Z”

}

3. Event Processing Pipeline

When a webhook arrives, our system:

1. Validates the webhook signature
2. Extracts subscription details (user ID, status, expiration)
3. Updates the unified subscription record
4. Propagates the status to all platforms

This ensures that regardless of where a user purchases their subscription, they get access everywhere.

Handling Stripe for Web Subscriptions

Adding web-based subscriptions through Stripe followed the same pattern. Stripe’s webhook system notifies us about:

• customer.subscription.created
• customer.subscription.updated
• customer.subscription.deleted
• invoice.payment_succeeded
• invoice.payment_failed

These events flow through the same processing pipeline, updating the same unified subscription record. From the user’s perspective, it doesn’t matter whether they subscribed via iOS, Android, or web-they get the same access across all platforms.

Benefits of This Approach

Single Source of Truth

Our backend database became the authoritative source for subscription status. All platforms query this central system, eliminating conflicts and ensuring consistency.

Prevention of Double Charging

Before allowing a new subscription purchase, we check if the user already has an active subscription from another platform. If they do, we can redirect them appropriately or prevent the duplicate purchase.

Platform Independence

Users can start their subscription on any platform and seamlessly access features on all others. Subscribe on the web? Your mobile apps reflect that immediately.

Simplified Support

Customer support teams have one place to check subscription status, not three different platform dashboards. This dramatically simplifies troubleshooting.

Flexibility

Want to add another platform? Just implement its webhook endpoint and plug it into the existing pipeline. The architecture scales naturally.

Technical Considerations

Webhook Reliability

Webhooks can fail or arrive out of order. We implemented:

• Idempotency – Processing the same webhook multiple times produces the same result
• Event ordering – Timestamps help us handle events that arrive out of sequence
• Retry logic – Failed webhook processing is retried with exponential backoff

User Account Linking

For this system to work, users must have accounts in your application that can be linked across platforms. We use:

• Email-based account identification
• Platform-specific user IDs mapped to our internal user ID
• Secure token exchange during first-time authentication on each platform

Real-World Scenarios

Scenario 1: iOS to Android

1. User subscribes via iPhone
2. Apple webhook notifies our backend
3. Subscription record created with platform: “ios”
4. User opens Android app
5. Android app queries our backend
6. Backend confirms active subscription
7. Premium features unlocked on Android

Scenario 2: Subscription Expiration

1. Google subscription expires (no renewal)
2. Google webhook notifies our backend with cancellation event
3. Subscription status updated to expired
4. All platforms (iOS, Android, web) reflect expired status
5. User sees renewal prompt across all devices

Scenario 3: Web to Mobile

1. User subscribes via web using Stripe
2. Stripe webhook confirms successful payment
3. Subscription record created with platform: “web”
4. User downloads mobile app
5. Mobile app unlocks premium features immediately

Challenges We Overcame

Testing Webhooks – Webhook testing requires special sandbox environments for each platform. We used tools like ngrok for local development and comprehensive test suites simulating webhook payloads.

Event Timing – Subscription events can take seconds to minutes to arrive via webhook. We implemented polling fallbacks for critical user-facing flows.

Platform Differences – Each platform has unique subscription concepts (grace periods, billing retry, etc.). We normalized these into a common model while preserving platform-specific metadata.

Refunds and Edge Cases – Handling refunds, involuntary churn, and billing issues required careful state machine design to ensure users aren’t unfairly locked out or given free access.

Results

By implementing webhook-based unified subscription management, we achieved:

Zero double-charging incidents – Users can only have one active subscription across all platforms

Seamless cross-platform access – Subscribe once, access everywhere

Reduced support burden – Single source of truth simplified troubleshooting

Platform flexibility – Easy to add new platforms or payment methods

Better user experience – No confusion about subscription status across devices

Conclusion

Managing subscriptions across multiple platforms doesn’t have to be a nightmare of conflicting states and frustrated users. By leveraging webhooks from Apple, Google, and Stripe, we created a unified subscription system that provides a seamless experience regardless of where users choose to subscribe.

The key insight is treating your backend as the single source of truth, with platform-specific payment systems as input sources rather than independent authorities. Webhooks make this possible by providing real-time subscription event streams that keep your central system perfectly synchronized.

For any application serving users across iOS, Android, and web, this webhook-based approach provides a robust foundation for subscription management-one that scales with your business and keeps your users happy.

Building a multi-platform subscription system? The webhook approach can be adapted to many payment providers and platforms beyond those mentioned here. The principles of centralized state management and event-driven updates apply universally.