Skip to main content

Publishing a React Native App to the Google Play Store: Complete Guide

· 10 min read
Michael
Mobile Developer
Last updated on August 14, 2025

publishing a react native app to the google play store

Congratulations on building your React Native app! You’re ready to share it with millions of Android users on the Google Play Store. Publishing might feel like a big step, but don’t worry—this beginner-friendly guide will walk you through every part of the process using Expo SDK, compatible with React Native 0.75.4 and Android SDK 35. We’ll use Expo Application Services (EAS) to make things smooth, and we’ll explain key terms like applicationId and keystore along the way. No prior Play Store experience is needed, and for a head start, check out prebuilt templates at Instamobile or Dopebase.

By the end, your app will be live on the Play Store, ready for users to download. Let’s dive in!

Prerequisites​

Before we start, make sure you have these tools and accounts ready:

  • Node.js (v20.x or later, LTS recommended): Download from nodejs.org.
  • npm (v10.x or later, included with Node.js).
  • Expo CLI: For easy React Native development.
  • Android Studio (2024.3.2 or later): For Android builds, with Android SDK 35 and NDK r25+.
  • A code editor like VS Code.
  • Git: For version control.
  • Google Play Developer Account: Sign up at play.google.com/console ($25 one-time fee).
  • Java Development Kit (JDK): Version 17 or later, included with Android Studio.

Got everything? Awesome—let’s create your app!

Step 1: Create and Configure Your React Native Project​

Let’s kick things off by setting up a React Native project ready for the Google Play Store.

  1. Install Expo CLI globally:

    npm install -g expo-cli

  2. Create a new project called MyApp:

    expo init MyApp

    Choose the blank (TypeScript) template for a type-safe setup with Expo SDK, which supports React Native.

  3. Navigate to your project folder:

    cd MyApp

  4. Configure app.json for Google Play:

    {
      "expo": {
        "name": "MyApp",
        "slug": "myapp",
        "version": "1.0.0",
        "orientation": "portrait",
        "icon": ".https://docs.instamobile.io/assets/icon.png",
        "splash": {
          "image": ".https://docs.instamobile.io/assets/splash.png",
          "resizeMode": "contain",
          "backgroundColor": "#ffffff"
        },
        "android": {
          "package": "com.myapp.app",
          "versionCode": 1
        }
      }
    }

    What’s a package (applicationId)? The package (or applicationId) is a unique identifier for your app in the Android ecosystem, using reverse-domain format like com.yourcompany.myapp. It’s like your app’s unique ID and can’t be changed after publishing, so choose wisely! Learn more in Android’s documentation.

    • Use a unique package (e.g., com.yourcompany.myapp).
    • Prepare a 512x512 PNG icon and a 2000x2000 PNG splash screen in assets/.

  5. Test your app locally:

    npx expo start

    Press a to run on an Android emulator or device. Make sure everything works smoothly before moving forward.

Summary: You’ve set up a React Native project with Expo SDK and configured app.json with a unique applicationId for the Play Store.

Mega Bundle Sale is ON! Get ALL of our React Native codebases at 90% OFF discount 🔥

Get the Mega Bundle

Step 2: Set Up Your Google Play Developer Account​

With your project ready, let’s get your Google Play Developer account set up to publish your app.

  1. Sign up for a Google Play Developer account at play.google.com/console ($25 one-time fee).
  2. Complete the account setup:
    • Provide your name, organization (or individual), and payment details.
    • Accept the Developer Program Policies and US export laws.
  3. Create a Google Service Account for EAS:
    • In the Play Console, go to Setup > API access > Choose a project to link.
    • Select Create a new project and click Link project.
    • Under Service Accounts, click Create Service Account, name it (e.g., MyAppService), and select Service Account User role.
    • Click Add Key > Create new key > JSON, then download the key file and store it securely. This key lets EAS submit your app automatically. Learn more in Expo’s guide.

Summary: Your Google Play Developer account is ready, with a service account for automated submissions. Let’s configure EAS next!

Step 3: Configure EAS for Play Store Builds​

