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 %