How to Get Started with Celigo CLI

Learn how to install and configure the Celigo CLI, authenticate with an integrator.io account, manage profiles, and use basic Celigo CLI commands to list integrations and flows.

Published August 11, 2026
Updated August 14, 2026

The Celigo CLI provides a command-line interface for working with integrator.io resources. It allows you to manage integrations and flows programmatically and incorporate integrator.io configuration into scripts, automation, and development workflows.

In this guide, we’ll install the CLI, configure authentication, create a profile, and use the CLI to inspect integrations and flows. We’ll also look at output formats and the local configuration stored in ~/.celigo/config.json.

By the end, you’ll have a working CLI environment and the foundation needed for the rest of this series.

NOTE: You can install and set up the Celigo CLI without a Celigo account. However, you will need an active integrator.io subscription to authenticate and connect the CLI to your Celigo environment. If you don’t have a subscription, you can request a free trial from Celigo.

Prerequisites

Before installing the Celigo CLI, make sure Node.js 22 or later is available in your development environment. The CLI is distributed through npm, which is included with Node.js, so the CLI itself is installed the same way on macOS, Linux, and Windows. Only the way you install Node.js differs; the examples below cover Linux and macOS. On Windows, use the official Node.js installer.

You can also install Node.js with a version manager such as Node Version Manager, which works on both macOS and Linux.

Linux

On Arch-based distributions, you can install Node.js and npm with pacman:

sudo pacman -S nodejs npm

On Arch, nodejs and npm are separate packages, so install both. Arch ships a current Node.js release (or an LTS branch such as nodejs-lts-jod for Node 22), so no third-party repository is required.

On Debian-based distributions such as Ubuntu, you can add the NodeSource repository and install Node.js with apt:

sudo apt install -y curl
curl -fsSL https://deb.nodesource.com/setup_22.x -o nodesource_setup.sh
sudo -E bash nodesource_setup.sh
sudo apt install -y nodejs

On Fedora or RHEL-based distributions, you can install Node.js with dnf:

sudo dnf install -y nodejs

TIP: The Node.js version packaged with your Linux distribution may be older than 22. If so, use nvm or the official Node.js installer instead.

macOS

On macOS, you can install Node.js with Homebrew:

brew install node

Verify that Node.js and npm are available:

node --version
npm --version

Installing the Celigo CLI

Once Node.js and npm are available, install the Celigo CLI globally using npm:

npm install -g @celigo/celigo-cli

Installing the CLI globally makes the celigo command available from your terminal, allowing you to use it from any directory in your development environment.

Verify the installation:

celigo --version

If the installation was successful, the command will return the installed version of the Celigo CLI.

2026.8.6

AI Coding Agent Skills

The Celigo CLI also installs Celigo-specific skills for supported AI coding agents. These skills provide context about integrator.io concepts and development workflows, allowing supported AI tools to work with Celigo resources more effectively.

The CLI installs the skills and creates symbolic links in the agent’s skills directory. The exact location depends on the AI coding agent you’re using.

For example, with pi.dev:

ls -la ~/.pi/agent/skills/

You should see Celigo-specific skills represented as symbolic links.

NOTE: The exact set of skills and their installation paths may change between CLI releases and supported AI coding agents.

building-apis -> ../../../.agents/skills/building-apis/
building-b2b -> ../../../.agents/skills/building-b2b/
building-flows -> ../../../.agents/skills/building-flows/
building-mcp-servers -> ../../../.agents/skills/building-mcp-servers/
building-tools -> ../../../.agents/skills/building-tools/
configuring-ai-agents -> ../../../.agents/skills/configuring-ai-agents/
configuring-connections -> ../../../.agents/skills/configuring-connections/
configuring-exports -> ../../../.agents/skills/configuring-exports/
configuring-filters -> ../../../.agents/skills/configuring-filters/
configuring-guardrails -> ../../../.agents/skills/configuring-guardrails/
configuring-imports -> ../../../.agents/skills/configuring-imports/
configuring-lookup-caches -> ../../../.agents/skills/configuring-lookup-caches/
getting-started -> ../../../.agents/skills/getting-started/
managing-api-tokens -> ../../../.agents/skills/managing-api-tokens/
managing-integrations -> ../../../.agents/skills/managing-integrations/
managing-on-premise-agents -> ../../../.agents/skills/managing-on-premise-agents/
managing-stacks -> ../../../.agents/skills/managing-stacks/
managing-users -> ../../../.agents/skills/managing-users/
troubleshooting-flows -> ../../../.agents/skills/troubleshooting-flows/
using-marketplace-templates -> ../../../.agents/skills/using-marketplace-templates/
writing-handlebars -> ../../../.agents/skills/writing-handlebars/
writing-mappings -> ../../../.agents/skills/writing-mappings/
writing-scripts -> ../../../.agents/skills/writing-scripts/
writing-sql -> ../../../.agents/skills/writing-sql/

