```
## Using the Realtime client
Use this when you open the WebSocket yourself with `client.realtime.connect()` and drive the event loop.
### Set up tracing
`wrap_realtime` returns a transparent proxy of your connection. Your existing `async for event in connection` loop, `session.update`, and tool handling stay the same:
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
from langsmith.integrations.openai_realtime import wrap_realtime
from openai import AsyncOpenAI
client = AsyncOpenAI()
async with client.realtime.connect(model="gpt-realtime-2") as raw, wrap_realtime(
raw,
project_name="openai-realtime-voice",
) as connection:
await connection.session.update(session={...}) # your existing config
async for event in connection:
... # your existing handling: play audio, run tools, update UI
```
Each conversation is captured as its own trace. To group it with related interactions in a LangSmith [thread](/langsmith/threads) (for example to continue an earlier session or pick up from a text chat), pass a `thread_id`. Reusing the same ID across traces links their events together.
Any [`@traceable`](/langsmith/annotate-code) tools you run while handling an event nest under that event automatically.
Enable `input_audio_transcription` and the agent transcript in your `session.update` in order to view a transcript as part of the trace.
### Record the conversation audio
When you feed the proxy your microphone and playback audio, it attaches a single stereo recording (user left, agent right) to the trace. To flag barge-ins, use `is_agent_speaking`:
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
import base64
async with client.realtime.connect(model="gpt-realtime-2") as raw, wrap_realtime(
raw,
is_agent_speaking=lambda: speaker.buffered_bytes() > 0,
) as connection:
# Record the agent's audio from the speaker, so the recording reflects only
# what was played — audio a barge-in discards before playback is never recorded.
speaker.set_played_callback(connection.record_agent_audio)
# Record the user's mic where you send it to the model.
async def send_mic(mic_chunk):
await connection.input_audio_buffer.append(
audio=base64.b64encode(mic_chunk).decode("ascii")
)
connection.record_user_audio(mic_chunk) # user mic PCM16 as sent
async for event in connection:
if event.type == "response.output_audio.delta":
speaker.play(base64.b64decode(event.delta))
```
You should record the agent's audio from the speaker, so that the recording reflects only what was played. During a barge-in, generated audio is discarded before playback and should not be recorded. Doing this keeps the trace aligned with what the user actually heard.
## Using the OpenAI Agents SDK
Use this when you build the agent with the [OpenAI Agents SDK](https://openai.github.io/openai-agents-python/realtime/guide/) (`RealtimeAgent` / `RealtimeRunner`), which owns the turn and tool-call loop.
The Agents SDK's built-in realtime tracing uploads to OpenAI's own dashboard. Call `agents.set_tracing_disabled(True)` to avoid a second, separate upload path.
### Set up tracing
`wrap_realtime_session` wraps the `RealtimeSession` and enters it for you. Iterate it as you would the original; the SDK runs tools and manages turns:
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
from agents import set_tracing_disabled
from agents.realtime import RealtimeAgent, RealtimeRunner
from langsmith.integrations.openai_realtime import wrap_realtime_session
set_tracing_disabled(True)
runner = RealtimeRunner(
starting_agent=RealtimeAgent(name="assistant", instructions="...", tools=[...]),
)
session = await runner.run()
async with wrap_realtime_session(
session,
project_name="openai-realtime-voice",
) as conn:
async for event in conn:
... # your handling: play audio, update UI
```
The conversation transcript is reconstructed from the session's `history` snapshots, so messages appear even though the SDK streams them as partials.
Each conversation is captured as its own trace. To group it with related interactions in a LangSmith [thread](/langsmith/threads), for example to continue an earlier session or pick up from a text chat, pass a `thread_id`. Reusing the same ID across traces links their events together.
### Record the conversation audio
Feed the proxy your microphone and playback audio:
```python theme={"theme":{"light":"catppuccin-latte","dark":"catppuccin-mocha"}}
# Record the agent's audio from the speaker, so the recording reflects only
# what was played — audio a barge-in discards before playback is never recorded.
speaker.set_played_callback(conn.record_agent_audio)
# Record the user's mic where you send it to the session.
async def send_mic(mic_chunk):
await conn.send_audio(mic_chunk)
conn.record_user_audio(mic_chunk) # user mic PCM16 as sent
async for event in conn:
if event.type == "audio":
speaker.play(event.audio.data)
```
You should record the agent's audio from the speaker, so that the recording reflects only what was played. During a barge-in, generated audio is discarded before playback and should not be recorded. Doing this keeps the trace aligned with what the user actually heard.
## Next steps
Core conventions for tracing voice agents.
Attach the conversation audio recording to your trace.
***
[Connect these docs](/use-these-docs) to Claude, VSCode, and more via MCP for real-time answers.
[Edit this page on GitHub](https://github.com/langchain-ai/docs/edit/main/src/langsmith/trace-openai-realtime.mdx) or [file an issue](https://github.com/langchain-ai/docs/issues/new/choose).