Expo Application Services (EAS) makes building and submitting Android apps super easy. Let’s set it up.

  1. Log in to Expo:

    eas login

    Authenticate via the browser.

  2. Configure EAS for your project:

    eas build:configure

    This creates an eas.json file:

    {
      "build": {
        "development": {
          "developmentClient": true,
          "distribution": "internal"
        },
        "preview": {
          "distribution": "internal"
        },
        "production": {
          "distribution": "store",
          "android": {
            "credentialsSource": "remote"
          }
        }
      }
    }

  3. Set up Android credentials:

    eas credentials

    Follow the prompts to upload your Google Service Account JSON key for automated Play Store submissions.

Summary: You’ve connected your project to EAS, setting the stage for Play Store-ready builds. Now, let’s create a signed app bundle!

Step 4: Generate a Signed Android App Bundle (AAB)​

Google Play requires apps to be submitted as Android App Bundles (AAB) since August 2021, signed with a secure key. Let’s generate one.

  1. Generate a keystore for signing:

    keytool -genkeypair -v -storetype PKCS12 -keystore my-upload-key.keystore -alias my-key-alias -keyalg RSA -keysize 2048 -validity 10000

    What’s a keystore and upload key? A keystore is a secure file that stores your app’s signing keys. The upload key (inside the keystore) signs your AAB, proving it’s from you. Google’s Play App Signing manages the final release key, but you control the upload key. Keep it safe, as losing it prevents future updates! See Android’s signing guide.

    • Enter your details and passwords when prompted. Store the my-upload-key.keystore file securely.
    • Note the alias (my-key-alias) and passwords.

  2. Configure Gradle to use the keystore:

    • Copy my-upload-key.keystore to android/app/.
    • Edit android/gradle.properties: 
      MYAPP_UPLOAD_STORE_FILE=my-upload-key.keystore
      MYAPP_UPLOAD_KEY_ALIAS=my-key-alias
      MYAPP_UPLOAD_STORE_PASSWORD=your_keystore_password
      MYAPP_UPLOAD_KEY_PASSWORD=your_key_alias_password
    • Update android/app/build.gradle: 
      android {
        ...
        defaultConfig {
          applicationId "com.myapp.app"
          versionCode 1
          versionName "1.0.0"
        }
        signingConfigs {
          release {
            if (project.hasProperty('MYAPP_UPLOAD_STORE_FILE')) {
              storeFile file(MYAPP_UPLOAD_STORE_FILE)
              storePassword MYAPP_UPLOAD_STORE_PASSWORD
              keyAlias MYAPP_UPLOAD_KEY_ALIAS
              keyPassword MYAPP_UPLOAD_KEY_PASSWORD
            }
          }
        }
        buildTypes {
          release {
            signingConfig signingConfigs.release
            minifyEnabled true
            proguardRules '-keep class com.myapp.** { *; }'
          }
        }
      }

  3. Build the AAB:

    cd android && ./gradlew bundleRelease

    The AAB is generated at android/app/build/outputs/bundle/release/app-release.aab.

  4. Test the release build:

    npx react-native run-android --mode=release

    Uninstall any previously installed debug builds to prevent signing conflicts.

Summary: You’ve created a signed AAB with a secure keystore, ready for Play Store submission. Let’s upload it next!

Step 5: Submit to the Google Play Store​

It’s time to get your app into the Play Store for review.

  1. Create your app in Google Play Console:

    • In the Play Console, click Create app.
    • Enter:
      • App name: The name users see (e.g., “MyApp”).
      • Default language: Your app’s primary language.
      • App or game: Select “App” unless it’s a game.
      • Free or paid: Choose your pricing model.
    • Confirm Developer Program Policies and US export laws.

  2. Fill in app metadata:

    • Go to App content in the Play Console:
      • App description: Write a clear, engaging description with relevant keywords.
      • Screenshots: Add 2–8 screenshots for 7-inch and 10-inch devices (use tools like Figma for professional UI mockups or to enhance your screenshots).
      • App icon: Use the 512x512 PNG from app.json.
      • Category: Choose a relevant category (e.g., “Productivity”).
      • Privacy policy: Required for apps with user data (use Termly).
    • Set availability (e.g., worldwide).

  3. Upload the AAB via EAS:

    eas submit --platform android

    Select the app-release.aab file. EAS uploads it to the Play Console. Note: The first submission must be manual due to Google Play API limitations; subsequent submissions can be automated.

  4. Create a release:

    • In Play Console, go to Production > Create new release.
    • Upload the AAB, add release notes (e.g., “Initial release: exciting features!”), and set a release name (e.g., v1.0.0).
    • Click Start rollout to production.

  5. Wait for Google’s review, typically 24–48 hours, though it may take longer depending on the app’s complexity and permissions. Check App status in the Play Console and respond to feedback promptly.

