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

Analytics API

Analytics endpoints exposed by the Devotel CPaaS API Base path: /api/v1 Endpoint count: 76

title: “Worked analytics queries” description: “KPI summary with filters, cursor-paged breakdown rows, prebuilt scheduled-report reads, the zeroed-period shape, and validation/role errors.”

Worked analytics queries

Every operation below is documented on this page with its parameters, but the bodies you branch on — the KPI envelope, the breakdown rows, the totals line — are easiest to learn as one reader chain: pick a metric/summary endpoint → filter by period and channel → page through the breakdown rows → read the totals row. The samples below walk that chain end to end and show the full response envelope at each step. Scope of this overlay:

Per the language note above, these samples show cURL and TypeScript — the two most-requested languages. The other four tabs appear on the endpoint blocks themselves.
The full endpoint catalogue with every filter combination lives at the stats API guide; recurring email delivery of the same data (schedule, recipients, cadence) is covered in scheduled reports. This overlay stays envelope-accurate: request, response, and the errors that decide what you branch on — nothing else.

All analytics reads are tenant-scoped and read-only. They degrade to a zeroed summary or an empty rows array — still a 200 — during a transient storage blip, so a poll loop or an always-on dashboard never flashes a 5xx; design your polling against that contract.

1. Pull a KPI summary

GET /api/v1/analytics/messages returns the headline KPIs for a period — sent, delivered, failed, read, the derived rates, and the average delivery time — plus a bucketed time series for charting. Filter the window with start_date / end_date (or a days lookback) and narrow to one channel with channel.

curl -G "https://api.orbit.devotel.io/api/v1/analytics/messages" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  --data-urlencode "start_date=2026-08-01" \
  --data-urlencode "end_date=2026-08-02" \
  --data-urlencode "channel=whatsapp" \
  --data-urlencode "group_by=day" \
  --data-urlencode "status=delivered"

const url = new URL("https://api.orbit.devotel.io/api/v1/analytics/messages");
url.searchParams.set("start_date", "2026-08-01");
url.searchParams.set("end_date", "2026-08-02");
url.searchParams.set("channel", "whatsapp");
url.searchParams.set("group_by", "day");
url.searchParams.set("status", "delivered");

const res = await fetch(url, {
  headers: { "X-API-Key": process.env.ORBIT_API_KEY! },
});
const body = await res.json();
// Chart `data.time_series`; show the totals row from `data.totals`.
console.log(body.data.totals.delivery_rate);

200

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Adopt the same envelope shape everywhere on this page: all counters live under data.totals, chartable buckets under data.time_series (or a named breakdown array), and the echoed granularity under data.group_by. The cost counterpart — GET /api/v1/analytics/costs — answers with the same totals + time_series envelope plus a by_channel breakdown.

2. Page a breakdown series

Breakdown endpoints return the counters you just read, re-sliced per dimension — channel, destination country, or error code behind failures. Page through the list endpoints that carry a cursor (for example goals): keep the same filters, pass the previous page’s nextCursor back as cursor, and stop when it comes back null. GET /api/v1/analytics/goals

curl -G "https://api.orbit.devotel.io/api/v1/analytics/goals/" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  --data-urlencode "limit=2"

const all = [];
let cursor: string | undefined;
do {
  const url = new URL("https://api.orbit.devotel.io/api/v1/analytics/goals/");
  url.searchParams.set("limit", "2");
  if (cursor) url.searchParams.set("cursor", cursor);
  const res = await fetch(url, {
    headers: { "X-API-Key": process.env.ORBIT_API_KEY! },
  });
  const body = await res.json();
  all.push(...body.data.items);
  cursor = body.data.nextCursor ?? undefined;
} while (cursor);

Page 1:

200

{
  "data": {
    "items": [
      {
        "id": "goal_7Fb2c1a7b",
        "name": "Checkout completed",
        "type": "pixel_fire",
        "enabled": true,
        "total_conversions": 312,
        "total_revenue_cents": 1559688
      },
      {
        "id": "goal_4Dc8e2b91",
        "name": "Demo booked",
        "type": "webhook_hit",
        "enabled": true,
        "total_conversions": 57,
        "total_revenue_cents": 0
      }
    ],
    "total": 3,
    "nextCursor": "cur_8Kw2mQ1z"
  },
  "meta": {
    "request_id": "req_9f2c1a7c",
    "timestamp": "2026-08-02T12:00:10.000Z"
  }
}

Page 2 — pass cursor=cur_8Kw2mQ1z; when this page’s nextCursor is null you have the full set:

200

{
  "data": {
    "items": [
      {
        "id": "goal_9Ae1f03cc",
        "name": "Upgrade started",
        "type": "manual",
        "enabled": false,
        "total_conversions": 12,
        "total_revenue_cents": 12000
      }
    ],
    "total": 3,
    "nextCursor": null
  },
  "meta": {
    "request_id": "req_9f2c1a7d",
    "timestamp": "2026-08-02T12:00:11.000Z"
  }
}

The fixed-shape breakdowns — GET /api/v1/analytics/messages/by-channel, /by-country, and /messages/errors — are single-response reads with no cursor; each returns its full ranked array (channels, countries, errors) so you render them directly.

3. Prebuilt report read (and the empty-period shape)

GET /api/v1/analytics/scheduled-reports lists the recurring reports already scheduled for your organization — the prebuilt views the scheduler emails on a cadence — with each report’s type, frequency, recipients, and its last- and next-send timestamps.

curl -G "https://api.orbit.devotel.io/api/v1/analytics/scheduled-reports" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  --data-urlencode "limit=50"

const url = new URL(
  "https://api.orbit.devotel.io/api/v1/analytics/scheduled-reports",
);
url.searchParams.set("limit", "50");
const res = await fetch(url, {
  headers: { "X-API-Key": process.env.ORBIT_API_KEY! },
});
console.log(await res.json());

200

{
  "data": {
    "items": [
      {
        "id": "rpt_7c1f0a",
        "name": "Weekly deliverability",
        "type": "deliverability",
        "frequency": "weekly",
        "recipients": ["ops@acme.com"],
        "enabled": true,
        "timezone": "America/New_York",
        "last_sent_at": "2026-07-26T13:00:00.000Z",
        "next_send_at": "2026-08-02T13:00:00.000Z"
      }
    ],
    "total": 1,
    "nextCursor": null
  },
  "meta": {
    "request_id": "req_9f2c1a7e",
    "timestamp": "2026-08-02T12:00:12.000Z"
  }
}

The empty period is a zeroed summary, not an error. Choose a window with no traffic (or hit the degraded path during a storage blip) and the KPI endpoint still returns 200 with zeroed totals and an empty series — test your client against this shape so a quiet period never parses as a failure:

200

{
  "data": {
    "totals": {
      "total_sent": 0,
      "total_delivered": 0,
      "total_failed": 0,
      "total_read": 0,
      "delivery_rate": 0,
      "read_rate": 0,
      "avg_delivery_time_ms": 0
    },
    "time_series": [],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7f",
    "timestamp": "2026-08-02T12:00:13.000Z"
  }
}

4. Errors

Two branches cover the mistakes callers actually hit on this surface. Validation — unrecognized filter value. Query params are validated before any query runs. A failed validation returns 422 VALIDATION_ERROR with error.details.issues listing each rejected field — for example a group_by outside the allowed set (hour / day / week / month):

422

