---
title: "RevenueCat React Native SDK adds React Native Web support"
description: "react-native-purchases gets web support; single code-base for subscriptions on three different platforms."
language: "en"
publishedAt: "2026-02-09T11:13:50Z"
updatedAt: "2026-02-09T11:13:50Z"
authors:
  - name: "Perttu Lähteenlahti"
    url: "https://www.revenuecat.com/blog/author/perttu-lahteenlahti"
category: "Engineering"
categoryUrl: "https://www.revenuecat.com/blog/engineering"
readingTime: 3
canonical: "https://www.revenuecat.com/blog/engineering/revenuecat-react-native-sdk-adds-react-native-web-support"
---

# RevenueCat React Native SDK adds React Native Web support

react-native-purchases gets web support; single code-base for subscriptions on three different platforms.

## Table of contents

- [Why we built this](#why-we-built-this)
- [How billing works on web](#how-billing-works-on-web)
- [Getting started with React Native Web](#getting-started-with-react-native-web)
- [Using Expo](#using-expo)
- [Current limitations](#current-limitations)
- [What’s next](#whats-next)

React Native apps can now support subscriptions across iOS, Android, and web using a single RevenueCat SDK instance. With React Native Web support, web purchases flow through RevenueCat Web Billing (powered by Stripe) into the same backend as native purchases, so entitlement checks stay consistent across platforms. Single code-base for subscriptions on three different platforms.

Starting from release [9.7.6 of react-native-purchases](https://github.com/RevenueCat/react-native-purchases/releases/tag/9.7.6), teams building with React Native can manage subscriptions across iOS, Android, and web using the same SDK and the same RevenueCat entitlements system. If your app already runs on mobile and you’re extending it to the web — or you’re starting with a shared codebase from day one — this makes it easier to support subscriptions everywhere without rethinking your architecture.

Add react-native-purchases to your Expo or React Native project, and you have power subscriptions, in-app purchases, entitlement management on three different platforms with a single code-base.

## **Why we built this**

As more React Native apps expand beyond mobile, the web has become part of the product rather than just a marketing surface. Teams want users to sign up, upgrade, or manage subscriptions in a browser, while still unlocking access inside their iOS and Android apps. Until now, that often meant maintaining a separate billing system for web and stitching everything together with custom logic.

React Native Web support removes that split. Web purchases flow into the same RevenueCat backend as native purchases, so you can rely on a single entitlements system instead of reconciling multiple sources of truth.

## **How billing works on web**

On iOS and Android, RevenueCat integrates directly with the App Store and Google Play. On the web, purchases are handled through [**RevenueCat Web Billing**](https://www.revenuecat.com/docs/web/web-billing/overview), which uses Stripe or Paddle as the payment processor. Web Billing is separate from native in-app purchases, but it connects to the same entitlements system, making it possible to grant access across platforms using a shared appUserID.

From your app’s perspective, subscription state stays consistent regardless of where a user originally subscribed. A customer who signs up on the web can immediately access premium features on mobile, without you needing to write platform-specific logic.

## **Getting started with React Native Web**

Enabling React Native Web support starts with configuring RevenueCat using the appropriate API key for each platform. When your app runs on the web, you’ll initialize the SDK with a Web Billing public API key, while iOS and Android continue to use their native keys.

Here’s what that looks like in practice:

```javascript
import { Platform } from 'react-native';
import Purchases from 'react-native-purchases';

if (Platform.OS === 'web') {
  Purchases.configure({ apiKey: '<public_web_billing_api_key>' });
} else if (Platform.OS === 'ios') {
  Purchases.configure({ apiKey: '<public_apple_api_key>' });
} else if (Platform.OS === 'android') {
  Purchases.configure({ apiKey: '<public_google_api_key>' });
}
```

Once configured, entitlement checks work the same way across platforms. Your app logic doesn’t need to branch based on where a subscription was purchased.

```javascript
import Purchases from 'react-native-purchases'
\/\/ all of the following methods work on iOS, Android, and Web

\/\/ Check offerings
try {
  const offerings = await Purchases.getOfferings();
  if (offerings.current !== null && offerings.current.availablePackages.length !== 0) {
    \/\/ Display packages for sale
  }
} catch (e) {
 
}

\/\/ Check entitlements
const customerInfo = await Purchases.getCustomerInfo();
if(typeof customerInfo.entitlements.active[<my_entitlement_identifier>] !== "undefined") {
  \/\/ Grant user "pro" access
}

\/\/ Purchase a package
try {
  const { customerInfo } = await Purchases.purchasePackage(package);
  if (
    typeof customerInfo.entitlements.active["my_entitlement_identifier"] !==
    "undefined"
  ) {
    \/\/ Unlock that great "pro" content
  }
} catch (e) {
  if (!e.userCancelled) {
    showError(e);
}

```

To enable web purchases, you’ll also need to create a **Web Billing app** in the RevenueCat dashboard and configure your products for web. These live alongside your iOS and Android products, but are billed through Web Billing rather than native stores.

## **Using Expo**

If you’re building with Expo, React Native Web support also improves the development experience. You can preview subscription UI, test entitlement logic, and validate integration flows directly on the web without immediately creating a custom development client. This makes it easier to iterate early and confirm that your setup works end to end.

To fully test real in-app purchases on iOS and Android, you’ll still need an Expo development build. Web support doesn’t replace that requirement, but it does remove a lot of friction during early development.

## **Current limitations**

Because web billing works differently from native app stores, there are a few limitations to be aware of. Web purchases require RevenueCat Web Billing and can’t process native iOS or Android in-app purchases. In addition, some operations that depend on native store APIs aren’t supported on web environments, including `getProducts`, `purchaseProduct`, and `restorePurchases`. Expo Go and similar sandbox enviroments don’t support purchasing either.

```javascript
\/\/ this will not work on web, but works on iOS and Android:
try {
  const restore = await Purchases.restorePurchases();
  \/\/ ... check restored purchaserInfo to see if entitlement is now active
} catch (e) {

}
```

Users can manage their web subscriptions through the RevenueCat-hosted customer portal, which provides a consistent way to update or cancel subscriptions outside of native app stores.

## **What’s next**

As subscription apps increasingly span mobile and web, we’re continuing to invest in making cross-platform subscription management simpler and more reliable. React Native Web support is a foundation for that work, and we’ll keep improving the experience as teams push it further in production.

If you’re already using RevenueCat with React Native on mobile, adding web support is now a natural next step.