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

RCS API

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

title: “Worked request and response samples” description: “Worked samples for RCS onboarding: register a bot, check its reach, and read template analytics. Each sample shows the request, the success envelope, and the error envelope to expect.”

Worked request and response samples

Copy a request body as written, substitute your own ids, and compare the response envelope. Errors follow Devotel Orbit’s { error, meta } envelope, shown once below under Error envelope.

Create an RCS bot

POST /api/v1/rcs/bots

Request

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/rcs/bots" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "Order status bot",
  "brand_id": "brand_2b3c4d5e6f7081a2b3c4d5"
}'

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/rcs/bots', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "name": "Order status bot",
  "brand_id": "brand_2b3c4d5e6f7081a2b3c4d5"
}),
})
console.log(await res.json())

Python

import os, requests

headers = {"X-API-Key": os.environ["ORBIT_API_KEY"]}
headers["Content-Type"] = "application/json"
r = requests.post("https://api.orbit.devotel.io/api/v1/rcs/bots", headers=headers, json={
  "name": "Order status bot",
  "brand_id": "brand_2b3c4d5e6f7081a2b3c4d5"
})
print(r.json())

package main

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

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

Ruby

require 'net/http'
require 'json'

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

PHP

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

{
  "data": {
    "id": "bot_8e7d6c5b4a3f201d5e6c7b8",
    "name": "Order status bot",
    "status": "draft"
  },
  "meta": {
    "request_id": "req_bot",
    "timestamp": "2026-08-01T12:00:00.000Z"
  }
}

Scan reach for a segment

POST /api/v1/rcs/reach-scan

Submit the contact segment you want to check. The response separates recipients who can receive RCS from those who fall back to SMS. Request

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/rcs/reach-scan" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "segment_id": "seg_7c4e2a9b1d3f50618293a4b5"
}'

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

Python

import os, requests

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

package main

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

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

Ruby

require 'net/http'
require 'json'

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

PHP

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List RCS templates for a bot

GET /api/v1/rcs/templates

string

required

The bot whose templates you list.

Request

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/templates" \
  -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/rcs/templates', {
  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/rcs/templates", 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/rcs/templates", 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/rcs/templates')
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/rcs/templates');
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": [
    {
      "name": "order_confirmation",
      "status": "approved"
    }
  ],
  "meta": {
    "request_id": "req_templates",
    "timestamp": "2026-08-01T12:02:00.000Z"
  }
}

Error envelope

422

{
  "error": {
    "code": "VALIDATION_ERROR",
    "status": 422,
    "message": "brand_id: Required"
  },
  "meta": {
    "request_id": "req_...",
    "timestamp": "2026-08-01T12:00:00.000Z"
  }
}

Get RCS daily analytics

GET /api/v1/rcs/analytics/daily

Get your RCS volume broken down by day: one row per date (YYYY-MM-DD) with sent, delivered and read counts. Pass days to set the window (1 to 90, default 30). Use it to chart send volume over time, to spot a delivery dip after a bot or template change, or to reconcile a billing period. Days inside the window with no traffic are omitted rather than returned as zeros, so pad the series client-side before plotting it.

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/rcs/analytics/daily" \
  -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/rcs/analytics/daily', {
  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/rcs/analytics/daily", 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/rcs/analytics/daily", 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/rcs/analytics/daily')
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/rcs/analytics/daily');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get RCS template analytics

GET /api/v1/rcs/analytics/templates

Compare how your RCS templates perform. Returns one row per template_name with sent, delivered, read and clicked counts plus the delivery_rate, read_rate and click_rate percentages derived from them, ordered by volume. Pass days to set the window (1 to 90, default 30). Use it to find which card or carousel earns taps before you scale a campaign onto it. Messages sent without a template are grouped under (no template), and a window with no RCS traffic returns an empty array.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/analytics/templates" \
  -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/rcs/analytics/templates', {
  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/rcs/analytics/templates", 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/rcs/analytics/templates", 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/rcs/analytics/templates')
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/rcs/analytics/templates');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List RCS bots

