curl -X DELETE https://api.orbit.devotel.io/api/v1/integrations/woocommerce/disconnect \
  -H "X-API-Key: dv_live_sk_your_key_here"

{
  "data": [
    {
      "id": "hubspot",
      "name": "HubSpot",
      "provider": "hubspot",
      "category": "crm",
      "connected": true,
      "syncs": ["contacts", "deals", "companies"]
    },
    {
      "id": "salesforce",
      "name": "Salesforce",
      "provider": "salesforce",
      "category": "crm",
      "connected": false,
      "syncs": ["contacts", "deals"]
    }
  ],
  "pagination": {
    "cursor": "salesforce",
    "has_more": true,
    "total": 14
  },
  "meta": {
    "request_id": "req_int_001",
    "timestamp": "2026-08-26T09:00:00Z"
  }
}

curl -X DELETE https://api.orbit.devotel.io/api/v1/integrations/woocommerce/disconnect \
  -H "X-API-Key: dv_live_sk_your_key_here"

{
  "data": [
    {
      "id": "hubspot",
      "name": "HubSpot",
      "provider": "hubspot",
      "category": "crm",
      "connected": true,
      "syncs": ["contacts", "deals", "companies"]
    },
    {
      "id": "salesforce",
      "name": "Salesforce",
      "provider": "salesforce",
      "category": "crm",
      "connected": false,
      "syncs": ["contacts", "deals"]
    }
  ],
  "pagination": {
    "cursor": "salesforce",
    "has_more": true,
    "total": 14
  },
  "meta": {
    "request_id": "req_int_001",
    "timestamp": "2026-08-26T09:00:00Z"
  }
}

Integrations API

Connect third-party SaaS apps (Salesforce, HubSpot, Shopify, Pipedrive, Zendesk, Intercom, …) and pull their data into Orbit for use in flows, AI agents, and contact enrichment. Auth, token refresh, rate limiting, and provider-specific quirks are handled for you. Base path: /api/v1/integrations Authentication: API key (X-API-Key) or session JWT. Connect, disconnect, and sync are owner/admin-only writes; list, status, and data reads require the integrations:read scope, writes the integrations:write scope. Every response below is wrapped in the standard envelope: a data payload plus a meta block with request_id and timestamp. Errors use an error object with code, message, and status.

Using the SDKs

This page’s endpoints sit outside the SDKs’ core typed resources, so every language below reaches them through the same generic escape hatch, which keeps auth, retries, and the response envelope identical to the typed resources. The Node SDK additionally ships a typed orbit.integrations surface for the catalog (listCatalog(), list(), sync()); the connect, status, disconnect, and data operations shown here ride the escape hatch in every language, and the per-operation samples further down the page run the same calls as the curl examples.

Node.js (@devotel-orbit/node) — orbit.request<T>(method, path, body?)
Python (orbit_sdk) — client.request(method, path, params={...}, json_body={...})
Go (orbit-go) — client.Request(ctx, method, path, query, body, out, idempotencyKey)
Ruby (orbit_sdk) — client.request(method, path, query: {...}, json_body: {...})
PHP (Devotel\Orbit) — $client->request(method: ..., path: ..., query: [...], jsonBody: [...])

curl "https://api.orbit.devotel.io/api/v1/integrations?limit=25" \
  -H "X-API-Key: $ORBIT_API_KEY"

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

// Typed surface for the catalog; the escape hatch for everything else:
const res = await orbit.request("GET", "/integrations?limit=25");

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

res = client.request("GET", "/integrations", params={"limit": "25"})

package main

import (
	"context"
	"fmt"
	"net/url"
	"os"

	"github.com/devotel/orbit-go/orbit"
)

func main() {
	client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
	if err != nil {
		panic(err)
	}

	query := url.Values{"limit": {"25"}}

	var res map[string]any
	if err := client.Request(context.Background(), "GET", "/integrations", query, nil, &res, ""); err != nil {
		panic(err)
	}
	fmt.Printf("Integrations: %d\n", len(res["data"].([]any)))
}

