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 5 show cURL and TypeScript — the two most-used.

Settings API

Workspace settings, API keys, and team membership Base path: /api/v1/settings Endpoint count: 20

List per-agent per-channel concurrency caps

GET /api/v1/settings/agent-channel-caps

Return every configured per-agent per-channel max-concurrent cap for the tenant. Optionally narrow to a single agent with ?agent_user_id=. A missing (agent, channel) row means “no cap, fail-OPEN”; a row with max_concurrent=0 blocks that agent from that channel entirely. Owner/admin only.

string

Narrow the list to one agent’s caps.

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/settings/agent-channel-caps" \
  -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/settings/agent-channel-caps', {
  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/settings/agent-channel-caps", 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/settings/agent-channel-caps", 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/settings/agent-channel-caps')
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/settings/agent-channel-caps');
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": [
    "string"
  ],
  "meta": "string"
}

List Messenger personas

GET /api/v1/settings/channels/messenger/personas

Lists the virtual sender personas configured on the connected Messenger Page. The Page access token is held server-side and never exposed to the browser.

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/settings/channels/messenger/personas" \
  -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/settings/channels/messenger/personas', {
  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/settings/channels/messenger/personas", 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/settings/channels/messenger/personas", 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/settings/channels/messenger/personas')
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/settings/channels/messenger/personas');
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": {
    "data": [
      {
        "id": "string",
        "name": "string",
        "profile_picture_url": "string"
      }
    ],
    "paging": {
      "cursors": {
        "before": "string",
        "after": "string"
      }
    }
  },
  "meta": {
    "request_id": "string",
    "timestamp": "1970-01-01T00:00:00.000Z"
  }
}

Read whether verbatim AI-turn audit logging is enabled

GET /api/v1/settings/compliance/ai-turn-audit

Return whether the org has opted in to verbatim AI-turn audit logging. When enabled, each turn’s system prompt, user prompt and assistant response are recorded to the org’s AI-turn audit log. Default OFF (fail-closed): audit logging is off until the org explicitly turns it on. Available to any member. (This is the Settings surface — distinct from GET /api/v1/agents/ai-turn-audit, which reads the recorded turns.)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/settings/compliance/ai-turn-audit" \
  -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/settings/compliance/ai-turn-audit', {
  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/settings/compliance/ai-turn-audit", 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/settings/compliance/ai-turn-audit", 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/settings/compliance/ai-turn-audit')
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/settings/compliance/ai-turn-audit');
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": {
    "enabled": false
  },
  "meta": "string"
}

GET /api/v1/settings/compliance/consent-default-policy

Return the org’s default consent policy — the policy Orbit applies when a contact has NO recorded consent. permit_on_missing (default, US TCPA legitimate-relationship posture) lets a send through on a missing record; deny_on_missing (EU GDPR affirmative opt-in posture) treats an unrecorded contact as a refusal. Universal legal protections (revoked consent, right-to-be-forgotten, opted-out) are never overridden by this setting. Available to any member.

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/settings/compliance/consent-default-policy" \
  -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/settings/compliance/consent-default-policy', {
  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/settings/compliance/consent-default-policy", 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/settings/compliance/consent-default-policy", 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/settings/compliance/consent-default-policy')
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/settings/compliance/consent-default-policy');
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": {
    "consent_default_policy": "permit_on_missing"
  },
  "meta": "string"
}

Read the org’s per-channel and voice fraud velocity / spend caps

GET /api/v1/settings/compliance/fraud-caps