GET /api/v1/rcs/bots

List the RCS bots registered for your account, each with its brand, status, verification status and per-carrier launch state. Paginate with cursor plus limit (defaults to 25, capped at 200). Use it to populate a bot picker, or to poll where each bot sits in the create → verify → launch sequence. An account with no bots yet gets an empty page rather than an error.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/bots" \
  -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/rcs/bots', {
  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/rcs/bots", 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/rcs/bots", 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/rcs/bots')
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/rcs/bots');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get RCS bot

GET /api/v1/rcs/bots/{id}

Fetch one bot by its RCS platform bot id (the dotgoBotId returned in the list, not the local record id), including its brand, contact and legal details, its status and verificationStatus, the per-carrier carrierStatuses map and a templateCount of the templates registered against it. Use it to render a bot detail page or to confirm a verification or launch submission has moved the bot on. Returns 404 when no bot with that id belongs to your account.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/bots/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/rcs/bots/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/rcs/bots/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/rcs/bots/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/rcs/bots/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/rcs/bots/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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List RCS tester devices

GET /api/v1/rcs/bots/{id}/devices

List the handsets registered as testers for a bot. A tester device can exchange messages with the bot while it is still unverified or unlaunched, which is how you preview rich cards, carousels and suggested actions on real hardware. Paginate with cursor plus limit (defaults to 25, capped at 200), where the cursor is the device id or phone number to continue after. A bot with no testers gets an empty page rather than an error.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/devices" \
  -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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/devices', {
  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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/devices", 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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/devices", 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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/devices')
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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/devices');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get RCS bot quality

GET /api/v1/rcs/bots/{id}/quality

Get the health of one bot as a sender: its brand and display name, its status and verification_status, whether it is launched on at least one carrier, and the per-carrier carrier_statuses map with carriers_launched out of carriers_total. Use it to drive a sender-health card, or to check reach before a campaign — a bot launched on only some carriers cannot reach subscribers on the rest. Returns 404 when no bot with that id belongs to your account.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/quality" \
  -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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/quality', {
  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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/quality", 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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/quality", 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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/quality')
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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/quality');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List RCS templates

GET /api/v1/rcs/bots/{id}/templates

List the message templates registered for a bot, with each template’s approval status merged in from the records the platform keeps for tracking. Paginate with cursor plus limit, where the cursor is the template name to continue after. Use it to populate a template picker or to audit which templates are still waiting on approval. A sync_warning field appears next to the envelope when the background approval-status refresh could not run — the templates are still returned. A bot with no templates, or a tenant whose template storage is not provisioned yet, gets an empty page rather than an error.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates" \
  -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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates', {
  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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates", 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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates", 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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates')
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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get RCS template

GET /api/v1/rcs/bots/{id}/templates/{name}

Fetch one of a bot’s templates by name, returning the stored rich-card or carousel definition together with its current approval status. Use it to preview a template before sending, or to compare the live definition against the one you are about to publish. Returns 404 when the bot has no template with that name.

string

required

—

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates/{name}" \
  -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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates/{name}', {
  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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates/{name}", 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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates/{name}", 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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates/{name}')
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/rcs/bots/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/templates/{name}');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List RCS brands

GET /api/v1/rcs/brands

List the RCS brands registered in this tenant, newest first, with opaque cursor pagination (cursor plus limit, capped at 200 rows a page). The list projection carries brand name, website, logo, industry, country, the contact’s display name, status and rejection reason; the full KYC contact and address block is only returned by the single-brand read. Use it to render a brand picker before creating a bot. A tenant with no brands — or one whose database is still being provisioned — gets an empty page rather than an error.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/brands" \
  -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/rcs/brands', {
  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/rcs/brands", 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/rcs/brands", 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/rcs/brands')
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/rcs/brands');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get RCS brand

GET /api/v1/rcs/brands/{id}