The -> notation indicates that these entries are symbolic links rather than regular directories. The links point back to the skill definitions installed by the Celigo CLI.

IMPORTANT: The Celigo CLI configures AI agent skills during installation. Make sure your AI development tool is installed before installing the Celigo CLI so the installer can detect the available agent environment and create the appropriate skill links. If you installed the Celigo CLI before setting up your AI development tool, reinstall the Celigo CLI after the agent is installed:

npm install -g @celigo/celigo-cli

Configuration

After installing the Celigo CLI, the CLI creates a ~/.celigo directory in your home directory. The directory contains config.json, which stores the Celigo CLI configuration, including connection details, authentication credentials, active profiles, and the default output format.

The configuration is profile-based. Each profile defines the settings the CLI uses when communicating with an integrator.io environment.

For this example, I’ll use Neovim to edit the configuration file:

nvim ~/.celigo/config.json

Add or update the configuration so it looks like this:

IMPORTANT: Treat your API token as a credential. Do not commit ~/.celigo/config.json to source control or share the file if it contains a valid token.

{
  "active_profile": "default",
  "profiles": {
    "default": {
      "base_url": "https://api.integrator.io",
      "api_token": "<YOUR_INTEGRATOR.IO_API_TOKEN>",
      "default_format": "table"
    }
  }
}

The active_profile property determines which profile the CLI uses by default. In this example, the active profile is default.

The base_url specifies the integrator.io API endpoint the CLI will communicate with.

The api_token is used to authenticate requests against that environment. You create and manage these tokens in the integrator.io app at https://integrator.io/accesstokens.

There are two kinds of token:

Token type	When to use
Personal access token (PAT)	Tied to your own user and carries the same permissions you do. The quickest option for a developer working with the CLI day to day.
Account API token	Created by an owner or administrator and can be limited to a specific set of resources instead of the whole account. Prefer it for automation that needs to keep working beyond any one person’s access.

The default_format controls how command results are displayed in the terminal. Setting it to table makes command output easier to read interactively. You can also switch to JSON when you need structured output for inspection or other tooling.

The output format can also be overridden for individual commands without changing the configured default. For example:

celigo integrations list --format json

This allows you to keep table as the default for interactive use while requesting JSON when a specific command requires structured output.

If you work with multiple Celigo environments or accounts, you can define multiple CLI profiles in the same configuration file.

You can maintain separate profiles for production, another account, and a sandbox environment:

{
  "active_profile": "prod",
  "profiles": {
    "prod": {
      "api_token": "<PRODUCTION_API_TOKEN>",
      "base_url": "https://api.integrator.io",
      "default_format": "table"
    },
    "eu": {
      "api_token": "<EU_API_TOKEN>",
      "base_url": "https://api.eu.integrator.io"
    },
    "sandbox": {
      "api_token": "<SANDBOX_API_TOKEN>",
      "base_url": "https://api.integrator.io",
      "default_format": "json"
    }
  }
}

Each profile defines the connection and CLI settings used when interacting with a specific integrator.io environment or account.

The active_profile property determines which profile the CLI uses by default. In this example, prod is the active profile.

You can switch the active profile without manually editing the configuration file:

celigo profile use eu

After switching profiles, subsequent commands use the selected profile unless you explicitly override the profile or other command options.

This profile-based approach is useful when working across multiple Celigo environments because each environment keeps its connection and authentication settings separate while using the same CLI configuration.

For more information about the available CLI configuration options and supported environments, refer to the Celigo CLI Documentation.

Querying Integrations and Flows

With the CLI configured and authenticated, you can use it to inspect and work with resources in your integrator.io environment.

The primary commands for discovery are:

celigo integrations list
celigo flows list

Both commands support the same output formats:

# Human-readable output
celigo integrations list --format table

# Structured output
celigo integrations list --format json

Use table when working interactively in the terminal. Use json when the output will be consumed by scripts, automation, or other tooling.

The same output options apply to flows:

celigo flows list --format json

Choosing an output format

Format	Best for
table	Interactive terminal use and quick inspection
json	Automation, scripting, filtering, and programmatic processing

This common output pattern applies across CLI resources, so once you understand it for one command, you can apply the same approach to other Celigo CLI commands.

Now have a configured CLI environment and can query integrations and flows directly from the terminal.

In the next post, How to Create Your First Integration with Celigo CLI, we’ll move beyond inspecting existing resources and create our first integration using the Celigo CLI.