Languages: every operation supports cURL, Node.js (TypeScript), Python, Go, Ruby, and PHP. The first 15 operations on this page show all six languages; the remaining 20 show cURL and TypeScript — the two most-used.

Integrations API

Integrations endpoints exposed by the Devotel CPaaS API Base path: /api/v1/integrations Endpoint count: 35

title: “Errors worth branching on” description: “Per-endpoint failure templates matching the envelope — what actually fires, what to retry, what to surface to the operator.”

Errors worth branching on

These five failures cover the integration create/list surface (POST /api/v1/integrations, GET /api/v1/integrations), the link every connect callback flows through. Each block below is a full { error, meta } envelope as the API returns it, and the matrix at the bottom answers retry vs surface for the same five classes. For the platform-wide decision table these branches plug into, see the error handling guide.

401 — Unauthorized

  {
    "error": {
      "code": "UNAUTHORIZED",
      "message": "The API key is invalid, expired, or lacks the required scope.",
      "status": 401
    },
    "meta": {
      "request_id": "req_integrata1",
      "timestamp": "2026-09-03T12:00:00Z"
    }
  }

A 401 on this page is the bearer key failing before the route ran — it never means the resource is wrong. Rotate the key or re-mint the scoped token; retrying the same request changes nothing.

403 — Forbidden

  {
    "error": {
      "code": "FORBIDDEN",
      "message": "The key is valid but does not have the scope this operation requires.",
      "status": 403
    },
    "meta": {
      "request_id": "req_integrata1f",
      "timestamp": "2026-09-03T12:00:00Z"
    }
  }

A 403 means the key authenticated but the operation is gated by scope — check the key’s scopes on the developer page; a 403 is never a data-not-found shape.

422 — Schema

  {
    "error": {
      "code": "VALIDATION_ERROR",
      "message": "The request failed input validation.",
      "status": 422,
      "details": { "field": "provider", "value": "hubspot", "expected": "one of the supported provider slugs" }
    },
    "meta": {
      "request_id": "req_integratb2",
      "timestamp": "2026-09-03T12:00:00Z"
    }
  }

A 422 means the payload did not match the request schema — branch on error.details.field and resend with one of the supported provider slugs instead of blind-retrying the same body.

429 — Rate

  {
    "error": {
      "code": "RATE_LIMITED",
      "message": "Too many requests in the current window.",
      "status": 429,
      "details": { "retry_after": 12 }
    },
    "meta": {
      "request_id": "req_integratc3",
      "timestamp": "2026-09-03T12:00:00Z",
      "docs_url": "https://docs.orbit.devotel.io/errors/RATE_LIMITED"
    }
  }

The Retry-After header and error.details.retry_after are both set on every 429 — resend the SAME request after the lower of the two.

402 — Feature gate

  {
    "error": {
      "code": "INTEGRATIONS_NOT_CONNECTED",
      "message": "This integration is not connected for the organization.",
      "status": 402
    },
    "meta": {
      "request_id": "req_integratd4",
      "timestamp": "2026-09-03T12:00:00Z"
    }
  }

Surface the connect flow — re-check after the handshake completes.

60-second retry matrix

Class	Meaning	Branch response
401 `UNAUTHORIZED`	the bearer key itself fails	Surface. Rotate the key or re-mint the scoped token; do not retry the same request.
403 `FORBIDDEN`	the key lacks this operation’s scope	Surface. Fix the key’s scope set; a retry with the same key never heals it.
422 `VALIDATION_ERROR`	the payload does not match the schema	Fix, then resend intentionally. Branch on `error.details.field`; a blind retry repeats the same 422.
429 `RATE_LIMITED`	the window quota is exhausted	Retry after `error.details.retry_after` (or the `Retry-After` header) with the same request body.
`INTEGRATIONS_NOT_CONNECTED` (402 feature gate)	Surface the connect flow	Branch on `error.code`. Re-check after the handshake completes.

List integrations with the org’s connection status

GET /api/v1/integrations

Lists every integration available to the current organization with a connected flag, provider, category and sync names, cursor-paginated. Backs the Settings → Integrations grid. Supports a ?fields= projection to trim the per-item payload, and falls back to a static catalog when the integration server is unreachable so the page always renders.

