# Outbound SIP on GPT-Live: capacity, cost and what failover can do

URL: https://infro.io/blog/outbound-sip-on-gpt-live-capacity-cost-and-what-failover-can-do
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-11-10
Last modified: 2026-11-10
Last reviewed: 2026-11-10 (next review due 2026-12-10)
Topic: Agents and multimodal systems
Format: Guide

> Size outbound GPT-Live calls from occupied session-minutes, not dial attempts, and forecast cost from answered and ringing time separately. Failover can retry setup on another trunk, but a call that has been answered cannot move; a drop means a new call. [^oai-sip]

Key takeaways:
- Outbound SIP on GPT-Live goes through POST /v1/live/sessions, not the Realtime API call-creation endpoint, and a 200 OK means the session initialised, not that anyone answered.
- Concurrency is occupied session-minutes: dial rate times average call length, with ringing time of up to 3 minutes holding a slot too.
- The pages read do not publish a concurrent-call limit or say whether ringing time bills; treat both as unconfirmed and measure them on a pilot.
- Failover is safe before the call is answered (a failed setup retried on another trunk) and impossible after it: the audio, the session and the caller are on one path.
- Dropped calls need a classification (setup failure, no answer, mid-call drop) and a redial policy that carries a summary, not a transcript replay.

## What changed: outbound SIP is open to every organization

OpenAI's GPT-Live guide now documents two SIP paths: inbound calls, where your SIP provider sends a call to your project and your backend accepts or rejects it, and outbound calls, where your backend creates a session that dials a number through your provider. The guide states that outbound SIP calling is available to all organizations through the Live API, not through the Realtime API call-creation endpoint.[1] If your existing dialer was built on Realtime call creation, this is a different endpoint with a different session shape.

The mechanics are short. You send `POST /v1/live/sessions` with a `session` object (model, instructions, voice, delegation mode) and a `transport` object of type `sip` holding the destination, your trunk's `sips:` URL, digest credentials and caller number. The request returns `200 OK` once the session initialises. The guide is explicit that this does not mean the call has been answered.[1] You then attach a sideband WebSocket and wait for `transport.answered`.

That one distinction drives everything below. Between "session created" and "answered" there is a window in which you hold a resource, may be billed for something, and can still fail over. After "answered" that window is closed.

## What the outbound request needs, and where it fails

Before sizing anything, get the trunk right. The guide requires a trunk with TLS signaling and SDES-SRTP media, and the `provider_url` must use `sips:` with a default port of 5061. Credentials, paths and URI parameters do not belong in that URL, and local hostnames or literal private IP addresses are rejected.[1] The destination must be E.164; SIP URI destinations are not supported.[1]

The failure surface is split between three places:

- **At creation.** Invalid configuration is returned on the creation request. Transport setup failures can return `502`, and initialization timeouts return `504`.[1]
- **After creation, before answer.** A `transport.failed` event carries `error.code` and `error.message` when setup fails asynchronously.[1]
- **After answer.** The call ends through hangup, a limit, or a network fault; the sideband stays open until `session.closed` supplies final usage.[1]

Network teams have a separate checklist. Signaling goes outbound over TCP/TLS on port 5061 to `sip.api.openai.com` or `sip-eu.api.openai.com`, which are GeoIP-routed, and SRTP media runs over UDP to the CIDRs the guide lists (four /28 blocks), with the media address and port negotiated in the SDP.[1] A firewall that allows signaling but not the media ranges produces calls that connect and carry no audio, which looks like a model problem and is not one.

## Capacity: size from occupied minutes

The pages read for this article do not publish a concurrent-call limit for GPT-Live sessions, and they do not describe a per-project limit on outbound call creation. Treat any number you have heard as unconfirmed until you have it in writing from your account page or OpenAI. What the guide does publish are two durations: ringing is limited to 3 minutes and a connected call to 2 hours, and neither is configurable in the creation request.[1]

Those two limits bound how long one slot can be held, which is what capacity planning needs. The working formula is Little's law:

```text
concurrent sessions ≈ (dial attempts per hour × average occupied minutes per attempt) / 60
average occupied minutes = answer_rate × talk_minutes + (1 − answer_rate) × ring_minutes
```

> **Example: Illustrative sizing for a campaign dialer**
> All figures are invented to show the arithmetic; replace them with your own pilot data.
> 
> Suppose the dialer places 600 attempts per hour at peak. 40% are answered and talk for 4 minutes on average. The other 60% ring for 30 seconds before failing or being abandoned.
> 
> Occupied minutes per hour: 600 × 0.4 × 4 = 960 talk-minutes, plus 600 × 0.6 × 0.5 = 180 ringing minutes, so 1,140. Divided by 60, that is 19 concurrent sessions on average. With a 1.5 peak factor for bunching, plan for about 29.
> 
> The ringing share is 16% of occupied time. If your answer rate drops to 20% and calls ring for the full 3-minute limit, the same 600 attempts occupy far more slots than the talk time suggests.

