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

Jambonz API

Jambonz endpoints exposed by the Devotel CPaaS API Base path: /api/v1/jambonz Endpoint count: 22

What Jambonz is here for

Devotel Orbit hosts a Jambonz instance for BYO-CPaaS voice: you bring your telephony stack (your SIP trunks, extensions, and voice webhooks), and Orbit runs the media server, the SIP edge, and the REST control plane that ties them together. This page is the wire contract of that hosted Jambonz. It is distinct from the native Voice API reference, which is Orbit’s own programmable-voice surface; the two share billing, numbers, and analytics, but they expose different models. The Jambonz model assumes you already know what an application, a carrier, and a verb hook are, so this overlay walks one tenant from registration to a first call before the per-operation reference below takes over. The SDKs do not ship a typed helper for this surface, so the worked samples use raw cURL plus a six-language CodeGroup where the call is one you make yourself. Every envelope below is what arrives on the wire in the softswitch → Orbit webhooks direction or on the control plane; field names are the public contract.

Bootstrap the tenant

Register your tenant with the hosted Jambonz control plane. The response carries the tenant credentials and the JWT you present on every subsequent control-plane call; store the JWT (it is short-lived; re-register or refresh before it expires rather than caching it in code).

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/auth/register" \
  -H "X-API-Key: dv_test_sk_your_key_here" \
  -H "X-Test-Mode: true" \
  -H "Content-Type: application/json" \
  -d '{
  "organization_name": "acme-support"
}'

Node.js

const res = await fetch('https://api.orbit.devotel.io/api/v1/jambonz/auth/register', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'X-Test-Mode': 'true',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({ organization_name: 'acme-support' }),
})
console.log(await res.json())

Python

import os, requests

r = requests.post(
    "https://api.orbit.devotel.io/api/v1/jambonz/auth/register",
    headers={"X-API-Key": os.environ["ORBIT_API_KEY"], "X-Test-Mode": "true"},
    json={"organization_name": "acme-support"},
)
print(r.json())

package main

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

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/jambonz/auth/register", bytes.NewBuffer([]byte(`{"organization_name":"acme-support"}`)))
	req.Header.Set("X-API-Key", os.Getenv("ORBIT_API_KEY"))
	req.Header.Set("X-Test-Mode", "true")
	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/jambonz/auth/register')
req = Net::HTTP::Post.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['X-Test-Mode'] = 'true'
req['Content-Type'] = 'application/json'
req.body = { organization_name: 'acme-support' }.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/jambonz/auth/register');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'X-API-Key: ' . getenv('ORBIT_API_KEY'),
  'X-Test-Mode: true',
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{"organization_name":"acme-support"}
JSON);
echo curl_exec($ch);

201

{
  "account_sid": "acc_01HX8ZQJMHNMK0GTF4R0P3FQ9V",
  "jwt": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJhY2NvdW50IjoiYWNjXzAxSFgifQ.k7signed",
  "expires_at": "2026-10-16T13:00:00.000Z",
  "webhook_base_url": "https://api.orbit.devotel.io/api/v1/jambonz"
}

The webhook_base_url is the address you configure on the switch: every hook on this page lives under it. The SIP-side bootstrap happens on the same call path. When the edge forwards a REGISTER, POST /api/v1/jambonz/auth/register answers with the digest verdict the registrar needs; a softphone credential returns the A1 hash, a trunk credential returns the stored password so the SBC can verify the digest itself:

200

{
  "status": "ok",
  "a1_hash": "md5:1001:orbit.devotel.io:9d4f1c7a2b8e",
  "algorithm": "MD5",
  "expires": "2026-10-16T13:00:00.000Z"
}

A credential that has no password configured on the tenant is rejected with a fail verdict, never a silent drop:

401

{
  "status": "fail",
  "reason": "no_password_configured"
}

Provision an application