Fetch one brand with its complete record — the identity fields plus the KYC contact and postal address the list projection omits, the current status, the directory id assigned once the brand is approved, the reviewer’s rejection reason when a submission was refused, and the submitted and approved timestamps. Use it to hydrate the brand detail or edit view. Returns 404 when the id is not a brand in this tenant.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/brands/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/rcs/brands/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/rcs/brands/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/rcs/brands/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/rcs/brands/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/rcs/brands/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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get RCS brand summary

GET /api/v1/rcs/brands/summary

Return brand counts only — total, approved and pending — instead of the full list, so a readiness banner or a prerequisite check can decide whether this tenant has a usable brand without pulling every brand’s KYC contact and address payload. pending counts every brand that is neither approved nor rejected, so a brand still in draft is included in it. This is an always-up read: a tenant with no brands, or one whose database is still being provisioned, gets zeroes rather than an error.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/brands/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/rcs/brands/summary', {
  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/rcs/brands/summary", 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/rcs/brands/summary", 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/rcs/brands/summary')
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/rcs/brands/summary');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Check RCS capability

GET /api/v1/rcs/capability/{botId}/{phone}

Check whether one recipient handset can receive RCS from a specific bot, before you spend a send on it. Returns the RBM capability verdict together with the negotiated GSMA Universal Profile version and the derived feature flags (MLS, rich links), plus fallback: "sms" when the handset is not RCS-capable — so a caller can route the message down the SMS path in the same round trip. botId is the bot’s provider id and must belong to the calling tenant; phone is the recipient in E.164 form.

string

required

—

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/rcs/capability/{botId}/%2B14155551234" \
  -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/rcs/capability/{botId}/%2B14155551234', {
  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/rcs/capability/{botId}/%2B14155551234", 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/rcs/capability/{botId}/%2B14155551234", 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/rcs/capability/{botId}/%2B14155551234')
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/rcs/capability/{botId}/%2B14155551234');
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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List RCS commerce catalog

GET /api/v1/rcs/commerce/catalog

List the commerce-catalog products available to bind into an RCS rich-card carousel. It reads the same catalog the WhatsApp surface uses, so a product only has to be connected once in Commerce Manager to be sendable on both channels. Use it to populate a product picker before calling send-catalog. An organization with no connected catalog gets an empty list rather than an error, so the UI can render its connect-your-catalog empty state.

string (enum: true|false)

cURL

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

Node.js

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

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

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

Python

import os, requests

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

package main

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

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

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

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


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

PHP

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

]);

echo curl_exec($ch);

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get RCS test account status

GET /api/v1/rcs/test-account/status

Read the organization’s RCS test-account state: whether a handset is verified and which number, how many demo sends are left today and for the lifetime of the account, whether the account is suspended, and the demo messages the try-it surface offers. Use it to hydrate the RCS test page and to decide whether to prompt for verification. An organization that has never verified a number — or one whose tenant database is still provisioning — gets the well-defined unverified state instead of an error.

string (enum: true|false)

cURL

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

Node.js

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

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

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

Python

import os, requests

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

package main

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

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

	http.DefaultClient.Do(req)
}

Ruby

require 'net/http'
require 'json'

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


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

PHP

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

]);

echo curl_exec($ch);

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Create RCS bot

POST /api/v1/rcs/bots

Register an RCS bot (the agent subscribers see in their messaging app) against one of your approved brands. Send brand_id pointing at an approved brand, a display_name, a description of 100 characters or fewer, tos_url and privacy_policy_url as HTTPS links, at least one of contact_phone or contact_email, and a non-empty carrier_mccmnc list of the 5–6-digit MCC/MNC carrier codes the agent should target; carriers reject a submission missing any of them. Optional bot_type (OTP, Transactional, Promotional or Multi-Use, case-sensitive), region, platform, and billing_category shape how the bot is routed. Create the bot first, then submit it for verification and launch. Returns 409 when the referenced brand is not approved yet, and 422 when a field is off-contract.

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

Python

import os, requests

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

package main

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

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

Ruby

require 'net/http'
require 'json'

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

PHP

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

