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

Webhooks API

title: “Worked request and response samples” description: “Worked samples for the most-used webhook operations: register an endpoint, read deliveries, and replay one. 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 a webhook endpoint

POST /api/v1/webhooks/

The body needs at least one subscribed event. Subscribe only the events you plan to consume — a broad ["*"] receiver is harder to debug and racy. Request

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "url": "https://receiver.example.dev/webhooks",
  "events": [
    "message.delivered",
    "message.failed"
  ],
  "description": "Project delivery notifications"
}'

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/webhooks/', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "url": "https://receiver.example.dev/webhooks",
  "events": [
    "message.delivered",
    "message.failed"
  ],
  "description": "Project delivery notifications"
}),
})
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/webhooks/", headers=headers, json={
  "url": "https://receiver.example.dev/webhooks",
  "events": [
    "message.delivered",
    "message.failed"
  ],
  "description": "Project delivery notifications"
})
print(r.json())

package main

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

func main() {
	req, _ := http.NewRequest("POST", "https://api.orbit.devotel.io/api/v1/webhooks/", bytes.NewBuffer([]byte(`{
  "url": "https://receiver.example.dev/webhooks",
  "events": [
    "message.delivered",
    "message.failed"
  ],
  "description": "Project delivery notifications"
}`)))
	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/webhooks/')
req = Net::HTTP::Post.new(uri)
req['X-API-Key'] = ENV['ORBIT_API_KEY']
req['Content-Type'] = 'application/json'
req.body = {
  "url": "https://receiver.example.dev/webhooks",
  "events": [
    "message.delivered",
    "message.failed"
  ],
  "description": "Project delivery notifications"
}.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/webhooks/');
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
{
  "url": "https://receiver.example.dev/webhooks",
  "events": [
    "message.delivered",
    "message.failed"
  ],
  "description": "Project delivery notifications"
}
JSON);
echo curl_exec($ch);

{
  "data": {
    "id": "wh_5f8a1c2d7a4b9e02c3d4e5f6",
    "url": "https://receiver.example.dev/webhooks",
    "events": ["message.delivered", "message.failed"],
    "status": "active"
  },
  "meta": {
    "request_id": "req_webhook",
    "timestamp": "2026-08-01T12:00:00.000Z"
  }
}

List outgoing deliveries for an endpoint

GET /api/v1/webhooks/deliveries

string

Restrict to one webhook endpoint id.

string

e.g. delivered, failed, pending.

Request

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/deliveries" \
  -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/webhooks/deliveries', {
  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/webhooks/deliveries", 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/webhooks/deliveries", 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/webhooks/deliveries')
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/webhooks/deliveries');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Replay a delivery

POST /api/v1/webhooks/dlq/{delivery_id}/replay

Redispatches a delivery whose previous attempt failed, without changing subscriptions.

{
  "data": {
    "id": "del_7c4e2a9b1d3f50618293a4b5",
    "status": "replayed"
  },
  "meta": {
    "request_id": "req_replay",
    "timestamp": "2026-08-01T12:02:00.000Z"
  }
}

Verify signatures on receipt

Registering the endpoint is half the work — the receiver must verify the X-Orbit-Signature header before trusting a body. A complete, copy-pasteable verification handler per SDK language (Node, Python, Go, PHP, Ruby, Java, C#) lives at Verify webhook signatures; draft-07 payload schemas come from GET /webhooks/event-schemas on this page.

Error envelope

422

{
  "error": {
    "code": "VALIDATION_ERROR",
    "status": 422,
    "message": "events: subscribe to at least one event"
  },
  "meta": {
    "request_id": "req_...",
    "timestamp": "2026-08-01T12:00:00.000Z"
  }
}

List webhook endpoints

GET /api/v1/webhooks

List all webhook endpoints for the tenant, cursor-paginated.

string

Opaque cursor for the next page (from previous response meta.pagination.cursor)

any

Number of items per page (default 25). Values above the page-size cap are silently clamped; negative, fractional, or unparseable values fall back to the default. Never 422s.

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/webhooks" \
  -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/webhooks', {
  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/webhooks", 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/webhooks", 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/webhooks')
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/webhooks');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get a webhook endpoint

GET /api/v1/webhooks/{id}

Retrieve a single webhook endpoint by its ID.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/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/webhooks/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/webhooks/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/webhooks/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/webhooks/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/webhooks/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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List webhook deliveries

GET /api/v1/webhooks/{id}/deliveries

List delivery attempts for a webhook endpoint, cursor-paginated. Filter by status, event_type, event_id, and a from_date/to_date range.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries', {
  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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries", 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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries", 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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries')
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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get a webhook delivery

GET /api/v1/webhooks/{id}/deliveries/{deliveryId}

Retrieve full detail for a single delivery attempt, including the request payload (PII redacted), response body, and timing information.

string

required

—

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}', {
  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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}", 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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}", 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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}')
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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get webhook endpoint health

