{
  "data": {
    "id": "msg_abc123",
    "status": "queued",
    "channel": "sms"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "msg_wa_abc123",
    "status": "queued",
    "channel": "whatsapp"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "msg_em_abc123",
    "status": "queued",
    "channel": "email"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "call_abc123",
    "status": "queued",
    "channel": "voice"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "msg_abc123",
    "status": "queued",
    "channel": "sms"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "msg_wa_abc123",
    "status": "queued",
    "channel": "whatsapp"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "msg_em_abc123",
    "status": "queued",
    "channel": "email"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "call_abc123",
    "status": "queued",
    "channel": "voice"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

Quickstart

Step 1: Create an Account

Sign up at orbit.devotel.io/signup. The dashboard will route you to your locale-preferred URL automatically. No credit card required — verifying your email is all it takes to unlock the sandbox in the next step.

Step 2: Get a Sandbox API Key

Navigate to Settings > API Keys, create a new key, and set its mode to Test. Sandbox keys are prefixed dv_test_sk_, work immediately with no KYC or approval step, and cost $0 — every sandbox send is simulated in-house and never reaches a real carrier or touches Stripe. Keep the key server-side only. (Live keys are prefixed dv_live_sk_ and bill real traffic — see Step 5: Go Live once you’re ready for production numbers.)

Step 3: Send Your First Message (Sandbox)

The same /messages/<channel> endpoint shape works across SMS, WhatsApp, Email, RCS, Viber, and the other messaging channels — pick the channel you’re integrating first. Voice is separate: place calls with POST /voice/calls (see the Voice example below). Use your dv_test_sk_ key from Step 2 as $ORBIT_API_KEY below — the send is free and instant, with no live traffic risk. Each send below is shown in six languages — curl plus Node.js, Python, Go, Ruby, and PHP — so pick your language’s tab. The core SDKs type the common send shapes; payloads outside that typed scope (for example a WhatsApp template with components) go through each SDK’s low-level escape hatch — see SDK scope by language.

SMS

curl -X POST https://api.orbit.devotel.io/api/v1/messages/sms \
  -H "X-API-Key: $ORBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+14155552671",
    "from": "+14155551234",
    "body": "Hello from Orbit!"
  }'

import { Devotel } from '@devotel-orbit/node';

const orbit = new Devotel({ apiKey: process.env.ORBIT_API_KEY });

const message = await orbit.messages.sendSms({
  to: '+14155552671',
  from: '+14155551234',
  body: 'Hello from Orbit!',
});

console.log(message.data.id);      // msg_abc123
console.log(message.data.status);  // 'queued'

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

message = client.messages.send_sms(
    to="+14155552671",
    body="Hello from Orbit!",
)

print(message["data"]["id"])       # msg_abc123
print(message["data"]["status"])   # 'queued'

// The typed SendSMS helper covers the plain-text shape fully.
message, err := client.Messages().SendSMS(context.Background(), orbit.SendSMSInput{
    To:   "+14155552671",
    From: "+14155551234",
    Body: "Hello from Orbit!",
})
if err != nil {
    panic(err)
}

fmt.Println(message.Data.ID)      // msg_abc123
fmt.Println(message.Data.Status)  // "queued"

require "orbit_sdk"

client = OrbitSdk::Client.from_env  # reads ORBIT_API_KEY

message = client.messages.send_sms(
  to: "+14155552671",
  body: "Hello from Orbit!",
)

puts message.dig("data", "id")      # msg_abc123
puts message.dig("data", "status")  # "queued"

<?php

use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();  // reads ORBIT_API_KEY

$message = $client->messages->sendSms(
    to: '+14155552671',
    body: 'Hello from Orbit!',
);

echo $message['data']['id'] . "\n";      // msg_abc123
echo $message['data']['status'] . "\n";  // 'queued'

curl -X POST https://api.orbit.devotel.io/api/v1/messages/whatsapp \
  -H "X-API-Key: $ORBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+14155552671",
    "type": "template",
    "template": {
      "name": "hello_world",
      "language": { "code": "en" }
    }
  }'

import { Devotel } from '@devotel-orbit/node';

const orbit = new Devotel({ apiKey: process.env.ORBIT_API_KEY });

