There is a Free plan. As of September 2026 it includes up to 15 Android and 15 iOS builds a month in the low-priority queue, with a 45-minute build timeout, one build at a time and medium workers only. Free accounts cannot go over the quota; once it is used, new builds wait until the first day of the next calendar month. The Starter plan is $19 a month plus usage, with $45 of build credit, the high-priority queue and a 2-hour timeout. After the credit is used, builds are billed at a flat rate: $1 or $2 for Android and $2 or $4 for iOS, depending on worker size.

Do I need a Mac to use EAS Build?

Not for cloud builds. EAS Build compiles iOS apps on its own macOS machines, so you can produce an .ipa from Windows or Linux. You do need a Mac if you run eas build --local for iOS, because the local flag runs the same pipeline on your machine and needs Xcode, fastlane and CocoaPods installed. Store and device builds for iOS also need an Apple Developer Program membership regardless of where they compile.

How long does an EAS build take?

Two clocks matter. Queue time depends on your plan: Free plan builds sit in the low-priority queue, which Expo says can reach 90 minutes or more at peak, while paid plans target zero wait in the high-priority queue. Build time depends on your project and the worker size; Expo caps it at 45 minutes on the Free plan and 2 hours on paid plans, and a build that runs past the cap is canceled. Expo publishes live queue lengths and average processing times on its EAS Build status page, which is the honest answer for any given afternoon.

What is the difference between an EAS development build and Expo Go?

Expo Go is a prebuilt sandbox app with a fixed set of native modules, so it can only run projects that stay inside that set. An EAS development build is your own app compiled with the expo-dev-client library, which gives you the same fast-refresh workflow plus any native library or native configuration you need. It is produced by the development profile in eas.json, which sets developmentClient to true and distribution to internal, and it is never submitted to a store.

Can I use EAS Build without an Apple Developer account?

For iOS Simulator builds, yes: set ios.simulator to true on a profile and EAS produces a .app you can run in the Simulator without any store membership. For anything that installs on a physical iPhone through EAS, or goes to TestFlight and the App Store, you need to sign in with an Apple Developer Program membership so EAS can generate a distribution certificate and provisioning profile. Expo notes that the only way to put a development build on an iPhone without a paid Apple account is to compile it locally with Expo CLI rather than through EAS.

GuidesUpdated September 2026

EAS Build: profiles, credentials, queue times and cost.

EAS Build is Expo's hosted build service: you run one command, your project is uploaded to a fresh virtual machine, compiled into a signed Android or iOS binary, and handed back as an install link or a store upload. If you are still getting oriented in the Expo ecosystem, start with Expo for beginners. This page assumes you have a project and want to know what happens when you type eas build, what it costs, and why a free build can sit in a queue for an hour.

Everything below comes from Expo's own documentation and pricing page, checked in September 2026. Prices and quotas change, so wherever a number matters, the source is linked for you to re-check.

See the three default build profiles

The short version

One command, three profiles, and a queue you pay to skip.

EAS Build compiles your Expo or React Native project in the cloud, so you can produce an iOS build without owning a Mac. A new project gets three build profiles in eas.json: development (includes developer tools, installs directly on a device), preview (no dev tools, still installs directly) and production (store-signed, installed through the stores). EAS generates and stores your signing credentials the first time you build. The Free plan includes up to 15 Android and 15 iOS builds a month in a low-priority queue that can wait 90 minutes or more at peak; the $19 a month Starter plan buys the high-priority queue and $45 of build credit, then $1 to $4 a build after that.

The service

What actually happens when you run eas build.

Expo splits the release process into three services that are easy to mix up. EAS Build compiles the binary. EAS Submit uploads it to App Store Connect or Google Play. EAS Update ships JavaScript changes to apps that are already installed. This page is about the first one. Whether you search for expo eas build, expo/eas build or eas build expo, you land on the same thing: a hosted pipeline that does the native compile step you would otherwise do in Xcode and Android Studio.

Expo's own description of the setup is that for a small app, builds for both platforms trigger within a few minutes. What happens after that, in order:

1UploadEAS CLI compresses your project and sends it to EAS along with the profile you picked.

2Fresh workerA dedicated VM starts for the job: Linux for Android, macOS on Mac mini hosts for iOS. Every build gets its own.

3Native projectIf the repo has no android or ios folder, prebuild generates them from your app config before anything compiles.