GET /api/v1/webhooks/{id}/health

Per-endpoint health over the last 24 hours: success rate, p50/p95 latency, the last five errors, a week-over-week degradation delta, and a red/amber/green colour band.

string

required

—

string (enum: true|false)

cURL

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

Node.js

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

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/health', {
  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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/health", 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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/health", 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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/health')
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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/health');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get bulk replay job status

GET /api/v1/webhooks/{id}/replay-range/{jobId}

Poll the status and progress of a bulk replay job: queued | running | done | failed, plus processed/total counts and the replayed window.

string

required

—

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range/job_6e8f0a2b4c" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range/job_6e8f0a2b4c', {
  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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range/job_6e8f0a2b4c", 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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range/job_6e8f0a2b4c", 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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range/job_6e8f0a2b4c')
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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range/job_6e8f0a2b4c');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get webhook rotation status

GET /api/v1/webhooks/{id}/rotation/status

Report the in-flight rotation state for an endpoint: whether a rotation is active, the grace-window expiry, the candidate secret fingerprint, and how many recent deliveries the receiver verified with the new secret.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List dead-lettered webhook deliveries

GET /api/v1/webhooks/dlq

List deliveries that exhausted every retry tier and landed in the dead-letter queue, cursor-paginated. Filter by endpoint_id, event_type, or the derived reason_code (network_error | max_retries_exceeded).

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/dlq" \
  -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/webhooks/dlq', {
  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/webhooks/dlq", 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/webhooks/dlq", 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/webhooks/dlq')
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/webhooks/dlq');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get a dead-lettered delivery’s full detail

GET /api/v1/webhooks/dlq/{deliveryId}

Full drill-down for one dead-lettered delivery: the untruncated last_response_body, the redacted event payload, request/response headers, latency, and the derived reason_code + failure_category the list row carried. Scope is the delivery id alone (no endpoint id) so the row stays inspectable after its endpoint is deleted — endpoint_url degrades to null in that case. Ids that are not currently dead-lettered (not failed, or retries not exhausted) return 404.

string

required

—

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/dlq/{deliveryId}" \
  -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/webhooks/dlq/{deliveryId}', {
  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/webhooks/dlq/{deliveryId}", 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/webhooks/dlq/{deliveryId}", 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/webhooks/dlq/{deliveryId}')
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/webhooks/dlq/{deliveryId}');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List email

GET /api/v1/webhooks/dlr/email

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/dlr/email" \
  -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/webhooks/dlr/email', {
  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/webhooks/dlr/email", 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/webhooks/dlr/email", 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/webhooks/dlr/email')
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/webhooks/dlr/email');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List webhook egress IPs

GET /api/v1/webhooks/egress-ips

Return the static source IP allowlist Orbit sends every webhook delivery from. Add these addresses to your firewall if your endpoint only accepts inbound HTTPS from known IPs. Each entry carries the bare IPv4 address and a /32 CIDR; the response also includes flat comma-separated ip_addresses and cidrs strings for a quick firewall paste. Allowlist EVERY entry — never assume a fixed count. This is a defence-in-depth convenience: always verify the HMAC signature on X-Orbit-Signature, never the source IP alone.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/egress-ips" \
  -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/webhooks/egress-ips', {
  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/webhooks/egress-ips", 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/webhooks/egress-ips", 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/webhooks/egress-ips')
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/webhooks/egress-ips');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List webhook event schemas

GET /api/v1/webhooks/event-schemas

Return the machine-readable catalog of every event type Orbit emits. Each entry carries a Draft-07 envelope JSON Schema (with the type literal pinned) plus a realistic example payload, for OpenAPI codegen, runtime validation, or type generation without mining the docs by hand.