Three practical rules follow:

1. **Pace on occupied slots, not on attempts.** Keep an in-process semaphore sized to your planning number and release it only on `session.closed` or `transport.failed`. Pacing on dials per second lets a slow-answer period pile up sessions.
2. **Cap your own ringing.** The 3-minute ring limit is a ceiling, not a target. If you hang up unanswered calls after 25–30 seconds with `POST /v1/live/sessions/{session_id}/hangup`, slots turn over faster.[1]
3. **Find the real ceiling on a pilot.** Raise concurrency in steps and watch for `429` responses and creation latency. The existing guides on [OpenAI usage tiers](https://infro.io/blog/openai-usage-tiers-rate-limits-2026) cover tier limits; confirm separately what applies to Live sessions on your account.

## Forecasting per-minute cost

INFRO's own comparison, which read OpenAI's pricing page on 2026-10-27, lists GPT-Live 1 at $0.05 per minute of session, billed per second, with the backend model and tools billed at their own rates.[2] Confirm the current rate on OpenAI's pricing page before you commit a budget; this guide cannot see it today. The same comparison, quoting OpenAI's cost guidance, notes that session time includes moments when both sides are silent or the backend is working.[2] So the unit you forecast is occupied session time, not speaking time.

Build the forecast from four lines:

| Line | Driver | Status |
| --- | --- | --- |
| Voice session time | Answered talk-minutes, silence and backend waits included | List rate cited above |
| Ringing and setup time | Ring minutes before answer | Unconfirmed: the pages read do not say whether it bills |
| Backend model and tools | Tokens and tool calls from delegated work | Billed at their own rates |
| SIP provider | Your trunk's per-minute and per-call charges | Billed by your provider, outside OpenAI |

Table: Cost lines for one outbound campaign.

Because the ringing rule is unconfirmed, forecast two cases and let the pilot's invoice choose between them. With the earlier invented figures, answered talk alone is 960 minutes an hour, or $48 of voice time at $0.05, and counting ringing as well would be 1,140 minutes, or $57. The $9 gap is small at this scale and large at a million attempts, so settle it with a real day of traffic rather than a guess.

The backend line is where forecasts miss. In client delegation your backend does the delegated work, so its model and tool calls are your own spend, and a longer call generates more of them.[1] Track cost per answered call and cost per completed outcome, not cost per minute: a slow backend lengthens the call and the session bill at once.

## Classify drops before you design the redial

"Dropped call" covers three cases that need different handling. A single retry rule for all of them will either redial people who answered or abandon calls that never started.

| Class | Signal | Safe to retry on another path? |
| --- | --- | --- |
| Setup failure | `502`, `504` on creation, or `transport.failed` | Yes, nobody was reached |
| No answer | Ringing ends without `transport.answered` | Yes, on your schedule, within your contact rules |
| Mid-call drop | `session.closed` after `transport.answered` | Only as a new call, with context |

Table: Drop classes for outbound SIP calls.

Operational details matter here. The sideband replays only events from the preceding 3 seconds, so attach immediately after creation or you can miss `transport.ringing` or `transport.answered`; replayed events keep their original IDs, so deduplicate by `event_id`.[1] Assign one handler to each side effect, because the same event can be observed on more than one connection and a tool must not run twice.[1] Keep the sideband open until `session.closed`, because that is where final usage arrives.[1]

The guide excerpt read does not show an idempotency key on session creation, so make your own call record the source of truth: write a `call_id` and its state before creating the session, map it to the returned `session.id`, and refuse a second create for the same `call_id` unless the first is in a failed state.

```python
import asyncio, json
import httpx, websockets

API = "https://api.openai.com/v1/live/sessions"
slots = asyncio.Semaphore(29)  # from your occupied-minutes sizing

async def place_call(call, trunk, api_key):
    async with slots:
        body = {
            "session": {"model": "gpt-live-1", "instructions": call.script,
                        "audio": {"output": {"voice": "marin"}},
                        "delegation": {"type": "client"}},
            "transport": {"type": "sip", "destination": call.e164,
                          "trunk": trunk.as_dict()},
        }
        async with httpx.AsyncClient(timeout=30) as http:
            r = await http.post(API, json=body,
                                headers={"Authorization": f"Bearer {api_key}"})
        if r.status_code in (502, 504):
            return "setup_failed"          # safe to try the next trunk
        r.raise_for_status()
        sid = r.json()["session"]["id"]

        seen, answered = set(), False
        url = f"wss://api.openai.com/v1/live/sessions/{sid}/attach"
        async with websockets.connect(
                url, additional_headers={"Authorization": f"Bearer {api_key}"}) as ws:
            async for raw in ws:
                ev = json.loads(raw)
                if ev.get("event_id") in seen:
                    continue
                seen.add(ev.get("event_id"))
                if ev["type"] == "transport.answered":
                    answered = True
                elif ev["type"] == "transport.failed":
                    return "setup_failed"
                elif ev["type"] == "session.closed":
                    return "completed" if answered else "no_answer"
```

The sketch omits delegated-work handling and usage recording, which belong in the same loop. Releasing the slot on `session.closed` rather than on the HTTP response is the point of it.

## What failover can and cannot do

Failover needs a second place to send the same work. On an outbound call, three different layers could in principle fail, and only some have a second place.

**Before the call is answered**, a failed setup can be retried. If the trunk at `provider_url` returns `502` or the session emits `transport.failed`, create a new session with a different trunk's `sips:` URL and caller number. Nobody was reached, so the retry is invisible to the callee. This is an ordinary retry-with-alternate-target pattern, and it is worth a drill: make the primary trunk's credentials wrong on purpose and confirm the second one carries traffic. Keep a retry budget, because a trunk outage plus an eager retry loop is how a dialer saturates its own slots.

**After the call is answered**, nothing moves. The audio is SRTP between your provider and OpenAI, the conversation state lives in the GPT-Live session, and the callee's phone is attached to that path.[1] There is no documented way to hand a live session to another trunk or another model mid-sentence. What you can do:

- **Transfer, deliberately.** `POST /v1/live/sessions/{session_id}/refer` sends a `Refer-To` target, a `tel:` or `sip:` URI, and your provider handles the rest of the transfer.[1] That is a handoff to a human or another system, not a failover of the model.
- **Hang up cleanly** with the hangup endpoint when your backend decides the call cannot continue.[1]
- **Redial as a new call.** Pass the new session a short summary of what was already agreed, not the full transcript, and open with an acknowledgement. Whether and when you may redial someone is a business and legal rule; encode it in the dialer, not in the prompt.

The same logic applies to the delegated backend. In client delegation your backend handles the delegated work,[1] and that backend's calls to a text model are ordinary requests that can fail over like any others. If a text model times out or returns a 5xx before its response starts, retrying on another target is safe for the caller, who hears at worst a pause. See [failover mid-agent-run](https://infro.io/blog/failover-mid-agent-run-what-happens-to-tool-calls-and-state) for what happens to tool calls when that retry lands partway through a run.

## Where INFRO fits, and where it does not

INFRO does not carry the SIP session or the voice audio, and it does not place calls. Its use here is on the delegated text side. If your backend calls chat completions for the reasoning behind a call, a named route over your own connections with health checks and failover retries a request that times out or returns a 5xx before the response starts, without your code seeing it. Per-request usage with estimated provider cost, budgets by project or key, and negotiated rates entered per model give the backend line of the forecast above. Voice session minutes remain on your OpenAI invoice and are not estimated by INFRO. Provider rates are always what your own provider bills.

## Checklist before the first real campaign

- [ ] Trunk accepts TLS signaling and SDES-SRTP, and firewall rules allow port 5061 and the listed UDP media ranges.
- [ ] A second trunk is configured, and a drill has proven the retry path.
- [ ] Sideband attaches immediately after creation, deduplicates by `event_id`, and releases the slot on `session.closed`.
- [ ] One handler per side effect, with your own `call_id` record preventing double creates.
- [ ] Ringing is cut well under the 3-minute limit.
- [ ] A pilot day settles whether ringing time bills and what concurrency your account sustains.
- [ ] Forecast shows voice, backend, and trunk lines separately, with cost per answered call as the headline.

For a comparison of how other vendors bill voice, see [Voice agent APIs compared](https://infro.io/blog/voice-agent-apis-compared-2026); for the billing edge cases of interrupted sessions, see [what providers bill for cancelled or failed streams](https://infro.io/blog/do-providers-bill-cancelled-or-failed-streams-what-to-forecast).

## Questions

### Can I use SIP URIs as the outbound destination?

No. The destination must be a phone number in E.164 format; OpenAI's guide says SIP URI destinations aren't supported for outbound calls. [1]

### Do I need an incoming-call webhook for outbound calls?

No. An outbound call needs no incoming-call webhook and no accept request. You create the session, then attach a sideband WebSocket to watch call progress. [1]

## Sources

1. Telephony and SIP (GPT-Live guide, markdown version) — OpenAI. https://developers.openai.com/api/docs/guides/voice-sip.md (accessed 2026-11-10)
2. Voice agent APIs compared: GPT-Live, Grok Voice, Voxtral, Gemini — INFRO. https://infro.io/blog/voice-agent-apis-compared-2026 (accessed 2026-11-10)
