splitchAlpha

DocsCLIcli.md

CLI.

Install, authenticate, automatically select project scope with splitch.json, and read every command: --json on any command, --confirm on Policy-gated changes, and stable exit codes.

The CLI is the same control plane the Control Panel drives, with one command per operation. Install it globally and authenticate once; the session is stored per machine.

npm install --global @splitch/cli
splitch login
splitch context --json

splitch context is the command to run first and after anything surprising: it reports the authenticated principal and the resolved App and Environment, and it fails loud rather than reporting an empty success.

Scope: App and Environment

Most commands operate on one App, and many on one Environment inside it. Both are resolved in the same order every time, first match wins:

  • --app / --env on the command.
  • SPLITCH_APP / SPLITCH_ENV in the environment.
  • splitch.json in the current directory or an ancestor, written by splitch use.
splitch use --app checkout --env dev
splitch flags list --json

Project configuration

Place splitch.json in a project directory to select its App automatically. The file is optional. The CLI checks the current directory and then each parent directory, stopping at the nearest file. This lets commands run from any nested package or source directory without repeating --app.

{
  "version": 1,
  "app": "app_...",
  "environment": "env_..."
}

environment is optional when the repository should select only the App. The file contains no credentials and is safe to commit. splitch use --app <app> [--env <env>] validates the selectors, writes canonical IDs, and updates the nearest existing splitch.json. If no parent contains one, it creates the file in the current directory.

An unresolved selector is a refusal (CLI_SCOPE_UNRESOLVED, exit 3), never a silent pick of the only App you can see.

--json on every command

--json prints the response body as one line on stdout, with nothing else on that stream. Failures answer in the same shape, so a caller branches on a field instead of matching a sentence:

{"code":"APPROVAL_REVIEW_REQUIRED","message":"...","remediation":"...","docsUrl":"https://splitch.dev/docs/error/APPROVAL_REVIEW_REQUIRED","details":{"approvalRequestId":"apr_..."}}
  • code is the stable identity. message says what happened, remediation says what to do next, and docsUrl resolves to the page for that code.
  • details carries the fields you have to act on (approvalRequestId, frozenFields, policyContexts) and is null when the failure has none.
  • The human sentence is written to stderr either way, so --json never costs you the readable error.

--confirm on Policy-gated changes

An Environment Policy can require confirmation or review before a change applies. A gated command refuses first and tells you which; it never applies half of a change. Re-run with --confirm when the Policy asks for confirmation:

splitch flag-config update new-checkout --enabled true --rollout 100 --confirm

When the Policy requires review instead, the refusal carries details.approvalRequestId and --confirm will not bypass it. The --confirm column below marks every command that parses the flag.

Secrets

splitch api-keys create returns the raw API Key under value, once. It is never readable again, so a run whose stdout is captured to a log has published the credential permanently. Pass --output-file to keep it off both streams:

splitch api-keys create --body-json '{"scopes":["data-plane:evaluate"]}' --output-file ./.splitch-api-key --json

The secret lands in one new 0600 file and the payload reports value: null with valueWrittenTo naming the path. The command refuses a path that already exists, before the Key is minted. A Client Key is public and needs none of this: read it any time with splitch client-key get.

Temporary Environments

A Temporary Environment is an expiring copy of another Environment in the same App, with its own Flag Configurations, Client Key, and API Keys. Use one per branch or pull request instead of editing a shared dev:

splitch envs create --key pr-123 --temporary --from dev --json
splitch envs sync --env pr-123 --from dev --json
splitch envs delete --env pr-123 --json

Creation returns the Client Key. The copy expires 7 days after creation unless --expires-at names an earlier day count such as 3d or an ISO 8601 instant, and expiry cannot be extended. Sync replaces every Flag Configuration with the source's, including rollout salts, and never copies a live Experiment Run. Its Policy allows every change and it cannot host Experiments. After expiry, its keys and every mutation except envs delete fail with ENVIRONMENT_EXPIRED until teardown removes it; deleting it starts teardown immediately.