{
  "error": {
    "code": "VALIDATION_ERROR",
    "status": 422,
    "message": "Invalid query parameters",
    "details": {
      "issues": [
        {
          "field": "group_by",
          "message": "Invalid enum value. Expected 'hour' | 'day' | 'week' | 'month', received 'minute'"
        }
      ]
    }
  },
  "meta": {
    "request_id": "req_9f2c1a80",
    "timestamp": "2026-08-02T12:00:14.000Z"
  }
}

Role — reads are gated to specific roles. The analytics reads on this page require an org role of owner, admin, developer, or viewer (writes such as creating goals or scheduled reports narrow to owner, admin, and developer); a key presented without one of those roles is rejected with 403 INSUFFICIENT_PERMISSIONS and a message naming the accepted roles:

403

{
  "error": {
    "code": "INSUFFICIENT_PERMISSIONS",
    "status": 403,
    "message": "This action requires one of: owner, admin, developer, viewer"
  },
  "meta": {
    "request_id": "req_9f2c1a81",
    "timestamp": "2026-08-02T12:00:15.000Z"
  }
}

Treat both as terminal, not retriable: the 422 needs a corrected filter before you re-send, and a 403 will not succeed until the role changes.

Multi-touch marketing attribution (first/last/linear model picker)

GET /api/v1/analytics/attribution

Re-attributes the conversions recorded by the goals pipeline across channels under a caller-chosen model: first_touch (100% to the oldest touchpoint), last_touch (100% to the newest), or linear (even split across every touchpoint). Returns by_channel + by_campaign credit buckets (conversions + value_cents + share) alongside totals and the unattributed-conversions count. Query params: model (first_touch|last_touch|linear, default last_touch), goal_id (restrict to one goal’s conversions, optional), window_days (conversions within trailing N days, 1-365, default 30), lookback_days (per-conversion touchpoint lookback, 1-365, default 30). Restricted to owner/admin/developer/viewer; read-only, rate-limited, 60s cached.

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/analytics/attribution" \
  -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/analytics/attribution', {
  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/analytics/attribution", 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/analytics/attribution", 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/analytics/attribution')
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/analytics/attribution');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Compare your rates against cross-tenant benchmark cohorts

GET /api/v1/analytics/benchmarks

Compares the caller’s own delivery and open rates (by channel, country, message type) against anonymized cross-tenant cohort percentile bands (p25/p50/p75/p90) published nightly. Only cohorts that clear the k-anonymity floor (at least five distinct tenants and five hundred messages) are ever published, so no single tenant is re-identifiable. Optional filters: channel, metric, messageType, country (ISO alpha-2). Use it to see how your deliverability stacks up against comparable senders. Responds available: false before the first nightly snapshot exists. Read-only; owner/admin/developer/viewer.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/benchmarks" \
  -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/analytics/benchmarks', {
  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/analytics/benchmarks", 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/analytics/benchmarks", 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/analytics/benchmarks')
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/analytics/benchmarks');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Estimated CO2e footprint per channel

GET /api/v1/analytics/carbon

Converts the tenant’s outbound usage telemetry (message counts + voice minutes) into an estimated CO2e footprint per channel over a date window, for sustainability reporting and EMEA / public-sector procurement questionnaires. Optional filters: start_date / end_date (YYYY-MM-DD) or a trailing days number (default 30). Read-only; owner/admin/developer/viewer. For a downloadable report use GET /analytics/carbon/export.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/carbon" \
  -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/analytics/carbon', {
  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/analytics/carbon", 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/analytics/carbon", 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/analytics/carbon')
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/analytics/carbon');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Download a CSV carbon sustainability report

GET /api/v1/analytics/carbon/export

Renders the same per-channel estimated CO2e report as GET /analytics/carbon as a downloadable, self-describing CSV attachment (Content-Type text/csv), ready to attach to a procurement sustainability questionnaire. Optional filters: start_date / end_date (YYYY-MM-DD) or trailing days, plus optional format. Read-only; owner/admin/developer/viewer.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/carbon/export" \
  -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/analytics/carbon/export', {
  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/analytics/carbon/export", 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/analytics/carbon/export", 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/analytics/carbon/export')
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/analytics/carbon/export');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Aggregated contact-reason volume analytics

GET /api/v1/analytics/contact-reasons

Answers ‘why are customers contacting us’ by rolling the inbox auto-categorize signal (auto_category / auto_urgency / auto_intent stamped on conversations) up into reason, category, urgency, channel, and trend breakdowns. Query params: window, optionally channel, category, reason. Use it for CX portfolio reporting and to close the voice-vs-text parity gap (voice has the equivalent under /voice/intelligence/trends). Read-only; owner/admin/developer/viewer; 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/contact-reasons" \
  -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/analytics/contact-reasons', {
  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/analytics/contact-reasons", 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/analytics/contact-reasons", 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/analytics/contact-reasons')
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/analytics/contact-reasons');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Top conversations by telco cost-to-serve

GET /api/v1/analytics/cost-per-conversation

Ranks conversations by telco cost-to-serve: sums the per-unit prices already stamped on message rows and call legs, grouped by conversation over a caller-supplied window (no re-pricing). Required query: start / end (ISO datetime with offset, end strictly after start); optional limit (1–500, default 100). Use it for P&L on high-volume support threads. Read-only; owner/admin/developer/viewer.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/cost-per-conversation" \
  -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/analytics/cost-per-conversation', {
  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/analytics/cost-per-conversation", 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/analytics/cost-per-conversation", 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/analytics/cost-per-conversation')
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/analytics/cost-per-conversation');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Cost analytics with time-series and channel breakdown

GET /api/v1/analytics/costs

Returns cost analytics over a date window with a time-series and a per-channel breakdown, so finance and ops can track messaging spend. Query: start_date / end_date (YYYY-MM-DD), optional channel, and group_by (day|hour|week|month, default day). Read-only; any authenticated member with analytics:read.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/costs" \
  -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/analytics/costs', {
  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/analytics/costs", 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/analytics/costs", 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/analytics/costs')
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/analytics/costs');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

GET /api/v1/analytics/dashboards/widgets

Returns every composable dashboard widget (id, title, category, backing read-only source endpoint, default visualization and size, accepted params) plus the grid constraints the builder enforces (default column count, max widgets per dashboard). Drives the palette of the no-code dashboard builder; each widget fetches its own already tenant-scoped source endpoint, so this catalog is stateless. Read-only; owner/admin/developer/viewer.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/dashboards/widgets" \
  -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/analytics/dashboards/widgets', {
  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/analytics/dashboards/widgets", 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/analytics/dashboards/widgets", 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/analytics/dashboards/widgets')
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/analytics/dashboards/widgets');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Per-channel deliverability dashboard

GET /api/v1/analytics/deliverability

Returns the deliverability dashboard for one channel: sent / accepted / delivered / read / failed / bounced / complained / unsubscribed totals, the canonical delivery / read / failure rates, a time-bucketed series, and top failure reasons and countries. Required query channel (sms | whatsapp | email | rcs | telegram | viber | voice); window (7d default) and optional groupBy. Series buckets are computed in the tenant’s billing timezone, echoed as timezone. Read-only; owner/admin/developer/viewer; 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/deliverability" \
  -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/analytics/deliverability', {
  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/analytics/deliverability", 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/analytics/deliverability", 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/analytics/deliverability')
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/analytics/deliverability');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Cross-channel deliverability and sender-reputation cockpit

