10+ AI SaaS templates for web & mobile
home

EAS Build and Submit: Ship Expo Apps to the Stores (2026)

ยท25 min read

Use EAS Build and EAS Submit to ship an Expo app to TestFlight, the App Store, and Google Play: eas.json, credentials, auto-submit, and EAS Update.

EAS Build is the cloud build for an Expo or React Native app. EAS Submit uploads the finished binary to App Store Connect or Google Play. Together they replace a local Xcode archive, a local Gradle release, and Apple's Transporter app for the usual store path.

Expo's pricing page (read on 17 November 2026) now calls the cloud products Expo Build, Expo Submit, and Expo Update. The CLI is still eas, the config file is still eas.json, and the docs URLs still contain eas. This guide uses the names people search, and it links the current docs for every command and key below.

If you already know React and want the wider map (Expo Router, permissions, sharing a Next.js API), start with the Expo React Native guide. This page is the build and store upload.

Short answer

Install EAS CLI, run eas login and eas build:configure, then eas build --platform ios --profile production (or android). On the first iOS build, let EAS create the distribution certificate and provisioning profile. Submit with eas submit --platform ios, or pass --auto-submit on the build. The binary shows up in TestFlight after Apple processes it, usually 10 to 15 minutes (submit to the App Store). Android production builds are an .aab. A preview profile with android.buildType set to apk is what you hand testers who are not on Play. JavaScript-only fixes after release go out with eas update on the same channel. Native changes still need a new store build.

Definition: EAS Build (eas build) compiles a signed iOS or Android binary on Expo's builders. EAS Submit (eas submit) uploads that binary to App Store Connect or Google Play. eas.json holds the named build profiles and the submit profile (including ascAppId on iOS).

What EAS Build and EAS Submit replace

A production iOS binary is an .ipa. A production Android binary for Play is an Android App Bundle (.aab). You can still make both on your own machine: eas build --local, Xcode, or Android Studio (create your first build). The cloud path exists so a Windows or Linux laptop can ship iOS, and so CI can repeat the same profile without a personal signing setup.

JobLocal toolsEAS command
Compile a store iOS binaryXcode archive on a Maceas build --platform ios --profile production
Compile a store Android binaryGradle / Android Studioeas build --platform android --profile production
Upload the iOS binaryTransporter or Xcodeeas submit --platform ios
Upload the Android binaryPlay Consoleeas submit --platform android
Ship a JS-only fixA new store binaryeas update --channel production

EAS Build's introduction is explicit about the split: cloud builds, internal distribution, and store submit are in scope. Debugging native code on your machine is not. Use a local build or npx expo run:ios when you are stepping through native code.

Development build or production build

Three profiles cover almost every app. eas build:configure creates them (configure with eas.json).

ProfileWhat it isInstall it from
developmentdevelopmentClient: true and distribution: internal. Includes expo-dev-client. Never submitted to a store.A shareable URL, or an iOS Simulator build
previewNo dev tools. Internal distribution, so testers install a build that behaves like production. Android should be an .apk here.The same internal URL, or Play internal testing if you submit a store build instead
productionThe empty default profile. Signed for the stores. An .aab on Android unless you override it.TestFlight, the App Store, or Google Play

You need a development build once the app uses a native module Expo Go does not include: push, in-app purchases, a custom dev client. You need a production build for TestFlight, App Review, and Play. Preview sits between them: stakeholders install a release-like binary without a store review.

Production store builds cannot be sideloaded. The exception Expo documents is an Android profile that sets "buildType": "apk". Use that for a file testers install directly. Keep the Play upload as an .aab.

Prerequisites

Store distribution has two memberships that are not Expo fees (build setup):

  • Apple Developer Program, $99 USD per year, before a release iOS build for the App Store.
  • Google Play Console developer account, a one-time $25 USD fee, before you can upload to Play. You can build and sign an Android binary without it.

