Make your first API request

Call GET /v1/integrations to retrieve a list of all integrations in your account.

1. Get an API token

You'll need a bearer token from the account you want to call against. Any user can create one. Owners and admins create service tokens; every other user creates a personal access token (PAT) that inherits their own permissions.

1. Sign in to your region's tenant: integrator.io (US), eu.integrator.io (EU), au.integrator.io (AU), or ca.integrator.io (CA).
2. Open Resources → API tokens and select + Generate token.
3. Give it a name and pick an expiration. Admins can choose Full access for a first try. Non-admins get a personal access token scoped to their own permissions.
4. Copy the token.

See Authentication for personal access tokens, scope-limited tokens, and best practices.

2. Find your base URL

Data center	Base URL
US	https://api.integrator.io
EU	https://api.eu.integrator.io
AU	https://api.au.integrator.io
CA	https://api.ca.integrator.io

Match the base URL to the hostname your Celigo tenant lives on: integrator.io → US, eu.integrator.io → EU, au.integrator.io → AU, ca.integrator.io → CA. Tenants are entirely isolated — a token from one region does not work against another. See Environments & regions.

3. Call the API

cURL

export CELIGO_API_TOKEN="<YOUR_API_TOKEN>"
export CELIGO_BASE_URL="https://api.integrator.io"

curl -s "$CELIGO_BASE_URL/v1/integrations" \
  -H "Authorization: Bearer $CELIGO_API_TOKEN" \
  -H "Accept: application/json"

Node.js

const BASE  = "https://api.integrator.io";
const TOKEN = process.env.CELIGO_API_TOKEN;

const res = await fetch(`${BASE}/v1/integrations`, {
  headers: {
    Authorization: `Bearer ${TOKEN}`,
    Accept: "application/json"
  }
});
const integrations = await res.json();
console.log(integrations);

Python

import os, requests

BASE  = "https://api.integrator.io"
TOKEN = os.environ["CELIGO_API_TOKEN"]

res = requests.get(
    f"{BASE}/v1/integrations",
    headers={"Authorization": f"Bearer {TOKEN}", "Accept": "application/json"},
    timeout=30,
)
res.raise_for_status()
print(res.json())

Celigo CLI

celigo config set api_token "<YOUR_API_TOKEN>"
celigo integrations list

You should see a JSON array of integrations on your account.

[
  {
    "_id": "5a1b2c3d4e5f6a7b8c9d0e1f",
    "name": "Shopify → NetSuite",
    "mode": "install",
    "createdAt": "2024-05-12T17:02:11.213Z"
  }
]

A non-2xx response? Jump to Errors & status codes.

REST semantics

Every resource in the API follows standard REST semantics.

Verb	Purpose
GET	Fetch a resource (/v1/connections/{id}) or list (/v1/connections).
POST	Create a new resource.
PUT	Full replace. All omitted fields are erased. See PUT is destructive.
PATCH	Partial update (supported on a subset of endpoints).
DELETE	Delete a resource.

⚠️ PUT is destructive. Celigo's API replaces the entire resource body on PUT. If you PUT a connection with only {"name":"new name"}, every other field on that connection becomes undefined and the connection will stop working. Always GET the resource first, modify only the fields you want to change, then PUT the complete object back. The CLI's celigo <resource> set command does this GET-modify-PUT round-trip for you.

Create a stub HTTP connection:

cURL

curl -s -X POST "$CELIGO_BASE_URL/v1/connections" \
  -H "Authorization: Bearer $CELIGO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "my-first-connection",
    "type": "http",
    "offline": true,
    "http": {
      "baseURI": "https://httpbin.org",
      "auth": { "type": "basic" }
    }
  }'

Node.js

const res = await fetch(`${BASE}/v1/connections`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${TOKEN}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "my-first-connection",
    type: "http",
    offline: true,
    http: {
      baseURI: "https://httpbin.org",
      auth: { type: "basic" }
    }
  })
});
const connection = await res.json();
console.log(connection._id);

Python

res = requests.post(
    f"{BASE}/v1/connections",
    headers={"Authorization": f"Bearer {TOKEN}", "Content-Type": "application/json"},
    json={
        "name": "my-first-connection",
        "type": "http",
        "offline": True,
        "http": {
            "baseURI": "https://httpbin.org",
            "auth": {"type": "basic"},
        },
    },
    timeout=30,
)
res.raise_for_status()
print(res.json()["_id"])

Celigo CLI

cat <<'EOF' | celigo connections create
{
  "name": "my-first-connection",
  "type": "http",
  "offline": true,
  "http": {
    "baseURI": "https://httpbin.org",
    "auth": { "type": "basic" }
  }
}
EOF

The response echoes the created resource, including its _id. Use that _id in subsequent GET, PUT, and DELETE calls.

Build flows

To build anything useful you need three resources, in this order:

1. A Connection — credentials for the system you're talking to.
2. An Export — how records are pulled out of that system.
3. An Import — how records are written into another system.

Then you wrap them into a flow.

What's next

• Authentication — scoped tokens, rotation, one-time tokens.
• Pagination — how to iterate over long result sets.
• CLI Reference — do all of the above from celigo <cmd>.