require "orbit_sdk"

client = OrbitSdk::Client.from_env

res = client.request("GET", "/integrations", query: { "limit" => "25" })

puts res["data"].length

<?php
use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();

$res = $client->request(
    method: "GET",
    path: "/integrations",
    query: ["limit" => "25"],
);

echo count($res["data"]) . PHP_EOL;

The Python SDK is core-scope — it wraps the 8 core resources (messaging, voice, contacts, campaigns, verify, numbers) and reaches everything else through the same escape hatch. See the Python SDK. Returns the typed ApiResponse envelope. See the SDK index at SDK quickstart.

Connections

Method	Path	Purpose
`GET`	`/api/v1/integrations`	List connected integrations
`POST`	`/api/v1/integrations/connect`	Initiate an OAuth connect flow
`GET`	`/api/v1/integrations/{id}/status`	Connection health + sync status
`DELETE`	`/api/v1/integrations/{id}/disconnect`	Disconnect (revokes provider tokens)

Sync & data

Method	Path	Purpose
`POST`	`/api/v1/integrations/{id}/sync`	Trigger a sync now
`GET`	`/api/v1/integrations/{id}/data`	Read synced records

The sections below walk one end-to-end HubSpot connection: list the catalog, start the OAuth flow, confirm the connection, trigger a sync, read records, and disconnect.

WooCommerce (key-pair connect)

Method	Path	Purpose
`POST`	`/api/v1/integrations/woocommerce/connect`	Validate + store a WooCommerce REST key pair
`DELETE`	`/api/v1/integrations/woocommerce/disconnect`	Remove the stored key pair

WooCommerce self-hosted does not run OAuth — it’s the one catalog entry that connects with a pasted REST API key pair instead of the consent flow. See Connect WooCommerce and Disconnect WooCommerce below.

Inbound webhook

The integration server posts auth + sync events to POST /api/v1/integrations/webhooks/nango — internal only. You don’t call this directly.

List integrations

GET /api/v1/integrations Returns every integration available to your organization with a connected flag, its provider, category, and the syncs it offers, cursor-paginated (?limit= + ?cursor=). Add a ?fields= projection (comma-separated field names) when you only need a couple of fields per item. If the integration server is unreachable, the route serves the built-in catalog with connected: false instead of an error, so your settings page always renders.

curl "https://api.orbit.devotel.io/api/v1/integrations?limit=25" \
  -H "X-API-Key: dv_live_sk_your_key_here"

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

const res = await orbit.request("GET", "/integrations?limit=25");

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

res = client.request("GET", "/integrations", params={"limit": "25"})

package main

import (
	"context"
	"fmt"
	"net/url"
	"os"

	"github.com/devotel/orbit-go/orbit"
)

func main() {
	client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
	if err != nil {
		panic(err)
	}

	query := url.Values{"limit": {"25"}}

	var res map[string]any
	if err := client.Request(context.Background(), "GET", "/integrations", query, nil, &res, ""); err != nil {
		panic(err)
	}
	fmt.Printf("Integrations: %d\n", len(res["data"].([]any)))
}

require "orbit_sdk"

client = OrbitSdk::Client.from_env

res = client.request("GET", "/integrations", query: { "limit" => "25" })

puts res["data"].length

<?php
use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();

$res = $client->request(
    method: "GET",
    path: "/integrations",
    query: ["limit" => "25"],
);

echo count($res["data"]) . PHP_EOL;

{
  "data": [
    {
      "id": "hubspot",
      "name": "HubSpot",
      "provider": "hubspot",
      "category": "crm",
      "connected": true,
      "syncs": ["contacts", "deals", "companies"]
    },
    {
      "id": "salesforce",
      "name": "Salesforce",
      "provider": "salesforce",
      "category": "crm",
      "connected": false,
      "syncs": ["contacts", "deals"]
    }
  ],
  "pagination": {
    "cursor": "salesforce",
    "has_more": true,
    "total": 14
  },
  "meta": {
    "request_id": "req_int_001",
    "timestamp": "2026-08-26T09:00:00Z"
  }
}