You also need a free Expo account. Paid Expo plans change queue priority and limits. They are not required to run the first build.

Install the CLI and log in. Any of these package managers works. The docs show npm:

npm install --global eas-cli
eas login
eas whoami

npx eas-cli@latest is the alternative if you do not want a global install. Then, from the app directory (the folder with package.json and the Expo config):

eas build:configure

That writes eas.json next to package.json. Put the store identifiers in the Expo config before the first store build:

{
  "expo": {
    "ios": { "bundleIdentifier": "com.yourcompany.yourapp" },
    "android": { "package": "com.yourcompany.yourapp" }
  }
}

Create the App Store Connect app record (name, language, bundle identifier, SKU) and the Play Console app before you care about submit. The iOS and Android publishing walkthroughs in the mobile docs list the store screens. The publishing checklist is the rest: database, screenshots, privacy labels, review notes.

eas.json, explained

eas.json is the config for EAS CLI. Build settings live under build. Submit settings live under submit. If you omit --profile, the CLI uses the profile named production when that profile exists (eas.json for builds).

Profiles can extends another profile, up to five levels, with no cycles. Platform keys (ios, android) override the same key on the profile root.

This is a realistic file. The Apple and Google IDs are the shape from Expo's schema example. Replace them. Do not commit a Google service-account JSON file. If that key is stored on your Expo account, omit serviceAccountKeyPath.

{
  "cli": {
    "version": ">= 16.0.0",
    "appVersionSource": "remote"
  },
  "build": {
    "development": {
      "developmentClient": true,
      "distribution": "internal",
      "environment": "development",
      "channel": "development"
    },
    "development-simulator": {
      "extends": "development",
      "ios": {
        "simulator": true
      }
    },
    "preview": {
      "distribution": "internal",
      "environment": "preview",
      "channel": "preview",
      "android": {
        "buildType": "apk"
      }
    },
    "production": {
      "autoIncrement": true,
      "environment": "production",
      "channel": "production",
      "env": {
        "APP_ENV": "production"
      }
    }
  },
  "submit": {
    "production": {
      "ios": {
        "ascAppId": "1234567890",
        "appleTeamId": "AB12XYZ34S"
      },
      "android": {
        "track": "internal"
      }
    }
  }
}

cli.version is a semver range. >= 16.0.0 is the example in Expo's schema, not a version you have to pin. The installed CLI has to fall inside the range or the command stops.

What each part is doing:

KeyWhereMeaning
cli.appVersionSourceTop levelremote (recommended since EAS CLI 12) stores ios.buildNumber and android.versionCode on Expo's servers. local reads them from the project.
autoIncrementProduction profileWith remote, each production build bumps the iOS build number and the Android version code. It does not bump the user-facing version.
distributioninternal or storeinternal makes a shareable install URL (ad hoc or enterprise on iOS, and the artifact must be an .ipa or .apk). Omit it on production so the build is for the store.
developmentClientDevelopmentRequires expo-dev-client. These builds are not store builds.
ios.simulatorIts own profileA simulator .app is not an .ipa you can submit. Expo's docs say to keep it on a separate profile, not on the internal device profile.
android.buildTypePreviewapk for a file testers can install. Production should stay on the default app-bundle (.aab).
channelEach store or preview profileThe EAS Update channel this binary checks. Ignored when developmentClient is true, because a dev client can run any channel.
environmentProfileWhich EAS environment's variables apply: development, preview, or production.
envProfilePlain values you would commit. Not passwords. Secrets belong in EAS environment variables.
submit.production.ios.ascAppIdSubmitThe App Store Connect Apple ID. Required for non-interactive submit.
submit.production.ios.appleTeamIdSubmitYour Apple Developer Team ID, when the Apple account belongs to more than one team.
submit.production.android.trackSubmitinternal, alpha, beta, or production.
serviceAccountKeyPathAndroid submitOptional path to the Play service-account JSON on the machine running submit.

