curl -X POST https://api.orbit.devotel.io/api/v1/voice/calls \
  -H "X-API-Key: dv_test_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+14155552671",
    "from": "+18005551234",
    "agent_id": "agt_support_bot",
    "record": true,
    "amd": true,
    "metadata": { "crm_id": "lead_4821" }
  }'

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

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

// Fully-typed call origination — prefer it over the generic HTTP path.
const call = await orbit.voice.calls.create({
  to: '+14155552671',
  from: '+18005551234',
  agent_id: 'agt_support_bot', // bind the call to a named voice agent
  record: true,                // record subject to two-party-consent rules
  amd: true,                   // server-side answering-machine detection
  metadata: { crm_id: 'lead_4821' },
});

console.log(call.data.id);      // call_abc123
console.log(call.data.status);  // 'initiated'

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

# The Python SDK has no typed voice module — reach the endpoint through
# the client.request escape hatch (raw JSON returned).
call = client.request(
    "POST",
    "/voice/calls",
    json_body={
        "to": "+14155552671",
        "from": "+18005551234",
        "agent_id": "agt_support_bot",
        "record": True,
        "amd": True,
        "metadata": {"crm_id": "lead_4821"},
    },
)

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

call, err := client.Voice().Create(context.Background(), orbit.CreateVoiceCallInput{
    To:     "+14155552671",
    From:   "+18005551234", // optional — falls back to a tenant default
    Record: true,             // record, subject to two-party-consent rules
})
if err != nil {
    panic(err)
}
fmt.Println("call id:", call.Data.ID)     // call_abc123
fmt.Println("status:", call.Data.Status)  // "initiated"

const res = await fetch('https://api.orbit.devotel.io/api/v1/voice/calls', {
  method: 'POST',
  headers: {
    'X-API-Key': process.env.ORBIT_API_KEY!, // dv_test_sk_...
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    to: '+14155552671',
    from: '+18005551234',
    agent_id: 'agt_support_bot',
    record: true,
    amd: true,
    metadata: { crm_id: 'lead_4821' },
  }),
});
if (!res.ok) throw new Error(`origination failed: ${res.status}`);
const call = (await res.json()) as { data: { id: string; status: string } };
console.log(call.data.id); // call_abc123

// Retrieve call details
const detail = await orbit.voice.calls.get('call_abc123');
console.log(detail.data.status);   // 'in-progress' | 'completed' | 'failed' | …
console.log(detail.data.duration); // seconds

// Hang up a live call
await orbit.voice.calls.hangup('call_abc123');

// Poll the call's status until it answers.
detail, err := client.Voice().Get(context.Background(), "call_abc123")
if err != nil {
    panic(err)
}
fmt.Println("status:", detail.Data.Status)  // "in-progress"

// Hang up.
if _, err := client.Voice().Hangup(context.Background(), "call_abc123"); err != nil {
    panic(err)
}

let cursor: string | undefined;
do {
  const page = await orbit.voice.calls.list({
    direction: 'outbound',
    status: 'completed',
    limit: 50,
    cursor,
  });
  for (const c of page.data) console.log(c.id, c.duration);
  cursor = page.meta.pagination.has_more
    ? page.meta.pagination.cursor
    : undefined;
} while (cursor);

cursor := ""
for {
    page, err := client.Voice().List(context.Background(), orbit.ListVoiceCallsParams{
        Direction: "outbound",
        Status:    "completed",
        Limit:     50,
        Cursor:    cursor,
    })
    if err != nil {
        panic(err)
    }
    for _, c := range page.Data {
        fmt.Println(c.ID, c.Status)
    }
    if page.Meta.NextCursor == "" {
        break
    }
    cursor = page.Meta.NextCursor
}

import crypto from 'node:crypto';
import express from 'express';

const app = express();

// Express must see the raw body — verify BEFORE parsing JSON.
app.post('/webhooks/orbit', express.raw({ type: 'application/json' }), (req, res) => {
  const rawBody = req.body.toString('utf-8');
  const header = (req.headers['x-orbit-signature'] as string) ?? '';
  const [t, v1] = header.split(',').map((p) => p.split('=')[1] ?? '');
  const expected = crypto
    .createHmac('sha256', process.env.ORBIT_WEBHOOK_SECRET!)
    .update(`${t}.${rawBody}`, 'utf-8')
    .digest('hex');
  const expectedBuf = Buffer.from(expected, 'hex');
  const v1Buf = Buffer.from(v1, 'hex');
  if (v1Buf.length !== expectedBuf.length || !crypto.timingSafeEqual(v1Buf, expectedBuf)) {
    return res.status(401).json({ error: 'Invalid signature' });
  }

  const event = JSON.parse(rawBody);
  switch (event.type) {
    case 'call.answered':
      // mark the contact reachable in your CRM
      break;
    case 'call.completed':
      // pull the latency breakdown + AI cost for the call
      break;
    default:
      // acknowledge unknown types so new events don't jam retries
      break;
  }
  res.status(200).json({ received: true });
});

app.listen(3000);

import hashlib
import hmac
import json
import os
from flask import Flask, jsonify, request

app = Flask(__name__)

@app.route("/webhooks/orbit", methods=["POST"])
def handle_webhook():
    header = request.headers.get("X-Orbit-Signature", "")
    parts = dict(p.split("=", 1) for p in header.split(",") if "=" in p)
    t, v1 = parts.get("t", ""), parts.get("v1", "")
    signed = f"{t}.".encode("utf-8") + request.data
    expected = hmac.new(
        os.environ["ORBIT_WEBHOOK_SECRET"].encode("utf-8"),
        signed,
        hashlib.sha256,
    ).hexdigest()
    if not v1 or not hmac.compare_digest(v1, expected):
        return jsonify({"error": "Invalid signature"}), 401

    event = json.loads(request.data)
    if event["type"] == "call.answered":
        pass  # mark the contact reachable in your CRM
    elif event["type"] == "call.completed":
        pass  # pull the latency breakdown + AI cost for the call
    return jsonify({"received": True}), 200