Skip to content

Agents and multimodal systemsGuide

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

Outbound SIP calling for GPT-Live is now available to every OpenAI organization through the Live API. This guide covers sizing concurrent calls, forecasting per-minute spend, classifying dropped calls, and the narrow set of things failover can do once a call is answered.

By INFRO Editorial

Published

10 min read

A glowing autonomous agent core coordinating tools, memory, and multiple AI model routes

In short

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. 1

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

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 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:

LineDriverStatus
Voice session timeAnswered talk-minutes, silence and backend waits includedList rate cited above
Ringing and setup timeRing minutes before answerUnconfirmed: the pages read do not say whether it bills
Backend model and toolsTokens and tool calls from delegated workBilled at their own rates
SIP providerYour trunk's per-minute and per-call chargesBilled by your provider, outside OpenAI
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.

ClassSignalSafe to retry on another path?
Setup failure502, 504 on creation, or transport.failedYes, nobody was reached
No answerRinging ends without transport.answeredYes, on your schedule, within your contact rules
Mid-call dropsession.closed after transport.answeredOnly as a new call, with context
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.

dial.py
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 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; for the billing edge cases of interrupted sessions, see what providers bill for cancelled or failed streams.

Questions readers ask

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

From the team that builds it

Where this shows up in INFRO

INFRO is a control plane in front of the provider accounts you already hold. The capabilities below are the parts of it this article touches, each with the documentation that defines its behaviour.

INFRO accounts are self-serve. Provider usage is billed to you by your providers; INFRO charges a software subscription and takes 0% of model spend. See plans.

Sources

Numbered in order of first citation. Each was opened and checked against the claim on the date shown.

  1. 1.Telephony and SIP (GPT-Live guide, markdown version) (opens in a new tab) — OpenAI. Accessed Nov 10, 2026.
  2. 2.Voice agent APIs compared: GPT-Live, Grok Voice, Voxtral, Gemini (opens in a new tab) — INFRO. Accessed Nov 10, 2026.

About this article

Read OpenAI's Telephony and SIP guide for GPT-Live (markdown version) and INFRO's own voice API comparison on 2026-11-10. OpenAI's pricing page, session-management page and cost page returned only navigation or errors, so no concurrent-call limit, close-reason list or ringing-billing rule is stated here; those are marked unconfirmed.

Last checked against its sources on . The next review is due by . No separate named reviewer is recorded for this article.

How articles are written, sourced and corrected is set out in the editorial standards.