In-app purchases are the engine behind the majority of top-grossing mobile apps, yet the implementation is notoriously painful. Apple and Google each have their own billing APIs, receipt validation rules, sandbox environments, and edge cases. Build it yourself and you are looking at weeks of work, a server-side validation layer, and an ongoing maintenance burden every time either platform ships a breaking change. That is the problem RevenueCat was built to solve.

But RevenueCat is not the only option. Apple's StoreKit 2 and Google's Play Billing Library v8 are both mature, well-documented native APIs. For some teams, going native is the right call. For others, RevenueCat's unified SDK, hosted receipt validation, and analytics dashboard are worth the 1% revenue share.

This guide covers the full picture: how RevenueCat works, how to integrate it in React Native, iOS, and Android, the honest pros and cons versus going native, pricing, and a decision framework to help you pick the right approach for your app.

1What Is RevenueCat and How Does It Work?

RevenueCat is a subscription management platform that sits between your app and the native billing APIs (Apple's StoreKit and Google's Play Billing). Instead of talking directly to the store, your app talks to RevenueCat's SDK, which handles:

• Purchase initiation — wrapping the native purchase flow in a unified API
• Receipt validation — server-side validation against Apple and Google backends so you never trust the client
• Entitlement tracking — a single source of truth for whether a user has an active subscription, regardless of platform
• Subscription lifecycle events — renewals, cancellations, billing retries, grace periods, and refunds, all surfaced via webhooks
• Analytics — MRR, churn, LTV, conversion funnels, and cohort analysis out of the box

The architecture is straightforward. Your app initializes the RevenueCat SDK with your API key, fetches the current user's entitlements, and checks whether a given entitlement (e.g., pro_access) is active before showing premium content. RevenueCat's backend handles all the receipt validation and subscription state management.

2RevenueCat Pricing in 2026

RevenueCat's pricing model is simple and developer-friendly:

The 1% fee is calculated on gross monthly tracked revenue — the full amount before the app store takes its 15-30% cut. On $100,000 in gross MTR, RevenueCat charges $1,000. After the standard 30% store commission, your net is $70,000, making the effective rate about 1.43% of net proceeds. For most apps, this is well worth the engineering time saved.

3Core Concepts: Products, Offerings & Entitlements

Before writing any code, you need to understand RevenueCat's three-layer model:

This separation is the key insight behind RevenueCat's design. Your app logic never hardcodes product IDs. It only asks: "does this user have the pro_access entitlement?" That means you can add new products, run A/B tests on pricing, or change your subscription structure without shipping a new app version.

4Integration Guide: React Native

RevenueCat's React Native SDK (react-native-purchases) requires React Native 0.73 or higher. Install it alongside the RevenueCatUI package if you want pre-built paywalls:

npm install react-native-purchases react-native-purchases-ui
# iOS: pod install

Initialize RevenueCat early in your app lifecycle, typically in your root component or app entry point. Use separate API keys for iOS and Android:

import Purchases, { LOG_LEVEL } from 'react-native-purchases';
import { Platform } from 'react-native';

// Initialize once at app startup
const API_KEY = Platform.select({
  ios: 'appl_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
  android: 'goog_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx',
});

Purchases.setLogLevel(LOG_LEVEL.DEBUG); // remove in production
await Purchases.configure({ apiKey: API_KEY! });

// Identify the user (use your own user ID)
await Purchases.logIn('user_123');

Fetching the current user's entitlements and checking access:

import Purchases from 'react-native-purchases';

async function checkProAccess(): Promise<boolean> {
  const customerInfo = await Purchases.getCustomerInfo();
  return customerInfo.entitlements.active['pro_access'] !== undefined;
}

// Fetch offerings and present a paywall
async function showPaywall() {
  const offerings = await Purchases.getOfferings();
  const current = offerings.current;
  if (!current) return;

  // current.availablePackages contains monthly, annual, etc.
  const monthly = current.monthly;
  if (!monthly) return;

  await Purchases.purchasePackage(monthly);
}

For pre-built paywalls using RevenueCatUI, you can render a full-screen paywall with a single component — no custom UI required:

import { RevenueCatUI } from 'react-native-purchases-ui';

// Full-screen paywall modal
<RevenueCatUI.Paywall
  onDismiss={() => setShowPaywall(false)}
  onPurchaseCompleted={({ customerInfo }) => {
    // user is now subscribed
    setShowPaywall(false);
  }}
/>

5Integration Guide: iOS (Swift / StoreKit 2)

Add RevenueCat to your iOS project via Swift Package Manager or CocoaPods. The iOS SDK uses StoreKit 2 by default for users on iOS 16+, with automatic fallback to StoreKit 1 for older OS versions.