{
  "data": {
    "id": "bot_8e7d6c5b4a3f201d5e6c7b8",
    "name": "Order status bot",
    "status": "draft"
  },
  "meta": {
    "request_id": "req_bot",
    "timestamp": "2026-08-01T12:00:00.000Z"
  }
}

Add RCS tester device

POST /api/v1/rcs/bots/{id}/devices

Register a handset as a tester for a bot so it can receive messages before the bot is verified or launched. Send { phone } in E.164 form. Add your own device here first when you are building a rich-card flow — an unlaunched bot cannot message any other number. To send the handset an on-device opt-in prompt instead of registering it directly, use the tester-invite endpoint. Returns 201 with the registration result.

string

required

—

string

string (enum: true|false)

cURL

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

{
  "data": {
    "id": "bot_8e7d6c5b4a3f201d5e6c7b8",
    "name": "Order status bot",
    "status": "draft"
  },
  "meta": {
    "request_id": "req_bot",
    "timestamp": "2026-08-01T12:00:00.000Z"
  }
}

Submit RCS bot for launch

POST /api/v1/rcs/bots/{id}/launch

Ask the carriers to put a verified bot live so it can message their subscribers. The bot has to be verified first — launching earlier returns 409 INVALID_LAUNCH_STATE. Send an optional { carrier_mccmnc } list of MCCMNC ids to stage the rollout across a subset of networks, and an optional comment (up to 2000 characters) that carriers see with the request. The bot moves to pending_launch immediately; each carrier’s decision arrives later and updates the bot’s carrier_statuses, so poll the bot or its quality endpoint rather than expecting a launched bot back from this call.

string

required

—

string

string (enum: true|false)

cURL

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Create RCS template

POST /api/v1/rcs/bots/{id}/templates

Create a message template for a bot. Send { rich_template_data } holding the rich-card or carousel definition, including the name that identifies the template on later reads, updates and sends. Any rich deep-link action in it needs a valid deepLink and fallbackUrl — a malformed one is rejected with a 422 before the template reaches the RCS platform. The template is submitted for approval and stored with a pending approval status so you can track the outcome. Returns 201 with the submission result.

string

required

—

string

string (enum: true|false)

cURL

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

{
  "data": {
    "id": "bot_8e7d6c5b4a3f201d5e6c7b8",
    "name": "Order status bot",
    "status": "draft"
  },
  "meta": {
    "request_id": "req_bot",
    "timestamp": "2026-08-01T12:00:00.000Z"
  }
}

Send RCS tester invite

POST /api/v1/rcs/bots/{id}/tester-invite

Invite a phone number to test a bot before it is launched. Send { phone } in E.164 form. The invite lands on the handset as a tester request; once it is accepted, the bot can exchange messages with that number while it is still unlaunched, which is how you preview cards and suggested actions on a real device. Returns 503 with a retryable message when the upstream RCS platform is briefly unavailable, so a failed invite is safe to retry.

string

required

—

string

string (enum: true|false)

cURL

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Submit RCS bot for verification

POST /api/v1/rcs/bots/{id}/verify

Submit a bot for carrier verification, the review every RCS agent passes before carriers let it message their subscribers. Send multipart/form-data with the conversation screenshots carriers ask for (screenImages[], up to 10), the KYC documents (kycdocs[], up to 5) and an optional brandLogoImage, each file up to 5MB, plus an optional JSON data field that overrides values otherwise filled in from the linked brand. A JSON-only body carrying just data is accepted for the same payload, but a submission without files is normally refused by the carrier. On success the bot moves to pending_verification and the submission is recorded on its history. Returns 409 when the bot and its brand do not carry enough detail to build a complete submission.

string

required

—

string

string (enum: true|false)

cURL

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Create RCS brand

POST /api/v1/rcs/brands

Register a new RCS brand in draft status. A brand carries the identity and KYC details carriers ask for before they let a bot message their subscribers — brand name, website, logo, industry vertical, a contact person with email and phone, the postal address, and optionally a tax id or legal entity name. Creating a brand does not start the review; patch it until it is complete, then submit it. Returns 201 with the stored brand, or 422 listing the fields that failed validation.

string

string (enum: true|false)