string (enum: true|false)

Sandbox opt-in for Clerk-session-authenticated requests. Set to true to route the call through the test-mode pipeline: no real provider delivery, no credits deducted, response meta.test_mode: true. Ignored for live API keys (dv_live_sk_*) — server-to-server clients must use a test-prefixed key (dv_test_sk_*) to exercise sandbox. Test-prefixed keys unconditionally enable sandbox regardless of this header.

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

Retrieve synced records for an integration model

GET /api/v1/integrations/{id}/data

Returns ALL records the integration has synced for the given data model (a required query parameter, e.g. contacts or deals) — the Nango client walks the full /sync/records cursor instead of the single default page. Reads from the integration server’s synced-record store and returns an empty array when it is not configured. Returns 502 when the fetch fails upstream.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/data" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/data', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/data", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/data", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/data')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/data');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

Get an integration’s feature preference flags

GET /api/v1/integrations/{id}/features

Returns the per-tenant feature toggles for the integration (audience, crm_context, agent_tools, engagement, automation). Each flag defaults to enabled unless explicitly turned off, so a freshly connected integration exposes all capabilities. Reading is always allowed, even before any preference has been saved.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/features" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/features', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/features", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/features", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/features')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/features');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

Get connection and sync status for an integration

GET /api/v1/integrations/{id}/status

Returns whether the integration is connected for the current organization plus its connection metadata and the status of each configured sync. An absent or unwired connection resolves to connected: false with an empty sync list rather than an error, so the Settings tab can render a disconnected state cleanly.

string

required

—

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/status', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/status", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/status", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/status')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/status');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

List the available integration catalog

GET /api/v1/integrations/catalog

Returns the live catalog of every integration configured on the integration server, merged with any ?coming_soon= roadmap hints. Each row carries its unique key, provider, display name, logo, status and the syncs and actions it exposes. Cached briefly per pod and fails closed with 503 when the integration server is not configured so the misconfiguration is visible to operators.

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/catalog', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/catalog", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/catalog", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/catalog')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/catalog');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

List per-integration connection statuses for the org

GET /api/v1/integrations/connections

Returns a per-integration connection summary for the current organization — connected flag, errored flag, last-synced timestamp and granted scopes — fanned out across the catalog (or the subset in ?keys=). Cached for 30s per org; pass ?fresh=1 to bypass the cache right after an OAuth popup closes.

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/connections', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/connections", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/connections", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/connections')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/connections');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

Complete the Intercom OAuth install

GET /api/v1/integrations/intercom/oauth/callback

OAuth redirect target Intercom sends the operator’s browser back to after they authorize the app. Verifies the HMAC-signed state, exchanges the code for a workspace access token, registers the webhook topics, and stores the connection. Intercom calls this endpoint as a top-level browser redirect — your application does not call it directly. A declined install returns a 400 error body.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/callback" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/callback', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/callback", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/callback", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/callback')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/callback');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

Start the direct Intercom OAuth install

GET /api/v1/integrations/intercom/oauth/start

Mints an HMAC-signed state token for the organization passed in the state query parameter and returns the Intercom auth_url the dashboard should redirect the operator to. Use this for a branded ‘Install on Intercom’ button instead of the generic Nango connect flow; the raw organization id is never forwarded to Intercom. Returns 503 when Intercom OAuth is not configured.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/start" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/start', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/start", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/start", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/start')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/intercom/oauth/start');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

List Segment inbound sources

GET /api/v1/integrations/segment/sources

Returns the tenant’s configured Segment inbound Sources, each with its masked inbound secret, delivery webhook URL and last-event / last-test status, cursor-paginated on (created_at, id). Backs the Segment integration settings screen. Page with ?limit= and ?cursor=; a limit above the hard cap is clamped rather than rejected. A not-yet-provisioned tenant returns an empty list.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/integrations/segment/sources" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/segment/sources', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/segment/sources", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/segment/sources", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/segment/sources')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/segment/sources');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

List channels

GET /api/v1/integrations/slack/channels

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/integrations/slack/channels" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/slack/channels', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/slack/channels", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/slack/channels", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/slack/channels')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/slack/channels');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Complete the Slack OAuth install

GET /api/v1/integrations/slack/oauth/callback

