EAS Build and Submit: Ship Expo Apps to the Stores (2026)
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.
| Job | Local tools | EAS command |
|---|---|---|
| Compile a store iOS binary | Xcode archive on a Mac | eas build --platform ios --profile production |
| Compile a store Android binary | Gradle / Android Studio | eas build --platform android --profile production |
| Upload the iOS binary | Transporter or Xcode | eas submit --platform ios |
| Upload the Android binary | Play Console | eas submit --platform android |
| Ship a JS-only fix | A new store binary | eas 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).
| Profile | What it is | Install it from |
|---|---|---|
development | developmentClient: true and distribution: internal. Includes expo-dev-client. Never submitted to a store. | A shareable URL, or an iOS Simulator build |
preview | No 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 |
production | The 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 whoaminpx 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:configureThat 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:
| Key | Where | Meaning |
|---|---|---|
cli.appVersionSource | Top level | remote (recommended since EAS CLI 12) stores ios.buildNumber and android.versionCode on Expo's servers. local reads them from the project. |
autoIncrement | Production profile | With remote, each production build bumps the iOS build number and the Android version code. It does not bump the user-facing version. |
distribution | internal or store | internal 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. |
developmentClient | Development | Requires expo-dev-client. These builds are not store builds. |
ios.simulator | Its own profile | A 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.buildType | Preview | apk for a file testers can install. Production should stay on the default app-bundle (.aab). |
channel | Each store or preview profile | The EAS Update channel this binary checks. Ignored when developmentClient is true, because a dev client can run any channel. |
environment | Profile | Which EAS environment's variables apply: development, preview, or production. |
env | Profile | Plain values you would commit. Not passwords. Secrets belong in EAS environment variables. |
submit.production.ios.ascAppId | Submit | The App Store Connect Apple ID. Required for non-interactive submit. |
submit.production.ios.appleTeamId | Submit | Your Apple Developer Team ID, when the Apple account belongs to more than one team. |
submit.production.android.track | Submit | internal, alpha, beta, or production. |
serviceAccountKeyPath | Android submit | Optional 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 productionThe 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-simulatorThat 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 productionIf 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 previewUse 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 iosOn 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:
- Sign in to App Store Connect and select the team.
- Open Apps and click the app.
- Stay on the App Store tab.
- Under General, open App Information.
- 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 iosChoose 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 androidPlay 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-submitDetails 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:configureCreate 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.
| Change | Ship it with |
|---|---|
| Copy, styling, a JS bugfix | eas update on the channel baked into the binary |
| A new native module, a config plugin, an icon, a permission string, an Expo SDK upgrade | eas build, then eas submit |
| A new marketing version | Edit 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-interactiveNon-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.
| Plan | Price | Builds | Update MAUs | Queue and timeout |
|---|---|---|---|---|
| Free | $0 | Up to 15 Android and 15 iOS builds | 1,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 build | 3,000, then usage | High priority. 2-hour timeout. Large workers |
| Production | $199/month plus usage | $225 of build credit, then per build | 50,000, then usage | High priority. 2-hour timeout. 15 concurrencies |
| Enterprise | Custom | Starting at $1,000 of build credit | Preferred pricing | High 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.
FAQ
The Free plan on expo.dev/pricing includes up to 15 Android builds and 15 iOS builds, a low-priority queue, a 45-minute build timeout, store submit, and EAS Update for 1,000 monthly active users. The Expo SDK is free. Starter is $19 per month plus usage ($45 of build credit). Production is $199 per month plus usage ($225 of build credit). Past the credit, iOS medium builds are $2 and Android medium builds are $1. Apple Developer Program ($99 per year) and Google Play ($25 once) are separate.
No, for the cloud path. eas build --platform ios runs on Expo's macOS builders, and eas submit --platform ios runs on macOS, Linux, or Windows (submit to the App Store). You need a Mac for the iOS Simulator, for Xcode, or for eas build --local on iOS.
ascAppId is the Apple ID number shown in App Store Connect under App Information, General Information. It identifies the app record to EAS Submit. It is not the bundle identifier (com.company.app) and not the Team ID. Set it on submit.production.ios in eas.json. Non-interactive submits require it.
eas build produces a new native binary and, for stores, a new upload. eas update publishes JavaScript and assets to a channel that an existing binary already trusts. Use update for a JS fix on the same runtime. Use build plus submit when native code, permissions, the icon, or the Expo SDK change.
Yes. Expo's current Play submit guide says the default eas submit creates the first release on the internal testing track, as long as the Play Console app exists and a Google service account key is assigned. The listing stays in draft until the Play setup tasks are done. A manual upload is optional. Set releaseStatus to draft if you want the file uploaded without a rollout.
Expo does not publish one typical duration. The setup guide says builds for a small app trigger within a few minutes. The pricing page says the Free plan's low-priority queue can wait 90 minutes or more at peak, and that high-priority queues are aimed at no wait. The Free build timeout is 45 minutes. Paid plans time out at 2 hours. After a successful iOS submit, TestFlight processing is usually 10 to 15 minutes.
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.
Drizzle vs Prisma in 2026 - which TypeScript ORM should you pick?
Drizzle vs Prisma for Next.js SaaS: schema, queries, migrations, serverless, and when each wins. Plus why TurboStarter ships Drizzle in production.
Envin - type-safe environment variable validation tool with live previews
Say goodbye to runtime environment variable errors with Envin. Get type-safe validation, live previews, and an interactive CLI that works across frameworks.