Start the OAuth connect flow

POST /api/v1/integrations/connect Initiates the OAuth authorization flow for one integration_id and returns the auth_url you redirect the operator to. Owner/admin only. A provider with no OAuth credentials set up yet returns 404; an integration-server outage returns 503. The narrative below uses HubSpot; swap the integration_id for any provider in the catalog.

curl -X POST https://api.orbit.devotel.io/api/v1/integrations/connect \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{ "integration_id": "hubspot" }'

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

const res = await orbit.request("POST", "/integrations/connect", {
  integration_id: "hubspot",
});
// Redirect the operator to res.data.auth_url

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

res = client.request(
    "POST",
    "/integrations/connect",
    json_body={"integration_id": "hubspot"},
)
print(res["data"]["auth_url"])

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/devotel/orbit-go/orbit"
)

func main() {
	client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
	if err != nil {
		panic(err)
	}

	body := map[string]any{"integration_id": "hubspot"}

	var res map[string]any
	if err := client.Request(context.Background(), "POST", "/integrations/connect", nil, body, &res, ""); err != nil {
		panic(err)
	}
	fmt.Println("Send the operator to:", res["data"].(map[string]any)["auth_url"])
}

require "orbit_sdk"

client = OrbitSdk::Client.from_env

res = client.request(
  "POST",
  "/integrations/connect",
  json_body: { "integration_id" => "hubspot" }
)
puts res["data"]["auth_url"]

<?php
use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();

$res = $client->request(
    method: "POST",
    path: "/integrations/connect",
    jsonBody: ["integration_id" => "hubspot"],
);

echo $res["data"]["auth_url"] . PHP_EOL;

{
  "data": {
    "auth_url": "https://app.hubspot.com/oauth/authorize?client_id=…&redirect_uri=…&scope=crm.objects.contacts.read"
  },
  "meta": {
    "request_id": "req_int_002",
    "timestamp": "2026-08-26T09:01:00Z"
  }
}

Redirect the operator to auth_url. After they consent on the provider’s page, they’re returned to Orbit and the connection is established — from here on, syncs can run.

Check connection status

GET /api/v1/integrations/{id}/status Returns whether the integration is connected for your organization plus the connection metadata and the per-sync status when connected. A never-connected or revoked integration resolves to connected: false with an empty sync list — not a 4xx — so you can render a disconnected state without special-casing errors.

curl https://api.orbit.devotel.io/api/v1/integrations/hubspot/status \
  -H "X-API-Key: dv_live_sk_your_key_here"

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

const status = await orbit.request("GET", "/integrations/hubspot/status");

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

status = client.request("GET", "/integrations/hubspot/status")

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/devotel/orbit-go/orbit"
)

func main() {
	client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
	if err != nil {
		panic(err)
	}

	var status map[string]any
	if err := client.Request(context.Background(), "GET", "/integrations/hubspot/status", nil, nil, &status, ""); err != nil {
		panic(err)
	}
	fmt.Println("Connected:", status["data"].(map[string]any)["connected"])
}

require "orbit_sdk"

client = OrbitSdk::Client.from_env

status = client.request("GET", "/integrations/hubspot/status")
puts status["data"]["connected"]

<?php
use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();

$status = $client->request(
    method: "GET",
    path: "/integrations/hubspot/status",
);

var_export($status["data"]["connected"]);