4Compile and signGradle or Xcode builds the app, then it is signed with the credentials EAS holds for the project.

5ArtifactAn .apk, .aab, .ipa or simulator .app, plus logs, a build page, and an install link or a hand-off to EAS Submit.

What EAS Build is not

It is not Expo Go, the sandbox app you scan a QR code into; a build is your own binary. It is not a substitute for a store developer account; Apple and Google still charge for those. And it is not required to compile locally: npx expo run:ios and npx expo run:android do that with your own Xcode and Android Studio, no Expo account needed.

Each cloud build runs on an image that pins the operating system, Xcode, Node and CocoaPods versions. You choose one with the image field in eas.json, or take the auto alias and let EAS match your SDK. Which image a given SDK expects, and what changed in the native toolchain along the way, is its own topic: Expo SDK 54.

Build profiles

The three default build profiles.

eas build:configure writes an eas.json next to package.json. In a new project it contains three profiles, and Expo's docs are explicit that the names are conventions rather than magic: they could just as well be called foo, bar and baz. What matters is the flags inside each one.

{
  "build": {
    "development": {
      "developmentClient": true,
      "distribution": "internal"
    },
    "preview": {
      "distribution": "internal"
    },
    "production": {}
  }
}

Run a profile with eas build --profile preview. Leave the flag off and EAS CLI uses the profile named production, if there is one. Profiles can inherit from each other with extends, up to five levels deep, which is how most teams keep one set of tool versions and environment settings and vary only how the build is distributed.

Profile	developmentClient	distribution	What you get	Who installs it
development	Yes	internal	Debug build with expo-dev-client, the dev menu and a launcher for switching dev servers	You, on a device, simulator or emulator
preview	No	internal	Release-style build with no developer tools: an .apk, or an ad hoc .ipa	Testers and stakeholders, from an install link
production	No	store (default)	Store-signed .aab and .ipa, ready for EAS Submit	End users, through Google Play, the App Store or TestFlight

Defaults and behaviour from Expo's eas.json documentation.

EAS development build: your own Expo Go

An eas development build is a debug build that includes expo-dev-client. Expo describes it as your own version of Expo Go: the same fast-refresh workflow, but it can include any native library and any native configuration, which Expo Go cannot. It defaults to internal distribution so it installs straight onto a physical device. For the iOS Simulator you add "ios": { "simulator": true } on a separate profile, which Expo suggests naming development-simulator. Android needs no such split: one .apk runs on both a device and the emulator. Development builds are never submitted to a store.

Preview builds

Preview builds drop the developer tools and are meant for people who are not you: testers, a client, a founder who wants to poke at the app on a Friday. They install directly rather than through a store, which on iOS means ad hoc or enterprise provisioning and a registered device list, and on Android means an .apk rather than the .aab that Google Play wants.

Production builds

Production builds are signed for store distribution and can only be installed through the stores, including TestFlight. Android defaults to an .aab; you can set buildType to apk, but Expo recommends the bundle for Play submissions. These are the builds that go through EAS Submit and then through Apple's review, which is a separate process with its own rules.

Signing

Credentials: what EAS holds for you.

Every store build has to be signed. Expo's default, credentialsSource set to remote, means EAS generates the credentials the first time you build, stores them on its servers, and reuses them on every build after that. What it generates depends on the platform:

iOS

A distribution certificate, which identifies your Apple team as the signer
A provisioning profile, which ties the bundle identifier, the certificate and, for ad hoc builds, a list of device IDs together
An Apple push key, not part of signing, but needed for push notifications and set up in the same flow

Generating these means signing in with an Apple Developer Program membership, $99 a year, from inside EAS CLI.

Android

A keystore, generated when you pick Generate new keystore on the first build and stored on EAS servers
An FCM API key for push notifications, managed through eas credentials if you need it

No store account is needed to generate a keystore, but you cannot upload to Google Play without one.

Two consequences are worth knowing before the first build. Once the iOS credentials exist, teammates can start iOS builds with only their Expo accounts; nobody else needs access to the Apple Developer team. And you can inspect, sync or replace everything with eas credentials, or switch to your own credentials.json with credentialsSource set to local if company policy says the private key never leaves your machine.