const message = await orbit.messages.sendWhatsApp({
  to: '+14155552671',
  type: 'template',
  template: {
    name: 'hello_world',
    language: { code: 'en' },
  },
});

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

# The typed send_whatsapp helper covers text payloads only — a template
# send goes through the client.request escape hatch (raw JSON returned).
message = client.request(
    "POST",
    "/messages/whatsapp",
    json_body={
        "to": "+14155552671",
        "type": "template",
        "template": {
            "name": "hello_world",
            "language": {"code": "en"},
        },
    },
)

print(message["data"]["id"])       # msg_wa_abc123
print(message["data"]["status"])   # 'queued'

// The typed SendWhatsApp helper covers text payloads only — a template
// send goes through the client.Request escape hatch (raw JSON out).
var message map[string]any
err := client.Request(
    context.Background(),
    "POST",
    "/messages/whatsapp",
    nil,
    map[string]any{
        "to":   "+14155552671",
        "type": "template",
        "template": map[string]any{
            "name":     "hello_world",
            "language": map[string]any{"code": "en"},
        },
    },
    &message,
    "",
)
if err != nil {
    panic(err)
}

fmt.Println(message["data"].(map[string]any)["id"])      // msg_wa_abc123
fmt.Println(message["data"].(map[string]any)["status"])  // "queued"

require "orbit_sdk"

client = OrbitSdk::Client.from_env  # reads ORBIT_API_KEY

# The typed send_whatsapp helper covers text payloads only — a template
# send goes through the client.request escape hatch (raw JSON returned).
message = client.request(
  "POST",
  "/messages/whatsapp",
  json_body: {
    "to" => "+14155552671",
    "type" => "template",
    "template" => {
      "name" => "hello_world",
      "language" => { "code" => "en" },
    },
  },
)

puts message.dig("data", "id")      # msg_wa_abc123
puts message.dig("data", "status")  # "queued"

<?php

use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();  // reads ORBIT_API_KEY

// The typed sendWhatsApp helper covers text payloads only — a template
// send goes through the request() escape hatch (raw array returned).
$message = $client->request(
    method: 'POST',
    path: '/messages/whatsapp',
    jsonBody: [
        'to' => '+14155552671',
        'type' => 'template',
        'template' => [
            'name' => 'hello_world',
            'language' => ['code' => 'en'],
        ],
    ],
);

echo $message['data']['id'] . "\n";      // msg_wa_abc123
echo $message['data']['status'] . "\n";  // 'queued'

Email

curl -X POST https://api.orbit.devotel.io/api/v1/messages/email \
  -H "X-API-Key: $ORBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "user@example.com",
    "from": "hello@yourdomain.com",
    "subject": "Welcome",
    "html": "<h1>Welcome to Acme</h1>"
  }'

import { Devotel } from '@devotel-orbit/node';

const orbit = new Devotel({ apiKey: process.env.ORBIT_API_KEY });

const message = await orbit.messages.sendEmail({
  to: 'user@example.com',
  from: 'hello@yourdomain.com',
  subject: 'Welcome',
  html: '<h1>Welcome to Acme</h1>',
});

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

message = client.messages.send_email(
    to="user@example.com",
    subject="Welcome",
    body="<h1>Welcome to Acme</h1>",
)

print(message["data"]["id"])       # msg_em_abc123
print(message["data"]["status"])   # 'queued'

// The typed SendEmail helper covers the subject + HTML body shape fully.
message, err := client.Messages().SendEmail(context.Background(), orbit.SendEmailInput{
    To:      "user@example.com",
    Subject: "Welcome",
    Body:    "<h1>Welcome to Acme</h1>",
})
if err != nil {
    panic(err)
}

fmt.Println(message.Data.ID)      // msg_em_abc123
fmt.Println(message.Data.Status)  // "queued"

require "orbit_sdk"

client = OrbitSdk::Client.from_env  # reads ORBIT_API_KEY

message = client.messages.send_email(
  to: "user@example.com",
  subject: "Welcome",
  body: "<h1>Welcome to Acme</h1>",
)

puts message.dig("data", "id")      # msg_em_abc123
puts message.dig("data", "status")  # "queued"

<?php

use Devotel\Orbit\OrbitClient;

$client = OrbitClient::fromEnv();  // reads ORBIT_API_KEY