env on a profile is evaluated locally when you start eas build, and it is set on the builder. The schema says to keep secrets out of that object.

EAS Build for iOS

A store build:

eas build --platform ios --profile production

The first time, EAS CLI can sign in to your Apple Developer account and create the distribution certificate and provisioning profile. Accept that unless you already manage credentials. They are stored on Expo (credentialsSource defaults to remote). You can supply your own later with eas credentials --platform ios.

A simulator build is a different artifact. It does not need a paid Apple membership to install in the Simulator, and it cannot go to TestFlight:

eas build --platform ios --profile development-simulator

That matches the development-simulator profile above (ios.simulator: true). One .ipa profile cannot also be a simulator build.

iOS cloud builds run on macOS builders in Expo's macOS cloud (build introduction). Android cloud builds run on Linux. Your laptop's OS does not have to match.

eas build waits until the job finishes. You can leave it. The CLI prints a build page URL, and eas build:list finds it again. Add --message "TestFlight 1.4.0" if the dashboard should say why this binary exists.

EAS Build for Android

eas build --platform android --profile production

If you have no keystore yet, choose Generate new keystore when the CLI asks. Expo stores it. Losing a Play signing key is a bad week. A keystore EAS generated is still on your Expo account, and Play App Signing (a Google-generated app signing key) is the extra backup Google documents for the first upload (manual Android submission).

The default production profile produces an .aab. Google Play requires new apps to ship as app bundles. Play then generates device-specific APKs. A profile produces an .apk only when android.buildType is apk. That file installs on a device or emulator and cannot be submitted to Play (submit to Google Play).

For a tester build you can sideload:

eas build --platform android --profile preview

Use the preview profile from the example, the one with buildType: apk and distribution: internal.

EAS Submit

Submit picks a finished build and uploads it. Without a profile flag it uses submit.production when that profile exists (submit eas.json).

iOS: TestFlight and App Store Connect

eas submit --platform ios

On the first interactive run the CLI asks for your Apple ID, then uploads the .ipa. Set ascAppId so CI does not have to guess which app.

What ascAppId is. It is the Apple ID number of the app in App Store Connect, not the bundle identifier and not the Team ID. Expo's submit guide lists the clicks:

  1. Sign in to App Store Connect and select the team.
  2. Open Apps and click the app.
  3. Stay on the App Store tab.
  4. Under General, open App Information.
  5. Under General Information, copy Apple ID.

That number is ascAppId. The iOS publishing docs use the same screen. When ascAppId is set, EAS skips creating the App Store Connect app (schema). appleTeamId is your Apple Developer Team ID, used when one Apple login can see more than one team.

For a non-interactive upload, create an App Store Connect API key and assign it to the app:

eas credentials --platform ios

Choose the production build profile, then App Store Connect: Manage your API Key, then set the project up to use an API key for submit. You can also point ascApiKeyPath, ascApiKeyIssuerId, and ascApiKeyId at a .p8 you created yourself. An app-specific password is the older option: EXPO_APPLE_APP_SPECIFIC_PASSWORD plus appleId in eas.json.

Android: Play tracks and the service account

eas submit --platform android

Play does not accept your Expo login. Submit needs a Google service account JSON key with access to the Play Console app. Create it with Expo's service account guide, then either upload it under the project's Android credentials or pass serviceAccountKeyPath. eas credentials --platform android walks the same assignment: production profile, then Google Service Account, then the JSON path.

track is where the release lands: internal, alpha, beta, or production. Start on internal.

The first Android upload. Current Expo docs (the Play submit page, checked 17 November 2026) say the default eas submit creates the app's first release on the internal track. The Play listing stays in draft until you finish the store setup tasks, and those tasks are required before a production release. A manual first upload is optional: use it if you want to create that release yourself in Play Console, or set releaseStatus to draft if you want the binary uploaded without a rollout.