An application binds a voice webhook URL to the tenant; a carrier tells the tenant where your SIP traffic enters. Create both with the JWT from the bootstrap step, then read the account’s application list to confirm the binding before you place a call.

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/applications" \
  -H "Authorization: Bearer $JAMBONZ_JWT" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "support-line",
  "voice_url": "https://example.com/voice",
  "call_status_url": "https://example.com/call-status"
}'

201

{
  "application_sid": "app_01HX9A2B3C4D5E6F7G8H9J0K",
  "name": "support-line",
  "voice_url": "https://example.com/voice"
}

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/carriers" \
  -H "Authorization: Bearer $JAMBONZ_JWT" \
  -H "Content-Type: application/json" \
  -d '{
  "name": "pbx-trunk",
  "ips": ["203.0.113.10"],
  "register": false
}'

201

{
  "voip_carrier_sid": "carrier_01HX9K1L2M3N4P5Q6R7S8T",
  "name": "pbx-trunk"
}

cURL

curl "https://api.orbit.devotel.io/api/v1/jambonz/accounts/acc_01HX8ZQJMHNMK0GTF4R0P3FQ9V/applications" \
  -H "Authorization: Bearer $JAMBONZ_JWT"

200

[
  {
    "application_sid": "app_01HX9A2B3C4D5E6F7G8H9J0K",
    "name": "support-line",
    "voice_url": "https://example.com/voice",
    "voip_carrier_sid": "carrier_01HX9K1L2M3N4P5Q6R7S8T"
  }
]

The list entry showing your voice_url next to the carrier sid is the confirmation that inbound calls will arrive at your webhook.

Place a call

A placed call is one REST call against the tenant, then a conversation between the switch and your webhooks. The REST shape:

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/calls" \
  -H "Authorization: Bearer $JAMBONZ_JWT" \
  -H "Content-Type: application/json" \
  -d '{
  "application_sid": "app_01HX9A2B3C4D5E6F7G8H9J0K",
  "from": "+14155550100",
  "to": "+14155550134"
}'

Node.js

const res = await fetch('https://api.orbit.devotel.io/api/v1/jambonz/calls', {
  method: 'POST',
  headers: {
    Authorization: `Bearer ${process.env.JAMBONZ_JWT!}`,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    application_sid: 'app_01HX9A2B3C4D5E6F7G8H9J0K',
    from: '+14155550100',
    to: '+14155550134',
  }),
})
console.log(await res.json())

Python

import os, requests

r = requests.post(
    "https://api.orbit.devotel.io/api/v1/jambonz/calls",
    headers={"Authorization": f"Bearer {os.environ['JAMBONZ_JWT']}"},
    json={
        "application_sid": "app_01HX9A2B3C4D5E6F7G8H9J0K",
        "from": "+14155550100",
        "to": "+14155550134",
    },
)
print(r.json())

package main

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

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/jambonz/calls", bytes.NewBuffer([]byte(`{"application_sid":"app_01HX9A2B3C4D5E6F7G8H9J0K","from":"+14155550100","to":"+14155550134"}`)))
	req.Header.Set("Authorization", "Bearer "+os.Getenv("JAMBONZ_JWT"))
	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/jambonz/calls')
req = Net::HTTP::Post.new(uri)
req['Authorization'] = "Bearer #{ENV['JAMBONZ_JWT']}"
req['Content-Type'] = 'application/json'
req.body = {
  application_sid: 'app_01HX9A2B3C4D5E6F7G8H9J0K',
  from: '+14155550100',
  to: '+14155550134',
}.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/jambonz/calls');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, 'POST');
curl_setopt($ch, CURLOPT_HTTPHEADER, [
  'Authorization: Bearer ' . getenv('JAMBONZ_JWT'),
  'Content-Type: application/json',
]);
curl_setopt($ch, CURLOPT_POSTFIELDS, <<<JSON
{"application_sid":"app_01HX9A2B3C4D5E6F7G8H9J0K","from":"+14155550100","to":"+14155550134"}
JSON);
echo curl_exec($ch);

201

{
  "call_sid": "call_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
  "call_status": "queued"
}

