Make your first outbound PSTN call

Two paths turn a new Orbit account into a phone that dials the PSTN:

Option A — register a SIP trunk with your own PBX or softphone software, and let API-origin calls dial out over it.
Option B — the browser softphone, where an agent dials straight from a web page with no SIP client to install.

Both end at the same place: an outbound PSTN call with a readable lifecycle (ringing → answered → completed). This guide walks either path end to end and links the deep-dive page for the path you pick.

Every outbound leg terminates through the Devotel softswitch. A trunk you register here is one origin surface; the termination path stays on Orbit’s own network either way.

From one call to a verified pipeline

The walkthrough below puts a single outbound call on the wire. What it leaves untouched is the part operators run every day: before any dial leaves the account, preview how it routes; as dials run, watch outcomes from the dashboard’s Voice → Calls console instead of polling raw statuses; and on retries or cold traffic, chain into the sibling guides that cover pacing, timing, and gates. The sequence below is the same one that shows up on every voice onboarding checklist.

1. Gate before the first dial

Run the pre-flight send gates checklist so the campaign does not trip on spend caps, quiet hours, or missing ownership of the caller-ID DID after the first call has already gone out.

2. Route with a preview, not a guess

If recipients on the campaign are reachable over more than one channel (SMS, WhatsApp, RCS, voice), call the smart-route-preview endpoint first. It returns the channel the router would pick, the ordered fallback chain, and a per-message cost estimate — without dispatching anything. For pure voice campaigns, use it to confirm voice is the selected surface before pacing begins.

3. Pace cold numbers and cold audiences

New numbers and new senders are rate-sensitive. Throttle the ramp with the number warming phases and daily caps (10DLC senders), and pick dial windows with best time to dial rather than sending the full audience at hour zero.

4. Verify and monitor from the Calls console

Once dials run, open Voice → Calls in the dashboard for live verification: each call row shows the lifecycle (ringing → in_progress → completed / failed / no-answer) plus recordings when calls were placed with record: true. That page is the verification loop of record — a failed dialed-leg, an unexpected terminal state, or a missing recording shows on the console first. For API-side verification on retry-aware campaigns, track delivery outcomes with DLR outcomes monitoring instead of hand-polling terminal states.

5. Find the gap from delivery logs

When the console shows an anomalous outcome (fallback fired when it should not have, a no-answer cluster at a specific hour), drill into the delivery logs the route-preview guide introduced — the same forensic read applies whether the failing hop was the route choice or the dial itself. Putting it together: buy → gate → preview → pace → monitor is one pipeline, and the Calls console is its verification point. The sections below walk a single call end to end; bring the loop above into play as soon as the account moves past the first call.

1. Prerequisites

Which prerequisite applies depends on the path:

Option A (SIP/trunk): a SIP-capable PBX (FreeSWITCH, Asterisk, 3CX) or a desktop SIP client (for example MicroSIP or Linphone), plus inbound SIP-credentials you mint on the account.
Option B (browser softphone): an HTTPS page and a browser with a microphone grant — the same rules the browser softphone guide lists in full.
Either path: at least one voice-enabled DID in the account to present as caller ID, and an API key with voice scope if you dial via the API.

2. Buy a voice-capable number

If the account has no DID yet, work through Buy and provision numbers — search inventory with capabilities=voice (or sms,voice when messaging will share the number), purchase, and poll the order until the line reports provisioned:

curl "https://api.orbit.devotel.io/api/v1/numbers/available?country=US&type=local&capabilities=voice" \
  -H "X-API-Key: dv_live_sk_..."

Keep the E.164 of the purchased number — it is the from on every dial below, and it is the only caller ID the outbound surface accepts.

3. Option A — register a SIP trunk

This path connects your own phone system to Orbit. The full lifecycle (direction choice, probe-before-save, credential capture, routing, monitoring) is a nine-step walkthrough in Connect a SIP trunk; the short version for a first call:

Create the trunk with the carrier-facing details:

The same create in cURL and in every published SDK. The SDK tabs use each client’s untyped request method, the escape hatch documented in the raw-request cookbook: same auth, same retry, same typed errors, and exact parity with the API whether or not a typed helper wraps the route yet.