$message = $client->messages->sendEmail(
    to: 'user@example.com',
    subject: 'Welcome',
    body: '<h1>Welcome to Acme</h1>',
);

echo $message['data']['id'] . "\n";      // msg_em_abc123
echo $message['data']['status'] . "\n";  // 'queued'

The full Node SDK reference — every channel helper, plus pagination, webhooks, and error handling — lives at Node.js SDK. Python, Go, Ruby, and PHP live inside the CodeGroups above — pick your language’s tab in the SMS, WhatsApp, Email, or Voice send. Java and C# route samples follow below; first-send tabs for them are landing on the per-language recipes guide.

Python SDK

pip install devotel-orbit-sdk
export ORBIT_API_KEY=dv_test_sk_your_key_here

The Python SDK is core-scope — SMS, WhatsApp, and email sends work today (the Python tabs in the CodeGroups above); deeper surfaces (voice recordings, conferences, IVR, dialer) are intentionally out of scope. For those, use the Node SDK or call the REST API directly via the low-level client.request(method, path, ...) escape hatch — see SDK scope by language.

# Escape hatch — POST a route the wrapper hasn't typed yet:
result = client.request(
    "POST",
    "/api/v1/voice/conferences",
    json_body={"name": "support-room-42"},
)
print(result["data"]["id"])

Go SDK

# Not yet on a public module proxy — go get the workspace module path:
#   go get github.com/devotel/orbit-go
export ORBIT_API_KEY=dv_test_sk_your_key_here

The Go SDK is core-scope and unpublished — client.Messages() + client.Voice() work today (the Go tabs above use them); voice conferences/IVR/dialer/recordings are out of scope. For those, use the Node SDK or the low-level client.Request(ctx, method, path, ...) escape hatch — see SDK scope by language.

// Escape hatch — out-of-scope surfaces call Request directly:
var conf struct {
	Data struct {
		ID string `json:"id"`
	} `json:"data"`
}
err = client.Request(
	ctx,
	"POST",
	"/voice/conferences",
	nil,
	map[string]interface{}{"name": "support-room-42"},
	&conf,
	"",
)

Ruby SDK

# Not yet on RubyGems — add the workspace path to your Gemfile:
#   gem "orbit_sdk", path: "packages/sdk-ruby"
export ORBIT_API_KEY=dv_test_sk_your_key_here

The Ruby SDK is core-scope and unpublished — client.messages + client.voice sends work today (the Ruby tabs above use them); recordings/transcripts/conferences/IVR/dialer are out of scope. For those, use the Node SDK or the low-level client.request(method, path, **opts) escape hatch — see SDK scope by language.

# Escape hatch — out-of-scope surfaces call request directly:
conf = client.request(
  "POST",
  "/voice/conferences",
  json_body: { "name" => "support-room-42" },
)
puts conf.dig("data", "id")

PHP SDK

# Not yet on Packagist — vendor the SDK from the monorepo or call the
# REST API directly. Setup lives on the PHP SDK page:
#   https://orbit.devotel.io/sdks/php
export ORBIT_API_KEY=dv_test_sk_your_key_here

The PHP SDK is core-scope and unpublished — $client->messages + $client->voice sends work today (the PHP tabs above use them); conferences, IVR, dialer, SIP trunks, and recordings are out of scope. For those, use the Node SDK or the low-level OrbitClient::request(method: ..., path: ..., ...) escape hatch — see SDK scope by language.

// Escape hatch — out-of-scope surfaces call request() directly:
$conf = $client->request(
    'POST',
    '/voice/conferences',
    null,
    ['name' => 'support-room-42'],
);
printf("conf: %s\n", $conf['data']['id'] ?? '?');

Java SDK

# Not yet on Maven Central — build + depend on the workspace module:
#   mvn -f packages/sdk-java/pom.xml install
export ORBIT_API_KEY=dv_test_sk_your_key_here

import io.devotel.orbit.OrbitClient;
import io.devotel.orbit.errors.OrbitError;

import java.util.Map;

OrbitClient client = OrbitClient.fromEnv();
try {
    Map<String, Object> result = client.messages.sendSms(
        "+14155552671",
        "Hello from Orbit!"
    );
    System.out.println("queued: " + result.get("data"));
} catch (OrbitError e) {
    System.err.println("send failed: " + e.getCode() + " — " + e.getMessage());
}