OAuth redirect target Slack sends the operator’s browser back to after they approve the workspace install. Verifies the HMAC-signed state, exchanges the code for a bot token, and stores the encrypted per-tenant Slack connection. Slack calls this endpoint as a top-level browser redirect — your application does not call it directly. A cancelled install returns 200 with ok: false.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/callback" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/callback', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/callback", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/callback", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/callback')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/callback');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

Start the direct Slack OAuth install

GET /api/v1/integrations/slack/oauth/start

Returns the Slack authorize_url the dashboard should redirect the logged-in operator to so they can install Orbit into their own Slack workspace. The organization is read from the authenticated session and pinned into an HMAC-signed state token so the resulting install cannot be replayed against another tenant. Use this to offer a branded “Add to Slack” button instead of the generic Nango connect flow. Returns 503 when Slack OAuth is not configured.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/start" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/start', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/start", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/start", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/start')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/slack/oauth/start');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{}

List nango

GET /api/v1/integrations/webhooks/nango

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/integrations/webhooks/nango" \
  -H "X-API-Key: dv_live_sk_your_key_here" 

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/webhooks/nango', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
r = requests.get("https://api.orbit.devotel.io/api/v1/integrations/webhooks/nango", headers=headers)
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("GET", "https://api.orbit.devotel.io/api/v1/integrations/webhooks/nango", nil)
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/webhooks/nango')
req = Net::HTTP::Get.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']


res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/webhooks/nango');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'GET');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),

]);

echo curl_exec($ch);

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Invoke a named action on an integration

POST /api/v1/integrations/{id}/actions/{name}

Fires an imperative provider action (for example create-contact or log-call) by name on the connected integration, forwarding the request body as the action input. The action name is validated against the provider’s advertised actions. Admin-only (owner/admin). Returns 400 for an unknown action, 404 when no connection exists, and 401 when the stored credentials have expired.

string

required

—

string

required

—

string

Stripe-style idempotency token. Pass a stable, client-generated value (1-255 chars) to dedupe retries on transient timeouts. The same key+credential+path replays the original response for 24h on 2xx (5min on 4xx, 30s on 5xx). Returns 409 if a concurrent request with the same key is already in flight; replayed responses include the Idempotency-Replay: true response header.

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/actions/{name}', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.post("https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/actions/{name}", headers=headers, json={})
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/actions/{name}", bytes.NewBuffer([]byte(`{}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/actions/{name}')
req = Net::HTTP::Post.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {}.to_json
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/actions/{name}');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{}
JSON);
echo curl_exec($ch);

{}

Trigger an immediate data sync for an integration

POST /api/v1/integrations/{id}/sync

Triggers an immediate run of the named sync (sync_name) for the connected integration via the integration server, instead of waiting for its scheduled cadence. Admin-only (owner/admin) and audited. Returns 502 when the trigger fails upstream.

string

required

—

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/sync', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.post("https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/sync", headers=headers, json={})
print(r.json())

package main

import (
	"bytes"
	"net/http"
	"os"
)

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/sync", bytes.NewBuffer([]byte(`{}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("Content-Type", "application/json")
	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

uri = URI('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/sync')
req = Net::HTTP::Post.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {}.to_json
res = Net::HTTP.start(uri.host, uri.port, use_ssl: true) { |h| h.request(req) }
puts res.body

PHP

<?php
$ch = curl_init('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/sync');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{}
JSON);
echo curl_exec($ch);

{}

Start an OAuth connect flow for an integration

POST /api/v1/integrations/connect

Initiates the OAuth authorization flow for the given integration_id via the integration server and returns the auth_url the client should redirect the operator to. Admin-only (owner/admin). Returns 503 when the integration server is not configured or unreachable, and 404 when the provider has no OAuth credentials set up yet.

string

string (enum: true|false)

cURL

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 '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/connect', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Request a new integration

POST /api/v1/integrations/requests

Records a customer request for an integration Orbit does not yet offer so the team can prioritize the connector backlog, and best-effort notifies the Orbit operators. Send the vendor name plus an optional use case and contact email. The request is always persisted and the created id returned even if the operator notification cannot be sent.

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/requests', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Create a Segment inbound source

POST /api/v1/integrations/segment/sources