string (enum: true|false)

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/event-schemas" \
  -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/webhooks/event-schemas', {
  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/webhooks/event-schemas", 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/webhooks/event-schemas", 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/webhooks/event-schemas')
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/webhooks/event-schemas');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List webhook events (tenant timeline)

GET /api/v1/webhooks/events

Cross-endpoint delivery timeline for the tenant, cursor-paginated. Filter by status, event_type, endpoint_id, a free-text search over the event type, and a from_date/to_date range. Scoped to the authenticated tenant — there is no organization_id parameter.

string (enum: true|false)

cURL

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

Node.js

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

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/webhooks/events', {
  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/webhooks/events", 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/webhooks/events", 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/webhooks/events')
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/webhooks/events');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List inbound-event normalization catalog

GET /api/v1/webhooks/inbound-events

Return the universal inbound-message normalization catalog: one canonical event envelope customers subscribe to once, folded out of every supported upstream carrier (Devotel softswitch, Telnyx, DIDWW, Meta). Each entry carries a canonical_event + canonical_status pair and the per-provider raw_status vocabulary that normalizes to it, plus the shipped normalizer name. Use this to wire delivery/fail/opt-out receivers without writing per-provider parsers; pair with the @devotel/shared/webhooks/inbound-normalization SDK export (normalizeInboundEvent) for runtime validation on the receiver.

cURL

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

Node.js

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

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/webhooks/inbound-events', {
  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/webhooks/inbound-events", 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/webhooks/inbound-events", 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/webhooks/inbound-events')
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/webhooks/inbound-events');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List instagram

GET /api/v1/webhooks/inbound/instagram

cURL

curl -X GET "https://api.orbit.devotel.io/api/v1/webhooks/inbound/instagram" \
  -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/webhooks/inbound/instagram', {
  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/webhooks/inbound/instagram", 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/webhooks/inbound/instagram", 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/webhooks/inbound/instagram')
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/webhooks/inbound/instagram');
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": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List messenger

GET /api/v1/webhooks/inbound/messenger

cURL

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

{
  "data": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

List meta

GET /api/v1/webhooks/inbound/meta

cURL

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

{
  "data": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Get webhook reliability rollup

GET /api/v1/webhooks/reliability

Per-endpoint reliability rollup across the tenant: success rate, p95 latency, the oldest still-pending delivery, and the last-event timestamp over a configurable window_hours (default 24).

string (enum: true|false)

cURL

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

{
  "data": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Register a webhook endpoint

POST /api/v1/webhooks

Register a webhook endpoint to receive event notifications. URL must be HTTPS and not target a private/loopback/link-local/CGNAT host (SSRF defense). Optional secret is used to compute the X-Devotel-Signature HMAC; if omitted, Devotel auto-generates one and returns it in the response (this is the only time the secret is returned in cleartext — it is encrypted at rest after).

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)

string

required

HTTPS endpoint URL.

string[]

required

Subscribed event types (e.g. message.delivered, call.completed, verification.approved). Pass ["*"] to subscribe to every event type, including ones added later.

string

Optional shared secret. Used to verify the X-Devotel-Signature HMAC on every delivery.

boolean

Whether to start dispatching events immediately.

string

—

integer

Per-endpoint HTTP delivery timeout in seconds (1-30). The dispatcher aborts an in-flight delivery once this many seconds elapse. Defaults to 30 (the platform hard ceiling) when omitted.

object

Optional per-endpoint custom request headers (e.g. {"Authorization": "Bearer …", "X-API-Key": "…"}) sent on every delivery so you can authenticate to gateways/middleware that require header-based auth. Up to 20 headers. Orbit-managed headers (Content-Type, the X-Devotel-/X-Orbit- signature + identity headers, Idempotency-Key, User-Agent) cannot be overridden and are rejected.

object

—

object

—

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks" \
  -H "X-API-Key: dv_live_sk_your_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "url": "https://yourapp.com/webhooks/orbit",
  "events": [
    "message.delivered",
    "message.failed",
    "call.completed"
  ]
}'

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/webhooks', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!,
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
  "url": "https://yourapp.com/webhooks/orbit",
  "events": [
    "message.delivered",
    "message.failed",
    "call.completed"
  ]
}),
})
console.log(await res.json())