The Java SDK is core-scope and unpublished — client.messages + client.voice sends work today; recordings/transcripts/conferences/ IVR/dialer and WhatsApp template components are out of scope. For those, use the Node SDK or the low-level client.request(method, path, ...) escape hatch — see SDK scope by language.

// Escape hatch — out-of-scope surfaces call request() directly:
Map<String, Object> conf = client.request(
    "POST",
    "/voice/conferences",
    null,
    Map.of("name", "support-room-42"),
    null
);

C# SDK

# Not yet on NuGet — add the workspace project reference:
#   dotnet add reference packages/sdk-csharp
export ORBIT_API_KEY=dv_test_sk_your_key_here

// xmlns/pep: the .NET client ships as Orbit.Sdk in the monorepo.
using Orbit.Sdk;
using Orbit.Sdk.Errors;

try
{
    var client = OrbitClient.FromEnv();
    var result = await client.Messages.SendSmsAsync(
        "+14155552671",
        "Hello from Orbit!"
    );
    if (result.TryGetProperty("data", out var data) &&
        data.TryGetProperty("id", out var id))
        Console.WriteLine($"queued: {id.GetString()}");
}
catch (OrbitError e)
{
    Console.Error.WriteLine($"send failed: {e.Code} — {e.Message}");
}

The .NET SDK is core-scope and unpublished — client.Messages + client.Voice sends work today; recordings/transcripts/conferences/ IVR/dialer are out of scope. For those, use the Node SDK or the low-level client.RequestAsync(method, path, ...) escape hatch — see SDK scope by language.

// Escape hatch — out-of-scope surfaces call RequestAsync directly:
var conf = await client.RequestAsync(
    "POST",
    "/voice/conferences",
    jsonBody: new Dictionary<string, object?>
    {
        ["name"] = "support-room-42"
    }
);

Voice

curl -X POST https://api.orbit.devotel.io/api/v1/voice/calls \
  -H "X-API-Key: $ORBIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+14155552671",
    "from": "+14155551234",
    "agent_id": "agt_support_bot"
  }'

const call = await orbit.voice.calls.create({
  to: '+14155552671',
  from: '+14155551234',
  agent_id: 'agt_support_bot',
});

# The core-scope voice wrapper covers the originate shape — `from` falls
# back to the tenant default server-side when omitted.
call = client.voice.create(
    to="+14155552671",
    from_="+14155551234",
)

print(call["data"]["id"])       # call_abc123
print(call["data"]["status"])   # 'queued'

// The core-scope voice wrapper covers the originate shape — `From` falls
// back to the tenant default server-side when omitted.
call, err := client.Voice().Create(context.Background(), orbit.CreateVoiceCallInput{
    To:   "+14155552671",
    From: "+14155551234",
})
if err != nil {
    panic(err)
}

fmt.Println(call.Data.ID)      // call_abc123
fmt.Println(call.Data.Status)  // "queued"

# The core-scope voice wrapper covers the originate shape — `from` falls
# back to the tenant default server-side when omitted.
call = client.voice.create(
  to: "+14155552671",
  from: "+14155551234",
)

puts call.dig("data", "id")      # call_abc123
puts call.dig("data", "status")  # "queued"

// The core-scope voice wrapper covers the originate shape — `from` falls
// back to the tenant default server-side when omitted.
$call = $client->voice->createCall([
    'to' => '+14155552671',
    'from' => '+14155551234',
]);

echo $call['data']['id'] . "\n";      // call_abc123
echo $call['data']['status'] . "\n";  // 'queued'

The core-scope SDKs (Python, Go, Ruby, PHP) type the originate shape above. Voice recordings, transcripts, conferences, IVR, and dialer are out of scope for those SDKs; use the Node SDK or the REST API directly via each language’s low-level request(...) escape hatch — see SDK scope by language.

Starting from zero with voice? Walk through the dedicated Voice Quickstart — it covers provisioning a number, configuring an agent with a system prompt, browser-mic testing, and SSE event subscription, all in under 5 minutes.