GET /api/v1/analytics/deliverability-health-center

One composite deliverability/reputation score (0-100 with an excellent/good/fair/poor/critical tier) rolled up from per-channel cards: SMS route quality, email domain and IP authentication, WhatsApp quality rating, RCS sender status, and voice call quality — each card independently fail-safe (a channel outage degrades that one card to an ‘error’ status instead of blanking the cockpit). Below the healthy bar a per-channel issue joins the worst-first issues remediation list with its root cause and what to do about it. Optional query days (1-90, default 7) sizes the SMS route-quality slice. Read-only; owner/admin/developer/viewer; 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/deliverability-health-center" \
  -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/analytics/deliverability-health-center', {
  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/analytics/deliverability-health-center", 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/analytics/deliverability-health-center", 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/analytics/deliverability-health-center')
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/analytics/deliverability-health-center');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Per-queue/campaign outbound delivery funnel

GET /api/v1/analytics/delivery-waterfall

Aggregates outbound SMS into a pending → sent → delivered → read / failed waterfall, grouped by the operational unit that files the ticket: an SMS queue (messaging service) or a campaign. Query params: group (queue|campaign, default queue), channel (sms), window (24h|7d|30d, default 7d), page (1-indexed), pageSize (1-100, default 25). Use it to say ‘the VIP-support queue lost 40% at the provider hop, not at the campaign hop’. Read-only; owner/admin/developer/viewer; 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/delivery-waterfall" \
  -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/analytics/delivery-waterfall', {
  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/analytics/delivery-waterfall", 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/analytics/delivery-waterfall", 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/analytics/delivery-waterfall')
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/analytics/delivery-waterfall');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Carrier rejection codes behind a funnel drop-off

GET /api/v1/analytics/funnel/{step}/drop-reasons

Drill down on one funnel step to see the top carrier rejection codes for messages that dropped there, each decorated with a human-readable name, description, and actionable guidance from the carrier error dictionary. Path step: sent (sent but never delivered) carries the reasons; delivered / read / queued are reserved and currently return an empty list. Query params: date range (start_date / end_date, else days), channel, and limit (1-20, default 5). Use it to answer ‘why did this funnel bar drop?’ inline. Read-only.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/funnel/{step}/drop-reasons" \
  -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/analytics/funnel/{step}/drop-reasons', {
  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/analytics/funnel/{step}/drop-reasons", 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/analytics/funnel/{step}/drop-reasons", 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/analytics/funnel/{step}/drop-reasons')
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/analytics/funnel/{step}/drop-reasons');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

List conversion goals

GET /api/v1/analytics/goals

Returns the tenant’s conversion goals with an all-time conversion count and revenue roll-up batched into the same page (one query — no per-goal N+1 stats call). Query params: limit (1-200, default 50) and offset. For pixel_fire goals each entry includes its signed pixel URL. Read-only.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/goals" \
  -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/analytics/goals', {
  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/analytics/goals", 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/analytics/goals", 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/analytics/goals')
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/analytics/goals');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Get one conversion goal

GET /api/v1/analytics/goals/{id}

Returns one goal by id: its configuration, attribution model, enabled flag, and — for pixel_fire goals — the signed pixel URL to embed on your site. Responds 404 when the goal does not exist. Read-only.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3" \
  -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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3', {
  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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3", 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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3", 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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3')
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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

List a goal’s conversions

GET /api/v1/analytics/goals/{id}/conversions

Returns the recorded conversions for one goal, newest first: contact id, value, attribution pointers (message / campaign / agent), conversion time, and free-form metadata. Optional query limit (1-500, default 100). Use it to inspect exactly which conversions a goal recorded instead of only the aggregated counts. Read-only.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/conversions" \
  -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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/conversions', {
  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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/conversions", 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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/conversions", 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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/conversions')
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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/conversions');
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": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Aggregate conversion stats for one goal

GET /api/v1/analytics/goals/{id}/stats

Rolls up one goal’s conversions over a trailing window: total conversion count, summed value, and the top attributed messages, campaigns, and agents the attribution model credited. Optional query window_days (1-365, default 30). Use it to see which of your sends actually drive conversions. Read-only.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/stats" \
  -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/analytics/goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/stats', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Cross-channel customer-journey path (Sankey) analytics

GET /api/v1/analytics/journey-paths

Reconstructs the ordered touchpoint sequence each customer walked across channels (chat, voice, email, WhatsApp, SMS) from the tenant’s conversations and folds it into a Sankey-ready payload: nodes (a channel occupying an ordered stage), links (stage-to-stage transitions with a journey count), stages (per-stage reached/continued/dropped/drop_off_rate), and top_paths (the most-walked full channel sequences with their share), alongside total_journeys, total_touchpoints, channels, and the echoed window/entry_channel/current_since. Query params: window (24h|7d|30d|90d, default 30d), entry_channel (keep only journeys whose first touchpoint was this channel), max_stages (2-10, default 6), min_journeys (prune links carried by fewer journeys, default 1). Restricted to owner/admin/developer/viewer; read-only, rate-limited, 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/journey-paths" \
  -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/analytics/journey-paths', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

List self-serve KPI alert rules

GET /api/v1/analytics/kpi-alert-rules

Returns every KPI alert rule defined for this organization with its runtime state (last evaluation outcome, last observed value, last fired timestamp) plus registry-derived display metadata (metric label, unit, direction, dashboard deep-link). Use this to render the rule list before creating or updating rules. Any authenticated member may read; writes are owner/admin/developer. Standard { data, meta } envelope with data.items + data.total.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/kpi-alert-rules" \
  -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/analytics/kpi-alert-rules', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

List fired KPI alert events

GET /api/v1/analytics/kpi-alert-rules/events

Returns the organization’s fired KPI alert feed, newest-cap-retained (up to 50 events): each entry carries the rule it came from, the metric value at fire time, the breached threshold (for threshold rules), the trigger mode, a rendered human message, and a dashboard deep-link. Poll this to build a notification history or alert-acknowledgement UI. Any authenticated member may read. Standard { data, meta } envelope with data.items + data.total.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/kpi-alert-rules/events" \
  -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/analytics/kpi-alert-rules/events', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Aggregate message delivery metrics with time series

GET /api/v1/analytics/messages

Returns headline totals (sent, delivered, failed, read, delivery rate, read rate, average delivery time in ms) plus a bucketed time series of the same counters. Query params: start_date / end_date (YYYY-MM-DD or ISO datetime; else days lookback, max 365), channel (sms|whatsapp|rcs|email|viber|voice|push|messenger|telegram), status, campaign_id, group_by (hour|day|week|month, default day), phone_number_id (narrow a WhatsApp breakdown to one WABA connection). Time-bucketed rows carry a tenant-local period_date for calendar alignment. Use this for the overview volume chart on the analytics dashboard.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/messages" \
  -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/analytics/messages', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Delivery metrics broken down by channel

GET /api/v1/analytics/messages/by-channel

Returns one counter bucket per messaging channel (sms, whatsapp, rcs, email, viber, voice, push, messenger, telegram): totals sent/delivered/failed/read, delivery + read rates, plus engagement counters (opened / clicked / spam) for email. Same date-range params as GET /analytics/messages; phone_number_id narrows the outbound breakdown to one WhatsApp WABA connection. Use this for the per-channel KPI cards on the analytics dashboard.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/messages/by-channel" \
  -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/analytics/messages/by-channel', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Delivery metrics broken down by destination country

