Submit Android to Google Play

To submit your Android app to Google Play, this template provides two GitHub Actions workflows powered by EAS Build and Submit:

• Cloud build (eas-build-cloud.yml) — the app is built on Expo’s servers (EAS Cloud).
• Local build (eas-build-local.yml) — the app is built on a GitHub-hosted (or self-hosted) runner using the --local flag, without relying on Expo’s servers.

Both workflows support the same inputs (platform, profile, auto_submit) and use the same environment names (production, preview). You can choose whichever path fits your project best.

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, First Submission of an Android App).

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

9. Configure Environment Variables & Secrets

Where you store secrets depends on which workflow you use:

• EAS Cloud (.github/workflows/eas-build-cloud.yml) Store runtime env and secrets in Expo (Project → Secrets). Follow the Cloud guide: Expo Environment Variables

• EAS Local on GitHub runner (.github/workflows/eas-build-local.yml) Store runtime env in GitHub Environments (e.g., production, preview), and global tokens as Repository secrets. Follow the Local guide: GitHub Environments

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.

Depending on your deployment path, run the appropriate workflow:

• EAS Cloud → .github/workflows/eas-build-cloud.yml (builds on Expo’s servers, can auto-submit).
• EAS Local → .github/workflows/eas-build-local.yml (builds on a GitHub runner using --local).

From the Actions tab in your repository, select the workflow and provide the inputs:

• platform: android
• profile: production (or preview)
• auto_submit: true to auto-submit to Google Play
• use_self_hosted: true if using your own runner (only for Local builds)

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