Creates a new Segment inbound Source for the tenant and returns its delivery webhook URL plus a freshly generated inbound HMAC secret shown in plaintext exactly once — store it now, it cannot be retrieved again (rotate to issue a new one). Point a Segment webhook destination at the returned URL and sign requests with the secret. Requires the integrations:write scope and an owner/admin role.

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/segment/sources', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Rotate a Segment source’s inbound secret

POST /api/v1/integrations/segment/sources/{id}/rotate-secret

Generates a new inbound HMAC secret for the Segment Source and immediately invalidates the previous one, returning the new secret in plaintext exactly once. Use this if the current secret may have leaked; update your Segment webhook destination with the new value right away, since deliveries signed with the old secret stop verifying. Requires the integrations:write scope and an owner/admin role. Returns 404 when the Source does not exist.

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/integrations/segment/sources/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotate-secret" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/segment/sources/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotate-secret', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Send a test event to a Segment source

POST /api/v1/integrations/segment/sources/{id}/test

Sends a synthetic identify call to Segment using the Source’s stored write key to verify the connection end-to-end, then records the outcome on the Source’s last-test status. Use it after creating a Source to confirm the write key is valid before relying on it. Requires the integrations:write scope and an owner/admin role. The call returns 200 with ok: false and the provider error when the test event could not be delivered.

string

required

—

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/segment/sources/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/test', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Receive a Calendly webhook event

POST /api/v1/integrations/webhooks/calendly

Ingests Calendly v2 scheduling events (invitee created and canceled, no-show, routing-form submission) for the tenant identified by the ?org= query parameter. The Calendly-Webhook-Signature HMAC is the authentication — Calendly calls this endpoint, not your application. Each event is matched to a contact, stored for audit and dedupe, and fanned out as a tenant webhook so downstream automations can react.

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/webhooks/calendly', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Receive a HubSpot webhook event

POST /api/v1/integrations/webhooks/hubspot

Ingests HubSpot v3 CRM events (contact, deal and ticket creation, property changes and deletions) and mirrors them into tenant state so campaign triggers can react in real time. The X-HubSpot-Signature-v3 HMAC is the authentication — HubSpot’s app subscription calls this endpoint, not your application. Events arrive as a batch and re-deliveries are idempotent; the response reports how many were processed, deduplicated or unrecognised.

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/webhooks/hubspot', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Intercom webhooks

POST /api/v1/integrations/webhooks/intercom

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/webhooks/intercom', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Nango webhooks

POST /api/v1/integrations/webhooks/nango

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/webhooks/nango', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Salesforce webhooks

POST /api/v1/integrations/webhooks/salesforce

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/webhooks/salesforce', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Segment webhooks

POST /api/v1/integrations/webhooks/segment

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/webhooks/segment', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Shopify webhooks

POST /api/v1/integrations/webhooks/shopify

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/webhooks/shopify', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Slack webhooks

POST /api/v1/integrations/webhooks/slack

string

string (enum: true|false)

cURL

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

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/webhooks/slack', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Connect woocommerce

POST /api/v1/integrations/woocommerce/connect

string

string (enum: true|false)

cURL

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 '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/woocommerce/connect', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Update an integration’s feature preference flags

PATCH /api/v1/integrations/{id}/features

Merges the supplied feature toggles into the integration’s stored preferences without touching other connection metadata. Only the known feature keys are accepted. Admin-only (owner/admin) and requires the integration to be connected (returns 409 otherwise). Returns the full merged preference set with defaults applied.

string

required

—

string (enum: true|false)

cURL

curl -X PATCH "https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/features" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/features', {
  method: 'PATCH',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Patch notifications-channel

PATCH /api/v1/integrations/slack/notifications-channel

string (enum: true|false)

cURL

curl -X PATCH "https://api.orbit.devotel.io/api/v1/integrations/slack/notifications-channel" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/slack/notifications-channel', {
  method: 'PATCH',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Disconnect an integration and revoke its connection

DELETE /api/v1/integrations/{id}/disconnect

Revokes the OAuth connection for the integration and, for Slack, flushes the per-tenant bot token and disables inbound events before the upstream revoke so no live credentials are stranded. Admin-only (owner/admin) and audited. Returns 502 if the revoke fails so the operator can safely retry.