{
  "data": {
    "connected": true,
    "connection_id": "b36e9147-…-8f2a",
    "provider": "hubspot",
    "created_at": "2026-08-20T14:11:00Z",
    "updated_at": "2026-08-26T08:58:00Z",
    "metadata": { "scopes": ["crm.objects.contacts.read", "crm.objects.deals.read"] },
    "syncs": [
      { "name": "contacts", "last_sync_at": "2026-08-26T08:55:00Z", "status": "idle" },
      { "name": "deals", "last_sync_at": "2026-08-26T08:55:12Z", "status": "idle" }
    ]
  },
  "meta": {
    "request_id": "req_int_003",
    "timestamp": "2026-08-26T09:02:00Z"
  }
}

Disconnected — whether it was never connected or the tokens were revoked — looks like this:

200

{
  "data": { "connected": false, "syncs": [] },
  "meta": { "request_id": "req_int_004", "timestamp": "2026-08-26T09:02:10Z" }
}

Trigger a sync

POST /api/v1/integrations/{id}/sync Runs one sync immediately instead of waiting for its scheduled cadence. The body names the sync — for HubSpot that’s contacts, deals, or companies from the catalog entry. Owner/admin only. A failed upstream trigger returns 502; there is no job handle to poll — watch the last_sync_at timestamps on the status endpoint to see the run complete.

curl -X POST https://api.orbit.devotel.io/api/v1/integrations/hubspot/sync \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{ "sync_name": "contacts" }'

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

const res = await orbit.request("POST", "/integrations/hubspot/sync", {
  sync_name: "contacts",
});

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

res = client.request(
    "POST",
    "/integrations/hubspot/sync",
    json_body={"sync_name": "contacts"},
)

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/devotel/orbit-go/orbit"
)

func main() {
	client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
	if err != nil {
		panic(err)
	}

	body := map[string]any{"sync_name": "contacts"}

	var res map[string]any
	if err := client.Request(context.Background(), "POST", "/integrations/hubspot/sync", nil, body, &res, ""); err != nil {
		panic(err)
	}
	fmt.Println("Sync status:", res["data"].(map[string]any)["status"])
}

require "orbit_sdk"

client = OrbitSdk::Client.from_env

res = client.request(
  "POST",
  "/integrations/hubspot/sync",
  json_body: { "sync_name" => "contacts" }
)
puts res["data"]["status"]

<?php
use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();

$res = $client->request(
    method: "POST",
    path: "/integrations/hubspot/sync",
    jsonBody: ["sync_name" => "contacts"],
);

echo $res["data"]["status"] . PHP_EOL;

{
  "data": {
    "status": "triggered",
    "integration_id": "hubspot",
    "sync_name": "contacts"
  },
  "meta": {
    "request_id": "req_int_005",
    "timestamp": "2026-08-26T09:03:00Z"
  }
}

Read synced records

GET /api/v1/integrations/{id}/data?model={name} Returns the records the integration has synced for one model. model is a required query parameter and names the model in the sync’s vocabulary (contacts, deals, companies for HubSpot). The response is the full record set — the route walks the integration server’s record cursor for you, so there is no pagination to manage on this endpoint. An unconfigured integration server returns an empty array; a failed upstream fetch returns 502.

curl "https://api.orbit.devotel.io/api/v1/integrations/hubspot/data?model=contacts" \
  -H "X-API-Key: dv_live_sk_your_key_here"

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

const records = await orbit.request("GET", "/integrations/hubspot/data?model=contacts");

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

records = client.request(
    "GET",
    "/integrations/hubspot/data",
    params={"model": "contacts"},
)

package main

import (
	"context"
	"fmt"
	"net/url"
	"os"

	"github.com/devotel/orbit-go/orbit"
)

func main() {
	client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
	if err != nil {
		panic(err)
	}

	query := url.Values{"model": {"contacts"}}

	var records map[string]any
	if err := client.Request(context.Background(), "GET", "/integrations/hubspot/data", query, nil, &records, ""); err != nil {
		panic(err)
	}
	fmt.Printf("Synced records: %d\n", len(records["data"].([]any)))
}

require "orbit_sdk"

client = OrbitSdk::Client.from_env