{
  "data": {
    "id": "msg_3f6a81c2d4e5471a9b0c2d5e",
    "url": "https://example.com",
    "events": [
      "string"
    ],
    "active": false,
    "description": null,
    "timeout_seconds": 0,
    "secret": null,
    "created_at": "1970-01-01T00:00:00.000Z",
    "updated_at": null
  },
  "meta": {
    "request_id": "req_sample",
    "timestamp": "1970-01-01T00:00:00.000Z"
  }
}

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

Replay a webhook delivery

POST /api/v1/webhooks/{id}/deliveries/{deliveryId}/replay

Re-dispatch a stored delivery’s original payload through the standard dispatch pipeline. Unlike retry (failed-only), replay works on both succeeded and failed deliveries.

string

required

—

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}/replay" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}/replay', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Retry a webhook delivery

POST /api/v1/webhooks/{id}/deliveries/{deliveryId}/retry

Re-queue a failed delivery attempt for another retry.

string

required

—

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}/retry" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/deliveries/{deliveryId}/retry', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Pause a webhook endpoint

POST /api/v1/webhooks/{id}/pause

Temporarily pause deliveries for a webhook endpoint. Set a bounded window via duration_minutes or an explicit until timestamp and deliveries auto-resume once the window passes; omit both to pause indefinitely until you call resume. Distinct from PUT /:id with active: false, which is an open-ended deactivation.

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/pause" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/pause', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Start a bulk webhook replay

POST /api/v1/webhooks/{id}/replay-range

Enqueue a bulk replay of every stored delivery in the from/to window (optionally filtered by eventTypeFilter). Returns 202 with a job_id to poll via GET /webhooks/:id/replay-range/:jobId. Returns 409 with machine-readable error code BULK_REPLAY_IN_PROGRESS when a bulk replay is already running or queued for the endpoint (at most one active bulk replay per endpoint) — wait for the in-flight job to finish before retrying.

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Preview a bulk webhook replay

POST /api/v1/webhooks/{id}/replay-range/preview

Dry-run a bulk replay: count how many stored deliveries fall in the from/to window (optionally filtered by eventTypeFilter) without enqueuing any job.

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range/preview" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/replay-range/preview', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Resume a webhook endpoint

POST /api/v1/webhooks/{id}/resume

Clear an in-flight pause window so deliveries resume immediately. Idempotent — calling it on an endpoint that is not paused returns the endpoint unchanged.

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/resume" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/resume', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Rotate a webhook signing secret

POST /api/v1/webhooks/{id}/rotate-secret

Rotate the signing secret for a webhook endpoint. The new secret is returned in cleartext exactly once — persist it immediately, since later reads only show a masked prefix. Pass ?force=true to override the 24-hour previous-secret grace window (e.g. after a confirmed leak).

string

required

—

string

string (enum: true|false)

cURL

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

Node.js

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

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

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

