> For the complete documentation index, see [llms.txt](https://developer.celigo.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://developer.celigo.com/changelog/2026.md).

# 2026

Notable changes to the Celigo developer platform across the REST API, CLI, and Platform MCP.

{% updates format="full" %}
{% update date="2026-09-13" tags="vscode,feature" %}

## Celigo VS Code extension 1.0.0

The **Celigo** extension (`Celigo.celigo`) is on the [Visual Studio Marketplace](https://marketplace.visualstudio.com/items?itemName=Celigo.celigo) and [Open VSX](https://open-vsx.org/extension/Celigo/celigo): the Flow Builder canvas in VS Code and Cursor for the tree `celigo pull` writes.

```bash
code --install-extension Celigo.celigo
```

Or search **Celigo** (publisher Celigo) in the Extensions view, or type `ext install Celigo.celigo` in Quick Open.

**The Flow Canvas**

* Open a pulled tree's `flow.json`, `tool.json`, or `api.json` and run `Celigo: Open Flow Canvas`, or press Cmd/Ctrl+Shift+V in the editor to open it beside the document: sources, destinations and lookups, branchings with their branch names, merge points, terminals, and each step's step components (filters, transformation, mapping, hooks, response mapping, error handling) as chips, laid out the way integrator.io's Flow Builder draws them. The graph is the CLI's own `celigo flows graph` engine. See [flows](https://developer.celigo.com/cli/commands/flows).
* Steps resolve through the tree, not just the file: names, categories, the application behind each connection, and the bindings of a `celigo pull --neutral` tree. `celigo status` badges (`modified`, `missing`, `untracked`) mark the flow and each step's document; `celigo lint` findings sit on the steps they concern.
* The canvas follows the editor — unsaved edits re-render as you type, the caret's step is highlighted, a double-click jumps to the step's definition — and drills down: flows started by this one (`_runNextFlowIds`) and an instance's abstract flow open in their own canvas.
* *Find node* (Cmd/Ctrl+F) matches step, application, resource, connection, and branch names; Enter / Shift+Enter walk the matches.

**The details panel**

* The selected step's JSON in an editor: its object in the flow (*Step*), the export or import document it references (*Resource*), or the whole document when nothing is selected. In *Edit* mode, *Apply* (Cmd/Ctrl+S) writes canonical JSON over exactly the value's range, linted inline and refused for instance flows and the `responseMapping` wrapper — the canvas's own guards.
* A *Related* tree lists everything the step reaches, in Flow Builder order: one item per step component (hooks per stage, each with its script), the export or import document with its connection and other references, and the flow-level links. Clicking a step component chip on a card opens the same item.
* Scripts and prompts load as their own tabs: a hook's `script.js` opens at the function the hook names; an AI agent's or guardrail's `instructions.md` opens with Markdown highlighting. Both are editable in *Edit* mode and written back verbatim.

**Editing and push**

* *Edit* turns on the Flow Builder affordances: `+` on an edge adds a step or a branching; step menus add, remove, and reorder steps and toggle error handling; branch ends merge, merge points unmerge, branchings gain branches and names; the *Enabled* / *Disabled* switch toggles `disabled`. Every edit is written to the document as canonical JSON through the CLI's mutation rules, so undo works and `celigo status` sees exactly the change.
* *Push* runs `celigo push --dry-run`, then `celigo push`, in a terminal for the flow and every referenced file with local changes — an import edited in the *Resource* tab, a hook's `script.js`, an AI agent's `instructions.md`. `--prune` is never passed. The extension holds no token: anything that needs credentials runs the installed `celigo` binary, and `celigo push` stays the only writer.

**Layout, export, live state**

* `celigo.canvas.direction` (`horizontal`, the default, or `vertical`) lays the canvas out left to right or top to bottom; *View › Vertical layout* flips one canvas without changing the setting. The vertical layout is Flow Builder's layout transposed — same rules, same spacing — with the sources in a row centred over the trunk.
* *Export* saves a PNG or SVG of the whole graph, or copies a Mermaid diagram (`flowchart LR` or `TD`, following the canvas) that renders natively in a GitHub pull request description.
* With `celigo.canvas.liveOverlay` on (off by default), the canvas reads the bound account through the CLI in read mode: open-error counts per step, whether the flow is enabled on the server and its last run, and whether the server copy moved since the pull. Nothing is written.

**Requirements and Restricted Mode**

* VS Code 1.104+ or Cursor. Rendering and editing work without the CLI; lint findings, the live overlay, and push need the [Celigo CLI](https://developer.celigo.com/cli) 2026.9.1 or later — the release that introduced `celigo pull` and the tree the canvas opens — on `PATH` (`npm install -g @celigo/celigo-cli`) or at `celigo.cliPath`. When no `celigo` answers, the extension offers once per session to run it through `npx`, pinned to that version.
* In an untrusted workspace (Restricted Mode) the canvas, the details panel, and the JSON editor work and edits are written to the open document, but nothing spawns the `celigo` CLI: lint findings, the live overlay, and push stay off until you trust the workspace (*Live* and *Push* say so in their tooltips), then open canvases refresh on their own. `celigo.cliPath` is a restricted setting.
* Settings: `celigo.cliPath` (`celigo`), `celigo.canvas.lint` (`true`), `celigo.canvas.liveOverlay` (`false`), `celigo.canvas.showComponents` (`true`), `celigo.canvas.direction` (`horizontal`). Commands: `Celigo: Open Flow Canvas`, `Celigo: Open Flow Canvas to the Side`, `Celigo: Copy Flow as Mermaid`, `Celigo: Push Flow with celigo (plan first)`, `Celigo: Refresh Live Overlay`.
  {% endupdate %}

{% update date="2026-09-13" tags="cli,feature" %}

## CLI 2026.9.1

`@celigo/celigo-cli` 2026.9.1 is on npm: the account as a local file tree you pull, edit, diff, and push back; promotion of that tree into another account or environment; flow graphs from the terminal; connector-first HTTP connections; Integration App settings; and EDI file definition rules generated from a specification PDF.

```bash
npm install -g @celigo/celigo-cli
```

**Profile safety**

* A `--profile` (or `CELIGO_PROFILE`) that names no profile is an error before any request — `Profile 'x' does not exist. Available: a, b (run 'celigo profile list').` — even when `CELIGO_API_TOKEN` or `--token` would supply a token. It used to resolve to an empty profile and fail later. See [Profiles & regions](https://developer.celigo.com/cli/getting-started/profiles).
* `CELIGO_PROFILE` binds a shell, agent session, or CI job to one profile. Resolution is `--profile`, then `CELIGO_PROFILE`, then the active profile; `celigo profile use <name>` prints the `export CELIGO_PROFILE=<name>` line to paste.
* Every command that writes names its target first on stderr — `celigo: profile 'acme-sandbox' → api.integrator.io` — and confirmation prompts carry the same label. Reads print nothing, stdout is untouched, and there is no opt-out.

**The local tree**

* `celigo pull` writes the account, or one integration with `--integration <id>`, as a file tree: one folder per resource holding a fixed-name document (`exports/<Name>/export.json`, `integrations/<Name>/flows/<Flow>/flow.json`), typed subfolders of links to everything the document references, and editable companions beside it — a script's `script.js`, a lookup cache's `data.json`, an AI agent's `instructions.md`. Pulls are incremental, a server-side rename is a folder move, and locally edited files are never overwritten without `--force`. Read mode.
* `celigo status` lists `modified`, `missing`, `untracked`, and `moved` files offline; `celigo diff` compares the tree with the live account field by field, with JSON-pointer paths, and never prints a secret (a replaced `******` renders as `(set)`). Both take `--exit-code` for CI gates.
* `celigo push` writes edits back: `PUT` for modified documents, create for new files, delete only with `--prune`. The plan prints before anything is sent, and `--dry-run` exits `1` when any item is refused, so a CI gate cannot pass a payload the push would refuse. Full mode.
* Every write holds a per-file optimistic lock — one `GET` before each `PUT` or `DELETE`, refused when the server copy changed since the pull (`celigo pull --force <path>` to take theirs, `push --force-remote` to overwrite).
* New files reference each other by relative path (`"_connectionId": "connections/_new-store.json"`) and are created in dependency order, so an import is never sent before its export's id exists.
* Push refuses, with no override, a document whose `_id` is not the tracked resource's, a `connections`/`iclients`/`mcp-oauth-providers` payload still holding `******`, and the `responseMapping` object wrapper — the platform accepts it and erases the step's mappings.
* Interrupting a push is safe: creates record their intent before the `POST`, so the next push adopts what landed as `recovered` instead of creating it twice; Ctrl-C finishes the requests on the wire and exits `130`.
* A tree is bound to the account it was pulled from — API host plus the token owner's user id — not to a profile name. `pull`, `diff`, and `push` refuse another host or another token owner however the profile was selected; `--allow-account-mismatch` on `pull` and `push` is the only override.
* `celigo pull --neutral` writes an environment-neutral tree: no `_id`s, every reference as a tree path, and per-environment resources (connections, iClients, stacks, on-premise agents) as `@bindings/` keys (`"_connectionId": "@bindings/connection/shopify"`) resolved from an untracked `.celigo/bindings.json`, so one git branch per environment merges cleanly. Decided at the first pull; a standard tree is not converted in place.
* `celigo lint` validates the tree offline against the platform's published schemas — the `@celigo/api-specs` package, pinned into the release and refreshed from npm at most once a day (`CELIGO_NO_SPEC_UPDATE=1` or `celigo config set specs_auto_update false` opts out). It reports unknown fields, type mismatches, enum misses, masked placeholders, unresolved references, and scope violations; a shape the account already exhibits downgrades to a warning, the `responseMapping` wrapper never does; `--strict` promotes warnings to errors. See [OpenAPI specs](https://developer.celigo.com/api/using-the-api/openapi-specs).
* `celigo resolve <ref>` maps a link, tree path, `type:id`, bare id, or `@bindings/` key to the real document; `--open` launches it in VS Code.
* `pull`, `diff`, and `push` run their requests `--concurrency <n>` at a time (1–16; `CELIGO_CONCURRENCY`; default 8). A `.celigoignore` in the tree root keeps parts of the account out of the tree, in gitignore syntax.
* Integration App documents are pull-only, and a tree pulled as one integration never writes into another (`--allow-dependencies` overrides). Celigo Storage is pull-only too; `--storage-files` downloads file contents.

**Promote**

* `celigo promote --to <profile>` writes the tree into another account or environment — Sandbox to production inside one account, or account to account. State per target lives in a committed `.celigo/targets/<name>.json` (source id → target id, lock token, how each connection resolved), so the second promote is an update, not a second copy. Plan first, `--dry-run`, `--prune` for deletes, `--force-remote` for a target copy edited since the last promote. Full mode on the target profile; neutral trees are not promotable in this version.
* Connections, iClients, stacks, and on-premise agents are never promoted with credentials: each resolves to a `--map connection/<source>=<target-id>` pin, a same-name resource in the target, or a credential-less shell created with `--create-connections` (masked values become `REPLACE-IN-UI` placeholders you fill in through the target's UI or `connections update`). `--adopt-by-name` maps hand-built namesakes instead of refusing the create.
* `celigo diff --target <name>` shows what promote would send, in any mode of the target profile.
* In CI the target has its own token: `CELIGO_TARGET_API_TOKEN` and `CELIGO_TARGET_BASE_URL`. `CELIGO_API_TOKEN` and `--token` belong to the source session and never reach the target; a target with neither a stored token nor the variable is refused.

**Flow graphs from the terminal**

* `celigo flows graph [ref]`, `apis graph`, and `tools graph` render a flow's, API's, or Tool's builder graph from the local tree, offline — the same sources, steps, branchings, merges, and terminals the Flow Builder canvas draws, each step with its step components (filters, transformation, mapping, hooks, response mapping, error handling). No profile or token needed. See [flows](https://developer.celigo.com/cli/commands/flows).
* Output is `--as json` (default), `--as mermaid` (renders natively in GitHub pull requests), or `--as dot`; `--status` adds each step's local-tree state, `--no-components` leaves the step component chips out of the mermaid and dot output, and `--file` renders any document (`-` for stdin).
* The same graph opens as an interactive Flow Builder canvas in VS Code and Cursor through the [Celigo extension](https://marketplace.visualstudio.com/items?itemName=Celigo.celigo) 1.0.0, released the same day (see its entry above).

**Connector-first HTTP connections**

* `http-connectors match <url|name>` names the pre-built connector for an API and what its connection form prescribes: `authTypes` and `defaultAuth`, the `globalIClientId` when Celigo ships a shared OAuth app, the fields you `mustSet`, `scopes`, the version, and the base URIs. A URL is confirmed against the name-related connectors with detail requests; `--scan` confirms every connector. See [http-connectors](https://developer.celigo.com/cli/commands/http-connectors).
* `http-connectors list --search <term>` filters by name or legacy application id, and the table gains a `legacyId` column.
* `connections create --connector <id|name>` scaffolds the connection the connector's own form saves — `type`, `assistant`, the connector, API, and version ids, its default `http.auth.type`, and every applicable pre-configured field — and merges your body over it (`--api`, `--version`, `--auth-type`, `--name`, `--dry-run`). The fields the form makes you set are listed on stderr, never invented. See [connections](https://developer.celigo.com/cli/commands/connections).
* A hand-written `type: http` connection whose base URI a pre-built connector serves is refused before the `POST`, naming the connector (`--allow-raw-http` proceeds deliberately), and so is a connector connection whose `http.auth.type` the connector's form does not offer (`--auth-type <type>` confirms it). The API accepts both shapes silently; neither authorizes the way the connector expects.
* `connections get` explains an empty `http._iClientId` on a connector OAuth connection: a stderr note says whether it authorizes through Celigo's global iClient or still needs your own.
* `edi-profiles create --tp-connector <id|name>` scaffolds the partner's EDI profile from its trading partner connector (file type, X12 version, ISA/GS flags and qualifiers) and lists the interchange and group identifiers left to you; `connections create --tp-connector <id|name>` links the connection (`_tpConnectorId`), refuses a transport the connector does not provision, and lists the fields its form requires. A hand-written `as2`/`ftp`/`s3`/`van` connection or EDI profile named after a partner that has a connector gets a stderr note, never a refusal. See [edi-profiles](https://developer.celigo.com/cli/commands/edi-profiles).

**Integration App settings**

* `integrations settings <id>` lists an Integration App's settings form flat — field name, type, current value, section, store id, `flowId` — with `--store`, `--section`, `--refreshable`, and `--field-name` for one field's full definition. `integrations refresh-settings-metadata <id> --field-name <name>` re-pulls a field's option list through the app's connector code. See [integrations](https://developer.celigo.com/cli/commands/integrations).
* `integrations persist-settings <id> <fieldName>=<value>…` saves through the connector, nests a multi-store app's values under the store id (`--store <id>`), and re-reads the document to report each field `saved`, `unchanged`, or `not-saved` — the platform answers `success: true` even when it saved nothing, so the exit code follows the field report. A body nothing on the form can locate is `unverified` and exits `1` unless `--allow-unverified`. Full mode.

**EDI file definition rules from a specification PDF**

* `file-definition-rules generate <pdf> --document-type <n>` generates X12 or EDIFACT file definition rules from an implementation guide and returns both artifacts: `generationFdr`, a complete file definition body, and `parsingFdr`, wrapped as `{resourcePath, fileDefinition}` for an export or import. `parse` returns the parsing rules only, `document-types` lists the supported transaction sets, and `status <requestId>` reads a job (`--wait`).
* Jobs poll to completion by default (`--timeout`, 420 s; `--no-wait` prints the `requestId`). Submissions are capped at 10 per hour per account, so a missing or non-PDF file, a file over 50 MB, or a document type outside the catalog is refused locally before anything is sent. Nothing is persisted — pipe the result into `file-definitions create`, adding the `globalId` the generator does not emit. Read mode blocks the submissions; operate mode allows them. See [file-definitions](https://developer.celigo.com/cli/commands/file-definitions).

**Also in this release**

* The HTTP client honors a 429's `Retry-After` (delay-seconds or an HTTP-date, capped at 60 s) instead of an exponential guess, and a request that times out says so before it retries — a write that timed out may still have landed.
* Richer `--help` for `flows`, `apis`, `tools`, `guardrails`, `ai-agents`, `lookup-caches`, and `edi-profiles`, and one-line group summaries in `celigo --help`.
* `exports invoke <id>` states that a `--file` or piped body is ignored when an id is given — the saved export is invoked exactly as stored. See [exports](https://developer.celigo.com/cli/commands/exports).

**Fixed**

* `flows retry-errors`, `resolve-errors`, `assign-errors`, `unassign-errors`, and `delete-resolved-errors` report what the API did, not how many keys were sent: retry names the job it queued (`Retry queued for N record(s). (job <id>)`), assign and unassign count the ids the API echoes, resolve and delete count only ids that are gone. Keys that matched nothing go to stderr, a run that changed nothing exits `1`, and `retry-errors` rejects an all-digit key (an `errorId`, not a `retryDataKey`) up front.
* `edi-profiles list`, `environments list`, `lookup-caches list`, `mcp-oauth-providers list`, and `tags list` work again by default. Their endpoints reject the `include` projection every projected `list` has sent since 2026.8.1, so only `--fields all` worked. Rows are now trimmed client-side to the same columns.
* `set` never `PUT`s a `******` mask it did not ask for: the GET + modify + PUT fallback refuses when the fetched document itself carries masked credentials and points at `update` with the real values. In operate mode, `set` can no longer restructure an allowed scalar through a dotted path (`disabled.foo=1`).
* `apis set timeoutPeriod=…` and `apis set pagination.enabled=…` go through the whitelisted atomic `PATCH`, the route on which a full `PUT` silently drops API fields. See [apis](https://developer.celigo.com/cli/commands/apis).
* On Windows, the background skills install no longer opens a console window, and `celigo skills install`, `list`, and `update` no longer fail with `EINVAL`.
* Two `list` columns that could never populate are gone: `http-connectors list` shows `lastModified` instead of `published`, and `syncs list` drops `lastExecutedAt` — run timing lives on `sync-jobs list`.
* Correction to the CLI 2026.8.8 note below: the camelCase `/v1/mcpServers` route did affect reads — the projected `GET` that `mcp-servers list` issues returned `422`, so 2026.8.7's `mcp-servers list` failed on every call. The 2026.8.8 switch to the documented lowercase path fixed it.

**Security**

* An id argument cannot change the request path. A positional id (`<id>`, `<flowId>`, …) holding `/`, `?`, `#`, or whitespace is refused before any request; interpolated into a path, `int1?x` turned a settings `PUT` into a `PUT` on the integration document itself — the verb that erases every field it omits.

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-08-31" tags="api,feature" %}

## OpenAPI specs on npm

* `@celigo/api-specs` (MIT) publishes the 44 OpenAPI documents behind the API reference, one self-contained file per resource under `dist/` with no cross-file `$ref`s. Install with `npm install --save-exact @celigo/api-specs`. See [OpenAPI specs](https://developer.celigo.com/api/using-the-api/openapi-specs).
* Every document declares `openapi: 3.2.0`, the four regional `servers` (US, EU, AU, CA), and the `bearerAuth` security scheme. Tools that parse only OpenAPI 3.0 or 3.1 may reject the documents.
* The specs are prescriptive: internal operations, deprecated fields, and retired enum values are removed before publishing. A request that validates against them is supported; the live server accepts more than the specs describe.
  {% endupdate %}

{% update date="2026-08-29" tags="cli,feature" %}

## CLI 2026.8.8

`@celigo/celigo-cli` 2026.8.8 is on npm.

```bash
npm install -g @celigo/celigo-cli
```

* **New: `exports reset-cursor <id>`** resets the CDC cursor on a stream (Debezium) export — the platform deletes the stored offset and restarts the stream consumer, no flow toggle required. The server refuses a reset while the saved `cdc.snapshotMode` is `initial_only`; `--snapshot-mode when_needed` flips the mode and resets in the same save, re-arming a one-shot snapshot export without cloning and deleting it. The save is fail-soft (HTTP 200 either way): the CLI reads the `_cursorResetStatus` verdict and exits non-zero on refusal. See [exports](https://developer.celigo.com/cli/commands/exports).
* **Fixed:** `mcp-servers` now calls `/v1/mcpservers` (lowercase), exactly as the API reference documents. Reads were never affected, but writes through the undocumented camelCase path could leave a live MCP server serving a stale `tools/list` for 15+ minutes after Tool schema edits. If you script against the REST API directly, use the documented lowercase path. See [mcp-servers](https://developer.celigo.com/cli/commands/mcp-servers).
  {% endupdate %}

{% update date="2026-08-23" tags="api,feature" %}

## AU and CA data centers

Data and tokens never cross a region boundary, so each region needs its own token and base URL.

* REST API base URLs `https://api.au.integrator.io` (AU) and `https://api.ca.integrator.io` (CA) join the existing US and EU hosts. Sign in at `au.integrator.io` or `ca.integrator.io`. See [Environments & regions](https://developer.celigo.com/api/getting-started/environments).
* Platform MCP answers at `https://api.au.integrator.io/celigo-mcp` and `https://api.ca.integrator.io/celigo-mcp`. OAuth sign-in routes to the tenant that matches the endpoint you configure. See [Connect a client](https://developer.celigo.com/mcp/connect).
* The CLI targets a region through a profile's base URL: `celigo profile add au --api-token "$AU_TOKEN" --api-base-url https://api.au.integrator.io`. See [Profiles & regions](https://developer.celigo.com/cli/getting-started/profiles).
* AU data stays in Australia and CA data stays in Canada, the same in-region residency the EU data center provides.
  {% endupdate %}

{% update date="2026-08-23" tags="cli,feature" %}

## CLI 2026.8.7

`@celigo/celigo-cli` 2026.8.7 is on npm: 34 new commands across end-user management, MCP server access, documentation search, product feedback, and API request logging.

```bash
npm install -g @celigo/celigo-cli
```

**Breaking and renamed**

* **Breaking:** `subscriptions usage` returns one combined object covering account, API, entitlement, historical monthly, EDI label-printing, storage, and syncs usage; license-gated sources appear inline as `{"error": ...}` entries. Anything parsing the old bare output should pipe `--jq .usage`, which returns exactly the previous payload. See [subscriptions](https://developer.celigo.com/cli/commands/subscriptions).
* `users` is now `workspace-users`: your team's account collaborators, distinct from the new `end-users` — external people who sign in to use your MCP servers. `users` is retained as a hidden alias, so existing invocations keep working.

**End-user management**

* `end-users` manages external MCP end users: `list` (with `--provisioned-by invite|jit`), `effective-access` for one user's compiled MCP access with each grant's source, `invite --email` (one address, or up to 100 per call), and `revoke`. Invitations send real emails.
* `groups` and `roles` bundle MCP grants for assignment: standard CRUD, plus `groups add-members` / `remove-members`.
* `mcp-servers effective-access <id>` lists every end user who can reach a server and their effective tools. `assign-end-users` and `assign-groups` bulk-assign a server's capabilities (`tool:`, `api:`, and `pset:` capability-set handles) to up to 100 targets per call; an assignment replaces each listed target's grant for that server. See [mcp-servers](https://developer.celigo.com/cli/commands/mcp-servers).

**Docs search and feedback**

* `docs search` asks Celigo's product documentation a question and returns an AI-generated answer with cited sources. `--thread` continues a conversation. Allowed in read mode.
* `feedback submit` sends structured product feedback (`--category`, `--severity`, `--command`, `--expected`, `--actual`), with the CLI version and runtime context attached automatically — never command arguments or payload data. Works in every mode, and `feedback submit --help` includes a worked incident-report example.

**API Builder request logging**

* `apis request-history <id>` lists an API's logged request executions — recorded while `logging.mode` is anything but `no_logging` — with time, status-code, method, trace-key-prefix, remote-IP, and URI filters.
* `apis execution-logs <apiId> <executionId>` prints one execution's trace; `--details` adds decoded step payloads, fan-out children, and payload download URLs. `apis delete-execution-logs` queues deletion of a date range.
* `apis set` applies `logging.mode`, `logging.debugUntil`, and `traceKeyTemplate` atomically via `PATCH` — the server ignores `logging` on a full `PUT`. See [apis](https://developer.celigo.com/cli/commands/apis).

**Also in this release**

* `tools invoke <id>` runs a Tool synchronously; `--log-mode debug` records the run. `tools clone` copies a Tool into a target integration — Tools that reference connections require a `connectionMap`. See [tools](https://developer.celigo.com/cli/commands/tools).
* `storage get <ids...>` fetches metadata for up to 100 files in one call, `storage move` moves up to 100 items (`--name` renames a single item as it moves), and `storage cancel-upload` aborts a stuck multipart upload. See [storage](https://developer.celigo.com/cli/commands/storage).
* `http-connectors catalog` and `http-connectors endpoint-detail` read the staged form-metadata summaries and scoped detail documents. See [http-connectors](https://developer.celigo.com/cli/commands/http-connectors).
* `integrations register-lookup-caches` and `deregister-lookup-caches` attach and detach lookup caches. Registering also writes an `aliases[]` entry, which must be removed before deregistering. See [integrations](https://developer.celigo.com/cli/commands/integrations).
* `flows get --merge-instance` returns an instance flow's effective config, and `flows list` adds `--name`, `--disabled`, `--include-instances`, `--abstract-flow-id`, and `--sort-by lastExecutedAt`. See [flows](https://developer.celigo.com/cli/commands/flows).

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-08-22" tags="api,feature" %}

## August API updates

Everything below is live in production and documented in the [API reference](https://developer.celigo.com/api).

* End-user management joins the reference: [End Users](https://developer.celigo.com/api/api-reference/end-users), Groups, and Roles cover listing end users, compiling one user's effective MCP access, single and bulk invites (up to 100 addresses), revocation, group membership, and role CRUD.
* MCP servers document `permissionSets[]` — embedded capability sets (`accessLevel: read|write`, `_toolIds`, `_apiIds`) referenced in grants as `pset:<_id>` — plus per-server effective access and bulk capability assignment to end users or groups, up to 100 per call. See [MCP Servers](https://developer.celigo.com/api/api-reference/mcp-servers).
* MCP server `prompts[]` entries document their server-generated `_id`.
* Tool invocation documents the `x-log-mode` header: only `debug` takes effect on a direct call; `basic`, `standard`, and `detailed` apply when an AI agent or MCP server invokes the Tool.
* Integrations document the lookup-cache registration endpoints' alias side effect: registering writes an `aliases[]` entry per cache, and deregistering fails with `400` until the alias is removed.
* Corrections to the APIs spec: mapping `dataType` is documented as required, `hardCodedValue` casing is fixed, and `logging` is writable only via `PATCH` — the server ignores it on `PUT`.
  {% endupdate %}

{% update date="2026-08-03" tags="cli,feature" %}

## CLI 2026.8.2

`@celigo/celigo-cli` 2026.8.2 is on npm and includes everything in 2026.8.1.

```bash
npm install -g @celigo/celigo-cli
```

**Renamed and removed options**

* **Breaking:** date and time options now name the field they bound, as `--*-gte` and `--*-lte`. `audit list` and `scripts debug-logs` take `--time-gte` and `--time-lte`, `edi-transactions list` takes `--modified-gte` and `--modified-lte`, and `flows delete-execution-logs` takes `--started-gte` and `--started-lte`. The former names no longer resolve.
* **Breaking:** `flows run` takes `--start-time` and `--end-time` for a delta window override, replacing `--start-date` and `--end-date`. The window accepts a full timestamp, which the former names read as a calendar date.
* **Breaking:** `--sandbox` is removed from `jobs current`, `jobs run-stats`, and `edi-transactions list`. The environment comes from the profile's token, so use a profile that targets the Sandbox environment.
* `tp-connectors` is now `trading-partner-connectors`. The former name is retained as an alias, so existing scripts keep working. See [trading-partner-connectors](https://developer.celigo.com/cli/commands/trading-partner-connectors).

**Projected list output**

* `list` requests server-side field projection by default. Each row carries `_id`, `name`, and the group's table columns instead of the complete document. On one account `exports list` went from 12.9 MB to 183 KB, and `flows list` measured 7.5× smaller.
* Table output and `get` are unchanged. `jobs`, `sync-jobs`, `recycle-bin`, `storage`, `audit`, the error listings, and `account snapshot` are never projected.
* `--fields all` returns complete documents. `--fields default` names the built-in projection explicitly. `--fields <a,b,c>` requests a specific set, with dot notation for nested fields.
* An explicit `--fields` list is a floor, not an exact shape. `_id` and `name` accompany every projection, as does any field the command filters on internally.
* `--jq` fetches complete documents on its own, so existing `jq` pipelines are unaffected. Precedence is `--fields`, then `--jq`, then the profile's `list_fields`, then the built-in default. Pairing `--jq` with an explicit `--fields` projects, and the expression can read a `null`. See [Global flags](https://developer.celigo.com/cli/getting-started/global-flags).
* `celigo config set list_fields all` makes complete documents the default for a profile. The key is per-profile and accepts `all` or `default`. See [Configuration reference](https://developer.celigo.com/cli/getting-started/configuration).
* `--limit <n>` returns at most `<n>` rows from a single page. It is available on the standard `list` verb. `ai-agents`, `guardrails`, `notifications`, `stacks`, `http-connectors`, `trading-partner-connectors`, and `templates marketplace` accept `--fields` without it.

**New command groups**

* `celigo storage` manages files and folders in Celigo Storage: `list`, `search`, `upload`, `download`, `replace`, `create-folder`, `set`, `move`, `copy`, `merge`, and `delete`. See [storage](https://developer.celigo.com/cli/commands/storage).
* `celigo datasets` selects which tables or objects a sync replicates, with `list`, `get`, and batch `upsert`. `datasets available <connectionId>` and `datasets fields <connectionId> <datasetName>` read the source catalog. See [datasets](https://developer.celigo.com/cli/commands/datasets).
* `celigo processors` runs the stateless parsers and generators: `list`, `invoke <name>`, `parse <csv|edi|xml>`, and `generate <csv|edi>`. Nothing on the account is created or changed, so these run in a `read`-mode profile. See [processors](https://developer.celigo.com/cli/commands/processors).

**Syncs**

* `syncs` adds `list` (with `--integration`), `get`, `create`, `update`, `set`, and `delete` beside the existing `run`, `audit`, and `cancel-jobs`. See [syncs](https://developer.celigo.com/cli/commands/syncs).
* `syncs events <syncId>` lists schema drift and data catalog events, filtered by `--type`, `--resource-name`, `--run`, or a time range.
* `syncs usage` reports records loaded per sync, per month with entitlement history, or per environment.

**AI assistant skills**

* The CLI installs the official Celigo skills in a detached background process, at most once every 24 hours, so an AI assistant driving the CLI has them without a manual step. It never blocks or fails the command that triggered it, and is skipped in CI. See [AI assistant skills](https://developer.celigo.com/cli/using-the-cli/skills).
* The background process installs only when the `celigo/ai` skills repository has moved since the last install. When it has not, the CLI installs nothing and prints nothing.
* `celigo skills install`, `celigo skills list`, and `celigo skills update` run the installer on demand. Nothing is installed at npm install time.
* Opt out with `CELIGO_NO_SKILLS_INSTALL=1` or `celigo config set skills_auto_install false`.
* `celigo config set skills_auto_install_exclude writing-sql,writing-handlebars` keeps named skills out of the background install, which then requests the rest by name instead of `--all`. An explicit `celigo skills install` ignores the list.
* `auto_update`, `skills_auto_install`, and `skills_auto_install_exclude` are machine-wide, stored outside the profiles rather than on one of them.

**Also in this release**

* `flows error-summary` makes one request to the per-step rollup endpoint instead of one request per flow step, and reports each step's `lastErrorAt`. The `stepType` column is gone — the rollup does not return it.
* `apis download` and `tools download` save a builder-mode API or a Tool as a template `.zip`. The API archive includes every resource it references; script-mode APIs cannot be exported. `apis clone --dry-run` validates the target version and route without creating anything.
* `audit list` and `audit download` accept multiple `--resource-type`, `--source`, and `--action` values, plus `--resource <type>:<id>` pairs. Each filter matches any of its values. See [audit](https://developer.celigo.com/cli/commands/audit).
* `storage merge <id> --to <destinationId>` merges one folder into another and removes the source. Requires `full` mode.
* JSON output is compact when stdout is a pipe or a file, and pretty-printed only at an interactive terminal.
* `mcp-oauth-providers` guards masked credentials the way `connections` and `iclients` do. `set` refuses every field on the group, which has no `PATCH` whitelist, and points at `update` with the real values.
* Commands behind a confirmation prompt exit `1` when there is no TTY, instead of exiting `0` after refusing to act.
* The background self-update names the exact command it runs, so the notice is auditable. `celigo config set auto_update false` downgrades it to a notify-only hint; `CELIGO_NO_UPDATE=1` disables the check entirely.

Full command reference in the [Celigo CLI](https://developer.celigo.com/cli) section.
{% endupdate %}

{% update date="2026-07-20" tags="mcp,feature" %}

## OAuth sign-in for Platform MCP

Add the [Platform MCP](https://developer.celigo.com/mcp) endpoint to your client with no credentials and it opens a browser sign-in — no more creating and copying API tokens. Per-client setup in [Connect a client](https://developer.celigo.com/mcp/connect).

```json
{
  "mcpServers": {
    "celigo": {
      "url": "https://api.integrator.io/celigo-mcp"
    }
  }
}
```

* The server implements OAuth 2.1 with PKCE and dynamic client registration. Clients that follow the MCP authorization spec discover the sign-in automatically — current releases of Claude, Cursor, VS Code, Windsurf, and ChatGPT all do.
* Sign-in uses your Celigo credentials, including SSO and MFA where your account requires them. The session acts as you, in the account and environment you pick at sign-in.
* Clients refresh the session automatically. You sign in again only if access is revoked, you switch account or environment, or the session goes unused for an extended period.
* API tokens and personal access tokens still work for CI, scripts, and clients without OAuth support — pass one in the `Authorization` header, same as before.
* The endpoint is region-specific: `https://api.eu.integrator.io/celigo-mcp` signs in against `eu.integrator.io`. To switch account or environment, disconnect the server and sign in again.
  {% endupdate %}

{% update date="2026-07-14" tags="api,feature" %}

## Personal access tokens

A personal access token (PAT) is a bearer token you create yourself that acts with your own user permissions — no admin provisioning, no scopes. Full details in [Authentication](https://developer.celigo.com/api/getting-started/authentication).

* Create one under **Resources → API tokens** → **+ Generate token** → **Personal access token**. Manage and Monitor roles get self-service API access for the first time; for them it is the only token type offered.
* The token inherits your permissions and follows role changes. Disabling your user blocks the token; deleting your user revokes it.
* Admins can see and revoke every PAT on the account, but cannot view a token value they didn't create.
* PATs auto-purge after 90 days by default, configurable from 1 hour to never.
* A PAT works anywhere an API token works: REST API calls, `CELIGO_API_TOKEN` in the CLI, and the `Authorization` header on Platform MCP.
  {% endupdate %}

{% update date="2026-07-14" tags="mcp,feature" %}

## Platform MCP: nine new tools

Connected clients pick these up automatically — the catalog is fetched at runtime. Full details in [Tools](https://developer.celigo.com/mcp/tools).

**B2B EDI**

* `list_edi_profiles` / `upsert_edi_profile` manage trading-partner interchange envelopes (X12 ISA/GS, EDIFACT UNB).
* `list_file_definitions` / `upsert_file_definition` manage parsing and generation rules for CSV, fixed-width, X12, and EDIFACT files.
* `list_edi_transactions` queries the EDI transaction log by document type, direction, document number, or date window; `includeFaDetails` / `includeMdn` add acknowledgment detail.
* `update_edi_fa_status` marks acknowledgments `accepted` or `rejected` in bulk.

**Marketplace and debugging**

* `list_marketplace` browses published templates or previews one template's full blueprint; `deploy_template` installs it as a new integration mapped to your connections.
* `list_execution_logs` reads a run's debug logs: the index, one record's step timeline, or request/response payloads per stage. Requires debug logging armed on the flow.

**Existing tools**

* `list_flow_errors` with no arguments returns an account-wide summary of every erroring flow and step.
* `list_flows` adds `hasOpenErrors`, `includeErrorCounts`, and `numError_gte`.
* `run_flow` takes optional overrides: `export.startDate` / `export.endDate` for backfills, `_exportIds` to run a subset of source exports.
* `list_jobs` with `includeFiles: true` returns short-lived download URLs for files a run produced.

**Fixes**

* Every tool declares MCP tool annotations (read-only, destructive, idempotent).
* `run_flow` and `cancel_job` take `_id`, matching every other tool (previously `id`).
* `update_flow_error_retry_data` advertises the correct body schema — the retry-data envelope, not the flow schema. `list_lookup_cache_data` drops a stray `body` parameter.
* `delete_resource` states that its dependency pre-flight runs for connections only and that warnings never block the delete; `resourceType` adds `edi-profiles` and `file-definitions`.
* `list_environments` returns an empty list with a warning on accounts without the feature. `list_jobs` returns `[]` instead of `null` when nothing matches.
  {% endupdate %}

{% update date="2026-07-14" tags="api,feature" %}

## July API updates

Everything below is live in production and documented in the [API reference](https://developer.celigo.com/api).

**AI agents**

* AI agent and guardrail imports support Anthropic Claude: set `provider: "anthropic"` with a Claude model id in `litellm.model` and Claude settings in `litellm._overrides.anthropic` (required `systemInstruction`, extended thinking via `thinkingConfig`, Claude tools including web search). `temperature` is capped at 1 and `responseFormat.type` must be `text` or `json_schema`.
* All three providers accept a `resources` array — read-only reference content (policies, schemas, documentation) pinned from connected MCP servers.
* OpenAI reasoning effort adds `none` and `xhigh`; OpenAI configs support `topLogprobs`; the LiteLLM `maxCompletionTokens` default rose from 1000 to 5000.

**Endpoints**

* The Syncs reference now covers the full build surface, not just running and monitoring: sync CRUD, dataset CRUD, schema-drift events, source and destination metadata catalogs, and usage endpoints.
* `POST /v1/connections` accepts `__integrationIds` (up to 100) to create a connection and register it on integrations in one call; post-save registration failures are reported in `__failedIntegrationRegistrations` without rolling back the connection.
* The step error endpoints (`GET /v1/flows/{_id}/{_stepId}/errors` and `.../resolved`) add filters: `_flowJobId` (paired with `occurredAt_gte` or `resolvedAt_gte`), occurred/resolved date bounds, `tags` (including `untagged`), and `resolvedBy` (including `auto`).
* `GET /v1/apis/{_id}/template` and `GET /v1/tools/{_id}/template` export a builder-mode API or Tool and everything it references as an installable `.zip` via a short-lived signed URL.
* `POST /v1/apis/{_id}/clone/validate` dry-runs a clone and returns `canClone`, catching version/route conflicts before anything is created.
* MCP servers (the `mcpservers` resource) accept a `resources` array: Celigo Storage files served to MCP clients through `resources/list` and `resources/read`.

**Also in the reference**

* Integration clone previews include Tool resources; the `tools_not_supported` rejection is gone.
* The recycle bin supports the `storageitems` resource type (list-only).
* License responses document `storage` entitlements (`maxAllowedUsage`, `disableOverage`) and EDI `labelPrinting` entitlements.
* Trading-partner connectors carry new `type` (`FTP`, `AS2`, `S3`) and `region` fields.
  {% endupdate %}

{% update date="2026-06-18" tags="mcp,feature" %}

## Celigo Platform MCP is generally available

The Celigo Platform MCP is now live at `https://api.integrator.io/celigo-mcp`. It's a hosted remote MCP endpoint that lets AI agents read, run, and troubleshoot your integrator.io account: no local process, no sidecar, a bearer token and any MCP-compatible client.

### Who it's for

Anyone working with AI coding agents: Claude Code, Claude Desktop, Cursor, VS Code with Copilot, Windsurf, or any client that speaks Streamable HTTP. Point the client at the endpoint, hand it an API token, and the agent can operate on your integrator.io account directly.

### What agents can do today

* **Inspect everything.** List and get connections, integrations, flows, exports, imports, scripts, agents, guardrails, APIs, tools, MCP servers, lookup caches, iClients, jobs, and audit entries.
* **Build and edit resources.** Create or update any resource with a single `upsert_*` tool, and delete any resource with `delete_resource`, which reports dependents as advisory warnings but doesn't block. A masked-credential guard keeps agents from overwriting stored secrets.
* **Run flows and triage errors.** Trigger a flow, wait for the job, inspect per-step results, then retry, resolve, tag, or assign failed records, all in one conversation.
* **Use built-in prompts.** Guided workflows ship with the server: account health audits, flow troubleshooting, connection diagnosis, integration planning, flow config review, and Handlebars/SQL writing assistance. The `search_knowledge_base` tool answers product questions straight from the Celigo Knowledge Base.
* **Load reference resources.** The server exposes a product glossary, tool usage guide, error pattern reference, connector catalog, and API reference as MCP resources: context the agent pulls on demand. (Full connector and resource schemas come from the `get_schema` tool, not a resource.)

### Get started

```json
{
  "mcpServers": {
    "celigo": {
      "url": "https://api.integrator.io/celigo-mcp",
      "headers": {
        "Authorization": "Bearer <YOUR_API_TOKEN>"
      }
    }
  }
}
```

Full setup, authentication details, transport options, and the complete tool catalog live in the [Platform MCP section](https://developer.celigo.com/mcp).

<details>

<summary>Notes</summary>

* Requires a full-access API token
* Region-aware: use `https://api.eu.integrator.io/celigo-mcp` for EU accounts

</details>
{% endupdate %}

{% update date="2026-06-17" tags="cli,feature" %}

## CLI 2026.6.1

`@celigo/celigo-cli` **2026.6.1** is on npm. A large release: seven new command groups, file-based input across every write command, credential-safe `set`, actionable error hints, and a round of command renames that align the CLI surface.

```bash
npm install -g @celigo/celigo-cli
```

### New command groups

* `celigo connectors`: base CRUD plus `install-base`, `install`, `push-update`, and `connectors licenses` CRUD.
* `celigo state`: read and write resource and account state with `list`, `get`, `set`, `delete`, `purge`. Global by default; scope to a resource with `--resource-type` and `--resource-id`.
* `celigo syncs`: `run`, `audit`, `sources`, `destinations`, `cancel-jobs`.
* `celigo sync-jobs`: `list` (auto-paginated per sync, newest first, with `--created-gte` / `--created-lte`), `get`, `errors`, `cancel`.
* `celigo recycle-bin`: `list`, `get`, `restore` (with `--cascade`), `purge`.
* `celigo mcp-oauth-providers`: full CRUD for MCP OAuth providers.
* `celigo event-reports`: `list`, `get`, `create`, `signed-url`, `cancel`.

### New subcommands on existing groups

* HTTP connectors: `create`, `update`, `delete`, `resources`, `resource`, `endpoints`, `endpoint`.
* Templates: `templates install` to install from a local `.zip` or by id with a connection map, plus `list`, `get`, `create`, `update`, `delete`.
* EDI transactions: `fa-detail`, `mdn-detail`, `update-fa-status`, `download-file --document-type`.
* APIs: `set-group` / `unset-group`, plus `create-api-group` / `delete-api-group` / `api-groups`.
* Flows: `error-summary`, `delete-execution-logs --started-at --end-at`, `cancel-jobs`, `set-group` / `unset-group`.
* Connections: `applications` (external apps in use, filterable with `--application`), `delete-debug-logs`, `purge-messages`.
* Scripts: `audit`, `delete-debug-logs`.
* Tools and partners: `tools connections`, `tp-connectors create/update/delete`.
* Across resources: `dependencies` (alias `used-by`), `audit`, `profile whoami`, `on-premise-agents installer-url --os`, `notifications list`, `stacks audit`, `users enable/disable`, `environments enable/disable`.

### File-based input

`-f, --file <path>` now works on every `create`, `update`, and `install` command (`--file -` still means stdin). And `set` accepts `file://<path>` assignment values to load multi-line content such as script source or SQL without escaping:

```bash
celigo exports create -f ./export.json
celigo scripts set 64a... content=file://./transform.js
```

This avoids shell input redirection, which is unreliable when driven by an agent and unsupported in PowerShell.

### Credential-safe writes

* `set` uses atomic JSON-Patch whitelists. Whitelisted fields PATCH cleanly; masked-credential endpoints (connections, iClients) refuse non-whitelisted edits rather than round-tripping a GET then PUT that would wipe stored secrets.
* `update` refuses payloads that still contain the masked `******` placeholder unless you pass `--force`.
* `profile delete` now confirms before deleting (`-y, --yes` to skip).

### Better errors

* Actionable hints mapped from API error codes (`inactive_flow`, `feature_not_enabled`, `invalid_ref`, `access_restricted`) now appear in the formatted error.
* Empty required positional arguments are rejected up front, catching unset shell variables like `celigo jobs get "$ID"` before they hit the API blind.
* `--limit` is validated as a positive integer instead of silently coercing bad input.

### Renamed and restructured commands

* `account deps` is now `account dependencies`.
* `<resource> debug-enable` / `debug-disable` are now `enable-debug` / `disable-debug`.
* `exports` / `imports` `test-run-step` is now `test-run-step-results`.
* `flows flow-group-create` is now `create-flow-group`; `flow-group-assign` is now `set-group` (with a new `unset-group`).
* `flows execution-logs-enable` / `-disable` are now `enable-execution-logs` / `disable-execution-logs`.
* `flows execution-log-query` is now `query-execution-logs`; `execution-log-data` is now `execution-log-detail`.
* `integrations snapshot` is now `create-snapshot`; `integrations files` plus `download` are now `download-files`.
* `agents` / `scripts` `logs` is now `debug-logs`.
* `usage historical` is now `historical-usage`.
* Token verbs consolidated: `system-token` / `display-token` to `token`; `recycle-token` / `change-token` to `rotate-token`.
* Error commands now take explicit ids: `resolve-errors` is now `error` (flow, step, and error ids passed as arguments), `error-analyze` is now `error-analysis`, `update-error-data` takes the error id explicitly, and `assign-errors` gained an explicit step argument.
* Templates: `templates list` (marketplace) is now `templates marketplace`; `invoke` and `preview` take an optional id.
* The interactive REPL was removed; running `celigo` with no arguments no longer opens a shell.
* The `account-info` group was removed; its `applications` listing is now `connections applications`.

### Fixes and internals

* `connections purge-messages` treats the API's "queue already empty" `404 Not Found` as a successful no-op.
* `users` and `environments` `enable/disable` read current state before toggling, so the verbs are honest and idempotent.
* `account dependencies` orphaned-script detection walks `_scriptId` references recursively, catching flow-level and nested refs.
* New `createdAt` cursor pagination with a truncation warning when the safety cap is hit (used by `sync-jobs list`).
* The account index staleness window tightened from 4 hours to 15 minutes.
* All 124 bundled skill schemas re-synced from the platform's published API specs, the drift check is now line-ending tolerant, and the legacy `rest` / `simple` schemas were removed (use `HTTPExport` / `HTTPImport` instead).
  {% endupdate %}

{% update date="2026-04-05" tags="cli,feature" %}

## CLI 2026.4.5 — generally available

`@celigo/celigo-cli` **2026.4.5** is now generally available on npm. This is the launch release: a first-party command-line tool for driving integrator.io from your terminal, your scripts, your CI pipelines, and the AI coding agents you already work with.

### Who it's for

Developers and AI coding agents who live in a terminal. If the integrator.io UI is the right tool for your day-to-day, keep using it — the CLI exists for the workflows where a UI slows you down: scripted bulk edits, version-controlled configuration, CI checks, and long-horizon agents that need to read and write live integrator.io state without burning context on a GUI.

### What you can do

* **Drive every resource.** Anything in the REST API maps to a `celigo <resource> <verb>` command — integrations, flows, connections, exports, imports, scripts, agents, guardrails, EDI profiles, on-premise agents, and more.
* **Manage multiple accounts.** Profiles switch between prod, sandbox, and EU regions without juggling tokens. `celigo profile use eu` is the whole context switch.
* **Lint your account.** `celigo account lint` runs static analysis across integrations, flows, and scripts — broken references, missing required fields, common script errors — before you push to production.
* **Snapshot, search, diff.** `celigo account snapshot` pulls every resource into a local index for full-text search (`celigo account search`), dependency graphs (`celigo account deps`), and per-resource stats.
* **Pipe-friendly output.** Every command supports `--format json|yaml|table|csv` and `--jq`, so results flow cleanly into shell scripts and other tools.

### AI assistant skills, included

Installing the CLI globally also installs a set of AI assistant skills for Claude Code, Cursor, and Windsurf — domain-specific guides plus OpenAPI-derived schemas the assistant loads on demand. Ask "build a Shopify → NetSuite flow" and the assistant pulls the `building-flows` skill and writes JSON that actually validates against integrator.io, instead of guessing field names. Skills update atomically when you upgrade the CLI.

### Get started

```bash
npm install -g @celigo/celigo-cli
celigo profile add prod --api-token "$CELIGO_API_TOKEN"
celigo integrations list --format table
```

Full install options, profile setup, region targeting, and skills coverage live in the [CLI section](https://developer.celigo.com/cli).

<details>

<summary>Notes</summary>

* Requires Node.js 22+
* MIT licensed
* Region-aware — pass `--api-base-url https://api.eu.integrator.io` for EU accounts, or scope it per profile

</details>
{% endupdate %}
{% endupdates %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://developer.celigo.com/changelog/2026.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.