The first-send snippets above stop at the send. The recipes that round out the loop — voice originate via the escape hatch, the full OTP verify round trip, and a paginated delivery-analytics read — have a per-language tab on the Per-language recipes guide.

Replace $ORBIT_API_KEY with the key from Step 2 (or export it in your shell). Don’t paste your key directly into shared snippets.

Step 4: Check the Response

Every messaging channel – and POST /voice/calls – returns the same queued envelope. Use the shape for the channel you’re integrating first — the How to read a worked sample guide explains the envelope conventions every worked sample in these docs follows:

{
  "data": {
    "id": "msg_abc123",
    "status": "queued",
    "channel": "sms"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "msg_wa_abc123",
    "status": "queued",
    "channel": "whatsapp"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "msg_em_abc123",
    "status": "queued",
    "channel": "email"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

{
  "data": {
    "id": "call_abc123",
    "status": "queued",
    "channel": "voice"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

Congratulations — you’ve sent your first message with Orbit, for free, in under 5 minutes. A sandbox send keeps its honest test_sent status rather than being promoted to delivered/failed — to trigger a specific delivery-receipt outcome (delivered, undelivered, expired, and 7 others) on demand, send to a recipient number with the matching trailing digit; see Sandbox Magic Numbers. Hook a delivery webhook next: see Webhooks.

Step 5: Go Live

Sandbox traffic never reaches a real carrier, so it’s the fastest way to build and test your integration — but going live requires two more things:

KYC verification. Submit your business documents under Settings > KYC. Once an admin approves your organization, live sending is unlocked — but Orbit is pay-as-you-go with no automatic trial credit, so your live balance stays $0 until you add funds under Settings > Billing. SMS (US or international), WhatsApp, and voice all require both approved KYC and a funded balance before they’ll send.

10DLC registration for US SMS. Sending SMS to US numbers over live traffic also requires a 10DLC brand + campaign registration — a further compliance step layered on top of KYC, not a substitute for it. The worked campaign body below is the same one from the 10DLC registration guide — copy it as-is and swap in your brand_id:

{
  "brand_id": "BXXXXXX",
  "usecase": "CUSTOMER_CARE",
  "description": "Sending order updates and support responses to customers who opted in on our website checkout form.",
  "sample_message": [
    "Your order #12345 has shipped! Track at https://acme.com/track/12345",
    "Hi! Your support ticket #567 has been resolved. Reply STOP to unsubscribe."
  ],
  "message_flow": "Customers opt in via a web form at checkout and confirm consent. They can reply STOP at any time to opt out.",
  "help_message": "Reply HELP for assistance or contact support@acme.com.",
  "optout_message": "You have been unsubscribed and will receive no further messages."
}

See Sender ID Registration for the broader sender-verification context, and 10DLC registration guide for the full walkthrough including throughput tiers and political-vertical cv_token notes.

Once KYC is approved, mint a live key (prefix dv_live_sk_) under Settings > API Keys and swap it in for the dv_test_sk_ key you used above — the request shape doesn’t change.

Getting Started

Channels

Channels (Voice)

AI Agents

Campaigns

Flows

Numbers & Verify

Concepts

Features

Billing

Webhooks

Security & SSO

Compliance

Legal

Brand & press

Tutorials

Changelog

Quickstart: send your first SMS, call, or email

Quickstart

Step 1: Create an Account

Step 2: Get a Sandbox API Key

Step 3: Send Your First Message (Sandbox)

SMS

WhatsApp

Email

Python SDK

Go SDK

Ruby SDK

PHP SDK

Java SDK

C# SDK

Voice

Step 4: Check the Response

Step 5: Go Live

​Quickstart

​Step 1: Create an Account

​Step 2: Get a Sandbox API Key

​Step 3: Send Your First Message (Sandbox)

​SMS

​WhatsApp

​Email

​Python SDK

​Go SDK

​Ruby SDK

​PHP SDK

​Java SDK

​C# SDK

​Voice

​Step 4: Check the Response

​Step 5: Go Live

Quickstart

Step 1: Create an Account

Step 2: Get a Sandbox API Key

Step 3: Send Your First Message (Sandbox)

SMS

WhatsApp

Email

Python SDK

Go SDK

Ruby SDK

PHP SDK

Java SDK

C# SDK

Voice

Step 4: Check the Response

Step 5: Go Live