An agent token created with --grant app:<app id>:owner:temporary_environments reads the whole App and writes only inside Temporary Environments. The same command against a permanent Environment or an App-level resource is refused with FORBIDDEN.

Query flags from the route schema

List and other routes that declare OpenAPI query parameters expose them as kebab-case flags derived from the schema (--cursor, --limit, --status, --run-id, and so on). Required query fields fail loud when omitted; invalid typed values fail with CLI_USAGE_INVALID. Hand-mapped flags such as --env, --by, --dry-run, and --from-environment-id keep working. If a query field's kebab name collides with a reserved global flag, the reserved flag wins and the query field is not re-derived under that name.

splitch approval-requests list --cursor page_2 --limit 25 --json

Exit codes

CodeMeaning
0Success.
1Usage, validation, or local configuration failure.
2Not authenticated, session expired, or email unverified.
3App or Environment scope unresolved, or the token refused the requested binding.
4The API refused the request; the code field names which failure.
5An App or Environment matched multiple candidates; retry as listed.

Command reference

Every command accepts --json and --help. splitch <resource> <action> --help prints the arguments, flags, and an example for that one command.

CommandScope--confirmWhat it does
splitch login-noAuthenticate the control-plane session with the browser device flow. Unset SPLITCH_TOKEN first.
splitch logout-noRevoke and remove the stored control-plane session. Unset SPLITCH_TOKEN first.
splitch use-noSelect the default App and Environment for this project.
splitch context-noShow the login session or SPLITCH_TOKEN metadata and effective authority, plus the resolved App and Environment.
splitch health-noCheck the Control Plane API health endpoint.
splitch api-keys createApp + EnvironmentnoMint an API Key (raw secret surfaced once only). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. API Key — the secret server-side SDK key. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","scopes":[]}
splitch api-keys listApp + EnvironmentnoList API Key metadata (no secrets; bounded; reports its own truncation). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. API Key — the secret server-side SDK key. App — the product or service surface that groups related Flags and hosts Experiments.
splitch api-keys revokeApp + EnvironmentnoRevoke an API Key. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. keyId: required canonical id. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. API Key — the secret server-side SDK key. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","keyId":"key_1"}
splitch app-attention-rollup getAppnoRead explicit per-Environment SRM and Guardrail attention for one App. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments.
splitch app-audit listAppnoList App audit events. Requires live App admin membership and credential scope. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: optional canonical id. resourceId: optional canonical id. approvalRequestId: optional canonical id. runId: optional canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch app-members addAppnoGrant a user a role on an App. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. userId: required canonical id. role: required one of "owner", "admin", "member". Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","userId":"user_1","role":"owner"}
splitch app-members listAppnoList the members of an App and their App roles. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch app-members removeAppnoRevoke a user's access to an App (rejected if removing the last owner). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. userId: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","userId":"user_1"}
splitch app-members updateAppnoChange a member's App role. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. userId: required canonical id. role: required one of "owner", "admin", "member". Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","userId":"user_1","role":"owner"}
splitch approval-request-reviews createAppnoReview a pending Approval Request and optionally apply its proposal. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. id: required canonical id. action: required one of "approve_and_apply", "decline". Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","id":"apr_01J00000000000000000000000","action":"approve_and_apply","idempotency_key":"idem-1"}
splitch approval-requests getAppnoGet one full Approval Request projection. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. id: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch approval-requests listAppnoList Approval Requests in an App (bounded; reports its own truncation). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. status: optional one of "pending", "applied", "declined", "stale". target_kind: optional one of "flag", "flag_configuration", "flag_variant", "segment", "experiment_draft". environmentId: optional canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch apps create-noCreate an App (provisions dev + prod Environments and Client Keys). Formats: orgId: required canonical id. Terms: Environment — a named deployment context under an App, such as dev or prod. Client Key — the public, non-secret key used by untrusted client-side SDKs. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"orgId":"org_1","name":"name"}
splitch apps deleteAppnoDelete an App. Dry-run mode lists every blocker with IDs and remove commands; force mode cascades non-gated children and stops with pending Approval Request IDs when Policy requires Review. Blocked while any Experiment is running. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1"}
splitch apps getAppnoGet one App. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch apps list-noList the Apps in an organization. Formats: orgId: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch apps updateAppnoRename an App or change its URL slug. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","name":"name"}
splitch client-key getApp + EnvironmentnoGet the Environment's public Client Key (never 404s for a live Env). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Client Key — the public, non-secret key used by untrusted client-side SDKs. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1"}
splitch client-key rotateApp + EnvironmentnoRevoke the current Client Key and create its replacement. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Client Key — the public, non-secret key used by untrusted client-side SDKs. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1"}
splitch client-key updateApp + EnvironmentnoUpdate the Client Key's origin allow-list / rate limit. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Client Key — the public, non-secret key used by untrusted client-side SDKs. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","originAllowlist":["https://app.example.com"]}
splitch cloudflare removeEnvironmentnoRevoke configuration delivery, unbind the service, and delete the integration Worker.
splitch cloudflare setupEnvironmentnoDeploy and bind a durable local-evaluation Worker for the selected Environment.
splitch cloudflare statusEnvironmentnoRead Cloudflare configuration delivery and local Worker status.
splitch cloudflare-installations listApp + EnvironmentnoList Cloudflare installations and their delivery health for this Environment. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments.
splitch cloudflare-installations revokeApp + EnvironmentnoRevoke a Cloudflare integration and suppress pending deliveries. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. installationId: required canonical id. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","installationId":"018f2b7c-3c9a-7b3e-9a52-0c1d2e3f4a5b"}
splitch conclusion-promotion-requests createApp + EnvironmentyesReplace a stale winner Promotion request from immutable conclusion evidence. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. runId: required canonical id. conclusionId: required canonical id. by: optional one of "id". idempotencyKey: required canonical id. Terms: Environment — a named deployment context under an App, such as dev or prod. Promotion — applying a Flag Configuration, or a Variant's availability, to a target Environment. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","experimentId":"experiment_1","runId":"run_1","conclusionId":"conclusion_1","expectedConfigVersion":0,"idempotencyKey":"idem-1"}
splitch convex-installations listApp + EnvironmentnoList Convex installations and their delivery health for this Environment. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments.
splitch convex-installations revokeApp + EnvironmentnoRevoke a Convex integration and suppress pending deliveries. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. installationId: required canonical id. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","installationId":"018f2b7c-3c9a-7b3e-9a52-0c1d2e3f4a5b"}
splitch env-policy getApp + EnvironmentnoGet the selected Environment Policy.
splitch env-policy setApp + EnvironmentnoUpdate the selected Environment Policy.
splitch environment-exposure-status getApp + EnvironmentnoGet whether an Environment has received its first real Exposure. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Exposure — the event that an Entity actually encountered its assigned Variant. App — the product or service surface that groups related Flags and hosts Experiments.
splitch envs createAppnoCreate an Environment and its Client Key. A Temporary Environment copies a source and expires within seven days. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: Environment — a named deployment context under an App, such as dev or prod. Client Key — the public, non-secret key used by untrusted client-side SDKs. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","key":"key"}
splitch envs deleteApp + EnvironmentnoDelete an Environment. Temporary Environments tear down immediately; permanent Environments retain running, non-empty and last-permanent-Environment guards. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1"}
splitch envs getApp + EnvironmentnoGet one Environment (includes its inline Policy). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments.
splitch envs listAppnoList an App's Environments. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments.
splitch envs syncApp + EnvironmentnoSync every Flag Configuration from a source Environment into a Temporary Environment, including salts and excluding live Runs. Retry an incomplete Sync to converge. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". fromEnvironmentId: required Source Environment ID or key in this App. Terms: Environment — a named deployment context under an App, such as dev or prod. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. Experiment Run — the immutable, time-boxed unit of experiment analysis. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","fromEnvironmentId":"fromEnvironment_1"}
splitch envs updateApp + EnvironmentnoRename an Environment or edit its Policy. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","name":"name"}
splitch event-definition-versions createAppnoPublish the next immutable Event Definition Version. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. eventDefinitionId: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","eventDefinitionId":"eventDefinition_1","entityType":"entityType","fields":[],"dimensions":[]}
splitch event-definition-versions getAppnoGet one immutable Event Definition Version. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. eventDefinitionId: required canonical id. versionId: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch event-definition-versions listAppnoList immutable Event Definition Versions. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. eventDefinitionId: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch event-definitions createAppnoCreate an App-level Event Definition. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. family: required one of "metric", "web". Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","name":"name","family":"metric","displayName":"displayName"}
splitch event-definitions getAppnoGet an Event Definition and its immutable published Versions. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. eventDefinitionId: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch event-definitions listAppnoList Event Definitions in an App. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch event-definitions updateAppnoUpdate Event Definition display metadata. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. eventDefinitionId: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","eventDefinitionId":"eventDefinition_1","displayName":"displayName"}
splitch experiment planApp + EnvironmentnoPlan sample size, always-valid inflation, target_n, and expected duration from a predeclared MDE (or solve MDE from a fixed size). Never computes post-hoc power from observed effects. Pass targetN to experiments_start. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". metricKind: required one of "continuous", "binomial". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments.
splitch experiment-results getApp + EnvironmentnoGet an Experiment's results: readiness, blockedBy, reasons, then ship recommendation when pre-registered; detailed stats by default; view=concise for the verdict block (includeExploratory attaches stats). States: ready, no_data, or no_run. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. runId: optional canonical id. view: optional one of "concise", "detailed". by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. App — the product or service surface that groups related Flags and hosts Experiments.
splitch experiment-results postApp + EnvironmentnoGet an Experiment's results: readiness, blockedBy, reasons, then ship recommendation when pre-registered; detailed stats by default; view=concise for the verdict block (includeExploratory attaches stats). States: ready, no_data, or no_run. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. by: optional one of "id". runId: optional canonical id. view: optional one of "concise", "detailed". Terms: Environment — a named deployment context under an App, such as dev or prod. Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. App — the product or service surface that groups related Flags and hosts Experiments.
splitch experiments createApp + EnvironmentnoCreate an Experiment draft. Formats: appId: required canonical id. environmentId: required canonical id. by: optional one of "id". flagId: required canonical id. targetingKey: required canonical id. activationMetricId: optional canonical id. segmentIds: optional canonical id. Terms: Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. Example arguments: {"appId":"app_1","environmentId":"environment_1","name":"name","key":"key","flagId":"flag_1","targetingKey":"userId","targetingKeyType":"user","metrics":[{"metricId":"metric_1"}]}
splitch experiments deleteApp + EnvironmentnoArchive an Experiment; Runs are retained (blocked while a Run is running). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. Experiment Run — the immutable, time-boxed unit of experiment analysis. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","experimentId":"experiment_1"}
splitch experiments getApp + EnvironmentnoGet an Experiment (includes live Run id, draft config). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. App — the product or service surface that groups related Flags and hosts Experiments. Experiment Run — the immutable, time-boxed unit of experiment analysis.
splitch experiments listApp + EnvironmentnoList Experiments in an Environment. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. App — the product or service surface that groups related Flags and hosts Experiments.
splitch experiments startApp + EnvironmentyesStart the draft as a new Run; ends any running Run (Policy-gated). Freezes draft Targeting Rules into the Run. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. by: optional one of "id". horizon: optional one of "sequential", "fixed". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments. Experiment Run — the immutable, time-boxed unit of experiment analysis. Example arguments: {"appId":"app_1","environmentId":"environment_1","experimentId":"experiment_1","idempotency_key":"idem-1","horizon":"sequential"}
splitch experiments updateApp + EnvironmentnoEdit an Experiment (assignment edits gated by RUN_FROZEN / DECISION_LOCKED). Staged Targeting Rule edits under a live Run leave evaluation on the frozen Run. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. by: optional one of "id". flagId: optional canonical id. targetingKey: optional canonical id. activationMetricId: optional canonical id. segmentIds: optional canonical id. stageForNextRun: optional one of true. Terms: Environment — a named deployment context under an App, such as dev or prod. Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. App — the product or service surface that groups related Flags and hosts Experiments. Experiment Run — the immutable, time-boxed unit of experiment analysis. Example arguments: {"appId":"app_1","environmentId":"environment_1","experimentId":"experiment_1","tags":[],"allocation":{"control":1,"treatment":1},"segmentIds":[],"dimensions":[],"stageForNextRun":true}
splitch expired-flags listAppnoList Flags past their expiresAt that still exist and can still be evaluated, most overdue first (bounded; reports its own truncation). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch flag-changes exportAppnoExport a Flag change-log time range, or the stored changes between two Environments, as JSON plus a unified text diff. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. from: required ISO-8601 instant with offset. to: required ISO-8601 instant with offset. environmentId: optional canonical id. fromEnvironmentId: optional canonical id. toEnvironmentId: optional canonical id. flagId: optional canonical id. format: optional one of "json", "unified". Terms: Environment — a named deployment context under an App, such as dev or prod. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch flag-changes listAppnoList Flag change-log entries with a structured before/after diff computed from stored records. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. from: optional ISO-8601 instant with offset. to: optional ISO-8601 instant with offset. environmentId: optional canonical id. fromEnvironmentId: optional canonical id. toEnvironmentId: optional canonical id. flagId: optional canonical id. Terms: Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch flag-config getApp + EnvironmentnoGet a Flag's per-Environment Configuration. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch flag-config updateApp + EnvironmentyesUpdate enabled state / available Variants (Policy-gated change types). Turning a Flag Config off applies without approval regardless of this level. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Variant — the OpenFeature term for a possible Flag value. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","flagId":"flag_1","idempotency_key":"idem-1","enabled":true,"availableVariantNames":[]}
splitch flag-inventory-health getAppnoPer-App Flag inventory health: counts by lifecycle class, age distribution, monthly additions versus removals, and expired-but-live count. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch flag-removal briefAppnoAdvisory brief for removing a Flag from customer code: served Variants per Environment, SDK search shapes, and explicit caveats (read-only; never writes code). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. Terms: Environment — a named deployment context under an App, such as dev or prod. Variant — the OpenFeature term for a possible Flag value. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch flag-targeting-rules addApp + EnvironmentyesAppend one equality Targeting Rule: serve a Variant when attributes match.
splitch flag-targeting-rules replaceApp + EnvironmentyesFull-replace this Environment's ordered Targeting Rule list. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1","flagId":"flag_1","targetingRules":[{"id":"id_1","flagId":"flag_1","priority":0,"conditions":[{"attribute":"attribute","operator":"eq","value":true}],"variantId":"variant_1"}],"idempotency_key":"idem-1"}
splitch flag-variants createAppyesAdd a Variant to the App-level catalog. Formats: appId: required canonical id. flagId: required canonical id. Terms: Variant — the OpenFeature term for a possible Flag value. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","flagId":"flag_1","name":"name","value":true,"idempotency_key":"idem-1"}
splitch flag-variants deleteAppnoRemove a catalog Variant (blocked if available, referenced by a Targeting Rule, or in a running Run). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. Terms: Variant — the OpenFeature term for a possible Flag value. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments. Experiment Run — the immutable, time-boxed unit of experiment analysis. Example arguments: {"appId":"app_1","flagId":"flag_1","variantName":"variantName","idempotency_key":"idem-1"}
splitch flag-variants updateAppyesUpdate a catalog Variant (value is Run-frozen). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. Terms: Variant — the OpenFeature term for a possible Flag value. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments. Experiment Run — the immutable, time-boxed unit of experiment analysis. Example arguments: {"appId":"app_1","flagId":"flag_1","variantName":"variantName","idempotency_key":"idem-1","value":true}
splitch flags createAppnoCreate a Flag definition (key, schema, Variant catalog, lifecycle class). Formats: appId: required canonical id. lifecycleClass: optional Why the Flag exists. Defaults to release. Release and experiment Flags are temporary: owner defaults to the caller and expiresAt to 90 (release) or 30 (experiment) days out. Ops and permission Flags are permanent unless given an expiry; use ops for a kill switch. one of "ops", "permission", "release", "experiment". owner: optional Person or team that answers for removing the Flag. expiresAt: optional When the Flag is due for removal (ISO 8601); stored as UTC. Terms: Variant — the OpenFeature term for a possible Flag value. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. Example arguments: {"appId":"app_1","name":"name","key":"key","variants":[{"name":"name","value":true,"isDefault":true}],"idempotency_key":"idem-1"}
splitch flags deleteAppnoDelete a Flag (blocked if referenced by a running Experiment). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. Terms: Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","flagId":"flag_1","idempotency_key":"idem-1","codeRemoval":{"reference":"reference","state":"claimed"}}
splitch flags getAppnoGet a Flag definition by canonical ID or key. Returns complete per-Environment Flag Configurations and running Experiment references for every Environment in the App by default. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. by: optional one of "id", "key". include: optional one of "config". Terms: Environment — a named deployment context under an App, such as dev or prod. Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch flags list-noList every readable Flag across the principal's Apps, ordered by App then Flag key (bounded; reports its own truncation). Returns complete per-Environment Flag Configurations and running Experiment references for every Environment across those Apps by default. Formats: include: optional one of "config". Terms: Environment — a named deployment context under an App, such as dev or prod. Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch flags promoteApp + EnvironmentyesPromote selected Flag Configuration field-groups between Environments. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. targetEnvironmentId: required Canonical Environment ID (env_...) or human-readable Environment key. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. by: optional one of "id". fromEnvironmentId: required canonical id. Terms: Environment — a named deployment context under an App, such as dev or prod. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","targetEnvironmentId":"targetEnvironment_1","flagId":"flag_1","fromEnvironmentId":"fromEnvironment_1","select":{"availability":[],"targeting":true,"rollout":true,"enabled":true},"idempotency_key":"idem-1"}
splitch flags test-evalApp + EnvironmentnoDry-run resolve a Flag with the flat data-plane reason token and full resolution detail without firing an Exposure. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. flagKey: required canonical id. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Exposure — the event that an Entity actually encountered its assigned Variant. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch flags updateAppnoUpdate a Flag definition's name, description, schema, or lifecycle. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. flagId: required Canonical Flag ID (flag_...) or human-readable Flag key. lifecycleClass: optional one of "ops", "permission", "release", "experiment". owner: optional Person or team that answers for removing the Flag. expiresAt: optional When the Flag is due for removal (ISO 8601); stored as UTC. Terms: Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","flagId":"flag_1","lifecycleClass":"ops"}
splitch flags verifyApp + EnvironmentnoVerify a Flag Key through the data plane without firing an Exposure.
splitch integration-deliveries createApp + EnvironmentnoWake this Environment's integration delivery coordinator and read outstanding delivery counts. Cron mode returns the summary without a wake. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","environmentId":"environment_1"}
splitch metrics createAppnoCreate a Metric (binomial, count, revenue, ratio, retention, guardrail). Formats: appId: required canonical id. kind: required one of "binomial", "count", "revenue", "ratio", "retention". eventDefinitionId: optional canonical id. direction: optional one of "higher_is_better", "lower_is_better". Terms: Metric — a fact plus an aggregation. Example arguments: {"appId":"app_1","name":"name","key":"key","kind":"binomial"}
splitch metrics deleteAppnoDelete a Metric (blocked if referenced by a running Experiment). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. metricId: required canonical id. Terms: Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. Metric — a fact plus an aggregation. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","metricId":"metric_1"}
splitch metrics getAppnoGet a Metric. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. metricId: required canonical id. Terms: Metric — a fact plus an aggregation. App — the product or service surface that groups related Flags and hosts Experiments.
splitch metrics listAppnoList Metrics in an App. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: Metric — a fact plus an aggregation. App — the product or service surface that groups related Flags and hosts Experiments.
splitch metrics updateAppnoUpdate a Metric (decision-valid edits gated by DECISION_LOCKED). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. metricId: required canonical id. kind: optional one of "binomial", "count", "revenue", "ratio", "retention". eventDefinitionId: optional canonical id. direction: optional one of "higher_is_better", "lower_is_better". Terms: Metric — a fact plus an aggregation. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","metricId":"metric_1","kind":"binomial"}
splitch organization-members add-noAdd a member to an organization. Formats: orgId: required canonical id. userId: required canonical id. role: required one of "owner", "admin", "member". Example arguments: {"orgId":"org_1","userId":"user_1","role":"owner"}
splitch organization-members list-noList organization members. Formats: orgId: required canonical id.
splitch organization-members remove-noRemove a member (rejected if removing the last owner). Formats: orgId: required canonical id. userId: required canonical id. Example arguments: {"orgId":"org_1","userId":"user_1"}
splitch organization-members update-noChange a member's role. Formats: orgId: required canonical id. userId: required canonical id. role: required one of "owner", "admin", "member". Example arguments: {"orgId":"org_1","userId":"user_1","role":"owner"}
splitch organization-usage get-noGet an Organization's current-month Evaluation usage breakdown. Formats: orgId: required canonical id. Terms: Organization — the account and ownership unit. It owns Apps and has Users as members.
splitch orgs create-noCreate an organization; the calling principal becomes its owner. Formats: no id, timestamp, or enum arguments. Example arguments: {"name":"name"}
splitch orgs get-noGet one organization. Formats: orgId: required canonical id.
splitch orgs list-noList organizations the token can reach (agent cold-start entry). Formats: no id, timestamp, or enum arguments.
splitch orgs update-noRename an organization or change its plan. Formats: orgId: required canonical id. plan: optional one of "free", "pro", "enterprise". Example arguments: {"orgId":"org_1","plan":"free"}
splitch runs concludeApp + EnvironmentyesEnd a Run, freeze its decision evidence, and request winner Promotion. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. runId: required canonical id. by: optional one of "id". idempotencyKey: required canonical id. Terms: Environment — a named deployment context under an App, such as dev or prod. Promotion — applying a Flag Configuration, or a Variant's availability, to a target Environment. App — the product or service surface that groups related Flags and hosts Experiments. Experiment Run — the immutable, time-boxed unit of experiment analysis. Example arguments: {"appId":"app_1","environmentId":"environment_1","experimentId":"experiment_1","runId":"run_1","selectedVariant":"selectedVariant","expectedResultToken":"sha256:aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa","dataWatermark":"2026-01-01T00:00:00.000Z","target":{"environmentId":"environment_1","flagId":"flag_1","expectedConfigVersion":0,"proposedConfig":{"enabled":true,"availableVariantNames":[],"targetingRules":[{"id":"id_1","flagId":"flag_1","priority":0,"conditions":[{"attribute":"attribute","operator":"eq","value":true}],"variantId":"variant_1"}],"rollout":{"percentage":50}}},"idempotencyKey":"idem-1"}
splitch runs endApp + EnvironmentnoEnd a running Run. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. runId: required canonical id. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments. Experiment Run — the immutable, time-boxed unit of experiment analysis. Example arguments: {"appId":"app_1","environmentId":"environment_1","runId":"run_1","reason":"reason"}
splitch runs getApp + EnvironmentnoGet a full Run (frozen assignment + measurement config + status). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. runId: required canonical id. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. App — the product or service surface that groups related Flags and hosts Experiments. Experiment Run — the immutable, time-boxed unit of experiment analysis.
splitch runs listApp + EnvironmentnoList an Experiment's Runs (newest first). Formats: appId: required Canonical App ID (app_...) or human-readable App slug. environmentId: required Canonical Environment ID (env_...) or human-readable Environment key. experimentId: required canonical id. by: optional one of "id". Terms: Environment — a named deployment context under an App, such as dev or prod. Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. Experiment Run — the immutable, time-boxed unit of experiment analysis. App — the product or service surface that groups related Flags and hosts Experiments.
splitch segments createAppnoCreate a Segment. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","name":"name","conditions":[{"attribute":"attribute","operator":"eq","value":true}]}
splitch segments deleteAppnoDelete a Segment when no mutable Flag Configuration or Experiment draft uses it. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. segmentId: required canonical id. Terms: Experiment — a test that compares Variants of one or more Flags to measure their effect on Metrics for a population of Entities. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","segmentId":"segment_1"}
splitch segments getAppnoGet a Segment. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. segmentId: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch segments listAppnoList Segments in an App. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: App — the product or service surface that groups related Flags and hosts Experiments.
splitch segments updateAppyesUpdate a Segment. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. segmentId: required canonical id. Terms: App — the product or service surface that groups related Flags and hosts Experiments. Example arguments: {"appId":"app_1","segmentId":"segment_1","name":"name"}
splitch sentry-installations create-noSend this Organization's Flag changes to a Sentry organization. Formats: orgId: required canonical id. installationId: required canonical id. Terms: Organization — the account and ownership unit. It owns Apps and has Users as members. Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. Example arguments: {"orgId":"org_1","installationId":"018f2b7c-3c9a-7b3e-9a52-0c1d2e3f4a5b","webhookUrl":"https://app.example.com"}
splitch sentry-installations delete-noRevoke a Sentry integration and stop change delivery. Formats: orgId: required canonical id. installationId: required canonical id. Example arguments: {"orgId":"org_1","installationId":"018f2b7c-3c9a-7b3e-9a52-0c1d2e3f4a5b"}
splitch sentry-installations get-noRead Sentry change-tracking delivery health without secrets. Formats: orgId: required canonical id. installationId: required canonical id.
splitch sentry-installations list-noList Sentry change-tracking installations and their delivery health. Formats: orgId: required canonical id.
splitch sentry-secret-rotations create-noRotate the Sentry webhook signing secret. Formats: orgId: required canonical id. installationId: required canonical id. rotationId: required canonical id. Example arguments: {"orgId":"org_1","installationId":"018f2b7c-3c9a-7b3e-9a52-0c1d2e3f4a5b","rotationId":"018f2b7c-3c9a-7b3e-9a52-0c1d2e3f4a5b"}
splitch stale-flags listAppnoList Flags that look stale from configuration state (uniform serving, past expiry, or unchanged), with typed reasons. Serving evidence is always unverified. Suggest only; never archives. Formats: appId: required Canonical App ID (app_...) or human-readable App slug. Terms: Flag — a named feature toggle with a key, Variants, Targeting Rules, and enabled state. App — the product or service surface that groups related Flags and hosts Experiments.
splitch tokens create-noCreate a Personal Access Token for the CLI and MCP server. Broader or permanent access requires browser approval. The secret is written to --output-file and never printed.
splitch tokens list-noList your Personal Access Tokens for the CLI and MCP server: names, grants, expiry, and status. Secrets are never shown.
splitch tokens revoke-noRevoke a Personal Access Token. Its next use is refused.
splitch tokens revoke-all-noRevoke every active Personal Access Token you own.
splitch tokens rotate-noReplace a Personal Access Token's secret. Broader or permanent access requires browser approval. The old secret stops working; the new one is written to --output-file and never printed.
splitch tokens update-noRename a Personal Access Token or replace its grants or expiry. Widening access requires browser approval; narrowing stays available without it. The secret is unchanged.

Also available as /docs/cli.md. Indexed from /llms.txt.