// Package.swift or via Xcode SPM
// https://github.com/RevenueCat/purchases-ios

// AppDelegate.swift or App.swift
import RevenueCat

@main
struct MyApp: App {
  init() {
    Purchases.logLevel = .debug // remove in production
    Purchases.configure(withAPIKey: "appl_xxxxxxxxxxxxxxxxxxxxxxxx")
  }
  var body: some Scene {
    WindowGroup { ContentView() }
  }
}

Checking entitlements and making a purchase in SwiftUI:

import RevenueCat

// Check entitlement
func checkProAccess() async -> Bool {
  do {
    let customerInfo = try await Purchases.shared.customerInfo()
    return customerInfo.entitlements["pro_access"]?.isActive == true
  } catch {
    return false
  }
}

// Purchase a package
func purchaseMonthly(package: Package) async {
  do {
    let result = try await Purchases.shared.purchase(package: package)
    if result.customerInfo.entitlements["pro_access"]?.isActive == true {
      // unlock premium content
    }
  } catch {
    // handle PurchasesError
  }
}

6Integration Guide: Android (Kotlin / Play Billing v8)

RevenueCat's Android SDK supports Google Play Billing Library v8, which is the current major version (latest stable: 8.2.1, December 2025). Add the dependency to your build.gradle:

// build.gradle (app)
dependencies {
  implementation 'com.revenuecat.purchases:purchases:8.x.x'
  implementation 'com.revenuecat.purchases:purchases-ui:8.x.x' // optional paywalls
}

// AndroidManifest.xml — add billing permission
<uses-permission android:name="com.android.vending.BILLING" />

Initialize in your Application class:

import com.revenuecat.purchases.Purchases
import com.revenuecat.purchases.PurchasesConfiguration

class MyApplication : Application() {
  override fun onCreate() {
    super.onCreate()
    Purchases.debugLogsEnabled = true // remove in production
    Purchases.configure(
      PurchasesConfiguration.Builder(this, "goog_xxxxxxxxxxxxxxxxxxxxxxxx")
        .build()
    )
  }
}

// Check entitlement
suspend fun checkProAccess(): Boolean {
  val customerInfo = Purchases.sharedInstance.awaitCustomerInfo()
  return customerInfo.entitlements["pro_access"]?.isActive == true
}

7RevenueCat vs Native: Honest Pros & Cons

This is the question most developers actually want answered. Here is an honest breakdown:

RevenueCat Pros

• Cross-platform in one SDK. One API for iOS, Android, React Native, Flutter, Unity, and web. No platform-specific billing code to maintain.
• Server-side receipt validation included. You do not need to build or host your own validation server. RevenueCat handles Apple and Google receipt verification on their backend.
• Entitlement management. The entitlement layer decouples your app logic from product IDs, making pricing changes and A/B tests trivial.
• Analytics out of the box. MRR, churn, LTV, trial conversion, and cohort analysis without building a data pipeline.
• Remote paywall configuration. Update your paywall copy, pricing, and layout without an app store review cycle.
• Webhooks for every lifecycle event. Renewals, cancellations, billing retries, refunds — all delivered to your backend in real time.
• Platform change insulation. When Apple or Google updates their billing APIs (like the PBL v8 migration), RevenueCat ships SDK updates so you do not have to scramble.
• Cross-platform subscription sharing. A user who subscribes on iOS can access their entitlement on Android via a shared App User ID.

RevenueCat Cons

• 1% revenue share above $2,500 MTR. At scale, this adds up. On $1M/month gross revenue, that is $10,000/month to RevenueCat. Some teams at this scale build in-house.
• Third-party dependency. Your subscription infrastructure depends on RevenueCat's uptime and continued operation. If they have an outage, your purchase flow is affected.
• Data leaves your infrastructure. Purchase events and customer data flow through RevenueCat's servers. For highly regulated industries, this may require additional compliance review.
• Less control over edge cases. Native APIs give you direct access to every billing edge case. RevenueCat abstracts these away, which is usually good but occasionally limits what you can do.
• Estimated revenue metrics. Some developers have noted that RevenueCat's revenue figures can differ slightly from App Store Connect and Google Play Console due to estimation methodology.

Native StoreKit 2 / Play Billing v8 Pros

• Zero revenue share. No third-party fee on top of the store commission.
• Full control. Direct access to every API, edge case, and platform feature the moment it ships.
• No external dependency. Your purchase flow only depends on Apple and Google, not a third party.
• StoreKit 2 is genuinely good. Apple's modern async/await API is clean, well-documented, and includes built-in transaction verification with JWS signatures.