From there Orbit posts back to the URLs on the application. Two payloads cover most of what you will parse on your side. The call-status webhook reports each lifecycle transition (ringing, answered, completed):

call-status webhook payload

{
  "call_sid": "call_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
  "call_status": "answered",
  "direction": "outbound",
  "from": "+14155550100",
  "to": "+14155550134",
  "timestamp": "2026-10-16T12:04:11.000Z"
}

The verb webhook is the other direction of the same conversation: your voice_url receives the session and answers with a Jambonz verb array the switch executes in order. This one plays a greeting and dials a phone number:

verb webhook payload

[
  {
    "verb": "say",
    "text": "Connecting you to support."
  },
  {
    "verb": "dial",
    "callerId": "+14155550100",
    "answerOnBridge": true,
    "target": [
      {
        "type": "phone",
        "number": "+14155550134",
        "trunk": "pbx-trunk"
      }
    ]
  }
]

The per-operation sections below document every hook the switch can fire while that call runs, chain by chain.

The webhook contract, chain by chain

Chain 1 — SIP trunk auth

POST /api/v1/jambonz/auth/register

Covered end to end in Bootstrap the tenant above: the control-plane register returns the JWT, and the SIP-side register answers the digest challenge with the A1 hash (or the fail verdict). The edge re-authorizes every REGISTER and INVITE this way; there is nothing long-lived to rotate on the SIP side.

200

{
  "status": "ok",
  "a1_hash": "md5:1001:orbit.devotel.io:9d4f1c7a2b8e",
  "allow": true,
  "extension": "1001"
}

POST /api/v1/jambonz/customer-trunk-auth

When your PBX INVITEs or REGISTERs through a customer-trunk carrier, this hook verifies the digest claim against the trunk’s stored credentials and records the attempt either way. A negative verdict can carry a blacklist window so the edge drops persistent unauthenticated callers:

200

{
  "status": "ok",
  "ttl": 300
}

POST /api/v1/jambonz/lookup

Fired once per inbound INVITE to resolve the route. The body is the session state, including the custom SIP headers the edge preserves:

Request

{
  "call_sid": "call_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
  "to": "+14155550100",
  "from": "+14155550134",
  "originating_sip_trunk_name": "pbx-trunk",
  "direction": "inbound",
  "sip": {
    "headers": {
      "X-Tenant-ID": "tn_01HX8ZQJMHNMK0GTF4R0P3FQ9V",
      "X-Devotel-Call-Id": "call_01HZQX4E7JQ4M2E2H2DM9XE5FJ"
    }
  }
}

200

[
  {
    "verb": "dial",
    "callerId": "+14155550100",
    "answerOnBridge": true,
    "target": [
      {
        "type": "phone",
        "number": "+14155550134",
        "trunk": "pbx-trunk"
      }
    ]
  }
]

POST /api/v1/jambonz/lookup-next

When a route resolves to more than one page of candidates, the Lookup-next hook walks the next page with the same body and the same verb-array answer:

200

[
  {
    "verb": "dial",
    "target": [
      {
        "type": "phone",
        "number": "+14155550199",
        "trunk": "pbx-trunk"
      }
    ]
  }
]

Chain 2 — inbound routing

POST /api/v1/jambonz/dial-confirm

Before the switch commits to a resolved dial target, it asks this hook to confirm. Answer with the dial as-is, rewrite it, or decline it:

200

[
  {
    "verb": "dial",
    "answerOnBridge": true,
    "target": [
      {
        "type": "phone",
        "number": "+14155550134",
        "trunk": "pbx-trunk"
      }
    ]
  }
]

POST /api/v1/jambonz/callback-answer

When a virtual-hold callback reaches the customer, the answered leg posts here and receives the same enqueue verbs a fresh inbound caller would get, re- placing the customer into their original queue:

200

[
  {
    "verb": "enqueue",
    "queueId": "queue_9f2c41",
    "maxWaitSec": 300,
    "waitHook": "https://api.orbit.devotel.io/api/v1/jambonz/queue-wait?queueId=queue_9f2c41",
    "actionHook": "https://api.orbit.devotel.io/api/v1/jambonz/queue-action?queueId=queue_9f2c41"
  }
]

