We’re building an internal supervisor view that lists ongoing calls and follows
what’s being said. The list works well via /v3/list-calls with
call_status filtered to “ongoing”.
For the transcript we’re polling GET /v2/get-call/{call_id} every few seconds,
but transcript and transcript_object stay empty until the call ends — which
matches your docs (“Available after call ends”) on both fields.
Your own Live Monitoring page does show the transcript updating live during a
call, so the data clearly exists mid-call.
Three questions:
Is there any API or webhook that exposes the partial transcript of an
in-progress call — an endpoint, a webhook event that fires per utterance, or
a beta we could opt into?
If not, is there a supported way to subscribe to live transcript for a phone
call WITHOUT moving to a custom LLM over the LLM WebSocket? We want Retell to
keep running the model; we only need read access to the transcript stream.
Is a v3 get-call planned, and would it populate transcript_object while
call_status is “ongoing”?
Happy to be a beta tester if something is in progress.
For questions 1 and 2, the supported approach is the Monitor Call WebSocket. It provides live transcript updates for an in-progress phone call while Retell continues running the configured LLM. Your server can connect in read-only mode using the API key and receive the initial snapshot along with subsequent user/agent turns, tool calls, and node transitions. Up to 5 connections can monitor the same call concurrently.
Please note that the live stream is text-only, provides utterance-level timestamps rather than per-word timing, and is raw/unscrubbed, so it should be handled as sensitive data. This is also the same mechanism used by Retell’s Live Monitoring view.
For question 3, we’ll confirm this with the relevant team and get back to you once we have an update.
Partial/live transcript via API or webhook
The only supported mid-call transcript stream is the transcript_updated webhook event. There is no REST endpoint, WebSocket, SSE stream, or beta flag that exposes partial transcript otherwise.
How it fires:
Per turn boundary. Every time turn-taking flips (user finishes speaking → agent turn, or vice versa), Retell emits transcript_updated with the full transcript-so-far. In practice that’s roughly one delivery per utterance in a normal back-and-forth.
Plus a final delivery at call end, so you never miss the last turn.
Payload = full call object + transcript_with_tool_calls — same shape as /v2/get-call post-call, just delivered incrementally. Each delivery is a complete replacement, not a delta — key by call_id and overwrite.
Signed with X-Retell-Signature on your existing webhook URL. No separate subscription infra.
What’s not available (so you don’t spend time looking):
No sub-turn / interim ASR partials. We don’t stream interim ASR hypotheses out to customers. If you need per-word streaming, the only path is a custom LLM over the LLM WebSocket (which you’ve said you want to avoid).
No mid-call GET /v2/get-call transcript. Documented as “available after the call ends,” and that reflects the storage model — the transcript isn’t persisted to the read path until finalization. There’s no org-level flag to change this.
No public equivalent of the dashboard Live Monitoring stream. That view uses internal transport and isn’t exposed as a customer API.
Enable it by adding transcript_updated to your agent’s (or org’s) webhook events: Retell webhooks overview - Retell AI . Your supervisor UI can then re-render on each delivery — same latency the dashboard’s Live Monitoring view sees, since both are driven off the same turn-boundary event internally.
Read-only live transcript without going custom-LLM transcript_updated is exactly that path — it’s push-based, requires no polling, and Retell keeps running the model. You don’t need to move to a custom LLM over the WebSocket to get read access to the transcript stream.
There is no public WebSocket/SSE endpoint for tapping the live transcript outside the webhook. Our dashboard’s Live Monitoring uses internal transport that isn’t exposed as a customer API.
Polling /v2/get-call won’t work for this use case — transcript and transcript_object are populated only after the call ends, as the docs state.
v3/get-call and mid-call transcript_object
There’s no v3/get-call endpoint today — v3 currently ships /v3/list-calls only. I can’t commit to roadmap on your behalf, so I’d rather not promise a timeline.
Recommended pattern for the supervisor view
Keep /v3/list-calls (filter call_status: ongoing) for the list.
Add transcript_updated to your webhook subscription, cache the latest payload per call_id, and render that in the supervisor UI.
On call_ended / call_analyzed, replace the in-memory copy with the final transcript and persist as needed.