GET /api/v1/analytics/messages/by-country

Returns one counter bucket per destination country with sent/delivered/failed totals and delivery rate — the geographic view of outbound messaging reach, resolved from the message’s network identity. Same date-range params as GET /analytics/messages plus an optional channel filter. Use this to surface which destinations hold the volume and where delivery lags.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/messages/by-country" \
  -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/analytics/messages/by-country', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Message failure analysis by carrier error code

GET /api/v1/analytics/messages/errors

Returns failed-message rows grouped by carrier error code for the selected window, each decorated with a human-readable name, a description, and a failure category — the “why did messages fail?” panel behind the funnel drop-off drill-down. Same date-range params as GET /analytics/messages plus an optional channel filter. Use this to triage quality issues before they become a deliverability problem.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/messages/errors" \
  -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/analytics/messages/errors', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Account-level messaging health score

GET /api/v1/analytics/messaging-health-score

Rolls every outbound message over the window into one benchmarked 0–100 composite with five subscores — Sent Rate (delivery success), Compliance (complaint + opt-out rates), Fraud (suspected-fraud block rate), Latency (median accept-to-delivered seconds), and Engagement (reply within the engagement window) — plus ranked “fix this to gain X points” recommendations. Below the minimum sample floor the response carries an insufficient tier instead of a misleading score. Query params: window (24h|7d|30d, default 7d) and optional minSampleSize override. Read-only, open to owner/admin/developer/viewer, 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/messaging-health-score" \
  -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/analytics/messaging-health-score', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Messaging insights — carrier, country, and error breakdowns

GET /api/v1/analytics/messaging-insights

Returns three histograms plus a totals roll-up for one channel over a window: per-carrier sent/delivered/failed with delivery + failure rates, per-country counters resolved from the message network identity, and per-error-code counts decorated with a human-readable name/description/category — plus a failure-category roll-up so you can see at a glance whether carrier filtering, content, or opt-outs dominate. Query params: channel (sms|whatsapp|rcs|email|viber|push|messenger|telegram), window (24h|7d|30d), and optional carrier / country / errorCode drill-downs; each dimension capped at the top 25 buckets. Owner/admin only — the carrier-side filtering signal is withheld from viewer scope. Read-only, 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/messaging-insights" \
  -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/analytics/messaging-insights', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Per-carrier (MNO) delivery truth with silent-drop inference

GET /api/v1/analytics/per-mno-delivery

Buckets outbound SMS or voice traffic by destination carrier (MCCMNC) and cross-checks the carrier-claimed delivery rate against an engagement signal (an inbound reply / a >0-second answered call within the silent-drop window) so you can spot an operator that reports delivered but never actually arrives. Use it when per-country deliverability looks clean but handsets stay quiet; the buckets array exposes silent_drop_suspected per carrier and totals aggregate the suspicion count. Restricted to owner/admin/developer/viewer; read-only, rate-limited, 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/per-mno-delivery" \
  -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/analytics/per-mno-delivery', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Per-carrier-connector (route-level) delivery breakdown

GET /api/v1/analytics/per-route-delivery

Groups outbound traffic by the carrier connector that actually carried each message — the wholesale softswitch, a per-SMPP credential, or the connector the retry pipeline fell back to (metadata._attempt_carrier when present, else the original provider) — and reports terminal/delivered/failed/undelivered counts with delivery, failure and undelivered rates per route. Use it when per-country or per-MNO deliverability degrades and you need to know which of YOUR connector paths is failing, not which destination operator. Paginated (page/pageSize); the totals.degraded counter covers ALL routes (not just the page) so a low-volume route past the row cap still surfaces. Restricted to owner/admin/developer/viewer; read-only, rate-limited, 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/per-route-delivery" \
  -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/analytics/per-route-delivery', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Per-route DLR-rate anomaly classification (drop/normal/insufficient_data)

GET /api/v1/analytics/route-dlr-anomaly

Compares the last COMPLETE day’s delivery rate on every outbound SMS route (carrier provider × destination country) against a learned 14-day baseline (z-score with a floored stddev, plus relative-ratio and absolute-points guards) and flags it drop, normal or insufficient_data. Use it to catch a carrier silently degrading one route — a blocked sender, a filtering change, an upstream wholesale outage — before customers open a ticket; the daily webhook-worker scheduler pages on the same classification. No query parameters. Restricted to owner/admin/developer/viewer; read-only, rate-limited, 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/route-dlr-anomaly" \
  -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/analytics/route-dlr-anomaly', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Per-route delivery-latency + silent-failure SLO status (ok/breach/insufficient_data)

GET /api/v1/analytics/route-latency-slo

Measures the last 6h of outbound SMS traffic per route (carrier provider × destination country) and classifies it against the delivery-latency SLO (p50/p95 of delivered_at − sent_at) and the silent-failure SLO (share of sends past the 15-min receipt grace still stuck non-terminal — the DLR that never arrived). Use it when a route keeps delivering ~100% but has slowed to minutes, or has silently stopped returning DLRs — the two blind spots the DLR-rate detector cannot see; the hourly webhook-worker sweep pages on the same thresholds. No query parameters. Restricted to owner/admin/developer/viewer; read-only, rate-limited, 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/route-latency-slo" \
  -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/analytics/route-latency-slo', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

List satisfaction goals (CSAT / NPS / CES targets + progress)

GET /api/v1/analytics/satisfaction-goals

Lists the organization’s satisfaction goals — named targets on a CX survey metric (CSAT 0–100 percent, NPS −100..100 points, CES 0–10 score) — each hydrated with its live current value and progress from the baseline captured at creation. Current values are recomputed from the tenant’s answered survey responses over the goal’s window_days lookback, so the surface never reports a stale figure. Use it to power a CX OKR widget; any authenticated member with analytics:read scope.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/satisfaction-goals" \
  -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/analytics/satisfaction-goals', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Get one satisfaction goal with live progress

GET /api/v1/analytics/satisfaction-goals/{id}

Returns a single satisfaction goal by id, hydrated with its live current value and progress (same computation as the list endpoint). Returns 404 when the id does not resolve to one of the org’s goals. Any authenticated member with analytics:read scope.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/satisfaction-goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3" \
  -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/analytics/satisfaction-goals/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

List scheduled analytics reports

GET /api/v1/analytics/scheduled-reports

Lists the organization’s scheduled reports — recurring digests (messaging_volume, deliverability, top_contacts, spend, or a custom saved query) emailed to a recipient list on a daily / weekly / monthly cadence (09:00 in the report’s IANA timezone, UTC when unset). Each row echoes last_sent_at, the display next_send_at and whether it is enabled. Keyset-paginated: pass cursor (the opaque nextCursor from the previous page) and limit (1–200, default 200). Any authenticated member with analytics:read scope.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/scheduled-reports" \
  -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/analytics/scheduled-reports', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Portfolio-level conversation sentiment analytics

GET /api/v1/analytics/sentiment

Rolls per-message sentiment (score in [-1, 1] plus positive/neutral/negative label) up across conversations into a CX portfolio view: a portfolio-wide totals roll-up, a chronological trend (hour buckets for 24h, day buckets otherwise), and breakdowns by_channel, by_agent, by_language, and by_resolution — each bucket carrying total, avg_score, the label counts, and a net_sentiment index in [-100, 100]. Query params: window (24h|7d|30d|90d, default 7d), optional channel and optional language (BCP-47 short code, e.g. en, es; unknown matches pre-enrichment messages). Use it to monitor experience week-on-week and find which channel, agent, or locale is degrading. Read-only; owner/admin/developer/viewer; 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/sentiment" \
  -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/analytics/sentiment', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