POST /api/v1/jambonz/feature-code

Star-code presses (hold, transfer, record) land here; the response is the verb sequence that implements the feature:

200

[
  {
    "verb": "play",
    "url": "https://cdn.example.com/hold-music.mp3"
  }
]

POST /api/v1/jambonz/queue-wait

While a caller holds, the switch re-posts this hook and plays what you answer, typically a position and estimated-wait announcement:

200

[
  {
    "verb": "say",
    "text": "You are caller 2. Estimated wait 40 seconds."
  }
]

POST /api/v1/jambonz/queue-action

Queue-action fires when a queued caller leaves the queue for any reason. On timeout the answer is the fallback verbs; on bridged or leave it is an empty array, and re-posting an outcome is safe because both are no-ops:

200

[]

POST /api/v1/jambonz/queue-overflow

Queue-overflow fires when the queue crosses its cap; answer with the overflow route, usually a dial to a backup destination:

200

[
  {
    "verb": "dial",
    "target": [
      {
        "type": "phone",
        "number": "+14155550199",
        "trunk": "pbx-trunk"
      }
    ]
  }
]

POST /api/v1/jambonz/conference-wait-music

Conference-wait-music loops hold audio for a waiting conference participant; the music URL arrives as a query parameter:

200

[
  {
    "verb": "play",
    "url": "https://cdn.example.com/hold-music.mp3"
  }
]

POST /api/v1/jambonz/mid-queue-voicemail

Mid-queue-voicemail offers a holding caller the escape hatch to voicemail; the gather’s actionHook points at the mailbox store:

200

[
  {
    "verb": "say",
    "text": "To leave a message instead, press 1."
  },
  {
    "verb": "gather",
    "numDigits": 1,
    "actionHook": "https://api.orbit.devotel.io/api/v1/jambonz/voicemail-store?callSid=call_01HZQX4E7JQ4M2E2H2DM9XE5FJ"
  }
]

POST /api/v1/jambonz/ivr-step

Each IVR node posts its gathered digits here and receives the next node’s verbs:

200

[
  {
    "verb": "gather",
    "numDigits": 1,
    "actionHook": "https://api.orbit.devotel.io/api/v1/jambonz/ivr-step?node=menu&callSid=call_01HZQX4E7JQ4M2E2H2DM9XE5FJ"
  }
]

POST /api/v1/jambonz/ivr-record-finalize

When a recording leg ends, this hook confirms storage; an empty array ends the leg cleanly:

200

[]

POST /api/v1/jambonz/call-status

Every lifecycle transition (ringing, answered, completed, failed) posts here; the ack is deliberately empty and fail-open, so a wobble on your side is never a 5xx that drops the call:

200

{}

POST /api/v1/jambonz/dial-status

Per-leg dial outcomes post here with the same fail-open ack:

200

{}

Chain 3 — AI voice agent

POST /api/v1/jambonz/bridge-to-lk

When a browser or mobile agent takes a call through LiveKit, the parked carrier leg redirects here; the response hands the leg to the room the client already joined, matched on the X-LK-Room SIP header:

200

[
  {
    "verb": "dial",
    "sipHeaders": {
      "X-LK-Room": "room_01HZQX4E7J"
    }
  }
]

POST /api/v1/jambonz/supervisor-bridge

A monitoring supervisor lands here; listen joins muted, whisper is audible only to the agent named by coachCallSid, and barge or conference join as an audible third party:

200

[
  {
    "verb": "conference",
    "name": "conf_call_01HZQX4E7J",
    "muted": true,
    "startConferenceOnEnter": false,
    "endConferenceOnExit": false,
    "coachCallSid": "call_01HZQX4E7JQ4M2E2H2DM9XE5FJ"
  }
]

POST /api/v1/jambonz/quality-ingest

After the call, RTCP-XR metrics post here; the ack confirms acceptance:

200

{
  "accepted": true,
  "metrics": {
    "mos_score": 4.31,
    "packet_loss_pct": 0.42,
    "rtcp_xr": true
  }
}

Chain 4 — Mailbox fallback

POST /api/v1/jambonz/voicemail-pin

The PIN gather for a passcode-protected mailbox posts the digits here; a wrong PIN with attempts remaining returns a spoken re-challenge:

200

[
  {
    "verb": "say",
    "text": "That PIN was not recognized. Please try again."
  },
  {
    "verb": "gather",
    "actionHook": "https://api.orbit.devotel.io/api/v1/jambonz/voicemail-pin?username=1001&attempt=2&callSid=call_01HZQXVM77Q4M2E2H2DM9XE5FJ"
  }
]

POST /api/v1/jambonz/voicemail-store

The recording leg posts the audio reference here; the empty ack confirms storage:

200

[]

POST /api/v1/jambonz/pause-elapsed

When a paused leg resumes reporting, this hook answers what plays during the pause:

200

[
  {
    "verb": "say",
    "text": "One moment please."
  }
]

Errors worth branching on

Every hook authenticates with the jambonz-signature HMAC over the body; an unsigned or tampered request gets a 401 before any routing runs, and hook failures fail open or fail cleanly with a 4xx envelope, never a 5xx mid-call. Retry 429 and 5xx on the control plane; surface 4xx to the operator.

401

{
  "error": {
    "code": "UNAUTHORIZED",
    "message": "The webhook signature is missing or does not match.",
    "status": 401
  },
  "meta": {
    "request_id": "req_jambonz_bridge_to_lk_01",
    "timestamp": "2026-10-16T12:00:00.000Z"
  }
}

422

{
  "error": {
    "code": "VALIDATION_ERROR",
    "message": "The request failed input validation.",
    "status": 422,
    "details": {
      "field": "to",
      "value": "",
      "expected": "a non-empty dialed number or SIP URI"
    }
  },
  "meta": {
    "request_id": "req_jambonz_lookup_01",
    "timestamp": "2026-10-16T12:00:00.000Z"
  }
}

429

{
  "error": {
    "code": "RATE_LIMITED",
    "message": "Too many requests in the current window.",
    "status": 429,
    "details": {
      "retry_after": 12
    }
  },
  "meta": {
    "request_id": "req_jambonz_queue_wait_01",
    "timestamp": "2026-10-16T12:00:00.000Z"
  }
}

For the platform-wide decision table these branches plug into, see the error handling guide.

Sandbox

Sandbox vs live

Every call on this page honors X-Test-Mode: with a test-prefixed key (or the header on a session-authenticated request) the softswitch → Orbit webhooks pipeline runs without real provider delivery and without credit deduction, and responses carry meta.test_mode: true. Live keys ignore the header, so a sandbox run can never accidentally place a live call.

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/auth/register" \
  -H "X-API-Key: dv_test_sk_your_key_here" \
  -H "X-Test-Mode: true" \
  -H "Content-Type: application/json" \
  -d '{}'

Register auth

POST /api/v1/jambonz/auth/register

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)

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 POST "https://api.orbit.devotel.io/api/v1/jambonz/auth/register" \
  -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/jambonz/auth/register', {
  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/jambonz/auth/register", 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/jambonz/auth/register", 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/jambonz/auth/register')
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/jambonz/auth/register');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Bridge-to-lk jambonz

POST /api/v1/jambonz/bridge-to-lk

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/bridge-to-lk" \
  -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/jambonz/bridge-to-lk', {
  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/jambonz/bridge-to-lk", 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/jambonz/bridge-to-lk", 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/jambonz/bridge-to-lk')
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/jambonz/bridge-to-lk');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Call-status jambonz

POST /api/v1/jambonz/call-status

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/call-status" \
  -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/jambonz/call-status', {
  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/jambonz/call-status", 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/jambonz/call-status", 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/jambonz/call-status')
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/jambonz/call-status');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Callback-answer jambonz

