A CI job can publish an app with a service-user API key. Run it in an isolated account with no cached human login, and set the variables below. dip app push prefers a selected human login even when an API key is present in the environment.
dip app dev and dip app install require a human dip login; neither accepts an API key. apps:install cannot be minted onto a key, even for an administrator’s service user. CI can build and publish. Installation requires the author’s explicit access and code-trust confirmation.
For a machine-readable publication result, run dip app push --json. It returns a confirmed receipt for the exact app, version and image. An unreadable or pending registration exits nonzero; progress stays on stderr. Plain dip app push preserves push-only CI behavior, including its warning when registration is not confirmed. An upload alone is not an installed app or a ready link.

Minting the key

Create the key under Settings → Service users in the console, on a service user that holds the app-authoring role. The key needs two independent things, granted in two different places, and a push is refused if either is missing: dip app push distinguishes the two in its refusal message, because the remedy is different for each.

Which capability each command needs

The same two-part rule (a capability plus a role) applies to every command a CI job is likely to run. See the full capability table for every command; the ones relevant to a build-and-push pipeline are:
The authoring verbs — dip semantic’s create/import/update/delete/propose and dip ontology’s create/update/delete/propose/import — take a dip login session that consented to the authoring scopes just as they take an API key. In CI the API key is the CI-friendly option, not the only credential that works; on a terminal you can drive them from a login session instead. Whichever you use, certifying still stays a person’s action in the console.

Environment variables dip reads

A run in your own CI is not routed anywhere different from a developer’s own machine, and every runner that sets the standard CI environment variable is marked as such: each event carries ci=true alongside the command, duration and status fields above. That marker is informational only — it does not change the sink or what gets collected. Only DIP_TELEMETRY=0 or DO_NOT_TRACK=1 turn telemetry off.
ALTIMATE_ISSUER and ALTIMATE_ENGINE_URL are not read by dip itself. They belong to the app SDK’s own contract for running your app process directly (AltimateData.for_local() in Python, createLocalDataClient() in TypeScript) — the path you use when running the app’s own code outside dip app dev, for example inside a test. Setting them does not change what any dip command does.
On a tenant with several data planes, point DIPPR_REGISTRY at the one you want to push to. The same key authorizes the push either way:
DIPPR_SLUG is not needed in that form — a <slug>.registry.<domain> host already names the tenant, so the slug is read out of it. Set it (or --slug) only when pushing to a registry that names no tenant of its own, such as ghcr.io or an ECR endpoint.

A worked GitHub Actions job

.github/workflows/build-and-push.yml
dip sets CI detection automatically off most runners (GitHub Actions sets the CI environment variable itself), which turns off the daily self-update check — a pipeline never re-executes itself mid-run on a binary it did not ask for. Running dip doctor as its own step, as above, still catches a missing docker or buildx before the build starts rather than partway through it.

Use Git from CI

Mint a service-user API key with the narrow Git scopes the job needs. git:write does not imply git:read, so a job that clones and pushes needs both. The service user’s role must also permit the repository operation. Configure the helper on the Git command, not globally:
Never print the helper response. The returned credential expires within 15 minutes, and the helper does not answer for GitHub, GitLab, or a different tenant host.

Waiting for asynchronous commands (--wait)

dip engine create, dip engine apply and dip crawl start all dispatch work that finishes on a data plane after the command returns. Pass --wait (with an optional --timeout) to have dip poll until it has a definite answer, instead of writing your own polling loop in the pipeline. See the full flags and exit codes on dip engine create, dip engine apply and dip crawl start. The three exit codes matter for how a CI job should react: This is the reason exit 3 exists as its own status rather than folding into 1: a pipeline that maps every non-zero exit to “failed, retry” would resend an apply or a crawl trigger onto one that is possibly still running.

Why does a CI build or push fail?

Reading a failure in a job

Run the setup commands (integration, engine, crawl, db) with --json and branch on the result, not on the wording. When a command fails, stdout holds one JSON error document and stderr holds the explanation. The exit status is 1, or 3 when a --wait could not establish the outcome (class inconclusive: read the state back before re-running). Status 2 means dip printed its help instead of running the command (an unknown subcommand or a missing argument caught by dip’s dispatcher); that also writes a usage document, but a usage document can come with status 1 too.
dip integration test --json is the exception: when the connection fails, stdout is the test result, not an error document, and the exit status is 1. Branch on .ok and read .error, which is the source’s own message:
Never retry a write automatically when may_have_landed is true. dip itself never retries a write, because the first attempt may already have landed. The full class table is in the command reference.

Command reference

Every dip command’s flags, defaults and capability requirements.

Install dip and sign in

Installing the binary and the interactive sign-in flow, for local development.