SMS click-through reporting parity panel

GET /api/v1/analytics/sms-click-through

Rolls the tracked short links in outbound SMS up to a per-campaign (or per-queue) click-through panel: sends, tracked_sends, sends_with_clicks, raw/unique/verified clicks, and both raw + verified CTR per bucket, plus aggregate totals and keyset pagination. Query params: group (campaign|queue, default campaign), window (24h|7d|30d, default 7d), page + pageSize (≤100, default 25). CTR denominators only count sends that actually carried a tracked link; click_rate is null when the bucket carried no tracked sends. Read-only; owner/admin/developer/viewer; 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/sms-click-through" \
  -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/analytics/sms-click-through', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Telegram-specific KPIs

GET /api/v1/analytics/telegram

Returns the Telegram-only KPIs the generic per-channel rollups can’t express: totals (total_outbound, bot_blocked_count/rate — the share of sends the Bot API rejected with a 403 user-blocked/chat-not-found family error — and custom_emoji_count/rate), group_vs_dm (DM vs non-DM volume plus a per-chat-type breakdown over private/group/supergroup/channel), and a daily trend keyed by period. Accepts the shared date-range params (start_date/end_date or days). Use it for the Telegram KPI cards on the analytics dashboard. Read-only; owner/admin/developer/viewer; 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/telegram" \
  -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/analytics/telegram', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Cross-channel topic & contact-reason intelligence

GET /api/v1/analytics/topic-intelligence

Answers “what are customers contacting us about, and is it rising or falling” across voice, SMS, WhatsApp, email, and web chat in one surface. Returns the window boundaries (current_since, previous_since), the current-window conversation count, and up to 50 trending topics — each with current vs prior volume, change_pct, a rising/falling/stable trend direction, the per-channel volume split, outcome rollups (avg_csat, deflection_rate, avg_aht_seconds), and up to 5 linked example threads. Query params: window (24h|7d|30d|90d, default 30d) and optional channel (voice|sms|whatsapp|email|web_chat). Read-only; owner/admin/developer/viewer; 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/topic-intelligence" \
  -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/analytics/topic-intelligence', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Aggregate usage & delivery anomaly snapshot

GET /api/v1/analytics/usage-anomalies

Classifies each usage metric family (SMS throughput, SMS telco cost, voice throughput, voice telco cost) by comparing the last complete UTC hour against a learned hourly baseline, and flags a statistically-significant spike or drop. Each metric entry carries the current value, baseline mean/stddev, signed z-score, ratio, sample size, a status (spike|drop|normal|insufficient_data), and an anomalous flag; the snapshot also echoes computed_at, bucket_start, baseline_hours, and a summary count block. Use it to catch a tenant-wide traffic stall (broken integration) or a runaway cost surge that per-route detectors are too narrow to see. Read-only; owner/admin/developer/viewer; 60s cached.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/analytics/usage-anomalies" \
  -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/analytics/usage-anomalies', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Recent activity feed

GET /api/v1/stats/activity

Most recent platform activity for the tenant — messages, agent events, and webhook deliveries — newest first. Powers the home overview’s activity widget and the Insights → Logs viewer. Use ?limit= to size the feed (default 20, max 100) and ?since_hours to bound the server-side query to the trailing N hours (max 8760) so time-range controls re-query real history instead of re-slicing a fixed top-100 feed. An always-on widget — transient database availability degrades to an empty feed (200) rather than an error.

integer

Number of recent activity items to return (default 20, max 100).

integer

Optional window bound — only return activity from the trailing N hours.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/activity" \
  -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/stats/activity', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Agent and conversation statistics

GET /api/v1/stats/agents

Aggregate statistics for AI agents and conversations: the total and active agent counts plus total and active conversation counts, as rendered by the Agents dashboard cards. Read-only; no query parameters.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/agents" \
  -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/stats/agents', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Advanced message analytics

GET /api/v1/stats/analytics

Full advanced-analytics payload for the window: daily volume, the delivery funnel, channel and geographic breakdown, peak hours (with the tenant timezone they’re computed in), cost by channel, and top recipients. Use ?days= (default 30, max 365) or an explicit start_date / end_date pair to select the window. Requires the advanced-analytics feature flag; otherwise returns 403.

integer

Trailing window in days (default 30, capped at 365). An explicit start_date / end_date pair takes precedence over days.

string

Window start date in YYYY-MM-DD local tenant time. Must be used together with end_date.

string

Window end date in YYYY-MM-DD local tenant time. Must be used together with start_date.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/analytics" \
  -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/stats/analytics', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Per-channel analytics breakdown

GET /api/v1/stats/analytics/channels

Message analytics broken down per channel (SMS, WhatsApp, email, voice) for the window: volume, delivery outcome, and spend per channel, as rendered by the analytics channel comparison view. Use ?days= (default 30, max 365) or an explicit start_date / end_date pair to select the window. Requires the advanced-analytics feature flag; otherwise returns 403.

integer

Trailing window in days (default 30, capped at 365). An explicit start_date / end_date pair takes precedence over days.

string

Window start date in YYYY-MM-DD local tenant time. Must be used together with end_date.

string

Window end date in YYYY-MM-DD local tenant time. Must be used together with start_date.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/analytics/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/stats/analytics/channels', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Delivery funnel for the window

GET /api/v1/stats/analytics/delivery

Message delivery funnel for the window: counts at each stage from sent through delivered / failed, as rendered by the analytics delivery-funnel chart. Use ?days= (default 30, max 365) or an explicit start_date / end_date pair to select the window. Requires the advanced-analytics feature flag; otherwise returns 403.

integer

Trailing window in days (default 30, capped at 365). An explicit start_date / end_date pair takes precedence over days.

string

Window start date in YYYY-MM-DD local tenant time. Must be used together with end_date.

string

Window end date in YYYY-MM-DD local tenant time. Must be used together with start_date.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/analytics/delivery" \
  -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/stats/analytics/delivery', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Analytics summary for the window

GET /api/v1/stats/analytics/summary

Consolidated analytics for the window: total messages and sent / delivered / terminal / failed counts, failed-delivery count, contact count, wallet spend for the window, and the delivery rate. Use ?days= (default 30, max 365) or an explicit start_date / end_date pair to select the window; only the counts you need are returned — cheaper than the full analytics payload. Requires the advanced-analytics feature flag; otherwise returns 403.

integer

Trailing window in days (default 30, capped at 365). An explicit start_date / end_date pair takes precedence over days.

string

Window start date in YYYY-MM-DD local tenant time. Must be used together with end_date.

string

Window end date in YYYY-MM-DD local tenant time. Must be used together with start_date.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/analytics/summary" \
  -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/stats/analytics/summary', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Daily message volume timeline

GET /api/v1/stats/analytics/volume

Daily message-volume timeline for the window — one entry per day with the sent and delivered counts — as rendered by the analytics volume chart. Use ?days= (default 30, max 365) or an explicit start_date / end_date pair to select the window. Requires the advanced-analytics feature flag; otherwise returns 403.

integer