Return the org’s per-channel fraud velocity (per-minute) and daily-spend (cents) cap overrides plus the platform-wide FLOOR for each channel, and the parallel voice spend / velocity overrides. These caps are enforced on every outbound send. An override is null when no org override is set (the platform floor applies). Available to any member.

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/settings/compliance/fraud-caps" \
  -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/settings/compliance/fraud-caps', {
  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/settings/compliance/fraud-caps", 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/settings/compliance/fraud-caps", 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/settings/compliance/fraud-caps')
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/settings/compliance/fraud-caps');
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": {
    "channels": [
      {
        "channel": "string",
        "max_per_min": 0,
        "max_daily_spend_cents": 0,
        "floor_per_min": 0,
        "floor_daily_spend_cents": 0
      }
    ],
    "voice": "string"
  },
  "meta": "string"
}

Read the org’s inbox-AI privacy toggles and spam-handling action

GET /api/v1/settings/compliance/inbox-ai-privacy

Return whether the two default-ON inbox-AI behaviours are enabled and the spam action. auto_categorize governs whether inbound messages are automatically categorized; auto_summarize governs whether conversations are summarized when closed. Both default ON — an org that never opted out reads as enabled. spam_action is the action applied when a message is classified as spam with high confidence (none tags the message as spam but takes no further action). Available to any member.

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/settings/compliance/inbox-ai-privacy" \
  -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/settings/compliance/inbox-ai-privacy', {
  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/settings/compliance/inbox-ai-privacy", 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/settings/compliance/inbox-ai-privacy", 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/settings/compliance/inbox-ai-privacy')
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/settings/compliance/inbox-ai-privacy');
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": "string",
  "meta": "string"
}

GET /api/v1/settings/compliance/unknown-marketing-policy

Return the org’s unknown_marketing_policy — the policy Orbit applies to a marketing send when a contact’s consent state is unknown. refuse (default, GDPR/PECR/LGPD-conservative) never sends; allow_with_logging (US double-opt-out / B2B legitimate-interest) sends and records a per-contact audit entry. Available to any member.

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/settings/compliance/unknown-marketing-policy" \
  -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/settings/compliance/unknown-marketing-policy', {
  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/settings/compliance/unknown-marketing-policy", 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/settings/compliance/unknown-marketing-policy", 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/settings/compliance/unknown-marketing-policy')
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/settings/compliance/unknown-marketing-policy');
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": {
    "unknown_marketing_policy": "refuse"
  },
  "meta": "string"
}

Get your current IP address

GET /api/v1/settings/ip-allowlist/current-ip

Returns your current IP address as the API sees it, plus whether IP-allowlist enforcement is active for your account. Use it to add the correct IP to your allowlist without locking yourself out. ip is null when your IP address cannot be determined; enforced is false when allowlist enforcement is not applied in the current environment.

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/settings/ip-allowlist/current-ip" \
  -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/settings/ip-allowlist/current-ip', {
  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/settings/ip-allowlist/current-ip", 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/settings/ip-allowlist/current-ip", 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/settings/ip-allowlist/current-ip')
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/settings/ip-allowlist/current-ip');
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": {
    "ip": "string",
    "enforced": false
  },
  "meta": {
    "request_id": "string",
    "timestamp": "1970-01-01T00:00:00.000Z"
  }
}

Create an API key

POST /api/v1/settings/api-keys

Mint a new tenant API key. The key value is returned ONLY on this response (Cache-Control: no-store) — store it immediately. mode: 'test' activates sandbox-mode (no real provider hits, no billing). Optional per-key allowed_ips enforces an IP allowlist at auth time.

string

required

Human-readable label shown in the dashboard. Not used for authentication.

string (enum: secret|public)

secret = server-only dv_*_sk_* key; public = browser-safe pk_* key for the embed SDK.

string[]

API key permission scopes (e.g. messages:write). At least one scope is required for keys minted after 2026-08-01; empty-scope keys are deprecated and treated as least-privilege (viewer) / will be rejected after the grandfather deadline.

string (enum: live|test)

test keys never deliver messages and never bill; useful for CI/staging.

string (enum: never|30d|90d|1y)

—

string[]

Optional IP/CIDR allowlist. Auth middleware rejects requests from a non-allowlisted source.