TurboStarter's Android publishing guide still documents the older manual-first path. If the kit page and the Expo page disagree, follow the Expo page for what the CLI does today, and still finish the Play Console dashboard tasks before you promote anything to production.

Build and submit in one command

--auto-submit hands a successful build to EAS Submit with the matching profile:

eas build --platform ios --profile production --auto-submit
eas build --platform android --profile production --auto-submit

Details are on automate submissions.

Expo TestFlight, then review

This is the path from a configured project to testers on TestFlight, then to App Review. Commands are the ones in submit to the App Store.

Confirm the Apple membership and the bundle identifier. The bundle identifier in the Expo config has to be the one on the App Store Connect app. Copy ascAppId from App Information into submit.production.ios.

Build. eas build --platform ios --profile production. Let EAS manage credentials on the first run. Wait for the build page to say finished.

Submit. eas submit --platform ios, or add --auto-submit on the build. Apple processes the binary. Expo's docs say it usually appears in TestFlight in 10 to 15 minutes.

Add testers in App Store Connect. Internal testers can install from the TestFlight app once processing finishes. submit.ios.groups can name internal TestFlight groups so EAS adds the build there. Groups created with App Store Connect's "Enable automatic distribution" setting receive the build as well (submit schema).

Submit for App Review when you want the public store. TestFlight is not the App Store. In App Store Connect, attach the build to a version, fill screenshots, privacy details, and review notes, then send it to review. Expo's submit guide stops at the upload on purpose: release is a button in App Store Connect. Apple's App Review page is the policy.

After approval you choose when the version goes live (automatically, on a date, or when you press release). The iOS publishing guide shows that distribution step with the store screens.

Versioning while you iterate on TestFlight: you can upload build 48, 49, and 50 all labeled 1.6.2. You cannot upload a build number the store already has. With appVersionSource: remote and autoIncrement: true, EAS bumps the build number and leaves the marketing version to you. The marketing version is what you change when you want a new user-facing release. The versioning guide is the cross-platform version of that rule. If the app is already live and EAS does not know the current build number, seed it once with eas build:version:set (app versions).

EAS Update for the fixes that are not native

EAS Update (eas update) publishes the JavaScript bundle and assets. Devices on a matching binary download them. It does not replace a store build.

npx expo install expo-updates
eas update:configure

Create a new store build after eas update:configure so the binary knows its channel. Later JS fixes:

eas update --channel production --message "Fix login button alignment"

That command is the one in the EAS Update introduction. The binary only accepts an update for the same platform, the same runtime, and the same channel.

Set runtimeVersion with the appVersion policy if you want the runtime to follow the user-facing version. Expo's app-version docs say autoIncrement does not support the nativeVersion runtime policy. Use appVersion instead. When you bump expo.version and ship a new binary, older OTA updates stay on the previous runtime.

ChangeShip it with
Copy, styling, a JS bugfixeas update on the channel baked into the binary
A new native module, a config plugin, an icon, a permission string, an Expo SDK upgradeeas build, then eas submit
A new marketing versionEdit version, then a new production build

Store rules still apply to OTA updates. Expo's own FAQ says behavior changes usually belong in review. A critical JS fix can go out immediately, with a store binary that contains the same fix following it.

A user who never downloads an update is not an update MAU. One install that downloads one or more updates in the billing cycle counts as one MAU (pricing).

CI without prompts

Two ways to run the same commands without a laptop session.

EAS Workflows use a YAML file under .eas/workflows/. Expo's iOS example builds on every push to main and submits to TestFlight with a testflight job. The Android example uses a submit job. Both are copied from the current submit guides:

name: Submit iOS

on:
  push:
    branches: ["main"]

jobs:
  build_ios:
    name: Build iOS app
    type: build
    params:
      platform: ios
      profile: production

  submit_ios:
    name: Submit to TestFlight
    needs: [build_ios]
    type: testflight
    params:
      build_id: ${{ needs.build_ios.outputs.build_id }}