The provisioning profile is the piece that trips people up most, because it expires, it is tied to a specific certificate, and an ad hoc profile only covers devices registered at the time it was made. If a build fails at the signing step, that is where to look first, and Apple provisioning profiles walks through how they fit together. Details above are from Expo's managed credentials guide.

Queue times

Why a free EAS build can wait an hour.

EAS has a fixed pool of build machines, and iOS capacity in particular does not scale on demand, so build requests wait in one of two queues. Free plan builds go into the low-priority queue; Starter, Production and Enterprise accounts go into the high-priority queue. Expo's pricing page is candid about the difference: at peak times the low-priority queue can mean waits of 90 minutes or more, while the stated target for the high-priority queue is zero wait. Peak, in Expo's own note on build queues, is the middle of the business day in North American time zones.

Queue time is separate from build time, and both have a ceiling. A Free plan build is canceled if it runs longer than 45 minutes; paid plans get 2 hours. Each account also has a cap of 50 pending builds per platform, after which new requests are rejected until the backlog drains. If you are stuck behind the queue, Expo lists four ways out:

Upgrade to Starter for the high-priority queue; Expo names it as the answer when you urgently need one build done.
Run the build on your own machine with eas build --local.
Run npx expo prebuild and archive and sign the project yourself in Xcode or Android Studio.
Build outside North American business hours, using the live charts on the EAS Build status page to pick a quiet time.

Plan	Price	Builds included	Queue	Build timeout	Concurrent builds	Large workers
Free	$0	Up to 15 Android and 15 iOS builds a month	Low priority	45 minutes	1	No
Starter	$19 a month, plus usage	$45 of build credit, then per-build rates	High priority	2 hours	1, then $50 each for up to 5 more	Yes
Production	$199 a month, plus usage	$225 of build credit, then per-build rates	High priority	2 hours	2, then $50 each for up to 5 more	Yes
Enterprise	Custom	From $1,000 of build credit	High priority	2 hours	5, then $50 each	Yes

From Expo's pricing page, checked September 2026. Every plan can submit to both stores; the differences are queue, credit, timeout and concurrency.

What it costs

What an EAS build costs.

Paid plans bill per build at a flat rate, drawn first from the monthly credit included in the plan. The rate depends on the platform and the worker size. Medium is the default and, in Expo's words, usually sufficient for both small and bigger projects; large is for builds that need more memory or that you want finished faster, and it is not available on the Free plan.

Platform	Medium worker	Large worker
Android	$1 a build4 vCPUs, 16 GB RAM	$2 a build8 vCPUs, 32 GB RAM
iOS	$2 a build5 cores, 20 GiB RAM	$4 a build10 cores, 40 GiB RAM

Three rules shape the real bill. Credits reset at the start of each billing period and do not roll over. Builds that fail within three minutes, a broken config or a typo that dies before the native compile starts, are not billed and do not count against the Free quota, up to ten a month, a policy Expo announced in its changelog on 2 May 2024. And the Free plan cannot incur overages: once the 15 iOS or 15 Android builds are used, new builds are unavailable until the first day of the next calendar month, per Expo's billing FAQ. Rates are from the pricing page linked above, and worker sizes from Expo's build infrastructure reference, both checked September 2026.

Try it

What would a month of builds cost?

Drag the sliders to the number of cloud builds you expect in a month. The estimate uses Expo's published flat rates as of September 2026, before any fast-failed waivers.

iOS builds a month8Android builds a month8

Free

Fits the Free plan: low-priority queue, 45-minute timeout, one build at a time.

Starter

$19

$19 base. Usage of $24 against $45 of credit, nothing extra.

Production

$199

$199 base. Usage of $24 against $225 of credit, nothing extra.

eas build --local

Running EAS Build locally.

eas build --local runs the same build pipeline on your own machine instead of an EAS worker. Expo positions it for two situations: debugging a build that fails in the cloud and you cannot reproduce any other way, and company policies that forbid third-party CI. In local mode the only calls to EAS are checking that the project exists and, if you use managed credentials, downloading them; everything else happens on your hardware. It still requires eas login, and it is a different thing from npx expo run:ios, which compiles with Expo CLI and no EAS involvement at all.

	eas build (cloud)	eas build --local	npx expo run:ios / run:android