Trailing window in days (default 30, capped at 365). An explicit start_date / end_date pair takes precedence over days.

string

Window start date in YYYY-MM-DD local tenant time. Must be used together with end_date.

string

Window end date in YYYY-MM-DD local tenant time. Must be used together with start_date.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/analytics/volume" \
  -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/stats/analytics/volume', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Per-channel operational health

GET /api/v1/stats/channel-health

Operational health for each messaging and voice channel (SMS, WhatsApp, email, voice): the delivery- or connect-quality signal and status the Messages hub and home overview render as channel tiles. An always-on dashboard widget — transient database availability degrades to an empty list (200) rather than an error.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/channel-health" \
  -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/stats/channel-health', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Contact count and growth statistics

GET /api/v1/stats/contacts

Contact-list statistics for the tenant: the total contact count, contacts created in the last 30 days, and the resulting growth rate, as rendered by the Contacts overview cards. Read-only; no query parameters.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/contacts" \
  -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/stats/contacts', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Conversation intelligence analytics

GET /api/v1/stats/conversation-intelligence

AI-powered conversation analytics for the trailing window: aggregate totals, sentiment distribution, per-channel breakdown, agent leaderboard, time-series volume, and recent conversations. Use the optional ?days= query param (default 30, max 365) to widen or narrow the trailing window. Powers the dashboard Conversation Intelligence page; a handled 200 with empty aggregates renders like a fresh tenant.

integer

Trailing window in days (default 30, capped at 365).

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/conversation-intelligence" \
  -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/stats/conversation-intelligence', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Unified home-overview dashboard

GET /api/v1/stats/dashboard

All home-overview widgets in a single request: the summary (message / agent / API-call / spend counters), per-channel health, usage timeline, and recent activity are computed in parallel and returned as one payload. Use the optional ?days= query param (default 30, max 365) for the usage-timeline window. Prefer this over polling the four widget routes individually — each leg shares cache keys with those routes. An always-on read — transient database availability degrades to a zero-valued payload (200) rather than an error.

integer

Usage-timeline window in days (default 30, capped at 365).

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/dashboard" \
  -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/stats/dashboard', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Flow execution statistics

GET /api/v1/stats/flows

Automation flow statistics: the total flow and published-flow counts plus aggregate execution totals (total, successful, and failed executions) across all flows, as rendered by the Flows overview. Read-only; no query parameters.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/flows" \
  -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/stats/flows', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

SMS gateway operational health

GET /api/v1/stats/gateway/sms

Operational health of the outbound SMS gateway over a rolling 24 hours: a status verdict (operational / degraded / down), the gateway latency, the total / delivered / failed counts for that window, the genuine terminal failure rate, and the terminal delivery rate as a first-class field — so availability and delivery performance can be rendered as separate dimensions, as the SMS workspace header card does.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/gateway/sms" \
  -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/stats/gateway/sms', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Phone number inventory statistics

GET /api/v1/stats/numbers

Phone-number inventory statistics for the tenant: the total number count, how many are active, and how many are SMS- or voice-capable. Powers the Numbers overview cards. Read-only; no query parameters.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/numbers" \
  -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/stats/numbers', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

API request logs for the tenant

GET /api/v1/stats/request-logs

Paginated API request logs for this tenant — the Developer → Request Logs viewer. Filter by method, status, path, api_key (API-key prefix), or request_id; bound the window with days or a start_date / end_date pair; page with cursor (and limit, max 100, default 50). Each entry carries timestamp, method, path, status, latency in ms, caller IP, user agent, request id, response size, and the W3C trace id for cross-system correlation.

integer

Page size (default 50, max 100).

string

Pagination cursor from a previous response’s next_cursor.

string

HTTP method filter (e.g. GET, POST).

string

HTTP status filter (e.g. 200, 4xx, 5xx).

string

Request path substring filter.

integer

Trailing window in days (capped at 365). An explicit start_date / end_date pair takes precedence.

string

Window start date in YYYY-MM-DD. Must be used together with end_date.

string

Window end date in YYYY-MM-DD. Must be used together with start_date.

string

API-key prefix filter — only requests made with keys matching this prefix.

string

Exact request correlation id — drill down to a single request.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/request-logs" \
  -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/stats/request-logs', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

SMS channel statistics

GET /api/v1/stats/sms

Aggregate SMS statistics for the tenant: total outbound messages, delivered and failed counts, the terminal delivery rate (delivered over delivered-plus-failed), and the average delivery latency in ms. Powers the SMS workspace overview cards. Read-only; no query parameters.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/sms" \
  -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/stats/sms', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Dashboard summary cards

GET /api/v1/stats/summary

The six home-overview summary cards in one read: 24-hour message volume, active agents, total contacts, 24-hour API calls, today’s spend, and the overall success rate — each card carries its value plus the change versus the previous period where one is computed. Powers the top card row on the dashboard home. An always-on read — transient database availability degrades to zeroed cards (200) rather than an error.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/summary" \
  -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/stats/summary', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Per-day usage timeline

GET /api/v1/stats/usage

Daily message-volume timeline across channels (SMS, WhatsApp, email, voice, agents) as rendered by the home-overview usage chart. Select the window with ?days= (default 30, max 365) or an explicit start_date / end_date pair — the explicit pair takes precedence. Each row carries date plus one counter key per channel. An always-on read — transient database availability degrades to an empty timeline (200) rather than an error.

integer

Trailing window in days (default 30, capped at 365). An explicit start_date / end_date pair takes precedence over days.

string

Window start date in YYYY-MM-DD. Must be used together with end_date.

string

Window end date in YYYY-MM-DD. Must be used together with start_date.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/usage" \
  -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/stats/usage', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Voice call statistics

GET /api/v1/stats/voice

Aggregate voice statistics for the tenant: total calls split into inbound and outbound counts, plus the average call duration in seconds. Powers the Voice overview cards. Read-only; no query parameters.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/voice" \
  -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/stats/voice', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

WhatsApp channel statistics

GET /api/v1/stats/whatsapp

Aggregate WhatsApp statistics for the tenant: total conversations, sent and received message counts, the terminal delivery rate, and the read rate. Powers the WhatsApp workspace overview cards. Read-only; no query parameters.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/stats/whatsapp" \
  -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/stats/whatsapp', {
  method: 'GET',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
  },
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

POST /api/v1/analytics/copilot/ask

Turns a natural-language question (body question, up to 500 chars) about messaging / voice / CDP data into a governed resolution: which dashboard-widget-catalog chart answers it and the resolved params to fetch it with. Deterministic — resolved to a pre-approved widget, never a synthesised query — so the answer always maps to an existing tenant-scoped read endpoint. Read-only (POST only because the question is a body); owner/admin/developer/viewer.

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/analytics/copilot/ask" \
  -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/analytics/copilot/ask', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

POST /api/v1/analytics/dashboards/share

Validates and normalises a draft dashboard layout, then signs it into an HMAC token delivering the layout snapshot inline, and returns the embed URL, the public JSON resolver URL, a copy-paste iframe snippet, and expiry. The unauthenticated public resolver renders the dashboard with the organization’s effective white-label branding — no Orbit session needed for recipients. Stateless; the two-week hard cap on ttl_days clamps the link lifetime. Body: the validate-layout shape, optionally wrapped as { layout, ttl_days, title }. Minting a public link to tenant analytics is gated to owner/admin.

string

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Validate and normalise a dashboard layout