Run it by hand with eas workflow:run submit-ios.yml.

GitHub Actions (or any other CI) calls the CLI. Create a personal access token on your Expo account and set it as EXPO_TOKEN. Then:

eas build --platform ios --profile production --non-interactive --auto-submit
eas submit --platform ios --profile production --non-interactive

Non-interactive mode cannot ask you to create credentials. iOS fails with App Store Connect API Keys cannot be set up in --non-interactive mode. until an API key is assigned to the app (or you pass ascApiKeyPath / issuer / key id). Android fails with Google Service Account Keys cannot be set up in --non-interactive mode. until a key is assigned or serviceAccountKeyPath points at a file on the runner. The submit profile also needs ascAppId for iOS.

The Free plan includes up to 60 minutes of CI/CD Workflows. Build jobs inside a workflow still draw from the plan's build allowance, not from that minute bucket (pricing).

What it costs

Numbers below are from expo.dev/pricing on 17 November 2026. The Expo SDK is free and MIT-licensed. These prices are the cloud services. Store fees ($99 per year, $25 once) are separate.

PlanPriceBuildsUpdate MAUsQueue and timeout
Free$0Up to 15 Android and 15 iOS builds1,000, no overage (the plan stops at the included MAUs)Low priority. 45-minute build timeout
Starter$19/month plus usage$45 of build credit, then per build3,000, then usageHigh priority. 2-hour timeout. Large workers
Production$199/month plus usage$225 of build credit, then per build50,000, then usageHigh priority. 2-hour timeout. 15 concurrencies
EnterpriseCustomStarting at $1,000 of build creditPreferred pricingHigh priority. 20 concurrencies

After the included credit, a build is a flat rate: Android medium $1, Android large $2, iOS medium $2, iOS large $4. The large resource class is not on the Free plan.

Update overage on Starter and Production starts at $0.005 per MAU past the included allowance (3,000 and 50,000). The Free plan has no overage rate. It is capped at 1,000 MAUs.

Expo's pricing page says the low-priority queue can mean waits of 90 minutes or more at peak, and that they aim for no wait on the high-priority queue. That is a queue time, not a compile time. The build setup guide says a small app's builds trigger within a few minutes. It does not publish a typical compile duration, so this page does not invent one.

eas build --local uses your machine and does not spend a cloud build. iOS local builds still need a Mac.

Errors worth recognizing

These are the failures the current docs name. The build log is still the source of truth: open the build page and expand the first phase that failed (troubleshooting).

Credentials in CI. The two non-interactive errors above. Fix them by assigning an App Store Connect API key or a Play service-account key before the workflow runs. Interactive eas build on a laptop can create the iOS certificate for you. CI cannot.

Bundle identifier mismatch. Submit prerequisites require ios.bundleIdentifier and android.package in the Expo config. ascAppId selects an existing App Store Connect app. Those three values have to describe the same app. A production binary signed for com.yourcompany.yourapp will not attach to a record created for a different identifier. If you use separate bundle IDs per environment, give each one its own App Store Connect app and its own ascAppId.

Version or build number already used. Expo's app version guide calls a duplicate developer-facing version a common store rejection: you uploaded a build number TestFlight or Play already has. Turn on autoIncrement with appVersionSource: remote, or set the remote counter with eas build:version:set so the next bump starts above the live build. Play also requires a unique version code on every release (manual Android submission).

Privacy manifest. If the app or a native dependency calls Apple's required-reason APIs (UserDefaults, file timestamps, disk space, boot time, active keyboard), the binary needs a privacy manifest. Add ios.privacyManifests in the Expo config, and run npx expo install --fix so Expo SDK packages are current. Apple emails you within a few minutes of a TestFlight external review or an App Store submit if a required reason is missing (privacy manifests). That email is the list of reasons to add. It is not a guess you should invent in advance.