curl -X POST https://api.orbit.devotel.io/api/v1/voice/sip-trunks \
  -H "X-API-Key: dv_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "name": "HQ PBX",
    "host": "pbx.example.com",
    "port": 5060,
    "transport": "udp"
  }'

import { Orbit } from "@devotel-orbit/node";

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

const { data: trunk } = await orbit.request("POST", "/api/v1/voice/sip-trunks", {
  name: "HQ PBX",
  host: "pbx.example.com",
  port: 5060,
  transport: "udp",
});
console.log(trunk.id);

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

envelope = client.request(
    "POST",
    "/voice/sip-trunks",
    json_body={
        "name": "HQ PBX",
        "host": "pbx.example.com",
        "port": 5060,
        "transport": "udp",
    },
)
trunk = envelope["data"]

client, err := orbit.NewClient(os.Getenv("ORBIT_API_KEY"))
if err != nil {
    log.Fatal(err)
}

var envelope map[string]any
if err := client.Request(context.Background(), "POST", "/voice/sip-trunks", nil, map[string]any{
    "name":      "HQ PBX",
    "host":      "pbx.example.com",
    "port":      5060,
    "transport": "udp",
}, &envelope, ""); err != nil {
    log.Fatal(err)
}

client = OrbitSdk::Client.from_env  # reads ORBIT_API_KEY

envelope = client.request("POST", "/voice/sip-trunks", json_body: {
  name: "HQ PBX",
  host: "pbx.example.com",
  port: 5060,
  transport: "udp"
})
trunk = envelope["data"]

use Devotel\Orbit\OrbitClient;

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

$envelope = $client->request('POST', '/voice/sip-trunks', null, [
    'name' => 'HQ PBX',
    'host' => 'pbx.example.com',
    'port' => 5060,
    'transport' => 'udp',
]);
$trunk = $envelope['data'];

The create returns the trunk row. status reads unregistered until your PBX completes its first REGISTER against the SIP edge host shown in Settings → SIP trunks:

Response

{
  "data": {
    "id": "trunk_8c41d2",
    "name": "HQ PBX",
    "host": "pbx.example.com",
    "port": 5060,
    "transport": "udp",
    "status": "unregistered"
  },
  "meta": {
    "request_id": "req_31c07a",
    "timestamp": "2026-10-27T09:14:02.118Z"
  }
}

Register the device that will originate calls (your PBX, or a SIP client on an agent’s desk) against the SIP edge host shown in Settings → SIP trunks, using the digest or IP-allowlist auth the trunk is configured with.
Skip to section 5 — once the originating surface exists, the dial step is identical to Option B.

A trunk that fails to register never carries the first call — run the pre-save probe (POST /api/v1/voice/sip-trunks/probe, exercised in sip-trunk-setup) and it names the failing phase (DNS, connect, or REGISTER) instead of a generic rejected call.

4. Option B — the browser softphone

The no-install path: mint a short-lived credential, connect the client, dial. The full guide is Set up the browser (WebRTC) softphone; on a first call you need three moves.

Mint a token:

curl -X POST https://api.orbit.devotel.io/api/v1/voice/softphone/token \
  -H "Authorization: Bearer dv_live_sk_..."

From your own page, mount the SDK softphone and connect — a minimal HTML page:

<!doctype html>
<button id="connect">Enable microphone</button>
<input id="to" placeholder="+14155550100" />
<button id="dial">Dial</button>

<script type="module">
  import { OrbitSoftphone } from "https://cdn.jsdelivr.net/npm/@devotel-orbit/web";

  const softphone = new OrbitSoftphone({
    apiBaseUrl: "https://api.orbit.devotel.io",
    apiKey: "dv_live_sk_...", // serve from your backend, never commit it
  });

  document.getElementById("connect").onclick = async () => {
    await navigator.mediaDevices.getUserMedia({ audio: true });
    await softphone.connect(); // mints token, publishes mic
  };

  document.getElementById("dial").onclick = () =>
    softphone.dial(document.getElementById("to").value);
</script>

Dial from the browser, or call the endpoint directly once the client is connected:

curl -X POST https://api.orbit.devotel.io/api/v1/voice/softphone/dial \
  -H "Authorization: Bearer dv_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{ "to": "+14155552671", "from": "+16572262362" }'

Credentials live 60 minutes — re-mint before expiresAt instead of recycling. The browser-fallback reality and the inbound decision (DNIS → queue or SIP routing for inbound rings) live in the softphone guide.

5. Dial a single PSTN call

With either origin surface registered, the dial step is one API call — POST /api/v1/voice/calls. Pass the bought DID as from and any PSTN destination as to; a record: true flag captures the audio for the post-call read:

curl -X POST https://api.orbit.devotel.io/api/v1/voice/calls \
  -H "X-API-Key: dv_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+14155552671",
    "from": "+16572262362",
    "record": true
  }'

const { data: call } = await orbit.request("POST", "/api/v1/voice/calls", {
  to: "+14155552671",
  from: "+16572262362",
  record: true,
});
// Expect: ringing -> answered (in_progress) -> completed.
// A declined or unanswered ring terminates as failed / no-answer.
console.log(call.id); // call_… — the handle every later step uses

envelope = client.request(
    "POST",
    "/voice/calls",
    json_body={"to": "+14155552671", "from": "+16572262362", "record": True},
)
call = envelope["data"]
# expect: ringing -> answered (in_progress) -> completed
# (terminal failed / no-answer on a declined or unanswered ring)

var dial map[string]any
if err := client.Request(context.Background(), "POST", "/voice/calls", nil, map[string]any{
    "to":     "+14155552671",
    "from":   "+16572262362",
    "record": true,
}, &dial, ""); err != nil {
    log.Fatal(err)
}
// Expect: ringing -> answered (in_progress) -> completed; terminal
// failed / no-answer on a declined or unanswered ring.

envelope = client.request("POST", "/voice/calls", json_body: {
  to: "+14155552671",
  from: "+16572262362",
  record: true
})
call = envelope["data"]
# expect: ringing -> answered (in_progress) -> completed

$envelope = $client->request('POST', '/voice/calls', null, [
    'to' => '+14155552671',
    'from' => '+16572262362',
    'record' => true,
]);
$call = $envelope['data'];
// Expect: ringing -> answered (in_progress) -> completed.

The 2xx envelope carries the new call at its first state:

Response

{
  "data": {
    "id": "call_9f2a1c",
    "to": "+14155552671",
    "from": "+16572262362",
    "record": true,
    "status": "ringing"
  },
  "meta": {
    "request_id": "req_5d1e07",
    "timestamp": "2026-10-27T09:15:41.930Z"
  }
}

The 2xx response returns data.id (call_…) — the handle every later step uses. Options answer_url/staticVerbs, AMD, and metadata-level bookkeeping are at Program an outbound voice call; for a first call there is nothing to configure beyond to and from.

6. Read the lifecycle states

A call moves ringing → in_progress → a terminal completed on answer (or failed / no-answer on a declined or unanswered ring). Poll the record:

curl https://api.orbit.devotel.io/api/v1/voice/calls/call_9f2a1c \
  -H "X-API-Key: dv_live_sk_..."

const { data: call } = await orbit.request(
  "GET",
  "/api/v1/voice/calls/call_9f2a1c",
);
// Sequence to expect: ringing -> answered -> in_progress -> completed.
const terminal =
  call.status === "completed" ||
  call.status === "failed" ||
  call.status === "no-answer";

envelope = client.request("GET", "/voice/calls/call_9f2a1c")
call = envelope["data"]
# sequence: ringing -> answered -> in_progress -> completed
# poll while status is not one of: completed / failed / no-answer

var read map[string]any
if err := client.Request(context.Background(), "GET", "/voice/calls/call_9f2a1c", nil, nil, &read, ""); err != nil {
    log.Fatal(err)
}
// sequence: ringing -> answered -> in_progress -> completed

envelope = client.request("GET", "/voice/calls/call_9f2a1c")
# sequence: ringing -> answered -> in_progress -> completed

$envelope = $client->request('GET', '/voice/calls/call_9f2a1c');
// sequence: ringing -> answered -> in_progress -> completed