POST /api/v1/analytics/dashboards/validate

Stateless dry-run for the custom dashboard builder: validates a draft layout (name + widget placements) against the widget catalog, normalises grid coordinates, instance ids, and accepted widget params, and rejects out-of-catalog widgets, grid overflow, or excess widgets with 422. Use it for inline validation before a layout is saved or rendered. No write; read-only; owner/admin/developer/viewer.

string

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Create a conversion goal

POST /api/v1/analytics/goals

Creates a conversion goal: give it a name and type (pixel_fire, webhook_hit, manual, tag_added, or custom_event), optionally a value per conversion, a lookback window (1-180 days, default 7), and an attribution model (last_touch default — also first_touch, linear, time_decay). For pixel_fire goals the response includes the signed pixel URL to embed. Owner/admin/developer role required.

string

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Create backfill

POST /api/v1/analytics/goals/{id}/backfill

string

required

—

string

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Record a conversion on a goal

POST /api/v1/analytics/goals/{id}/record

Fires a conversion on one goal. Server-to-server callers sign the contact id with HMAC-SHA256 (Authorization: HMAC <contact_id>:<signature>) — the signature is verified against the body’s contact id, otherwise the authenticated dashboard session supplies it. Optional body fields: contact_id, value_cents, metadata. Responds 401 when the HMAC check fails.

string

required

—

string

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Create a KPI alert rule

POST /api/v1/analytics/kpi-alert-rules

Defines a self-serve alert over a cross-pillar KPI metric (csat, nps, ces, llm_spend, ai_containment). Body: { name, metric, mode, comparator?, threshold?, window_days?, notify_channels?, cooldown_hours?, enabled? }. Use mode: "threshold" for an explicit cutoff (needs comparator + threshold, e.g. < 80 on CSAT) or mode: "anomaly" to let the rule train on its own z-score baseline. Capped at 50 rules per organization (422 above that); the evaluator runs on a schedule and notifies via the requested channels. Owner/admin/developer role required; audit-logged. Returns the created rule (201).

string

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Evaluate KPI alert rules on demand

POST /api/v1/analytics/kpi-alert-rules/evaluate

Runs every enabled KPI alert rule for this organization immediately instead of waiting for the scheduled evaluator tick — the “test my rule / re-check now” action behind the UI’s evaluate button. Resolves each enabled rule’s live metric value, fires notifications for breached rules that are past their cooldown, and returns the per-rule outcomes (status, current value) for the run. Owner/admin/developer role required.

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/analytics/kpi-alert-rules/evaluate" \
  -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/analytics/kpi-alert-rules/evaluate', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Create a satisfaction goal

POST /api/v1/analytics/satisfaction-goals

Creates a satisfaction goal: a named target on one survey metric. Body: name (≤160 chars), metric (csat | nps | ces), target (range-checked against the metric’s native scale — CSAT 0–100, NPS −100..100, CES 0–10), optional survey_id (UUID; when set it must point at a LIVE survey whose type matches the metric, else 422 — a mismatched pointer would silently report zero forever; omit it for the tenant-wide aggregate over all surveys of that type), optional window_days (1–365, default 30) and enabled (default true). A tenant may hold at most 50 goals (they live on the org settings blob, not a table). The metric’s current value at creation is captured as the baseline — the progress origin. Requires owner / admin / developer; returns 201 with the created goal.

string

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Create a scheduled analytics report

POST /api/v1/analytics/scheduled-reports

Schedules a recurring analytics report emailed to 1–50 recipients. Body: name (≤120 chars), type (messaging_volume | deliverability | top_contacts | spend | custom — custom runs the saved query in filters.saved_query, and filters.dataset may select a non-messaging dataset such as queue_performance), frequency (daily | weekly | monthly), recipients (array of emails or a single comma-separated string), optional filters, enabled (default true) and timezone (IANA zone the 09:00 cadence anchors to). The first send is scheduled on the next cadence tick. Requires owner/admin; returns 201 with the created report.

string

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Send a scheduled report immediately

POST /api/v1/analytics/scheduled-reports/{id}/send-now

Marks one of the organization’s scheduled reports due NOW so the report dispatcher emails it to the recipient list on its next tick, instead of waiting for the next cadence tick — the UI polls last_sent_at to show delivery progress. The report is owned by the caller’s organization; returns 200 with { id, queued: true }, 404 when the id does not resolve. Supports the Idempotency-Key header. Requires owner/admin.

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/analytics/scheduled-reports/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/send-now" \
  -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/analytics/scheduled-reports/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/send-now', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({}),
})
console.log(await res.json())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Update a goal

PATCH /api/v1/analytics/goals/{id}

Partially updates one goal — name, type, config, value, lookback, attribution model, or enabled flag; at least one field is required. The audit log records which keys changed. Responds 404 when the goal does not exist. Owner/admin/developer role required.

string

required

—

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Update a KPI alert rule

PATCH /api/v1/analytics/kpi-alert-rules/{id}

Partially updates one KPI alert rule (name, comparator, threshold, window_days, notify_channels, cooldown_hours, enabled). Any subset of fields may be sent, but a rule whose mode is “threshold” must keep a comparator and a finite threshold (422 otherwise); a bare empty body is rejected (422). Returns the updated rule DTO with registry display metadata. Owner/admin/developer role required; audit-logged.

string

required

—

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Update a satisfaction goal

PATCH /api/v1/analytics/satisfaction-goals/{id}

Patches a satisfaction goal — name, target, survey_id, window_days and enabled are all optional but at least one must be provided. metric is immutable: a goal’s metric fixes its scale and the baseline captured at creation, so changing it would silently invalidate stored progress. The new target is range-checked against the STORED metric; a (re)pointed survey_id must resolve to a live survey of the same type, exactly as on create. Returns 404 for an unknown id. Requires owner / admin / developer; returns the updated goal with live progress.

string

required

—

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Update a scheduled analytics report

PATCH /api/v1/analytics/scheduled-reports/{id}

Patches a scheduled report — every field of the create body (name, type, frequency, recipients, filters, enabled, timezone) is optional but at least one must be provided. Changing frequency re-anchors the cadence from the last send; the derived next tick can never land in the past. Requires owner/admin; returns the updated report.

string

required

—

string (enum: true|false)

cURL

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

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Delete a goal

DELETE /api/v1/analytics/goals/{id}

Removes one conversion goal by id. The audit log records the deletion; existing conversion history on the goal’s other endpoints disappears with it. Responds 404 when the goal does not exist. Owner/admin/developer role required.

string

required

—

string (enum: true|false)

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/analytics/goals/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/analytics/goals/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())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Delete a KPI alert rule

DELETE /api/v1/analytics/kpi-alert-rules/{id}

Removes one KPI alert rule by id; the evaluator stops evaluating it immediately and no further notifications fire for it. Returns { id, deleted: true } in the standard { data, meta } envelope, 404 when the id is unknown. Owner/admin/developer role required; audit-logged.

string

required

—

string (enum: true|false)

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/analytics/kpi-alert-rules/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/analytics/kpi-alert-rules/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())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Delete a satisfaction goal

DELETE /api/v1/analytics/satisfaction-goals/{id}

Deletes a satisfaction goal so it stops tracking a CX target. Returns 200 with { id, deleted: true }; 404 when the id does not resolve to one of the org’s goals. Requires owner / admin / developer.

string

required

—

