​

Live transcript streaming

​

Why this surface exists

• Post-call transcription and recordings produce a complete transcript once the call ends. Use the recording library when you need the finished, normalised document, search across calls, or exports. The recording lifecycle covers what happens to recordings and their transcripts after hang-up.
• This surface is live-redact-then-stream. There is no batch step and no webhook delivery: frames only arrive while an SSE connection is open. If your integration can wait for the call to end, use the post-call surfaces instead of holding a stream open.

​

Endpoint contract

​

Events

​

Transcript frame shape

​

Lifecycle

​

Redaction guarantees

• Every hydrated frame and every live frame is masked before it is written to the stream. The redacted frame is all a subscriber ever sees; with redaction enabled, a spoken payment card number, social security number, phone number, email address, or IP address (or every supported category, when your policy does not restrict the set) never reaches a subscriber.
• The category set is resolved once, when the stream opens, from the same tenant policy the recording pipeline uses, so the live stream and the stored recording cannot disagree about what is masked.
• Redaction is a tenant setting, not a client option. Subscribers cannot request more or less redaction per connection, in real time or otherwise; a change to your policy applies to streams opened after the change.
• When redaction is disabled for your organization, frames pass through unchanged.

​

Subscribe from a client

const source = new EventSource(
  `https://api.orbit.devotel.io/api/v1/voice/calls/${callId}/transcript/stream?token=${API_KEY}`,
);

source.addEventListener("connected", (e) => {
  const { status } = JSON.parse(e.data);
  console.log("stream live, call status:", status);
});

source.addEventListener("transcript", (e) => {
  const frame = JSON.parse(e.data);
  if (frame.type === "final") appendLine(frame.speaker, frame.text);
  else renderPartial(frame.speaker, frame.text);
});

source.addEventListener("end", (e) => {
  const { reason } = JSON.parse(e.data);
  if (reason === "max-duration") reconnectWithBackoff();
  // "terminal" means the call is over; do not retry.
});

• The browser EventSource reconnects on its own after a drop. If you build your own client, use exponential backoff capped at roughly 30 seconds, and stop retrying after a terminal end, a terminal: true status, or a 404.
• Reconnects replay the hydration burst, so de-duplicate against the last frame you rendered. Do not assume a zero gap: frames published while you were disconnected are not re-delivered.
• Register listeners only for the event names you handle and ignore the rest. New event types may be added over time; treat unknown names as no-ops, never as errors.
• ?token= puts your key in the URL. Query strings are stripped from access logs platform-wide, but keep the key in server-side or short-lived session contexts in production.

​

Failure modes

• The stream closes unexpectedly. Proxies, sleeping laptops, and load balancers all sever SSE connections. Treat any close as recoverable unless it follows end with reason: "terminal" or a 404: reconnect and let hydration restore history.
• Silence on a live call. Live frames ride a push channel that is not replayed. If the event bus blips, frames published during the blip are not re-delivered; the next reconnect hydrates whatever was captured. A run of : ping keepalives with no transcript events means the connection is healthy; it does not mean speech stopped.
• Transcription not enabled. When live transcription is off for the call, the stream opens and delivers connected, status, and keepalives, but no transcript events. Silence is a signal: check your transcription configuration (see Live call transcription) rather than the stream.
• The 30-minute cap. end with reason: "max-duration" is routine housekeeping, not an error. Reconnect to continue.

​

Example: supervisor console

function attachTranscript(callId, cardEl, sessionToken) {
  const box = document.createElement("div");
  cardEl.appendChild(box);

  const source = new EventSource(
    `/api/v1/voice/calls/${callId}/transcript/stream?token=${sessionToken}`,
  );

  let partialEl = null;
  source.addEventListener("transcript", (e) => {
    const frame = JSON.parse(e.data);
    if (frame.type === "final") {
      if (partialEl) {
        partialEl.remove();
        partialEl = null;
      }
      const line = document.createElement("p");
      line.textContent = `${frame.speaker}: ${frame.text}`;
      box.appendChild(line);
    } else if (partialEl) {
      partialEl.textContent = `${frame.speaker}: ${frame.text} ...`;
    } else {
      partialEl = document.createElement("p");
      partialEl.textContent = `${frame.speaker}: ${frame.text} ...`;
      box.appendChild(partialEl);
    }
  });
  source.addEventListener("end", () => source.close());
  return () => source.close();
}

​

Related

• Live call transcription: how speech-to-text works during a call.
• Live-call speech failover: what provider failover means for a live transcript.
• Supervisor plane model: delegated supervision, including the supervisor transcript surface.
• Recording lifecycle: the post-call path for recordings and transcripts.