POST /api/v1/jambonz/callback-answer

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/callback-answer" \
  -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/jambonz/callback-answer', {
  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/jambonz/callback-answer", 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/jambonz/callback-answer", 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/jambonz/callback-answer')
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/jambonz/callback-answer');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Conference-wait-music jambonz

POST /api/v1/jambonz/conference-wait-music

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/conference-wait-music" \
  -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/jambonz/conference-wait-music', {
  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/jambonz/conference-wait-music", 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/jambonz/conference-wait-music", 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/jambonz/conference-wait-music')
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/jambonz/conference-wait-music');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Customer-trunk-auth jambonz

POST /api/v1/jambonz/customer-trunk-auth

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/customer-trunk-auth" \
  -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/jambonz/customer-trunk-auth', {
  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/jambonz/customer-trunk-auth", 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/jambonz/customer-trunk-auth", 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/jambonz/customer-trunk-auth')
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/jambonz/customer-trunk-auth');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Dial-confirm jambonz

POST /api/v1/jambonz/dial-confirm

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/dial-confirm" \
  -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/jambonz/dial-confirm', {
  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/jambonz/dial-confirm", 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/jambonz/dial-confirm", 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/jambonz/dial-confirm')
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/jambonz/dial-confirm');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Dial-status jambonz

POST /api/v1/jambonz/dial-status

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/dial-status" \
  -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/jambonz/dial-status', {
  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/jambonz/dial-status", 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/jambonz/dial-status", 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/jambonz/dial-status')
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/jambonz/dial-status');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Feature-code jambonz

POST /api/v1/jambonz/feature-code

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/feature-code" \
  -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/jambonz/feature-code', {
  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/jambonz/feature-code", 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/jambonz/feature-code", 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/jambonz/feature-code')
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/jambonz/feature-code');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Ivr-record-finalize jambonz

POST /api/v1/jambonz/ivr-record-finalize

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/ivr-record-finalize" \
  -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/jambonz/ivr-record-finalize', {
  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/jambonz/ivr-record-finalize", 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/jambonz/ivr-record-finalize", 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/jambonz/ivr-record-finalize')
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/jambonz/ivr-record-finalize');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Ivr-step jambonz

POST /api/v1/jambonz/ivr-step

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/ivr-step" \
  -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/jambonz/ivr-step', {
  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/jambonz/ivr-step", 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/jambonz/ivr-step", 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/jambonz/ivr-step')
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/jambonz/ivr-step');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Lookup jambonz

POST /api/v1/jambonz/lookup

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/lookup" \
  -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/jambonz/lookup', {
  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/jambonz/lookup", 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/jambonz/lookup", 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/jambonz/lookup')
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/jambonz/lookup');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Lookup-next jambonz

POST /api/v1/jambonz/lookup-next

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/lookup-next" \
  -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/jambonz/lookup-next', {
  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/jambonz/lookup-next", 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/jambonz/lookup-next", 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/jambonz/lookup-next')
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/jambonz/lookup-next');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Mid-queue-voicemail jambonz

POST /api/v1/jambonz/mid-queue-voicemail

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/mid-queue-voicemail" \
  -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/jambonz/mid-queue-voicemail', {
  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/jambonz/mid-queue-voicemail", 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/jambonz/mid-queue-voicemail", 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/jambonz/mid-queue-voicemail')
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/jambonz/mid-queue-voicemail');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Pause-elapsed jambonz

POST /api/v1/jambonz/pause-elapsed

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/jambonz/pause-elapsed" \
  -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/jambonz/pause-elapsed', {
  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/jambonz/pause-elapsed", 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/jambonz/pause-elapsed", 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/jambonz/pause-elapsed')
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/jambonz/pause-elapsed');
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": {},
  "meta": {
    "request_id": "req_01HZQX4E7JQ4M2E2H2DM9XE5FJ",
    "timestamp": "2026-08-26T12:00:00.000Z"
  }
}

Quality-ingest jambonz