Permission strings. iOS usage descriptions live in ios.infoPlist (for example NSCameraUsageDescription) or on the config plugin that adds the permission. Expo's permissions guide says a missing or unexplained permission can get the app rejected or pulled, and that the default plugin copy usually needs to describe your app. Info.plist edits do not ship over the air. They need a new eas build.

Gradle killed the JS bundle. The log line Gradle build daemon disappeared unexpectedly means the Node process bundling JavaScript was killed. Expo's troubleshooting page points at a huge JS bundle and, as a capacity fix, the large resource class. That class needs a paid plan.

A file in .gitignore is missing on the builder. eas build does not upload ignored files. The failure looks like None of these files exist. Move secrets to EAS environment variables. Do not delete the gitignore entry for a key just to make the upload succeed.

If the JS bundle is the part that fails, npx expo export reproduces the Metro error locally without waiting for a cloud build.

How TurboStarter ships the same setup

TurboStarter is a production-ready starter kit: a Next.js web app, an Expo mobile app, and a browser extension, on one backend you own. The mobile app is apps/mobile. It calls the same API and the same auth as the web app. There is no second user table for phones. The layout is the one in cross-platform SaaS with one backend.

The kit's EAS config is apps/mobile/eas.json, documented in app configuration. That example uses a base profile for shared env, a preview profile that extends it with distribution: internal and an Android apk, and a production profile with its own APP_ENV. The example also sets ios.resourceClass to m-medium. The current Expo schema lists default, medium, and large (large is not on the Free plan). If you are editing that file, use a value from the schema. Build infrastructure is the page for images and worker sizes. Keep the CLI, Node, and pnpm fields aligned with the repo.

Versioning in the kit matches the remote source described above. Production builds use autoIncrement, and runtimeVersion uses the appVersion policy, so an OTA bundle stays on the marketing version of the binary that can run it (mobile versioning). JS-only fixes use OTA updates:

eas update --environment production --channel production --message "Fix checkout copy"

Native changes still go through the store checklist.

Submit is the GitHub Actions workflow at .github/workflows/publish-mobile.yml. It needs EXPO_TOKEN in the repository secrets, an App Store Connect API key assigned with eas credentials --platform ios, and ascAppId in the submit profile. Android uses a Play service-account key uploaded to EAS so the JSON file stays out of the repo. That is the flow in the iOS and Android publishing docs.

Auth on that binary is Better Auth, shared with the web app: Better Auth on Expo and the Expo Better Auth template. In-app purchases are a native SDK. They do not run for real inside Expo Go, so they belong on a development or production build. The billing tradeoff is covered in RevenueCat vs Stripe and Superwall vs RevenueCat.

Which kit includes the mobile app is the kit chooser. Core Kit is the one with web, mobile, and the extension. Compare is the side-by-side with other starters. Pricing for the kit is on the homepage. EAS itself is billed by Expo, on the account you connect, not by the starter kit.

Ship web and mobile from one repoCore Kit is the Expo app, the web app, and the extension on one backend.
Try TurboStarter

FAQ

Ship the binary, then the JS

EAS Build is how you get a signed binary without owning the Xcode or Gradle machine. EAS Submit is how that binary reaches TestFlight, App Review, and Play. Keep eas.json boring: development and preview on internal, production on the store defaults, appVersionSource remote, autoIncrement on production, ascAppId and an Android track in the submit profile. Use EAS Update for the JS fixes that match the runtime you already shipped. Anything native still goes through eas build and the stores.

When the same product also has a web app, the binary should call the backend you already run. That is the mobile app in the TurboStarter docs, not a second API.

world map
Community

Connect with like-minded people

Join our community to get feedback, support, and grow together with 1,000+ builders on board, let's ship it!

Join us

Ship your startup everywhere. In minutes.

Don't burn tokens on setup and start building features on day one.

Get TurboStarter