Dispatching outbound calls

You need an SLNG key and an agent created via the API or Agent Infra. See Configuring voice agents for system prompt and tool setup.

Outbound calls require the agent to be configured with an outbound SIP trunk (sip_outbound_trunk_id). Configure this in the Dashboard Telephony page and attach it to your agent.

Placeholders

Use these values in the examples:

Placeholder	Replace with
`SLNG_API_KEY`	An SLNG key with access to the Voice Agents API
`AGENT_ID`	The ID of an agent configured with an outbound SIP trunk
`+14155551234`	The destination phone number in E.164 format

Basic Call Dispatch

Send a single outbound call by providing the agent ID and a phone number in E.164 format.

const API_KEY = "SLNG_API_KEY";
const BASE_URL = "https://api.agents.slng.ai";

async function dispatchCall(agentId, phoneNumber, args = {}) {
  const response = await fetch(`${BASE_URL}/v1/agents/${agentId}/calls`, {
    method: "POST",
    headers: {
      Authorization: `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      phone_number: phoneNumber,
      arguments: args,
    }),
  });

  if (!response.ok) {
    const error = await response.json().catch(() => ({}));
    throw new Error(`Failed to dispatch call: ${error.error || error.detail || response.status}`);
  }

  return response.json();
}

// Basic call
const result = await dispatchCall(
  "AGENT_ID",
  "+14155551234",
);
console.log(`Call dispatched: ${result.call_id}`);

import requests

API_KEY = "SLNG_API_KEY"
BASE_URL = "https://api.agents.slng.ai"

def dispatch_call(agent_id, phone_number, arguments=None):
    response = requests.post(
        f"{BASE_URL}/v1/agents/{agent_id}/calls",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "phone_number": phone_number,
            "arguments": arguments or {}
        }
    )
    response.raise_for_status()
    return response.json()

# Basic call
result = dispatch_call(
    "AGENT_ID",
    "+14155551234"
)
print(f"Call dispatched: {result['call_id']}")

curl -X POST https://api.agents.slng.ai/v1/agents/AGENT_ID/calls \
  -H "Authorization: Bearer SLNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "phone_number": "+14155551234"
  }'

Calls with Template Variables

If your agent’s system prompt or greeting contains {{variables}}, pass them via the arguments field. These override any template_defaults set on the agent. arguments is bounded to 32 keys, with keys up to 64 characters, values up to 1024 characters, and a combined value payload up to 8192 characters.

// Agent system_prompt uses: {{patient_name}}, {{practice_name}}
const API_KEY = "SLNG_API_KEY";
const BASE_URL = "https://api.agents.slng.ai";

const response = await fetch(`${BASE_URL}/v1/agents/AGENT_ID/calls`, {
  method: "POST",
  headers: {
    Authorization: `Bearer ${API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    phone_number: "+14155551234",
    arguments: {
      patient_name: "Maria",
      practice_name: "Greenfield Family Medicine",
    },
  }),
});

if (!response.ok) {
  const error = await response.json().catch(() => ({}));
  throw new Error(`Failed to dispatch call: ${error.error || error.detail || response.status}`);
}

const result = await response.json();
console.log(`Call dispatched: ${result.call_id}`);

import requests

API_KEY = "SLNG_API_KEY"
BASE_URL = "https://api.agents.slng.ai"

# Agent system_prompt uses: {{patient_name}}, {{practice_name}}
response = requests.post(
    f"{BASE_URL}/v1/agents/AGENT_ID/calls",
    headers={
        "Authorization": f"Bearer {API_KEY}",
        "Content-Type": "application/json",
    },
    json={
        "phone_number": "+14155551234",
        "arguments": {
            "patient_name": "Maria",
            "practice_name": "Greenfield Family Medicine",
        },
    },
)
response.raise_for_status()

result = response.json()
print(f"Call dispatched: {result['call_id']}")

curl -X POST https://api.agents.slng.ai/v1/agents/AGENT_ID/calls \
  -H "Authorization: Bearer SLNG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "phone_number": "+14155551234",
    "arguments": {
      "patient_name": "Maria",
      "practice_name": "Greenfield Family Medicine"
    }
  }'

Batch Call Dispatch

When you need to call a list of contacts, you can loop through them one at a time or fire multiple calls in parallel with a concurrency cap.

Sequential Dispatch