POST /api/v1/jambonz/quality-ingest

string

string (enum: true|false)

cURL

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

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

Queue-action jambonz

POST /api/v1/jambonz/queue-action

string

string (enum: true|false)

cURL

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

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

Queue-overflow jambonz

POST /api/v1/jambonz/queue-overflow

string

string (enum: true|false)

cURL

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

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

Queue-wait jambonz

POST /api/v1/jambonz/queue-wait

string

string (enum: true|false)

cURL

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

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

Supervisor-bridge jambonz

POST /api/v1/jambonz/supervisor-bridge

string

string (enum: true|false)

cURL

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

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

Voicemail-pin jambonz

POST /api/v1/jambonz/voicemail-pin

string

string (enum: true|false)

cURL

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

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

Voicemail-store jambonz

POST /api/v1/jambonz/voicemail-store

string

string (enum: true|false)

cURL

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

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

API Reference

All Endpoints

Jambonz API

Jambonz API

What Jambonz is here for

Bootstrap the tenant

Provision an application

Place a call

The webhook contract, chain by chain

Chain 1 — SIP trunk auth

Chain 2 — inbound routing

Chain 3 — AI voice agent

Chain 4 — Mailbox fallback

Errors worth branching on

Sandbox

Sandbox vs live

Register auth

Bridge-to-lk jambonz

Call-status jambonz

Callback-answer jambonz

Conference-wait-music jambonz

Customer-trunk-auth jambonz

Dial-confirm jambonz

Dial-status jambonz

Feature-code jambonz

Ivr-record-finalize jambonz

Ivr-step jambonz

Lookup jambonz

Lookup-next jambonz

Mid-queue-voicemail jambonz

Pause-elapsed jambonz

Quality-ingest jambonz

Queue-action jambonz

Queue-overflow jambonz

Queue-wait jambonz

Supervisor-bridge jambonz

Voicemail-pin jambonz

Voicemail-store jambonz

​Jambonz API

​What Jambonz is here for

​Bootstrap the tenant

​Provision an application

​Place a call

​The webhook contract, chain by chain

​Chain 1 — SIP trunk auth

​Chain 2 — inbound routing

​Chain 3 — AI voice agent

​Chain 4 — Mailbox fallback

​Errors worth branching on

​Sandbox

​Sandbox vs live

​Register auth

​Bridge-to-lk jambonz

​Call-status jambonz

​Callback-answer jambonz

​Conference-wait-music jambonz

​Customer-trunk-auth jambonz

​Dial-confirm jambonz

​Dial-status jambonz

​Feature-code jambonz

​Ivr-record-finalize jambonz

​Ivr-step jambonz

​Lookup jambonz

​Lookup-next jambonz

​Mid-queue-voicemail jambonz

​Pause-elapsed jambonz

​Quality-ingest jambonz

​Queue-action jambonz

​Queue-overflow jambonz

​Queue-wait jambonz

​Supervisor-bridge jambonz

​Voicemail-pin jambonz

​Voicemail-store jambonz

Jambonz API

What Jambonz is here for

Bootstrap the tenant

Provision an application

Place a call

The webhook contract, chain by chain

Chain 1 — SIP trunk auth

Chain 2 — inbound routing

Chain 3 — AI voice agent

Chain 4 — Mailbox fallback

Errors worth branching on

Sandbox

Sandbox vs live

Register auth

Bridge-to-lk jambonz

Call-status jambonz

Callback-answer jambonz

Conference-wait-music jambonz

Customer-trunk-auth jambonz

Dial-confirm jambonz

Dial-status jambonz

Feature-code jambonz

Ivr-record-finalize jambonz

Ivr-step jambonz

Lookup jambonz

Lookup-next jambonz

Mid-queue-voicemail jambonz

Pause-elapsed jambonz

Quality-ingest jambonz

Queue-action jambonz

Queue-overflow jambonz

Queue-wait jambonz

Supervisor-bridge jambonz

Voicemail-pin jambonz

Voicemail-store jambonz