The record keeps the same shape as the create response, with status advanced along the sequence above; a terminal read looks like:

Response

{
  "data": {
    "id": "call_9f2a1c",
    "to": "+14155552671",
    "from": "+16572262362",
    "record": true,
    "status": "completed"
  },
  "meta": {
    "request_id": "req_6e8b44",
    "timestamp": "2026-10-27T09:16:02.517Z"
  }
}

…or subscribe to call.completed / call.failed webhooks under Settings → Webhooks and verify the delivery signature. The Voice calls page in the dashboard lists the same progression per call; the full state map and webhook payloads live in programmable-voice-call.

7. Common errors

These cover the failures a first outbound call hits in the wild:

Symptom	Cause	Fix
`401`/`407` on REGISTER, or trunk `unregistered`	SIP auth fails: wrong register username/password, or a digest challenge answered with a stale password	Re-check the credentials the carrier issued (Option A trunk) or the minted SIP credential (desk client). On Orbit-side incoming trunks, rotate the digest password — the plaintext is shown exactly once at create.
Call connects, then one-way or no audio	Codec mismatch or SRTP posture	On the trunk, drop to the codecs your carrier lists; on softphone credentials, SRTP is mandatory and an RTP-only client never establishes audio. See TLS/SRTP posture in sip-trunk-setup.
Outbound rejected right at originate	Outbound blocked	Emergency-shaped dials are rejected (`EMERGENCY_CALLING_NOT_SUPPORTED`). Otherwise the trunk’s routing rules (a destination blocklist) or the account’s spend cap and quiet-hours gate stopped it, or no trunk registered at all — the error returned on the dial names the gate.
`403 Organisation does not own phone number …`	`from`/`callerIdNumber` is not a DID the account owns	Buy or port the number first; outbound CLI can only be an owned DID.
Register probe never succeeds	DNS or firewall on the SIP edge	Probe before save (`POST /api/v1/voice/sip-trunks/probe`) names the failing phase explicitly.

SIP failures past this short list are covered in Troubleshooting: SIP trunk down or calls failing; lifecycle outcomes that look like (no-answer, busy, unreachable) map in programmable-voice-call.

Where to go next

Program every call — answer_url verbs, AMD, recordings, transcripts: Program an outbound voice call.
Run the trunk in production — failover, health snapshot, route quality: Connect a SIP trunk.
Give agents the full softphone — inbound routing, mobile push, SDK events: Browser (WebRTC) softphone.
Build the verification pipeline — send gates pre-flight checklist, route preview, and delivery forensics.

WhatsApp

Developer console

Contact center

Guides

Messaging Controls

Audience & Support Tools

Make your first outbound PSTN call: SIP trunk or browser softphone

Make your first outbound PSTN call

From one call to a verified pipeline

1. Gate before the first dial

2. Route with a preview, not a guess

3. Pace cold numbers and cold audiences

4. Verify and monitor from the Calls console

5. Find the gap from delivery logs

1. Prerequisites

2. Buy a voice-capable number

3. Option A — register a SIP trunk

4. Option B — the browser softphone

5. Dial a single PSTN call

6. Read the lifecycle states

7. Common errors

Where to go next

​Make your first outbound PSTN call

​From one call to a verified pipeline

​1. Gate before the first dial

​2. Route with a preview, not a guess

​3. Pace cold numbers and cold audiences

​4. Verify and monitor from the Calls console

​5. Find the gap from delivery logs

​1. Prerequisites

​2. Buy a voice-capable number

​3. Option A — register a SIP trunk

​4. Option B — the browser softphone

​5. Dial a single PSTN call

​6. Read the lifecycle states

​7. Common errors

​Where to go next

Make your first outbound PSTN call

From one call to a verified pipeline

1. Gate before the first dial

2. Route with a preview, not a guess

3. Pace cold numbers and cold audiences

4. Verify and monitor from the Calls console

5. Find the gap from delivery logs

1. Prerequisites

2. Buy a voice-capable number

3. Option A — register a SIP trunk

4. Option B — the browser softphone

5. Dial a single PSTN call

6. Read the lifecycle states

7. Common errors

Where to go next