async function dispatchBatch(agentId, contacts) {
  const results = [];

  for (const contact of contacts) {
    try {
      const result = await dispatchCall(agentId, contact.phone, contact.args);
      results.push({
        phone: contact.phone,
        success: true,
        call_id: result.call_id,
      });

      // Small delay between calls to avoid rate limiting
      await new Promise((resolve) => setTimeout(resolve, 500));
    } catch (error) {
      results.push({
        phone: contact.phone,
        success: false,
        error: error.message,
      });
    }
  }

  return results;
}

// Usage
const contacts = [
  {
    phone: "+14155551234",
    args: { patient_name: "Maria", practice_name: "Greenfield Family Medicine" },
  },
  {
    phone: "+14155555678",
    args: { patient_name: "John", practice_name: "Greenfield Family Medicine" },
  },
  {
    phone: "+14155559012",
    args: { patient_name: "Jane", practice_name: "Greenfield Family Medicine" },
  },
];

const results = await dispatchBatch(
  "AGENT_ID",
  contacts,
);
console.log("Batch results:", results);

Parallel Dispatch (with concurrency limit)

Process calls in chunks to stay within rate limits while dispatching faster than sequential.

async function dispatchBatchParallel(agentId, contacts, concurrency = 5) {
  const results = [];

  // Process in chunks
  for (let i = 0; i < contacts.length; i += concurrency) {
    const chunk = contacts.slice(i, i + concurrency);

    const chunkResults = await Promise.allSettled(
      chunk.map((contact) =>
        dispatchCall(agentId, contact.phone, contact.args)
          .then((result) => ({
            phone: contact.phone,
            success: true,
            call_id: result.call_id,
          }))
          .catch((error) => ({
            phone: contact.phone,
            success: false,
            error: error.message,
          })),
      ),
    );

    results.push(...chunkResults.map((r) => r.value || r.reason));
  }

  return results;
}

import asyncio
import aiohttp

API_KEY = "SLNG_API_KEY"
BASE_URL = "https://api.agents.slng.ai"

async def dispatch_call_async(session, agent_id, phone_number, arguments=None):
    async with session.post(
        f"{BASE_URL}/v1/agents/{agent_id}/calls",
        headers={
            "Authorization": f"Bearer {API_KEY}",
            "Content-Type": "application/json"
        },
        json={
            "phone_number": phone_number,
            "arguments": arguments or {}
        }
    ) as response:
        if response.status == 200:
            data = await response.json()
            return {"phone": phone_number, "success": True, "call_id": data["call_id"]}
        else:
            error = await response.json()
            return {
                "phone": phone_number,
                "success": False,
                "error": error.get("error") or error.get("detail") or str(error),
            }

async def dispatch_batch(agent_id, contacts, concurrency=5):
    semaphore = asyncio.Semaphore(concurrency)

    async def limited_dispatch(session, contact):
        async with semaphore:
            return await dispatch_call_async(
                session, agent_id, contact["phone"], contact.get("args")
            )

    async with aiohttp.ClientSession() as session:
        tasks = [limited_dispatch(session, contact) for contact in contacts]
        return await asyncio.gather(*tasks)

# Usage
contacts = [
    {"phone": "+14155551234", "args": {"customer_name": "John Smith"}},
    {"phone": "+14155555678", "args": {"customer_name": "Jane Doe"}},
    {"phone": "+14155559012", "args": {"customer_name": "Bob Wilson"}},
]

results = asyncio.run(dispatch_batch("AGENT_ID", contacts))
for result in results:
    if result["success"]:
        print(f"✓ {result['phone']}: {result['call_id']}")
    else:
        print(f"✗ {result['phone']}: {result['error']}")

Common Use Cases

Outbound voice agents work well for automated calls that follow a predictable structure. Common examples include:

Appointment reminders: confirm or reschedule upcoming visits
Payment collection: notify customers of outstanding balances
Survey and feedback: gather post-purchase or post-service input
Lead qualification: follow up on inbound interest and route warm leads to sales

Use template variables to personalize each call with contact-specific details like names, dates, and amounts.

Get started

Text-to-Speech

Speech-to-Text

Managed Agents

Integrations

SDKs & Tools

Reference

Placeholders

Basic Call Dispatch

Calls with Template Variables

Batch Call Dispatch

Sequential Dispatch

Parallel Dispatch (with concurrency limit)

Common Use Cases

​Placeholders

​Basic Call Dispatch

​Calls with Template Variables

​Batch Call Dispatch

​Sequential Dispatch

​Parallel Dispatch (with concurrency limit)

​Common Use Cases

Placeholders

Basic Call Dispatch

Calls with Template Variables

Batch Call Dispatch

Sequential Dispatch

Parallel Dispatch (with concurrency limit)

Common Use Cases