Native Cons

• You build everything. Server-side receipt validation, entitlement tracking, subscription state management, analytics, and webhook handling — all on you.
• Two separate codebases. StoreKit 2 and Play Billing v8 have completely different APIs. Cross-platform apps need platform abstraction layers.
• Maintenance burden. Every time Apple or Google deprecates an API or changes behavior, you need to update your code.
• No built-in analytics. You need to build or integrate a separate analytics pipeline for subscription metrics.

8Cross-Platform Subscription Sharing

One of RevenueCat's most useful features for cross-platform apps is the ability to share subscription state between iOS and Android. Apple and Google have no native interoperability — a subscription purchased on iOS is invisible to Android and vice versa.

RevenueCat solves this with the App User ID. When a user logs in, you call Purchases.logIn(yourUserId) on both platforms. RevenueCat's backend links all purchases to that user ID, so when you check entitlements on Android, it sees the iOS subscription and grants access.

// React Native — call this after your auth flow
import Purchases from 'react-native-purchases';

async function onUserLogin(userId: string) {
  const { customerInfo } = await Purchases.logIn(userId);
  const hasPro = customerInfo.entitlements.active['pro_access'] !== undefined;
  // hasPro is true regardless of which platform the user subscribed on
}

This works because RevenueCat is the source of truth for entitlements, not the individual stores. The stores only know about their own purchases; RevenueCat aggregates them under a single user identity.

9Paywalls, A/B Testing & Analytics

RevenueCat includes a paywall editor and A/B testing framework (Experiments) that lets you test different pricing, copy, and layouts without shipping a new app version. The workflow is:

1. Create multiple Offerings in the RevenueCat dashboard (e.g., "control" with monthly pricing, "variant_a" with annual pricing highlighted)
2. Set up an Experiment assigning a percentage of users to each offering
3. Your app fetches Purchases.getOfferings() — RevenueCat automatically returns the correct offering for each user based on the experiment assignment
4. Monitor conversion, trial starts, and revenue per user in the RevenueCat dashboard

The analytics dashboard tracks 15+ subscription metrics automatically:

10Security, Webhooks & Server-Side Validation

Never trust the client for entitlement decisions in high-value scenarios. RevenueCat provides two mechanisms for server-side verification:

REST API

Query a user's entitlements from your backend using the RevenueCat REST API:

GET https://api.revenuecat.com/v1/subscribers/:app_user_id

Authorization: Bearer YOUR_SECRET_API_KEY

// Response includes entitlements, subscriptions, and purchase history

Webhooks

Configure a webhook endpoint in the RevenueCat dashboard to receive real-time events for every subscription lifecycle change:

• INITIAL_PURCHASE — new subscriber
• RENEWAL — successful renewal
• CANCELLATION — user cancelled (subscription still active until period end)
• BILLING_ISSUE — payment failed, grace period started
• PRODUCT_CHANGE — user upgraded or downgraded
• REFUND — refund issued
• EXPIRATION — subscription fully expired

Always validate the webhook signature using the X-RevenueCat-Signature header to prevent spoofed events. RevenueCat signs all webhook payloads with HMAC-SHA256.

11Decision Framework: When to Use RevenueCat vs Native

Use this framework to decide which approach fits your situation:

The break-even point where building native becomes financially attractive is roughly when your RevenueCat bill exceeds the cost of the engineering time to build and maintain an equivalent in-house solution. For most teams, that is well above $500K/month in gross revenue — and even then, the ongoing maintenance cost of native billing is often underestimated.

❓ Frequently Asked Questions

12Why Lushbinary for Your Mobile Monetization

Implementing in-app purchases correctly is harder than it looks. The happy path is straightforward, but the edge cases — billing retries, grace periods, subscription upgrades, refund handling, sandbox testing across both stores, and App Store Review compliance — take real experience to get right.

At Lushbinary, we build mobile apps with RevenueCat and native billing integrations for clients across iOS, Android, and React Native. We handle the full stack: product configuration in App Store Connect and Google Play Console, SDK integration, server-side webhook handling, entitlement logic, paywall design, and A/B test setup.

• React Native & Flutter cross-platform apps with RevenueCat integration
• Native iOS (Swift) apps with StoreKit 2 or RevenueCat
• Native Android (Kotlin) apps with Play Billing v8 or RevenueCat
• Paywall design & A/B testing setup for conversion optimization
• Webhook & backend integration for subscription lifecycle management
• Migration from legacy StoreKit 1 or Play Billing v5/v6 to modern APIs

Whether you are launching a new subscription app or migrating an existing one, we can get you to production faster and with fewer surprises.