Submit Android to Google Play

To submit your Android app to Google Play, we use EAS Build and Submit via GitHub Actions.

In this setup, we build the app on GitHub-hosted runners using the --local flag, which means the build is executed inside the GitHub CI environment — not on Expo’s servers. This helps avoid Expo’s build limits and costs, especially if you already pay for GitHub (e.g., via GitHub Pro or GitHub Team).

I chose this approach to centralize CI/CD billing via GitHub and avoid additional charges from EAS Build servers.

Prerequisites

To submit your Android app to Google Play, you need:

• A Google Play Developer account ($25 one-time fee)
• An Expo account for building and submitting your app using EAS
• A properly configured GitHub repository with your app code and GitHub Actions
• Your app linked to an Expo project via eas init

Once your accounts are set up and your app is ready, you can build and submit it using GitHub Actions.

1. Prepare Your App for Submission

Before submitting your app:

• The app should be fully developed and tested
• Required assets (icons, splash screens, screenshots, descriptions) must be ready
• Your app should be registered in the Google Play Console

Refer to Expo documentation to prepare your app.

2. Create Expo Account

Create a free Expo account. It is required to build and submit Android apps using EAS.

3. Link the Project to Expo

This template includes eas.json and .eas/ folders. You must link the project to your Expo account:

npx eas init --id-only

To verify the link:

npx eas project:view

You should see your Expo username and project name.

4. Set up eas.json

This template includes a basic eas.json. You can configure it like this:

{
  "cli": {
    "version": ">=3.0.0"
  },
  "build": {
    "production": {
      "releaseChannel": "production",
      "developmentClient": false,
      "distribution": "internal"
    }
  },
  "submit": {
    "production": {
      "android": {
        "track": "internal"
      }
    }
  }
}

5. Generate an Expo Access Token

Generate a token locally:

npx expo login
npx expo token:access

Then go to GitHub → Settings → Secrets → Actions → New repository secret and add:

• Name: EXPO_TOKEN
• Value: (paste the token)

This token will authenticate EAS builds from GitHub Actions.

You can change track to alpha, beta, or production depending on your desired release track in Google Play.

6. Run eas credentials Locally (important)

Before triggering GitHub Actions, configure Android credentials:

Step 1: Start credentials setup

npx eas credentials

Select:

Keystore: Manage everything needed to build your project

Step 2: Generate or provide a Keystore

You’ll be prompted:

• Let Expo generate a new Keystore ✅ (recommended for first-time upload)
• Or upload an existing .jks if you already published to Google Play

Expo will store this Keystore on their servers and use it to sign the app.

You can later download it using:

npx eas credentials -p android --download

🔐 Keystore Strategy (Dev vs Prod)

You will typically work with two SHA-1 certificates:

🔧 How to get SHA-1

Development SHA-1:

keytool -list -v -keystore ./android/app/debug.keystore \
  -alias androiddebugkey \
  -storepass android -keypass android

Production SHA-1:

• Go to Google Play Console
• Select your app → Setup → App Integrity
• Copy the App signing certificate SHA-1 fingerprint

Recommendation:

• Allow EAS to generate the keystore on first upload.
• For OAuth in dev, use SHA-1 from debug keystore.
• For OAuth in prod (Google Sign-In, RevenueCat, etc.), use SHA-1 from Play Console.
• If you previously uploaded an app — re-use your original .jks file.

7. Configure Sentry Integration

If you use Sentry to monitor your app, you can integrate it with EAS builds to automatically upload source maps and native debug symbols.

Required secrets:

• SENTRY_AUTH_TOKEN: Create one from your Sentry account here
• EXPO_PUBLIC_SENTRY_DSN: Copy from your Sentry project settings

Sentry CLI setup:

Expo CLI will automatically detect these variables during build and upload source maps.

More info: Expo + Sentry integration

8. Upload to Google Play

Once the .aab is built, you can manually upload it to the Google Play Console or use EAS Submit to automate this step.

To use EAS Submit, configure your Google Service Account and JSON key (see Expo docs).

You can also upload the .aab file manually from the GitHub Actions output.

9. Configure Secrets in GitHub

To use GitHub Actions with EAS, configure the following secrets in your GitHub repository:

• EXPO_TOKEN: Personal access token from Expo
• EXPO_PUBLIC_SUPABASE_PROJECT_URL
• EXPO_PUBLIC_SUPABASE_ANON_KEY
• EXPO_PUBLIC_GOOGLE_WEB_CLIENT_ID
• EXPO_PUBLIC_GOOGLE_WEB_CLIENT_SECRET
• EXPO_PUBLIC_GOOGLE_IOS_CLIENT_ID
• EXPO_PUBLIC_REVENUECAT_API_KEY_IOS
• EXPO_PUBLIC_SENTRY_DSN
• SENTRY_AUTH_TOKEN

10. GitHub Actions Workflow for EAS Build & Submit

Once everything is set up, you can manually trigger the GitHub Action to build and (optionally) submit your app.

The workflow file is located at:

.github/workflows/eas-build.yml

You can trigger it from the Actions tab in your GitHub repository.

The action supports the following parameters:

• platform — select android
• profile — choose between production or preview build profiles
• auto_submit — set to true if you want to automatically submit the build to TestFlight
• use_self_hosted — set to true if you want to build the app locally (useful when EAS build limits are reached)

If auto_submit is disabled, the build output will be saved as an artifact that you can download from the GitHub Actions UI.

11. Submit to Google Play

Once the build and (optional) submit finishes:

• The app will be uploaded to the selected track (e.g., internal or production)
• You can go to Google Play Console → your app → Releases to review and publish it

Resources