cURL

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

{
  "data": {
    "id": "bot_8e7d6c5b4a3f201d5e6c7b8",
    "name": "Order status bot",
    "status": "draft"
  },
  "meta": {
    "request_id": "req_bot",
    "timestamp": "2026-08-01T12:00:00.000Z"
  }
}

Submit RCS brand for approval

POST /api/v1/rcs/brands/{id}/submit

Send a completed brand for review. The brand moves to pending_review and is queued for the Devotel review team — carrier brand registration is a manual workflow rather than an instant approval, so wait for the status to change before you rely on the brand for a bot. Accepted from draft, from rejected once you have corrected what the reviewer called out, and from pending_review, where it is a safe re-send: if the review has already moved on, the call re-syncs your view of the brand instead of restarting it. Any other status returns 409 naming the status that blocked the submission, and an id that is not a brand in this tenant returns 404.

string

required

—

string

string (enum: true|false)

cURL

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Send RCS catalog carousel

POST /api/v1/rcs/commerce/send-catalog

Render catalog products into an RCS rich-card carousel with add-to-cart and checkout suggested actions, and send it to one recipient through the standard message pipeline (billing, delivery receipts, and rate limits all apply unchanged). Omit product_ids to send the whole catalog — the renderer caps it at the RBM carousel ceiling. At least two usable products are required; fewer returns a validation error. Use it to turn a product list into a shoppable conversation.

string

string (enum: true|false)

string

Recipient phone number in E.164 format.

string[]

Catalog product (retailer) ids to include. Omit to use the whole catalog.

string

Optional message text rendered above the carousel.

string

HTTPS URL opened by the message-level checkout suggested action.

string (enum: SMALL|MEDIUM)

Carousel card width.

string

Override label for the per-card add-to-cart suggested action.

string

Override label for the message-level checkout suggested action.

cURL

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

{}

Scan RCS reach for a segment

POST /api/v1/rcs/reach-scan

Estimate how much of a contact segment can actually receive RCS from a bot before you build the campaign. Samples up to sample_size contacts from the segment, probes each number’s RBM capability, and returns the capable share plus a recommended channel mix (rcs, mixed, or sms). Use it to decide between an RCS-only send and an SMS fallback split. Owner / admin / developer only — it reads contact phone numbers and fans out billable capability lookups. An unknown bot or segment returns 404 rather than a misleading 0% reach.

string

string (enum: true|false)

string

Provider bot id to probe reach for. Must belong to this tenant.

string

Contact segment whose members are sampled.

any

How many segment members to probe (defaults to 50, capped at the platform sample ceiling).

cURL

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Combined first RCS setup (brand + first bot)

POST /api/v1/rcs/setup

Set up RCS in ONE call for a brand-new tenant. Send the brand identity (brand name, website, logo, industry, contact person, postal address, optional tax id / legal entity) together with the FIRST bot (display name, a 100-character-or-fewer description, https Terms-of-Service and Privacy-Policy URLs, at least one of bot_contact_phone / bot_contact_email, a non-empty carrier_mccmnc list of the 5–6-digit MCC/MNC carrier codes the agent should target — the RCS provider rejects an agent without a carrier list — and optional bot_type / region / platform / billing_category). The server creates the brand, marks it submitted (observe-only — there is NO blocking platform approval step), then submits the bot to the RCS directory with the brand bundled in the same combined registration, because the RCS provider has no standalone brand-creation API and receives the brand ONLY alongside the bot. Returns 201 with { brand, bot } on success. This endpoint is for the FIRST setup only — a tenant that already has a brand reuses it with POST /rcs/bots (passing its brand_id); sending setup with an existing brand returns 422. 422 when a field fails validation; 502 with the provider’s rejection reason verbatim when the directory refuses the combined submission; 500 when the local record could not be saved after the provider accepted (try again — our team is notified).

string

string (enum: true|false)

cURL

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

{
  "data": {
    "id": "bot_8e7d6c5b4a3f201d5e6c7b8",
    "name": "Order status bot",
    "status": "draft"
  },
  "meta": {
    "request_id": "req_bot",
    "timestamp": "2026-08-01T12:00:00.000Z"
  }
}