string

required

—

string (enum: true|false)

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/disconnect" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/disconnect', {
  method: 'DELETE',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Disconnect an integration connection by key

DELETE /api/v1/integrations/connections/{uniqueKey}

Revokes the integration connection identified by its unique key and drops the org’s cached connection snapshot so the change shows immediately. For Slack it also flushes the per-tenant bot token and disables inbound events first. Admin-only (owner/admin) and audited. Returns 502 if the upstream revoke fails.

string

required

—

string (enum: true|false)

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/integrations/connections/{uniqueKey}" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/connections/{uniqueKey}', {
  method: 'DELETE',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Delete a Segment inbound source

DELETE /api/v1/integrations/segment/sources/{id}

Permanently removes the Segment inbound Source with the given id and stops accepting inbound events on its webhook URL. Use this to decommission a Source whose write key or inbound secret you no longer want honored. Requires the integrations:write scope and an owner/admin role. Returns 404 when no Source with that id exists for the tenant.

string

required

—

string (enum: true|false)

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/integrations/segment/sources/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/segment/sources/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3', {
  method: 'DELETE',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{}

Delete disconnect

DELETE /api/v1/integrations/woocommerce/disconnect

string (enum: true|false)

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/integrations/woocommerce/disconnect" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{}'

Node.js

import { Orbit } from '@devotel-orbit/node'

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/integrations/woocommerce/disconnect', {
  method: 'DELETE',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {
    "ok": true
  },
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

​Integrations API

​title: “Errors worth branching on” description: “Per-endpoint failure templates matching the envelope — what actually fires, what to retry, what to surface to the operator.”

​Errors worth branching on

​401 — Unauthorized

​403 — Forbidden

​422 — Schema

​429 — Rate

​402 — Feature gate

​60-second retry matrix

​List integrations with the org’s connection status

​Retrieve synced records for an integration model

​Get an integration’s feature preference flags

​Get connection and sync status for an integration

​List the available integration catalog

​List per-integration connection statuses for the org

​Complete the Intercom OAuth install

​Start the direct Intercom OAuth install

​List Segment inbound sources

​List channels

​Complete the Slack OAuth install

​Start the direct Slack OAuth install

​List nango

​Invoke a named action on an integration

​Trigger an immediate data sync for an integration

​Start an OAuth connect flow for an integration

​Request a new integration

​Create a Segment inbound source

​Rotate a Segment source’s inbound secret

​Send a test event to a Segment source

​Receive a Calendly webhook event

​Receive a HubSpot webhook event

​Intercom webhooks

​Nango webhooks

​Salesforce webhooks

​Segment webhooks

​Shopify webhooks

​Slack webhooks

​Connect woocommerce

​Update an integration’s feature preference flags

​Patch notifications-channel

​Disconnect an integration and revoke its connection

​Disconnect an integration connection by key

​Delete a Segment inbound source

​Delete disconnect

Integrations API

title: “Errors worth branching on” description: “Per-endpoint failure templates matching the envelope — what actually fires, what to retry, what to surface to the operator.”

Errors worth branching on

401 — Unauthorized

403 — Forbidden

422 — Schema

429 — Rate

402 — Feature gate

60-second retry matrix

List integrations with the org’s connection status

Retrieve synced records for an integration model

Get an integration’s feature preference flags

Get connection and sync status for an integration

List the available integration catalog

List per-integration connection statuses for the org

Complete the Intercom OAuth install

Start the direct Intercom OAuth install

List Segment inbound sources

List channels

Complete the Slack OAuth install

Start the direct Slack OAuth install

List nango

Invoke a named action on an integration

Trigger an immediate data sync for an integration

Start an OAuth connect flow for an integration

Request a new integration

Create a Segment inbound source

Rotate a Segment source’s inbound secret

Send a test event to a Segment source

Receive a Calendly webhook event

Receive a HubSpot webhook event

Intercom webhooks

Nango webhooks

Salesforce webhooks

Segment webhooks

Shopify webhooks

Slack webhooks

Connect woocommerce

Update an integration’s feature preference flags

Patch notifications-channel

Disconnect an integration and revoke its connection

Disconnect an integration connection by key

Delete a Segment inbound source

Delete disconnect