records = client.request(
  "GET",
  "/integrations/hubspot/data",
  query: { "model" => "contacts" }
)
puts records["data"].length

<?php
use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();

$records = $client->request(
    method: "GET",
    path: "/integrations/hubspot/data",
    query: ["model" => "contacts"],
);

echo count($records["data"]) . PHP_EOL;

{
  "data": [
    {
      "id": "hs-88412",
      "firstname": "Amara",
      "lastname": "Osei",
      "email": "amara@acme.example",
      "hs_lastmodifieddate": "2026-08-26T08:55:00Z"
    },
    {
      "id": "hs-88413",
      "firstname": "Jonas",
      "lastname": "Mikkelsen",
      "email": "jonas@globex.example",
      "hs_lastmodifieddate": "2026-08-26T08:55:01Z"
    }
  ],
  "meta": {
    "request_id": "req_int_006",
    "timestamp": "2026-08-26T09:04:00Z"
  }
}

Record fields are the provider’s own, passed through unchanged — the envelope is normalized, the record body is not. Map the provider fields you need; anything absent from a record stays absent.

Connect WooCommerce (key-pair connect)

POST /api/v1/integrations/woocommerce/connect WooCommerce self-hosted stores don’t run OAuth, so the catalog’s OAuth flow doesn’t apply. Generate a REST API key pair in WP-Admin → WooCommerce → Settings → Advanced → REST API, then POST the store URL and both halves here. Owner/admin only. Idempotency-Key is honored, so a retry after a timeout is safe. Before storing anything, Orbit validates the pair live against the store with GET {store_url}/wp-json/wc/v3/orders?per_page=1: a 2xx stores the credentials, a 401/403 comes back as WOO_AUTH_FAILED, a failed or timed-out reach as WOO_UNREACHABLE. The store URL must be HTTPS and publicly reachable — private, loopback, and metadata endpoints are rejected. On success both halves are encrypted before they are written, and the integration card flips to Connected. Re-running connect with a new pair replaces the stored one — use it to rotate keys.

curl -X POST https://api.orbit.devotel.io/api/v1/integrations/woocommerce/connect \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "store_url": "https://store.example.com",
    "consumer_key": "ck_your_consumer_key_here",
    "consumer_secret": "cs_your_consumer_secret_here"
  }'

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

const res = await orbit.request("POST", "/integrations/woocommerce/connect", {
  store_url: "https://store.example.com",
  consumer_key: "ck_your_consumer_key_here",
  consumer_secret: "cs_your_consumer_secret_here",
});

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

res = client.request(
    "POST",
    "/integrations/woocommerce/connect",
    json_body={
        "store_url": "https://store.example.com",
        "consumer_key": "ck_your_consumer_key_here",
        "consumer_secret": "cs_your_consumer_secret_here",
    },
)

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/devotel/orbit-go/orbit"
)

func main() {
	client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
	if err != nil {
		panic(err)
	}

	body := map[string]any{
		"store_url":       "https://store.example.com",
		"consumer_key":    "ck_your_consumer_key_here",
		"consumer_secret": "cs_your_consumer_secret_here",
	}

	var res map[string]any
	if err := client.Request(context.Background(), "POST", "/integrations/woocommerce/connect", nil, body, &res, ""); err != nil {
		panic(err)
	}
	fmt.Println("Status:", res["data"].(map[string]any)["status"])
}

require "orbit_sdk"

client = OrbitSdk::Client.from_env

res = client.request(
  "POST",
  "/integrations/woocommerce/connect",
  json_body: {
    "store_url" => "https://store.example.com",
    "consumer_key" => "ck_your_consumer_key_here",
    "consumer_secret" => "cs_your_consumer_secret_here",
  }
)
puts res["data"]["status"]

<?php
use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();

$res = $client->request(
    method: "POST",
    path: "/integrations/woocommerce/connect",
    jsonBody: [
        "store_url" => "https://store.example.com",
        "consumer_key" => "ck_your_consumer_key_here",
        "consumer_secret" => "cs_your_consumer_secret_here",
    ],
);