Change RCS test account number

POST /api/v1/rcs/test-account/change-number

Clear the verified test-account number so a different handset can be verified. The current number’s tester device is removed from Devotel’s shared RCS bot and the verification state is reset, while the daily and lifetime demo-send counters are deliberately KEPT — re-verifying a new handset does not reset the quota. Call it before verifying a replacement device. Owner / admin only and capped at five calls per hour.

string

string (enum: true|false)

cURL

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Send RCS test account OTP

POST /api/v1/rcs/test-account/send-otp

Start test-account verification for a phone number: the handset’s RCS capability is checked, the number is registered as a tester device on Devotel’s shared RCS bot, and the tester invite is delivered to the device. Call it before sending any demo message, then poll verify-otp with the returned verification_id until the invite is accepted on the handset. Formatting characters are stripped, but the number must resolve to E.164; a handset with no RCS support is rejected instead of being registered. Owner / admin / developer only, limited to a few attempts per 10-minute window per organization.

string

string (enum: true|false)

string

Handset to verify, in E.164 format (spaces, dashes, dots, and parentheses are stripped first).

cURL

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Verify RCS test account OTP

POST /api/v1/rcs/test-account/verify-otp

Complete test-account verification for a pending verification_id. This is a poll, not a manual code submit: verification finishes when the tester invite is accepted on the handset, which this endpoint re-checks on every call. While the invite is still waiting to be accepted it answers 425 PENDING_ACCEPTANCE — keep polling (the dashboard polls every few seconds for up to ten minutes). A declined invite returns 422 INVITE_DECLINED, and an unknown or expired session returns 422 — in both cases start again with send-otp. code is accepted for backwards compatibility and ignored. Owner / admin / developer only, rate-limited per minute to match the polling cadence.

string

string (enum: true|false)

string

The verification_id returned by send-otp.

string

Deprecated. Accepted for older clients and ignored — acceptance happens on the handset.

cURL

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Update RCS bot

PUT /api/v1/rcs/bots

Update an existing bot’s registration details. Send the COMPLETE payload accepted by bot creation — the update replaces the stored creation data rather than merging individual fields — including the brand_id, which must still point at an approved brand. Use it to correct a display name, description, legal URLs or contact details before verification, or to widen carrier_mccmnc afterwards. Changes to a verified bot may require re-verification by the carriers. Returns 409 when the brand is not approved and 404 when the brand has no bot.

string

string (enum: true|false)

cURL

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Update RCS template

PUT /api/v1/rcs/bots/{id}/templates/{name}

Replace a template’s definition. Send the complete { rich_template_data } — the update overwrites the stored card rather than merging individual fields — and keep the same name so existing references stay valid. Rich deep-link actions are validated the same way as on create. The template returns to pending approval after the change, so publish updates before a campaign depends on them.

string

required

—

string

required

—

string

string (enum: true|false)

cURL

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

Node.js

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

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

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