Summary: You’ve submitted your app with all required metadata and are awaiting Google’s approval. You’re almost live!

Mega Bundle Sale is ON! Get ALL of our React Native codebases at 90% OFF discount 🔥

Get the Mega Bundle

Step 6: Launch and Maintain Your App​

Your app’s approved—time to celebrate! Let’s launch it and keep it running smoothly.

  1. Launch Your App:

    • After approval, your app’s status changes to “Available on Google Play.” Share its Play Store link via social media or platforms like Instamobile.
    • Monitor downloads and reviews in the Play Console.

  2. Enable OTA Updates (Optional):

    • Install expo-updates for instant JavaScript and asset updates: 
      npm install expo-updates
      Check the latest compatible version for Expo SDK in Expo’s package documentation. What are OTA updates? Over-the-air updates let you push new JavaScript code or assets (like images) to users without a new Play Store submission, perfect for quick bug fixes or small feature updates. They’re fast and don’t require app store approval, saving you time. See Expo’s Updates guide.
    • Update app.json: 
      {
        "expo": {
          "updates": {
            "enabled": true,
            "url": "https://u.expo.dev/your-project-id",
            "checkAutomatically": "ON_LOAD",
            "fallbackToCacheTimeout": 0
          }
        }
      }
      Replace your-project-id with the ID from eas update:configure.
    • Add update-checking logic to src/App.tsx: 
      import { useEffect } from 'react';
      import { View, Text } from 'react-native';
      import * as Updates from 'expo-updates';

      export default function App() {
        useEffect(() => {
          const checkForUpdates = async () => {
            try {
              const update = await Updates.checkForUpdateAsync();
              if (update.isAvailable) {
                await Updates.fetchUpdateAsync();
                await Updates.reloadAsync();
              }
            } catch (e) {
              console.error('Update check failed:', e);
            }
          };
          if (!__DEV__) {
            checkForUpdates();
          }
        }, []);

        return (
          <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
            <Text>Welcome to MyApp!</Text>
          </View>
        );
      }
    • Publish updates: 
      eas update --branch production

  3. Release Updates:

    • Increment versionName and versionCode in android/app/build.gradle (e.g., versionName "1.0.1", versionCode 2).
    • Rebuild the AAB: 
      cd android && ./gradlew bundleRelease
    • Upload via Play Console or EAS, add release notes, and roll out.

Summary: Your app is live, and you’ve set up OTA updates for quick fixes and a process for future releases, keeping your users happy.

Troubleshooting Tips​

  • Build Fails: Verify android/gradle.properties and keystore details. Ensure Android Studio uses SDK 35.
  • Play Store Rejection: Common issues include missing privacy policies or sensitive permissions. Review Google’s Developer Program Policies and resubmit.
  • Signature Conflicts: Uninstall any previously installed debug builds before testing release builds (npx react-native run-android --mode=release).
  • EAS Errors: Check eas.json and Google Service Account key. Rerun eas credentials if needed.
Looking for a custom mobile application?

Our team of expert mobile developers can help you build a custom mobile app that meets your specific needs.

Get in Touch

Conclusion​

You’ve successfully published your React Native app to the Google Play Store using Expo SDK! From setting up your project to navigating Google’s review process, you’re now ready to share your app with the world. For a faster path to market, explore Play Store-ready templates at Instamobile or Dopebase. Want to dive deeper? Check out Expo’s documentation for advanced workflows or join the React Native community at reactnative.dev.

Additional Resources​