demo % man exact-build
EXACT-BUILD(1) Exact Build Manual EXACT-BUILD(1)
NAME
exact-build – build native iOS apps from anywhere, in seconds
SYNOPSIS
POST https://exact.appdrop.app/build[?option=value&...]
GET https://exact.appdrop.app/id/
GET https://exact.appdrop.app/id.ipa
GET https://exact.appdrop.app/sdk?exact=commit
GET https://exact.appdrop.app/new?name=app[&pattern=pattern&exact=commit]
GET https://exact.appdrop.app/usage
POST https://exact.appdrop.app/auth/device[/request]
REQUESTS
POST /build
Send the app directory as a .tar.gz file with the header
Content-Type: application/gzip. The service returns 202 and
{"id": "id"}. An archive it cannot build is refused at
once, before a build starts, with {"error": "reason"}: 400
for one that is not a gzip-compressed tar (a zip, a plain or xz
tar), has no app.contract at its root or in one folder there, or
holds a link out of the app; 413 for one over 64 MiB, or
over 512 MiB or 20000 files unpacked. Make it with
tar -czhf app.tar.gz --exclude=.exact -C app .
(.exact/checkout, the link to an Exact checkout in an app
made with one, is ignored; -h without the exclude would
pack the whole checkout).
GET /id/
The service returns the status of the build as JSON. See
STATUS.
GET /id.ipa
If the build succeeded, the service returns the IPA, an iOS app
package. The IPA is unsigned and runs on iPhone and iPad. Use
appdrop(1) to install it.
GET /sdk?exact=commit
The service returns the snapshot that a build with this
exact value would use, as JSON. Its upstream field is the
expo/exact commit to diff against for an SDK patch. See
SDK PATCHES. Its snapshots field lists every prebuilt
snapshot.
GET /new?name=app
The service returns a new app as a .tar.gz of the folder app,
with no expo/exact checkout needed: one of the SDK's starter
patterns (pattern, default one-screen; an unknown one is
refused with the list), its app.json and package.json, and an
AGENTS.md whose guides are links to expo/exact on GitHub at the
snapshot's commit. exact picks the snapshot as POST /build
does (default: main's); the X-Exact-Commit header names its
commit, to send as exact with every build. title and id set
app.json's name and bundle id (default: from app, and
com.exact.app-random). 502 or 503 (with Retry-After)
means GitHub could not be read: try again.
curl -sS "https://exact.appdrop.app/new?name=groceries" \
-H "Authorization: Bearer $EXACT_TOKEN" | tar -xz
AUTHENTICATION
Every request needs a token. Get one with the user's Expo account:
POST /auth/device
The service returns {"request_id", "url", "expires_at",
"interval"}. Send the user the url. They sign in to Expo,
approve, and see a number. (The page says EAS CLI for now.)
POST /auth/device/request
Send {"match": "number"} when the user tells you the number.
The status field is one of:
authenticated The token field holds your token. It
lasts 30 days. Save it to
~/.exact-build-token (mode 600) and
never print it.
authorization_pending The user has not approved yet.
matching_required Send the number from the browser.
slow_down Wait for the Retry-After seconds.
access_denied, expired_token, invalid_grant
Start again with POST /auth/device.
GET /auth/token, DELETE /auth/token
Show the Expo user and expiry of your token, or revoke it.
curl -sS -X POST https://exact.appdrop.app/auth/device
curl -sS -X POST https://exact.appdrop.app/auth/device/$REQ \
-H 'Content-Type: application/json' -d '{"match":"42"}'
LIMITS
A token from an Expo login has a budget of worker time, the time a
worker spends on your builds (not the time in the queue), for each
Expo account:
15 minutes an hour, 60 minutes a day, 4 hours a week,
and 4 builds at once.
When a window is spent, POST /build returns 429 with window
(hour, day, week or active), used_seconds, limit_seconds,
available_at and a Retry-After header. A running build is never
stopped. A base rebuild uses a few seconds.
A failed build shows failure.class, one of three:
service the service failed (a worker crash, a timeout, a
damaged IPA). Never counts.
refused the upload broke a rule the build checks before compiling
your code (a bad archive or app.json, an asset name, a
permission purpose string, a top-level await). Never
counts.
user your code failed to build (a compile error, a bad SDK
patch). The first 30 minutes of these each week do not
count towards your usage limits.
A build's status shows its workerSeconds and chargedSeconds.
An upload byte-identical to one of your succeeded builds (same SDK
snapshot, options, build toolchain and build code) is answered from
that build's IPA with no worker: its status has reused (from: that build's
id) and 0 worker seconds. An app with npm dependencies and no
bun.lock gets the newest versions when it builds, so an identical
re-upload returns the versions the earlier build got: change a byte in
the app (or add a lockfile) to build it fresh.
GET /usage
Shows how much of your limits you have used. Returns:
worker_time used_seconds, limit_seconds and resets_at
for each window, and available_at when
a window is spent
failed_builds how much of this week's free allowance
for your own failed builds is left
builds builds in progress, and in the last hour
and day
build_caches your stored build caches: stored_bytes,
entries and the limits (limit_bytes;
least recently used go past it, and any
unused for unused_days_kept days)
DELETE /caches
Drops your stored build caches (what your builds compiled,
kept so the next build of the same app recompiles only what
changed). Your next build of each app is a cold one.
HEADERS
Authorization: Bearer token
Every request must have this header, except the device login
(POST /auth/device). See AUTHENTICATION.
OPTIONS
extensions=all|none|list
This option sets the app extensions that the service builds:
all (the default), none, or a list of widgets, activities,
intents, alarms, notifications and watch. An
older SDK snapshot builds only the kinds it has. The list
widgets,activities,intents,alarms, the whole list before
notifications and watch, still means all.
base=id|none
If the native code did not change after your last successful
build id, the service reuses its binary and finishes in about
4 seconds. Without base, the service uses your last
successful build of the same app (by app.json's app.id and
app.name), on the same SDK and options. none builds
in full.
exact=commit
The expo/exact commit your app was made with. Builds are
fastest on commits that have a prebuilt snapshot. You can
view this list at GET /sdk. A commit newer than every
snapshot builds on the newest one. Once the service knows the
commit is on expo/exact main (a minute or so for one the catalog
does not list yet), it asks for a snapshot of main, and
sdk.snapshotDue says when to build again. If no snapshot has included the commit a while later
(2 hours by default), the service may refuse it; the error
then names a commit to build on.
SDK PATCHES
If you changed files in your expo/exact checkout, send the change with
the app. Before you change anything, check out the commit the service
builds, or your patch will carry every newer upstream commit:
C=$(git -C ~/exact rev-parse HEAD)
U=$(curl -sS -H "Authorization: Bearer $T" \
"https://exact.appdrop.app/sdk?exact=$C" | \
python3 -c 'import json,sys;print(json.load(sys.stdin)["upstream"])')
git -C ~/exact fetch -q origin $U && git -C ~/exact checkout -q $U
Make your change, put it at the app's root as .exact-sdk.patch,
then make the .tar.gz file as usual:
git -C ~/exact add -N .
git -C ~/exact diff --full-index --binary --no-renames $U \
> ~/app/.exact-sdk.patch
Send exact=$U with the build. The service applies the patch to
that snapshot. A patch that conflicts with the service's own SDK
changes fails at once and names the files. A patch can be up to
8 MiB and 2,000 files. It cannot change .cargo/, rust-toolchain
files, bunfig.toml, .npmrc, links or submodules.
A patched build is slower: it never reuses a base build, and it
compiles the SDK code that the patch changes, which takes from about
20 seconds to a few minutes. Delete .exact-sdk.patch when you no
longer need the change.
STATUS
The status field is queued, building, succeeded or failed. The
steps field shows each step of the build and its time. If the
build failed, the error field shows the output of the compiler,
and diagnostics lists its errors in contract build --json's fields:
{"file", "line", "col", "id", "severity", "message"}, so an app
needs no local check: build it, fix what is listed, build again.
They are read from the build's own output, so a line the app's
build prints in that form is listed too.
The sdk field names the snapshot the build used, and sdk.patch
shows the files of your SDK patch, if you sent one. A note says
what the IPA leaves out, such as a declared watch app, and an
sdk.note says why the build used another SDK than the one you
sent. Tell the user both.
SEE ALSO
appdrop(1), exact(1), exact.appdrop.app
Exact Build November 2026 EXACT-BUILD(1)
demo %