{
  "data": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Update RCS brand

PATCH /api/v1/rcs/brands/{id}

Update a brand in place. Every field is optional — send only the ones you are changing. Edits are accepted only while the brand is in draft or rejected, which is what lets you correct the details a reviewer called out and resubmit; any other status returns 409 with the status that blocked the edit. Returns the updated brand, 404 when the id is not a brand in this tenant, or 422 listing the fields that failed validation.

string

required

—

string (enum: true|false)

cURL

curl -X PATCH "https://api.orbit.devotel.io/api/v1/rcs/brands/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/rcs/brands/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": {
    "segment_id": "seg_7c4e2a9b1d3f50618293a4b5",
    "reachable": 812,
    "unreachable": 21
  },
  "meta": {
    "request_id": "req_reach",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Delete RCS bot

DELETE /api/v1/rcs/bots/{id}

Remove a bot registration from your account, along with its templates and tester devices. This clears your side only — the agent stays registered with the carriers until it is decommissioned through support, so deleting and re-creating does not reset a verification. Sends made after the delete fall back to the shared test bot. Returns 204 with no body, or 404 when no bot with that id belongs to your account.

string

required

—

string (enum: true|false)

cURL

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

Response: 204 No Content

Remove RCS tester device

DELETE /api/v1/rcs/bots/{id}/devices

Unregister a tester handset from a bot. This endpoint identifies the device by number, so send { phone } in E.164 form as the request body rather than in the path. The handset stops receiving messages from an unlaunched bot straight away; a launched bot still reaches it as an ordinary subscriber. Returns 204 with no body, and 403 when the bot does not belong to your account.

string

required

—

string (enum: true|false)

cURL

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

Response: 204 No Content

Delete RCS template

DELETE /api/v1/rcs/bots/{id}/templates/{name}

Delete one of a bot’s templates by name. The template is removed from the RCS platform directory and from the local approval records, so any campaign or flow still referencing it starts failing — check those first. Returns 204 with no body, or 404 when the bot has no template with that name.

string

required

—

string

required

—

string (enum: true|false)

cURL

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

Node.js

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

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

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

Response: 204 No Content

Delete RCS brand

DELETE /api/v1/rcs/brands/{id}

Permanently delete a brand. Only a brand still in draft or rejected can be deleted — one in review, already sent to the carrier directory, approved or suspended returns 409, so a brand backing a live bot cannot disappear underneath it. Bots linked to the brand are not deleted; they are unlinked and stay in place for you to re-link or remove. Returns 204 with no body, or 404 when the id is not a brand in this tenant.

string

required

—

string (enum: true|false)

cURL

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

Response: 204 No Content

​RCS API

​title: “Worked request and response samples” description: “Worked samples for RCS onboarding: register a bot, check its reach, and read template analytics. Each sample shows the request, the success envelope, and the error envelope to expect.”

​Worked request and response samples

​Create an RCS bot

​Scan reach for a segment

​List RCS templates for a bot

​Error envelope

​Get RCS daily analytics

​Get RCS template analytics

​List RCS bots

​Get RCS bot

​List RCS tester devices

​Get RCS bot quality

​List RCS templates

​Get RCS template

​List RCS brands

​Get RCS brand

​Get RCS brand summary

​Check RCS capability

​List RCS commerce catalog

​Get RCS test account status

​Create RCS bot

​Add RCS tester device

​Submit RCS bot for launch

​Create RCS template

​Send RCS tester invite

​Submit RCS bot for verification

​Create RCS brand

​Submit RCS brand for approval

​Send RCS catalog carousel

​Scan RCS reach for a segment

​Combined first RCS setup (brand + first bot)

​Change RCS test account number

​Send RCS test account OTP

​Verify RCS test account OTP

​Update RCS bot

​Update RCS template

​Update RCS brand

​Delete RCS bot

​Remove RCS tester device

​Delete RCS template

​Delete RCS brand

RCS API

title: “Worked request and response samples” description: “Worked samples for RCS onboarding: register a bot, check its reach, and read template analytics. Each sample shows the request, the success envelope, and the error envelope to expect.”

Worked request and response samples

Create an RCS bot

Scan reach for a segment

List RCS templates for a bot

Error envelope

Get RCS daily analytics

Get RCS template analytics

List RCS bots

Get RCS bot

List RCS tester devices

Get RCS bot quality

List RCS templates

Get RCS template

List RCS brands

Get RCS brand

Get RCS brand summary

Check RCS capability

List RCS commerce catalog

Get RCS test account status

Create RCS bot

Add RCS tester device

Submit RCS bot for launch

Create RCS template

Send RCS tester invite

Submit RCS bot for verification

Create RCS brand

Submit RCS brand for approval

Send RCS catalog carousel

Scan RCS reach for a segment

Combined first RCS setup (brand + first bot)

Change RCS test account number

Send RCS test account OTP

Verify RCS test account OTP

Update RCS bot

Update RCS template

Update RCS brand

Delete RCS bot

Remove RCS tester device

Delete RCS template

Delete RCS brand