string (enum: true|false)

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/analytics/satisfaction-goals/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/analytics/satisfaction-goals/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())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

Delete a scheduled analytics report

DELETE /api/v1/analytics/scheduled-reports/{id}

Deletes a scheduled report owned by the caller’s organization so it stops emailing on its cadence. Returns 200 with { id, deleted: true }; 404 when the id does not resolve to one of the org’s reports. Requires owner/admin.

string

required

—

string (enum: true|false)

cURL

curl -X DELETE "https://api.orbit.devotel.io/api/v1/analytics/scheduled-reports/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/analytics/scheduled-reports/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())

{
  "data": {
    "totals": {
      "total_sent": 17150,
      "total_delivered": 16899,
      "total_failed": 251,
      "total_read": 12042,
      "delivery_rate": 98.54,
      "read_rate": 71.26,
      "avg_delivery_time_ms": 1840
    },
    "time_series": [
      {
        "period": "2026-08-01T00:00:00.000Z",
        "period_date": "2026-08-01",
        "total_sent": 2450,
        "total_delivered": 2416,
        "total_failed": 34,
        "total_read": 1720,
        "delivery_rate": 98.61,
        "read_rate": 71.19,
        "avg_delivery_time_ms": 1795
      }
    ],
    "group_by": "day"
  },
  "meta": {
    "request_id": "req_9f2c1a7b",
    "timestamp": "2026-08-02T12:00:00.000Z"
  }
}

​Analytics API

​title: “Worked analytics queries” description: “KPI summary with filters, cursor-paged breakdown rows, prebuilt scheduled-report reads, the zeroed-period shape, and validation/role errors.”

​Worked analytics queries

​1. Pull a KPI summary

​2. Page a breakdown series

​3. Prebuilt report read (and the empty-period shape)

​4. Errors

​Multi-touch marketing attribution (first/last/linear model picker)

​Compare your rates against cross-tenant benchmark cohorts

​Estimated CO2e footprint per channel

​Download a CSV carbon sustainability report

​Aggregated contact-reason volume analytics

​Top conversations by telco cost-to-serve

​Cost analytics with time-series and channel breakdown

​List the widget catalog for custom dashboards

​Per-channel deliverability dashboard

​Cross-channel deliverability and sender-reputation cockpit

​Per-queue/campaign outbound delivery funnel

​Carrier rejection codes behind a funnel drop-off

​List conversion goals

​Get one conversion goal

​List a goal’s conversions

​Aggregate conversion stats for one goal

​Cross-channel customer-journey path (Sankey) analytics

​List self-serve KPI alert rules

​List fired KPI alert events

​Aggregate message delivery metrics with time series

​Delivery metrics broken down by channel

​Delivery metrics broken down by destination country

​Message failure analysis by carrier error code

​Account-level messaging health score

​Messaging insights — carrier, country, and error breakdowns

​Per-carrier (MNO) delivery truth with silent-drop inference

​Per-carrier-connector (route-level) delivery breakdown

​Per-route DLR-rate anomaly classification (drop/normal/insufficient_data)

​Per-route delivery-latency + silent-failure SLO status (ok/breach/insufficient_data)

​List satisfaction goals (CSAT / NPS / CES targets + progress)

​Get one satisfaction goal with live progress

​List scheduled analytics reports

​Portfolio-level conversation sentiment analytics

​SMS click-through reporting parity panel

​Telegram-specific KPIs

​Cross-channel topic & contact-reason intelligence

​Aggregate usage & delivery anomaly snapshot

​Recent activity feed

​Agent and conversation statistics

​Advanced message analytics

​Per-channel analytics breakdown

​Delivery funnel for the window

​Analytics summary for the window

​Daily message volume timeline

​Per-channel operational health

​Contact count and growth statistics

​Conversation intelligence analytics

​Unified home-overview dashboard

​Flow execution statistics

​SMS gateway operational health

​Phone number inventory statistics

​API request logs for the tenant

​SMS channel statistics

​Dashboard summary cards

​Per-day usage timeline

​Voice call statistics

​WhatsApp channel statistics

​Resolve a plain-English question to a governed widget

​Mint a signed embeddable dashboard share link

​Validate and normalise a dashboard layout

​Create a conversion goal

​Create backfill

​Record a conversion on a goal

​Create a KPI alert rule

​Evaluate KPI alert rules on demand

​Create a satisfaction goal

​Create a scheduled analytics report

​Send a scheduled report immediately

​Update a goal

​Update a KPI alert rule

​Update a satisfaction goal

​Update a scheduled analytics report

​Delete a goal

Analytics API

title: “Worked analytics queries” description: “KPI summary with filters, cursor-paged breakdown rows, prebuilt scheduled-report reads, the zeroed-period shape, and validation/role errors.”

Worked analytics queries

1. Pull a KPI summary

2. Page a breakdown series

3. Prebuilt report read (and the empty-period shape)

4. Errors

Multi-touch marketing attribution (first/last/linear model picker)

Compare your rates against cross-tenant benchmark cohorts

Estimated CO2e footprint per channel

Download a CSV carbon sustainability report

Aggregated contact-reason volume analytics

Top conversations by telco cost-to-serve

Cost analytics with time-series and channel breakdown

List the widget catalog for custom dashboards

Per-channel deliverability dashboard

Cross-channel deliverability and sender-reputation cockpit

Per-queue/campaign outbound delivery funnel

Carrier rejection codes behind a funnel drop-off

List conversion goals

Get one conversion goal

List a goal’s conversions

Aggregate conversion stats for one goal

Cross-channel customer-journey path (Sankey) analytics

List self-serve KPI alert rules

List fired KPI alert events

Aggregate message delivery metrics with time series

Delivery metrics broken down by channel

Delivery metrics broken down by destination country

Message failure analysis by carrier error code

Account-level messaging health score

Messaging insights — carrier, country, and error breakdowns

Per-carrier (MNO) delivery truth with silent-drop inference

Per-carrier-connector (route-level) delivery breakdown

Per-route DLR-rate anomaly classification (drop/normal/insufficient_data)

Per-route delivery-latency + silent-failure SLO status (ok/breach/insufficient_data)

List satisfaction goals (CSAT / NPS / CES targets + progress)

Get one satisfaction goal with live progress

List scheduled analytics reports

Portfolio-level conversation sentiment analytics

SMS click-through reporting parity panel

Telegram-specific KPIs

Cross-channel topic & contact-reason intelligence

Aggregate usage & delivery anomaly snapshot

Recent activity feed

Agent and conversation statistics

Advanced message analytics

Per-channel analytics breakdown

Delivery funnel for the window

Analytics summary for the window

Daily message volume timeline

Per-channel operational health

Contact count and growth statistics

Conversation intelligence analytics

Unified home-overview dashboard

Flow execution statistics

SMS gateway operational health

Phone number inventory statistics

API request logs for the tenant

SMS channel statistics

Dashboard summary cards

Per-day usage timeline

Voice call statistics

WhatsApp channel statistics

Resolve a plain-English question to a governed widget

Mint a signed embeddable dashboard share link

Validate and normalise a dashboard layout

Create a conversion goal

Create backfill

Record a conversion on a goal

Create a KPI alert rule

Evaluate KPI alert rules on demand

Create a satisfaction goal

Create a scheduled analytics report

Send a scheduled report immediately

Update a goal

Update a KPI alert rule

Update a satisfaction goal

Update a scheduled analytics report

Delete a goal