Where it compiles	An EAS worker	Your machine	Your machine
Mac needed for iOS	No	Yes	Yes
Expo account	Yes	yes, eas login	No
Signing credentials	Managed by EAS	Downloaded from EAS, or your own credentials.json	Xcode and Gradle handle it
Waits in a queue	Yes	No	No
Tool versions from eas.json	Yes	ignored	n/a
Build cache	Yes	No	Xcode and Gradle caches
Platforms per run	One or both	One	One

What the local flag gives up

One platform per run: the all option is disabled.
The node, yarn, fastlane, cocoapods, ndk and image fields in eas.json are ignored.
No caching between builds.
Environment variables with Secret visibility are not available; set them locally.
You install the toolchain yourself: Node, fastlane and CocoaPods for iOS, the Android SDK and NDK for Android.
macOS and Linux are supported. Windows only via WSL, and Expo does not test or support it.

Limitations from Expo's local builds reference. The practical read: local is a debugging and compliance tool, not a way to dodge the queue for free on a machine that lacks Xcode.

Step by step

Your first EAS build, in six steps.

This is the sequence from Expo's own first-build guide, trimmed to what you actually type. It assumes a project made with create-expo-app, though EAS Build also works with plain React Native projects.

1
Install EAS CLI
npm install --global eas-cli
Or run it without installing, as npx eas-cli@latest. Expo recommends staying on the latest version.
2
Log in
eas login
eas whoami confirms which account you are on. Builds run on behalf of that account or its organization.
3
Configure the project
eas build:configure
Writes eas.json with the development, preview and production profiles. For a development build, also run npx expo install expo-dev-client.
4
Decide what you are building
simulator, device or store?
Simulator and emulator builds need no store account. Store builds need a Google Play developer account (a one-time $25 fee, per Expo's docs) or an Apple Developer Program membership ($99 a year).
5
Run the build
eas build --platform ios --profile production
Swap in android, or all for both. Add --message to leave a note on the build page. The first run prompts you to generate or supply credentials.
6
Wait, then ship
eas build:list
The CLI waits by default, but you can interrupt it and follow the build page instead. Internal builds get an Install button; store builds go on to EAS Submit.

A production build is the end of EAS Build's job and the start of the store's. Uploading to App Store Connect, getting the build into TestFlight, filling in the listing and surviving review are covered in publishing to the App Store.

If you would rather not own a pipeline

When you do not want to run the build yourself.

Everything above is the cost of owning an Expo project: an eas.json to maintain, credentials to keep straight, a queue to plan around and a bill that scales with how often you rebuild. For a team with engineers, that is a fair trade for full control. For someone with an app idea and no Expo project, it is a lot of plumbing before the first screen exists. That gap is what Newly is for: describe the app, and it builds a real native app, compiles it, and submits the build to App Store Connect for you, typically in 5 to 15 minutes according to its own submission guide, so testing happens in TestFlight rather than in a terminal.

Be clear-eyed about the trade. It costs $25 a month with no free plan, it still needs your own Apple Developer Program membership, and the current version ships iOS only: Android release builds are not part of Newly v2. If Play Store distribution is a must today, EAS Build with a production profile is still the route, and the rest of this page is the map.

Sources

Where the specifics came from.

Every number and default on this page comes from one of four Expo pages, all read in September 2026:

expo.devEAS pricing, September 2026Plan prices, the Free plan's 15 plus 15 builds, queue priority, timeouts, concurrency and the per-build rates.Expo docsConfigure EAS Build with eas.jsonThe default development, preview and production profiles, extends, resource classes and images.Expo docsUsing automatically managed credentialsWhat EAS generates and stores for iOS and Android, and how teammates build without the Apple team login.Expo docsRun EAS Build locally with the local flagUse cases, what still talks to EAS, and the list of options that local builds ignore.

FAQ

EAS Build, answered.

EAS Build is Expo's hosted build service for React Native and Expo apps. You run eas build from your project, EAS CLI uploads the project to a fresh virtual machine (Linux for Android, macOS for iOS), compiles it into a signed .apk, .aab or .ipa using the credentials it stores for you, and gives you a build page with logs, an install link for internal builds, or a hand-off to EAS Submit for the stores. It is one of three EAS services: Build compiles, Submit uploads to the stores, and Update ships JavaScript changes to apps that are already installed.

Skip the queue, and the eas.json.

If you would rather describe the app than maintain the pipeline, Newly compiles it and submits the build to App Store Connect for you, no eas.json required.

Start building your app