echo $res["data"]["status"] . PHP_EOL;

{
  "data": {
    "status": "connected",
    "store_url": "https://store.example.com",
    "consumer_key_prefix": "ck_4f2b9c"
  },
  "meta": {
    "request_id": "req_int_woo_001",
    "timestamp": "2026-09-19T09:00:00Z"
  }
}

A rejected store URL looks like this — the failure_code field names the category so you can branch on it without string-matching the message:

422

{
  "error": {
    "code": "WOO_INVALID_STORE_URL",
    "message": "store_url resolves to a private or internal IP address. Use a publicly reachable store URL.",
    "failure_code": "private_ip",
    "status": 422
  },
  "meta": { "request_id": "req_int_woo_002", "timestamp": "2026-09-19T09:00:05Z" }
}

failure_code is one of parse_error, protocol, blocked_host, internal_suffix, dns_invalid, or private_ip. Once connected, customers, orders, and products sync on the scheduled cadence, and order events land as woocommerce.order events flows can trigger on.

Disconnect WooCommerce

DELETE /api/v1/integrations/woocommerce/disconnect Drops the stored key pair for your organization. The store itself is untouched — revoke the key pair in WP-Admin too if you want it fully retired. Owner/admin only. Disconnecting an org that never connected returns 200, so the call is idempotent.

curl -X DELETE https://api.orbit.devotel.io/api/v1/integrations/woocommerce/disconnect \
  -H "X-API-Key: dv_live_sk_your_key_here"

{
  "data": { "status": "disconnected" },
  "meta": {
    "request_id": "req_int_woo_003",
    "timestamp": "2026-09-19T09:01:00Z"
  }
}

Disconnect

DELETE /api/v1/integrations/{id}/disconnect Revokes the OAuth connection. Provider tokens stop working immediately and no further syncs run. Owner/admin only. A failed upstream revoke returns 502 — retry rather than assuming it went through.

curl -X DELETE https://api.orbit.devotel.io/api/v1/integrations/hubspot/disconnect \
  -H "X-API-Key: dv_live_sk_your_key_here"

import { Orbit } from "@devotel-orbit/node";

const orbit = new Orbit({ apiKey: process.env.ORBIT_API_KEY! });

const res = await orbit.request("DELETE", "/integrations/hubspot/disconnect");

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

res = client.request("DELETE", "/integrations/hubspot/disconnect")

package main

import (
	"context"
	"fmt"
	"os"

	"github.com/devotel/orbit-go/orbit"
)

func main() {
	client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
	if err != nil {
		panic(err)
	}

	var res map[string]any
	if err := client.Request(context.Background(), "DELETE", "/integrations/hubspot/disconnect", nil, nil, &res, ""); err != nil {
		panic(err)
	}
	fmt.Println("Status:", res["data"].(map[string]any)["status"])
}

require "orbit_sdk"

client = OrbitSdk::Client.from_env

res = client.request("DELETE", "/integrations/hubspot/disconnect")
puts res["data"]["status"]

<?php
use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();

$res = $client->request(
    method: "DELETE",
    path: "/integrations/hubspot/disconnect",
);

echo $res["data"]["status"] . PHP_EOL;

{
  "data": {
    "status": "disconnected",
    "integration_id": "hubspot"
  },
  "meta": {
    "request_id": "req_int_007",
    "timestamp": "2026-08-26T09:05:00Z"
  }
}

After the revoke, GET /{id}/status reports connected: false, and you can leave the revoked integration in your catalog or remove it from view entirely.

Same flow in Node `fetch`

No SDK required — plain Node 18+ fetch, dependency-free, walking the whole HubSpot narrative above.

const API_KEY = process.env.ORBIT_API_KEY;
const BASE = 'https://api.orbit.devotel.io/api/v1/integrations';

