Mobile development · Advanced · 20 min
How to Build and Submit an Expo App to the App Stores with EAS
By Padding · Updated 15 Nov 2026
Expo SDK 58 · EAS CLI 27
You will set up EAS for an Expo SDK 58 app, build it for testers with an internal distribution profile, build a production release, and submit it to TestFlight and Google Play, with the costs, the accounts you need and the places where credentials stay out of your repository.
On this page
A phone app has to be compiled, signed with a certificate that proves who made it, and uploaded to Apple's App Store Connect or the Google Play Console before anyone but you can install it. EAS, Expo Application Services, does the compiling in the cloud and keeps the signing credentials for you. That means you can build an iOS app without a Mac and an Android app without installing the Android toolchain. This tutorial takes an Expo SDK 58 project from "it runs in Expo Go" to a build in TestFlight and in a Google Play test track.
It covers three kinds of build, the eas.json file that describes them, and eas submit, the command that uploads a build to a store. Read the costs section first. The steps involve accounts that cost money and cannot be undone casually.
Step 1 · Know what you need and what it costs
- An Expo account is free. The free plan includes a limited number of cloud builds and runs them at low priority, so a build may wait in a queue. Paid plans on the pricing page (the Starter plan was listed at $19 a month and Production at $199 a month when this was written, each plus usage) give priority queues and more builds. Check expo.dev/pricing before you rely on the numbers.
- An Apple Developer Program membership is required to build for real iPhones, to use TestFlight and to publish on the App Store. It is a paid, yearly membership: check the current price on developer.apple.com. Without it you can still run your app in the iOS Simulator.
- A Google Play Developer account is required to publish on Google Play. Google charges a one-off registration fee, listed on its sign-up page. You can build and install Android apps on your own devices without it.
- Check your plan before you start practice builds: every build you start counts against it.
Everything that follows names the commands, but it does not run them for you. Run them in your own project, in a terminal, and answer the prompts yourself.
Step 2 · Install the EAS CLI and log in
The EAS command line is a Node package. Install it globally, or run it without installing through npx. This tutorial uses version 27:
npm install --global eas-cli@27
eas --version
eas login
eas whoamieas --version prints eas-cli/27. and more. eas login opens a browser to sign in, and eas whoami shows your username. In scripts and CI, set the EXPO_TOKEN environment variable to an access token created in your Expo account settings instead of logging in. Treat the token as a password: keep it in your CI provider's secret store, never in a file in the repository.
Step 3 · Configure the project
Run the configuration command from the project folder. It links the project to your Expo account and creates eas.json:
cd ~/expo-demo/hello-expo
eas init
eas build:configureeas init creates a project on your Expo account and writes its ID into app.json under extra.eas.projectId. That ID is not a secret. eas build:configure asks which platforms to configure and writes eas.json. The file it creates has three build profiles:
{
"build": {
"development": {
"developmentClient": true,
"distribution": "internal"
},
"preview": {
"distribution": "internal"
},
"production": {}
}
}A profile is a named set of options, and you pick one with --profile. What these three are for:
developmentmakes a development build: your app plus theexpo-dev-clientpackage, which gives you the Expo Go experience with your own native libraries. It needsexpo-dev-clientin the project (npx expo install expo-dev-client).previewmakes a build that you hand to testers directly, outside the stores.distribution: "internal"means the build gets a link that testers open, and on iOS the testers' devices must be registered in your Apple account.productionmakes the build that goes to the stores.
Two more settings usually belong in the file. cli.appVersionSource set to "remote" makes EAS keep the build number, so it no longer lives in your code, and autoIncrement in the production profile raises it on every build. Both stop you from submitting a build whose number the store has already seen. Expo's app versions documentation describes remote as the recommended source: Expo's servers store and increment android.versionCode and ios.buildNumber, starting from the value in your project, and the values in your app config are then ignored. With autoIncrement in build.production, each production build gets the next number. Add them:
{
"cli": {
"version": ">= 27.0.0",
"appVersionSource": "remote"
},
"build": {
"development": {
"developmentClient": true,
"distribution": "internal"
},
"preview": {
"distribution": "internal"
},
"production": {
"autoIncrement": true
}
},
"submit": {
"production": {}
}
}Commit eas.json. It holds no secrets and should be in version control. Before the first iOS build, also set a bundle identifier, and before the first Android build, a package name. Both are in app.json, and each must be unique to your app and cannot change once the app is published. Use a reverse domain you own:
{
"expo": {
"ios": { "bundleIdentifier": "com.example.helloexpo" },
"android": { "package": "com.example.helloexpo" }
}
}Keep the rest of your expo object as it is, and add only these two keys to it. Replace com.example.helloexpo with your own identifier.
Step 4 · Build for testers
Start with the preview profile, so you test on real devices before any store is involved. An Android build comes out as an installable file:
eas build --platform android --profile previewThe CLI asks about the keystore on the first Android build. Let EAS generate one: it stores it on its servers, ties it to your project, and you never handle the file. The build runs in the cloud, and the CLI prints a link to follow it. By default an Android build is an App Bundle (.aab), which is the format for Google Play and cannot be installed directly on a phone. For testers you want an .apk, so set buildType in the preview profile of eas.json before you build:
{
"build": {
"preview": {
"distribution": "internal",
"android": { "buildType": "apk" }
}
}
}When the build finishes, you get a URL and a QR code that installs the .apk on an Android device.
For iOS, register the test devices first. EAS creates an ad hoc provisioning profile that lists them:
eas device:create
eas build --platform ios --profile previeweas device:create gives you a link or QR code that each tester opens on their iPhone to register the device. The first iOS build asks you to sign in with your Apple ID. EAS then creates and stores the distribution certificate and provisioning profile for you. Answer the prompts. If you use two-factor authentication, enter the code Apple sends. Credentials live in your Expo account, which you manage with:
eas credentialsThat interactive command lets you view, replace or download the certificates, keystores and keys that EAS holds. Download a backup of your Android keystore before you publish: if you lose the key that signed your app, you cannot update it under the same listing without Google's help.
Step 5 · Build for the stores
A production build is signed for distribution through a store. Build for both platforms in one go, or one at a time:
eas build --platform all --profile productionFor the App Store it makes an .ipa signed with a distribution certificate, and for Google Play an .aab. With autoIncrement, each build gets the next build number. Builds are kept on EAS for a limited time, so submit promptly or download the files. eas build:list shows your recent builds, and --non-interactive makes the command fail instead of prompting, which is what you want in CI (the credentials must already exist).
Step 6 · Prepare the store listings
eas submit uploads the binary, and the store listing is still yours to fill in.
- On iOS, create the app record in App Store Connect with the same bundle identifier, or let
eas submitcreate it on the first run. Before you can release, App Store Connect needs the name, description, screenshots, a privacy policy URL and the answers to its privacy questions. - On Android, create the app in the Google Play Console. Before your first release, Play requires the store listing, a content rating, the data safety form, and, for accounts created as individuals after November 2023, a period of closed testing. Check the current rules in the Play Console help.
Step 7 · Submit to the stores
Submit the latest build of each platform. eas submit picks the profile named production by default:
eas submit --platform ios --latest
eas submit --platform android --latestThe flag --latest selects your most recent build for the platform. --id <build-id> picks a specific one, and --path takes a file you built elsewhere.
On iOS, the CLI asks for your Apple ID on the first run. For automation, create an App Store Connect API key in App Store Connect under Users and Access, Integrations, and give it to EAS with eas credentials --platform ios, so that submissions need no password or two-factor code. The build appears in TestFlight after Apple finishes processing it, which takes a few minutes to longer. A release to the public needs an App Review submission from App Store Connect.
On Android, eas submit needs a Google Service Account key to talk to the Play API. You create the key in Google Cloud and give it access in the Play Console, then upload it to EAS with eas credentials --platform android or in the Expo dashboard, under Credentials. For a new app, the default submission creates the first release on the internal testing track. In eas.json, the track and releaseStatus options control where it goes, and releaseStatus: "draft" uploads without rolling out:
{
"submit": {
"production": {
"android": {
"track": "internal",
"releaseStatus": "draft"
}
}
}
}To submit straight after a build, add --auto-submit to eas build, which uses the submit profile of the same name as the build profile.
Step 8 · Keep credentials out of the repository
Several eas.json options point to secrets, and they are easy to commit by accident:
serviceAccountKeyPathpoints to a Google Service Account key file. Prefer uploading the key to EAS, as above, and leave this option out. If a CI job needs the path, write the key to a file from the CI secret store during the job and delete it afterwards.ascApiKeyPath,ascApiKeyIssuerIdandascApiKeyIddescribe an App Store Connect API key. Leave them out for the same reason, and store the key witheas credentials.- Environment values your app needs at build time should be EAS environment variables, created with
eas env:set(use--visibility secretfor values that should stay hidden) or in the dashboard, not written intoeas.jsonas plainenvvalues. Remember that anything compiled into the app can be read by anyone who has the app, so a secret that must stay secret belongs on a server, never in the app. - Add the key files you keep locally, such as
*.p8,*.p12,*.keystoreand Google key files, to.gitignore. If one is ever committed, treat it as leaked and replace it. See keep secrets out of Git.
Step 9 · Check that it worked
After a build and a submission, check each place:
eas build:listshows the build with a status ofFINISHED, and the platform and profile you chose.- In App Store Connect, open TestFlight. The build appears under the app after processing, and you can add internal testers.
- In the Google Play Console, open Testing, Internal testing. The release appears with the version code that EAS assigned.
- Install the build on a device and open it. A development or preview build opens your app and shows the screens you wrote.
Troubleshooting
- A build fails in the "Install dependencies" phase: check that
package-lock.jsonis committed and matchespackage.json, and that the build log names a package that is not compatible with your SDK. Fix it locally, runnpx expo-doctor, and rebuild. - The iOS build asks for Apple login in CI: run
eas credentials --platform iosonce on your computer so the credentials exist, then build in CI with--non-interactive. eas submitsays the build number or version code has already been used: each upload needs a higher one. EnableappVersionSource: "remote"withautoIncrement.- The bundle identifier or package name is already taken: pick another. They are global across the store.
- Apple rejects an upload for a missing privacy declaration or usage description: the message names the key, for example a camera permission text. Add it to the
ios.infoPlistobject inapp.json.
Next steps
- Review the app you are building: create your first React Native app with Expo.
- Add screens and tabs: add navigation to an Expo app with Expo Router.
- Keep the keys safe: keep secrets out of Git.
Related tutorials
- How to Install Node.js 26 LTS on Ubuntu 26.04You will install Node.js 26 LTS with npm from the NodeSource apt repository on Ubuntu 26.04 so that apt keeps it patched, run a first script, set up global npm packages without sudo, and learn the checksum-verified tarball route as an alternative.
- How to Keep Passwords and API Keys Out of GitYou will keep secrets in a git-ignored .env file, commit a safe template instead, stop a commit that contains a key with a pre-commit hook, and learn what to do when a secret has already been committed.
Need this done for you?
Padding does this work for growing companies, from the first diagnosis to a system that keeps working.
Get new tutorials