{
  "data": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Cancel a webhook secret rotation

POST /api/v1/webhooks/{id}/rotation/cancel

Discard the candidate secret and keep the current canonical secret in place. Idempotent.

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/cancel" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/cancel', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Complete a webhook secret rotation

POST /api/v1/webhooks/{id}/rotation/complete

Promote the candidate secret to canonical and end the dual-signing grace window. Pass force: true to skip the auto-complete eligibility check (recent deliveries verified with the new secret).

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/complete" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/complete', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Initiate a webhook secret rotation

POST /api/v1/webhooks/{id}/rotation/initiate

Mint a new candidate signing secret and open a grace window during which deliveries are dual-signed with the old and new secret. The plaintext secret is returned exactly once. Idempotent within the 24-hour dedup window (returns reused_existing_rotation: true).

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/initiate" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/rotation/initiate', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Test a webhook endpoint

POST /api/v1/webhooks/{id}/test

Send a test event to a registered webhook endpoint to verify connectivity and signature handling.

string

required

—

string

string (enum: true|false)

cURL

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

Node.js

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

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

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

{
  "data": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Fire a synthetic test event

POST /api/v1/webhooks/{id}/test-fire

Fire a synthetic event of a given type at a registered endpoint. Optionally override the sample payload or pick a variant (success | failure | minimal). Returns a stable event_id you can poll the deliveries list with for the real receiver outcome.

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/test-fire" \
  -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/webhooks/num_8fb2d1b7c00c4ec9a1d3f5e7b9c1d3/test-fire', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Clerk webhooks

POST /api/v1/webhooks/clerk

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/clerk" \
  -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/webhooks/clerk', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Create address-verification

POST /api/v1/webhooks/didww/address-verification/{token}

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/didww/address-verification/tkn_0c1d3e5f7a" \
  -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/webhooks/didww/address-verification/tkn_0c1d3e5f7a', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Requeue a dead-lettered delivery

POST /api/v1/webhooks/dlq/{deliveryId}/requeue

Move a single dead-lettered delivery back into the retry queue — resets its status to pending and clears the attempt counter so the retry scheduler picks it up again.

string

required

—

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlq/{deliveryId}/requeue" \
  -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/webhooks/dlq/{deliveryId}/requeue', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Bulk-replay dead-lettered deliveries

POST /api/v1/webhooks/dlq/bulk-replay

Requeue up to 200 dead-lettered deliveries in one request. Each id is re-checked against the dead-letter eligibility gate (status='failed' and retries exhausted); ids that are not currently dead-lettered are reported in ineligible alongside the per-row outcomes. Responds 409 when NONE of the requested ids are in the dead-letter queue. Rows locked by a concurrent bulk attempt are skipped (reason='stale').

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlq/bulk-replay" \
  -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/webhooks/dlq/bulk-replay', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Discord dlr

POST /api/v1/webhooks/dlr/discord

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/discord" \
  -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/webhooks/dlr/discord', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Dotgo dlr

POST /api/v1/webhooks/dlr/dotgo

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/dotgo" \
  -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/webhooks/dlr/dotgo', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Email dlr

POST /api/v1/webhooks/dlr/email

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/email" \
  -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/webhooks/dlr/email', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Create email

POST /api/v1/webhooks/dlr/email/{tenantId}

string

required

—

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/email/{tenantId}" \
  -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/webhooks/dlr/email/{tenantId}', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Fax dlr

POST /api/v1/webhooks/dlr/fax

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/fax" \
  -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/webhooks/dlr/fax', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Instagram dlr

POST /api/v1/webhooks/dlr/instagram

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/instagram" \
  -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/webhooks/dlr/instagram', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Jasmin dlr

POST /api/v1/webhooks/dlr/jasmin

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/jasmin" \
  -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/webhooks/dlr/jasmin', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Kakao dlr

POST /api/v1/webhooks/dlr/kakao

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/kakao" \
  -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/webhooks/dlr/kakao', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Line dlr

POST /api/v1/webhooks/dlr/line

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/line" \
  -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/webhooks/dlr/line', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Messenger dlr

POST /api/v1/webhooks/dlr/messenger

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/messenger" \
  -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/webhooks/dlr/messenger', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Sms dlr

POST /api/v1/webhooks/dlr/sms

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/sms" \
  -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/webhooks/dlr/sms', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Telegram dlr

POST /api/v1/webhooks/dlr/telegram

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/telegram" \
  -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/webhooks/dlr/telegram', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Telnyx dlr

POST /api/v1/webhooks/dlr/telnyx

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/telnyx" \
  -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/webhooks/dlr/telnyx', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Viber dlr

POST /api/v1/webhooks/dlr/viber

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/viber" \
  -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/webhooks/dlr/viber', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Wechat dlr

POST /api/v1/webhooks/dlr/wechat

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/wechat" \
  -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/webhooks/dlr/wechat', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Whatsapp dlr

POST /api/v1/webhooks/dlr/whatsapp

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/whatsapp" \
  -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/webhooks/dlr/whatsapp', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Zalo dlr

POST /api/v1/webhooks/dlr/zalo

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/dlr/zalo" \
  -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/webhooks/dlr/zalo', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Email inbound

POST /api/v1/webhooks/inbound/email

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/email" \
  -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/webhooks/inbound/email', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Create tenantId

POST /api/v1/webhooks/inbound/email/{tenantId}/{tenantToken}

string

required

—

string

required

—

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/email/{tenantId}/{tenantToken}" \
  -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/webhooks/inbound/email/{tenantId}/{tenantToken}', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Fax inbound

POST /api/v1/webhooks/inbound/fax

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/fax" \
  -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/webhooks/inbound/fax', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Instagram inbound

POST /api/v1/webhooks/inbound/instagram

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/instagram" \
  -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/webhooks/inbound/instagram', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Kakao inbound

POST /api/v1/webhooks/inbound/kakao

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/kakao" \
  -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/webhooks/inbound/kakao', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Line inbound

POST /api/v1/webhooks/inbound/line

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/line" \
  -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/webhooks/inbound/line', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Messenger inbound

POST /api/v1/webhooks/inbound/messenger

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/messenger" \
  -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/webhooks/inbound/messenger', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Rcs inbound

POST /api/v1/webhooks/inbound/rcs

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/rcs" \
  -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/webhooks/inbound/rcs', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Sms inbound

POST /api/v1/webhooks/inbound/sms

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/sms" \
  -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/webhooks/inbound/sms', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Telegram inbound

POST /api/v1/webhooks/inbound/telegram

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/telegram" \
  -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/webhooks/inbound/telegram', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Viber inbound

POST /api/v1/webhooks/inbound/viber

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/viber" \
  -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/webhooks/inbound/viber', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Wechat inbound

POST /api/v1/webhooks/inbound/wechat

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/wechat" \
  -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/webhooks/inbound/wechat', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Whatsapp inbound

POST /api/v1/webhooks/inbound/whatsapp

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/whatsapp" \
  -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/webhooks/inbound/whatsapp', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Zalo inbound

POST /api/v1/webhooks/inbound/zalo

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/inbound/zalo" \
  -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/webhooks/inbound/zalo', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Network-events webhooks

POST /api/v1/webhooks/network-events

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/network-events" \
  -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/webhooks/network-events', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Events slack

POST /api/v1/webhooks/slack/events

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/slack/events" \
  -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/webhooks/slack/events', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Tcr webhooks

POST /api/v1/webhooks/tcr

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/tcr" \
  -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/webhooks/tcr', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Telnyx-events webhooks

POST /api/v1/webhooks/telnyx-events

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/telnyx-events" \
  -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/webhooks/telnyx-events', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Number-orders telnyx

POST /api/v1/webhooks/telnyx/number-orders

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/telnyx/number-orders" \
  -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/webhooks/telnyx/number-orders', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Voice-noop telnyx

POST /api/v1/webhooks/telnyx/voice-noop

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/telnyx/voice-noop" \
  -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/webhooks/telnyx/voice-noop', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Send an ad-hoc test webhook

POST /api/v1/webhooks/test

Send a one-off test event to an arbitrary HTTPS URL without registering an endpoint. The URL is SSRF-guarded (HTTPS-only; private/loopback/link-local/CGNAT hosts rejected; DNS pinned to the validated IP). Returns the receiver’s status code, latency, and truncated response body.

string

string (enum: true|false)

cURL

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

Node.js

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

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

const res = await fetch('https://api.orbit.devotel.io/api/v1/webhooks/test', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Tfv-twilio webhooks

POST /api/v1/webhooks/tfv-twilio

string

string (enum: true|false)

cURL

curl -X POST "https://api.orbit.devotel.io/api/v1/webhooks/tfv-twilio" \
  -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/webhooks/tfv-twilio', {
  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": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Update a webhook endpoint

PUT /api/v1/webhooks/{id}

Update an existing webhook endpoint’s URL, subscribed events, active state, description, or per-endpoint delivery timeout.

string

required

—

string

string (enum: true|false)

cURL

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

{
  "data": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

Delete a webhook endpoint

DELETE /api/v1/webhooks/{id}

Delete a webhook endpoint. Stored deliveries are removed with it; returns 204 No Content on success.

string

required

—

string (enum: true|false)

cURL

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

{
  "data": [
    {
      "id": "del_7c4e2a9b1d3f50618293a4b5",
      "event": "message.delivered",
      "status": "failed",
      "response_code": 502
    }
  ],
  "meta": {
    "request_id": "req_deliveries",
    "timestamp": "2026-08-01T12:01:00.000Z"
  }
}

​Webhooks API

​title: “Worked request and response samples” description: “Worked samples for the most-used webhook operations: register an endpoint, read deliveries, and replay one. Each sample shows the request, the success envelope, and the error envelope to expect.”

​Worked request and response samples

​Create a webhook endpoint

​List outgoing deliveries for an endpoint

​Replay a delivery

​Verify signatures on receipt

​Error envelope

​List webhook endpoints

​Get a webhook endpoint

​List webhook deliveries

​Get a webhook delivery

​Get webhook endpoint health

​Get bulk replay job status

​Get webhook rotation status

​List dead-lettered webhook deliveries

​Get a dead-lettered delivery’s full detail

​List email

​List webhook egress IPs

​List webhook event schemas

​List webhook events (tenant timeline)

​List inbound-event normalization catalog

​List instagram

​List messenger

​List meta

​Get webhook reliability rollup

​Register a webhook endpoint

​Replay a webhook delivery

​Retry a webhook delivery

​Pause a webhook endpoint

​Start a bulk webhook replay

​Preview a bulk webhook replay

​Resume a webhook endpoint

​Rotate a webhook signing secret

​Cancel a webhook secret rotation

​Complete a webhook secret rotation

​Initiate a webhook secret rotation

​Test a webhook endpoint

​Fire a synthetic test event

​Clerk webhooks

​Create address-verification

​Requeue a dead-lettered delivery

​Bulk-replay dead-lettered deliveries

​Discord dlr

​Dotgo dlr

​Email dlr

​Create email

​Fax dlr

​Instagram dlr

​Jasmin dlr

​Kakao dlr

​Line dlr

​Messenger dlr

​Sms dlr

​Telegram dlr

​Telnyx dlr

​Viber dlr

​Wechat dlr

​Whatsapp dlr

​Zalo dlr

​Email inbound

​Create tenantId

​Fax inbound

​Instagram inbound

​Kakao inbound

​Line inbound

​Messenger inbound

​Rcs inbound

​Sms inbound

​Telegram inbound

​Viber inbound

​Wechat inbound

​Whatsapp inbound

​Zalo inbound

​Network-events webhooks

​Events slack

​Tcr webhooks

​Telnyx-events webhooks

​Number-orders telnyx

​Voice-noop telnyx

Webhooks API

title: “Worked request and response samples” description: “Worked samples for the most-used webhook operations: register an endpoint, read deliveries, and replay one. Each sample shows the request, the success envelope, and the error envelope to expect.”

Worked request and response samples

Create a webhook endpoint

List outgoing deliveries for an endpoint

Replay a delivery

Verify signatures on receipt

Error envelope

List webhook endpoints

Get a webhook endpoint

List webhook deliveries

Get a webhook delivery

Get webhook endpoint health

Get bulk replay job status

Get webhook rotation status

List dead-lettered webhook deliveries

Get a dead-lettered delivery’s full detail

List email

List webhook egress IPs

List webhook event schemas

List webhook events (tenant timeline)

List inbound-event normalization catalog

List instagram

List messenger

List meta

Get webhook reliability rollup

Register a webhook endpoint

Replay a webhook delivery

Retry a webhook delivery

Pause a webhook endpoint

Start a bulk webhook replay

Preview a bulk webhook replay

Resume a webhook endpoint

Rotate a webhook signing secret

Cancel a webhook secret rotation

Complete a webhook secret rotation

Initiate a webhook secret rotation

Test a webhook endpoint

Fire a synthetic test event

Clerk webhooks

Create address-verification

Requeue a dead-lettered delivery

Bulk-replay dead-lettered deliveries

Discord dlr

Dotgo dlr

Email dlr

Create email

Fax dlr

Instagram dlr

Jasmin dlr

Kakao dlr

Line dlr

Messenger dlr

Sms dlr

Telegram dlr

Telnyx dlr

Viber dlr

Wechat dlr

Whatsapp dlr

Zalo dlr

Email inbound

Create tenantId

Fax inbound

Instagram inbound

Kakao inbound

Line inbound

Messenger inbound

Rcs inbound

Sms inbound

Telegram inbound

Viber inbound

Wechat inbound

Whatsapp inbound

Zalo inbound

Network-events webhooks

Events slack

Tcr webhooks

Telnyx-events webhooks

Number-orders telnyx

Voice-noop telnyx