cURL

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

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/settings/api-keys', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "name": "string"
}),
})
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/settings/api-keys", headers=headers, json={
  "name": "string"
})
print(r.json())

package main

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

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/settings/api-keys", bytes.NewBuffer([]byte(`{
  "name": "string"
}`)))
	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/settings/api-keys')
req = Net::HTTP::Post.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {
  "name": "string"
}.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/settings/api-keys');
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
{
  "name": "string"
}
JSON);
echo curl_exec($ch);

{
  "data": {
    "id": "string",
    "key": "string",
    "name": "string",
    "type": "secret",
    "mode": "live",
    "scopes": [
      "string"
    ],
    "allowed_ips": null,
    "expires_at": null,
    "created_at": "1970-01-01T00:00:00.000Z",
    "_warning": "string"
  },
  "meta": {
    "request_id": "string",
    "timestamp": "1970-01-01T00:00:00.000Z"
  }
}

{
  "error": {
    "code": "string",
    "message": "string",
    "status": 0,
    "details": {}
  },
  "meta": {
    "request_id": "string",
    "timestamp": "1970-01-01T00:00:00.000Z",
    "docs_url": "https://example.com"
  }
}

Create a Messenger persona

POST /api/v1/settings/channels/messenger/personas

Creates a new virtual sender persona on the connected Messenger Page. Meta mints the id; the supplied name and avatar are echoed back so the UI can render the row without a refetch.

string

required

Display name shown to the recipient.

string

required

HTTPS avatar URL. Meta fetches it at create time and rejects non-https schemes.

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/settings/channels/messenger/personas" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "string",
  "profile_picture_url": "string"
}'

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/settings/channels/messenger/personas', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "name": "string",
  "profile_picture_url": "string"
}),
})
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/settings/channels/messenger/personas", headers=headers, json={
  "name": "string",
  "profile_picture_url": "string"
})
print(r.json())

package main

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

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/settings/channels/messenger/personas", bytes.NewBuffer([]byte(`{
  "name": "string",
  "profile_picture_url": "string"
}`)))
	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/settings/channels/messenger/personas')
req = Net::HTTP::Post.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {
  "name": "string",
  "profile_picture_url": "string"
}.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/settings/channels/messenger/personas');
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
{
  "name": "string",
  "profile_picture_url": "string"
}
JSON);
echo curl_exec($ch);

{
  "data": {
    "id": "string",
    "name": "string",
    "profile_picture_url": "string"
  },
  "meta": {
    "request_id": "string",
    "timestamp": "1970-01-01T00:00:00.000Z"
  }
}

Record a completed self-service password change

POST /api/v1/settings/security/password-changed

Record a completed password change for the authenticated user and send them the matching security alert — an in-app notification, a security email, and a mobile push. Call this after a self-service password change succeeds so the user is notified that their credentials were updated. Only the authenticated caller is ever notified, so the endpoint cannot raise an alert on another account. The request body is optional and ignored; the response returns ok and the changed_at timestamp of the recorded change.

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/settings/security/password-changed" \
  -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/settings/security/password-changed', {
  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/settings/security/password-changed", 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/settings/security/password-changed", 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/settings/security/password-changed')
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/settings/security/password-changed');
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);

{
  "data": {
    "ok": false,
    "changed_at": "1970-01-01T00:00:00.000Z"
  },
  "meta": "string"
}

Upsert one per-agent per-channel concurrency cap

PUT /api/v1/settings/agent-channel-caps

Set the maximum simultaneous open interactions of one channel an agent can be routed (e.g. agent X = 3 chats). max_concurrent=0 opts the agent OUT of that channel entirely; a positive value caps concurrency; deleting the row reverts to “no cap”. Idempotent upsert keyed on (agent_user_id, channel). Owner/admin only.

string

required

—

any

required

—

integer

required

—

cURL

curl -X PUT "https://api.orbit.devotel.io/api/v1/settings/agent-channel-caps" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "agent_user_id": "string",
  "channel": "string",
  "max_concurrent": 0
}'

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/settings/agent-channel-caps', {
  method: 'PUT',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "agent_user_id": "string",
  "channel": "string",
  "max_concurrent": 0
}),
})
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.put("https://api.orbit.devotel.io/api/v1/settings/agent-channel-caps", headers=headers, json={
  "agent_user_id": "string",
  "channel": "string",
  "max_concurrent": 0
})
print(r.json())

package main

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

func main() {
	req, _ := http.NewRequest("PUT", "https://api.orbit.devotel.io/api/v1/settings/agent-channel-caps", bytes.NewBuffer([]byte(`{
  "agent_user_id": "string",
  "channel": "string",
  "max_concurrent": 0
}`)))
	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/settings/agent-channel-caps')
req = Net::HTTP::Put.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {
  "agent_user_id": "string",
  "channel": "string",
  "max_concurrent": 0
}.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/settings/agent-channel-caps');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{
  "agent_user_id": "string",
  "channel": "string",
  "max_concurrent": 0
}
JSON);
echo curl_exec($ch);

{
  "data": "string",
  "meta": "string"
}

Bulk upsert per-agent per-channel concurrency caps

PUT /api/v1/settings/agent-channel-caps/bulk

Upsert a batch of (agent_user_id, channel, max_concurrent) caps in one call — the team-members cap-matrix save. Idempotent: re-sending an (agent, channel) pair updates its existing cap instead of creating a duplicate. Up to 500 rows; duplicate (agent, channel) keys in the payload keep the last value. Owner/admin only.

object[]

required

—

cURL

curl -X PUT "https://api.orbit.devotel.io/api/v1/settings/agent-channel-caps/bulk" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "caps": []
}'

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/settings/agent-channel-caps/bulk', {
  method: 'PUT',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "caps": []
}),
})
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.put("https://api.orbit.devotel.io/api/v1/settings/agent-channel-caps/bulk", headers=headers, json={
  "caps": []
})
print(r.json())

package main

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

func main() {
	req, _ := http.NewRequest("PUT", "https://api.orbit.devotel.io/api/v1/settings/agent-channel-caps/bulk", bytes.NewBuffer([]byte(`{
  "caps": []
}`)))
	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/settings/agent-channel-caps/bulk')
req = Net::HTTP::Put.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {
  "caps": []
}.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/settings/agent-channel-caps/bulk');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{
  "caps": []
}
JSON);
echo curl_exec($ch);

{
  "data": [
    "string"
  ],
  "meta": "string"
}

Opt the org in/out of verbatim AI-turn audit logging

PUT /api/v1/settings/compliance/ai-turn-audit

Enable or disable verbatim AI-turn audit logging. Owner only — the setting governs whether the full system prompt, user prompt and assistant response of every AI turn is recorded to the org’s AI-turn audit log (a multi-year verbatim store of PII).

boolean

required

—

cURL

curl -X PUT "https://api.orbit.devotel.io/api/v1/settings/compliance/ai-turn-audit" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "enabled": false
}'

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/settings/compliance/ai-turn-audit', {
  method: 'PUT',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "enabled": false
}),
})
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.put("https://api.orbit.devotel.io/api/v1/settings/compliance/ai-turn-audit", headers=headers, json={
  "enabled": false
})
print(r.json())

package main

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

func main() {
	req, _ := http.NewRequest("PUT", "https://api.orbit.devotel.io/api/v1/settings/compliance/ai-turn-audit", bytes.NewBuffer([]byte(`{
  "enabled": false
}`)))
	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/settings/compliance/ai-turn-audit')
req = Net::HTTP::Put.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {
  "enabled": false
}.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/settings/compliance/ai-turn-audit');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{
  "enabled": false
}
JSON);
echo curl_exec($ch);

{
  "data": {
    "enabled": false
  },
  "meta": "string"
}

Upsert the org’s per-channel and/or voice fraud caps

PUT /api/v1/settings/compliance/fraud-caps

Upsert per-channel fraud cap overrides. Owner only — it governs the outbound velocity / spend limits enforced on every send. caps is a sparse map keyed by messaging channel; only channels present are touched. A leaf number SETs the override; a leaf null REMOVEs it (reverting to the platform floor). voice carries the parallel per-org voice overrides, with country_max_per_min a per-destination-country calls/min map that REPLACES the stored map wholesale (an empty map clears it). Other fraud-protection settings (e.g. the country allowlist) are left untouched.

cURL

curl -X PUT "https://api.orbit.devotel.io/api/v1/settings/compliance/fraud-caps" \
  -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/settings/compliance/fraud-caps', {
  method: 'PUT',
  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.put("https://api.orbit.devotel.io/api/v1/settings/compliance/fraud-caps", headers=headers, json={})
print(r.json())

package main

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

func main() {
	req, _ := http.NewRequest("PUT", "https://api.orbit.devotel.io/api/v1/settings/compliance/fraud-caps", 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/settings/compliance/fraud-caps')
req = Net::HTTP::Put.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/settings/compliance/fraud-caps');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'PUT');
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);

{
  "data": {
    "set": {},
    "cleared": [
      "string"
    ]
  },
  "meta": "string"
}

PATCH /api/v1/settings/compliance/consent-default-policy

Switch the default consent policy between permit_on_missing and deny_on_missing. Owner only — it changes whether a message reaches a contact with no recorded consent. The change takes effect immediately.

—

cURL

curl -X PATCH "https://api.orbit.devotel.io/api/v1/settings/compliance/consent-default-policy" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "consent_default_policy": "permit_on_missing"
}'

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/settings/compliance/consent-default-policy', {
  method: 'PATCH',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "consent_default_policy": "permit_on_missing"
}),
})
console.log(await res.json())

{
  "data": {
    "consent_default_policy": "permit_on_missing"
  },
  "meta": "string"
}

Update the org’s inbox-AI privacy toggles and/or spam action

PATCH /api/v1/settings/compliance/inbox-ai-privacy

Opt the org in/out of inbox auto-categorize and/or auto-summarize, and/or set the spam action. Owner only. Each field is optional so a single toggle can be flipped without resending the others — at least one of auto_categorize, auto_summarize or spam_action must be present. A change can take up to a minute to take effect. The response reflects the merged state of all three fields.

boolean

—

boolean

—

string (enum: none|archive|close)

—

cURL

curl -X PATCH "https://api.orbit.devotel.io/api/v1/settings/compliance/inbox-ai-privacy" \
  -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/settings/compliance/inbox-ai-privacy', {
  method: 'PATCH',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": "string",
  "meta": "string"
}

PATCH /api/v1/settings/compliance/unknown-marketing-policy

Switch the marketing posture for unknown-state contacts between refuse and allow_with_logging. Owner only — flipping to allow_with_logging widens who the platform will lawfully market to, so it requires a documented decision: reason (a written justification of at least 10 characters) and lawful_basis are BOTH mandatory when setting allow_with_logging. The change — including the previous value, the administrator, the reason, and the lawful basis — is recorded in the tamper-evident audit chain. Tightening back to refuse needs neither field.

string (enum: refuse|allow_with_logging)

required

—

string

Written justification for the change. Required (minimum 10 characters) when unknown_marketing_policy is allow_with_logging; recorded in the audit trail.

string (enum: legitimate_interest|existing_business_relationship|consent|contract|other)

The lawful basis relied on for the looser posture. Required when unknown_marketing_policy is allow_with_logging.

cURL

curl -X PATCH "https://api.orbit.devotel.io/api/v1/settings/compliance/unknown-marketing-policy" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "unknown_marketing_policy": "refuse"
}'

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/settings/compliance/unknown-marketing-policy', {
  method: 'PATCH',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "unknown_marketing_policy": "refuse"
}),
})
console.log(await res.json())

{
  "data": {
    "unknown_marketing_policy": "refuse"
  },
  "meta": "string"
}

Clear a per-agent per-channel concurrency cap

DELETE /api/v1/settings/agent-channel-caps/{agentUserId}/{channel}

Remove the cap row for one (agent, channel) pair, reverting it to the “no cap, fail-OPEN” default. Returns 404 when no cap was configured for that pair. Owner/admin only.

string

required

—

any

required

—

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/settings/agent-channel-caps/{agentUserId}/{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/settings/agent-channel-caps/{agentUserId}/{channel}', {
  method: 'DELETE',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {
    "deleted": false,
    "agent_user_id": "string",
    "channel": "string"
  },
  "meta": "string"
}

Delete a Messenger persona

DELETE /api/v1/settings/channels/messenger/personas/{personaId}

Removes a virtual sender persona from the connected Messenger Page by its Meta object id. Returns 204 on success.

string

required

Meta persona object id (numeric string).

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/settings/channels/messenger/personas/{personaId}" \
  -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/settings/channels/messenger/personas/{personaId}', {
  method: 'DELETE',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

Response: 204 No Content

API Reference

All Endpoints

Settings API

Settings API

List per-agent per-channel concurrency caps

List Messenger personas

Read whether verbatim AI-turn audit logging is enabled

Read the org’s per-channel and voice fraud velocity / spend caps

Read the org’s inbox-AI privacy toggles and spam-handling action

Get your current IP address

Create an API key

Create a Messenger persona

Record a completed self-service password change

Upsert one per-agent per-channel concurrency cap

Bulk upsert per-agent per-channel concurrency caps

Opt the org in/out of verbatim AI-turn audit logging

Upsert the org’s per-channel and/or voice fraud caps

Update the org’s inbox-AI privacy toggles and/or spam action

Clear a per-agent per-channel concurrency cap

Delete a Messenger persona

​Settings API

​List per-agent per-channel concurrency caps

​List Messenger personas

​Read whether verbatim AI-turn audit logging is enabled

​Read the org’s default consent policy for contacts with no consent record

​Read the org’s per-channel and voice fraud velocity / spend caps

​Read the org’s inbox-AI privacy toggles and spam-handling action

​Read the org’s marketing policy for contacts whose consent state is unknown

​Get your current IP address

​Create an API key

​Create a Messenger persona

​Record a completed self-service password change

​Upsert one per-agent per-channel concurrency cap

​Bulk upsert per-agent per-channel concurrency caps

​Opt the org in/out of verbatim AI-turn audit logging

​Upsert the org’s per-channel and/or voice fraud caps

​Update the org’s default consent policy

​Update the org’s inbox-AI privacy toggles and/or spam action

​Update the org’s unknown-consent marketing policy

​Clear a per-agent per-channel concurrency cap

​Delete a Messenger persona

Settings API

List per-agent per-channel concurrency caps

List Messenger personas

Read whether verbatim AI-turn audit logging is enabled

Read the org’s default consent policy for contacts with no consent record

Read the org’s per-channel and voice fraud velocity / spend caps

Read the org’s inbox-AI privacy toggles and spam-handling action

Read the org’s marketing policy for contacts whose consent state is unknown

Get your current IP address

Create an API key

Create a Messenger persona

Record a completed self-service password change

Upsert one per-agent per-channel concurrency cap

Bulk upsert per-agent per-channel concurrency caps

Opt the org in/out of verbatim AI-turn audit logging

Upsert the org’s per-channel and/or voice fraud caps

Update the org’s default consent policy

Update the org’s inbox-AI privacy toggles and/or spam action

Update the org’s unknown-consent marketing policy

Clear a per-agent per-channel concurrency cap

Delete a Messenger persona