Ctrlk
For the complete documentation index, see llms.txt. This page is also available as Markdown.
RSS feed

2026

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

CLI 2026.8.8

@celigo/celigo-cli 2026.8.8 is on npm.

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.

  • 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.

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.

  • 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.

  • 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.

  • AU data stays in Australia and CA data stays in Canada, the same in-region residency the EU data center provides.

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.

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.

  • 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.

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.

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.

  • 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.

  • http-connectors catalog and http-connectors endpoint-detail read the staged form-metadata summaries and scoped detail documents. See 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.

  • 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.

Full command reference in the Celigo CLI section.

August API updates

Everything below is live in production and documented in the API reference.

  • End-user management joins the 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.

  • 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.

CLI 2026.8.2

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

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.

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.

  • 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.

  • --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.

  • 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.

  • 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.

Syncs

  • syncs adds list (with --integration), get, create, update, set, and delete beside the existing run, audit, and cancel-jobs. See 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.

  • 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.

  • 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 section.

OAuth sign-in for Platform MCP

Add the Platform 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.

{
  "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.

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.

  • 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.

Platform MCP: nine new tools

Connected clients pick these up automatically — the catalog is fetched at runtime. Full details in 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.

July API updates

Everything below is live in production and documented in the API reference.

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.

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

{
  "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.

Notes

  • Requires a full-access API token

  • Region-aware: use https://api.eu.integrator.io/celigo-mcp for EU accounts

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.

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:

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).

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

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.

Notes

  • 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

Last updated

Was this helpful?