async function call(path, options = {}) {
  const res = await fetch(BASE + path, {
    ...options,
    headers: { 'X-API-Key': API_KEY, 'Content-Type': 'application/json', ...options.headers },
  });
  const body = await res.json();
  if (!res.ok) throw new Error(`${res.status} ${body.error?.code}: ${body.error?.message}`);
  return body.data;
}

// 1. Start the OAuth flow and get the redirect URL.
const { auth_url } = await call('/connect', {
  method: 'POST',
  body: JSON.stringify({ integration_id: 'hubspot' }),
});
console.log('Send the operator to:', auth_url);

// 2. After consent, confirm the connection is live.
const status = await call('/hubspot/status');
if (!status.connected) throw new Error('HubSpot not connected yet');
console.log('Connected as', status.connection_id);

// 3. Trigger a contacts sync on demand.
await call('/hubspot/sync', {
  method: 'POST',
  body: JSON.stringify({ sync_name: 'contacts' }),
});

// 4. Read the synced contacts.
const records = await call('/hubspot/data?model=contacts');
console.log(`Synced ${records.length} contacts`);

// 5. Disconnect when you're done.
await call('/hubspot/disconnect', { method: 'DELETE' });

More task-shaped recipes in the same curl + Node style: REST API recipes.

Errors

Status	Condition	Error code
`401`	Missing or invalid API key, or the key lacks `integrations:read` / `integrations:write`	`UNAUTHORIZED`
`404`	Unknown `integration_id`, or the provider has no OAuth credentials set up. On WooCommerce connect, the store’s REST API was not found at the URL	`INTEGRATION_NOT_CONFIGURED` / `WOO_REST_NOT_FOUND`
`409`	Duplicate connection — writing per-connection settings before connecting	`INTEGRATION_NOT_CONNECTED`
`422`	The WooCommerce `store_url` failed safety validation, with a `failure_code` category	`WOO_INVALID_STORE_URL`
`502`	The sync trigger, record fetch, or disconnect failed upstream. On WooCommerce connect, the store was unreachable or the validation probe returned a non-2xx	`SYNC_TRIGGER_FAILED` / `SYNC_RECORDS_FAILED` / `DISCONNECT_FAILED` / `WOO_UNREACHABLE` / `WOO_VALIDATION_FAILED`
`503`	Integration server not configured or unreachable	`NANGO_NOT_CONFIGURED` / `NANGO_UNAVAILABLE`

WooCommerce connect adds a few more: 400 WOO_INVALID_URL / WOO_HTTPS_REQUIRED for a malformed or non-HTTPS store_url, and 401 WOO_AUTH_FAILED when the store rejects the key pair — fix the pair in WP-Admin and retry. A disconnected integration is not an error — status and data reads stay 200 with connected: false / [] — so reserve error handling for the table above.

API Reference

All Endpoints

Integrations API: connect Salesforce, HubSpot, and more

Integrations API

Using the SDKs

Connections

Sync & data

WooCommerce (key-pair connect)

Inbound webhook

List integrations

Start the OAuth connect flow

Check connection status

Trigger a sync

Read synced records

Connect WooCommerce (key-pair connect)

Disconnect WooCommerce

Disconnect

Same flow in Node `fetch`

Errors

See also

​Integrations API

​Using the SDKs

​Connections

​Sync & data

​WooCommerce (key-pair connect)

​Inbound webhook

​List integrations

​Start the OAuth connect flow

​Check connection status

​Trigger a sync

​Read synced records

​Connect WooCommerce (key-pair connect)

​Disconnect WooCommerce

​Disconnect

​Same flow in Node fetch

​Errors

​See also

Integrations API

Using the SDKs

Connections

Sync & data

WooCommerce (key-pair connect)

Inbound webhook

List integrations

Start the OAuth connect flow

Check connection status

Trigger a sync

Read synced records

Connect WooCommerce (key-pair connect)

Disconnect WooCommerce

Disconnect

Same flow in Node `fetch`

Errors

See also