7 Best Session Replay Tools for AI Chat and LLM Apps in 2026

On its own, a replay of a chat UI shows someone typing, a spinner, and text appearing. It can't tell you whether the answer was right, which tools the agent called, or what it cost. How well a tool joins the replay to the LLM side comes down to five things.

• Two session IDs. A conversation and a browser visit are different things: one visit can hold several conversations, and one conversation can span several visits. Pick your conversation ID before you instrument. In Amplitude, billing is per agent session, so a conversation sent without one bills as several.
• Getting the replay ID to your backend. The LLM call runs on your server; the replay ID lives in the browser. Every tool here sends a browser ID with the chat request. PostHog's SDK can add the header for you, and Dynatrace's RUM injects a W3C traceparent into every fetch().
• Prompt content and PII. Replay masking covers what's on screen. It does nothing for the prompt text you send to an LLM trace. Sentry's Python SDK leaves prompts out unless you set send_default_pii=True, LaunchDarkly tells you to redact in your instrumentation, and Amplitude offers three privacy modes, down to metadata only (cost, tokens, latency, no transcript).
• Signals as well as traces. A trace shows an engineer one request. A PM needs to know how often conversations fail and for whom, so look for evaluators that score every conversation and a way to filter replays by that score.
• Streaming responses. Answers that stream in can shift the layout and get abandoned halfway. Sentry tells you to keep the span open until the stream finishes. New Relic tracks Cumulative Layout Shift as AI content streams in.

1. Amplitude: best for quality signals on each conversation, linked to replay, funnels, guides, and flags

Amplitude is an AI analytics platform. Product analytics, session replay, Agent Analytics, guides and surveys, feature experimentation, and feature flags run on one set of events and one user record. Agent Analytics turns LLM traces into agent sessions, turns, tool calls, cost, latency, and quality signals. When your frontend runs Amplitude Session Replay, each agent session can carry a link to the recording of the visit it happened in.

Setup takes three paths. The Node and Python AI SDK is the fastest, and Agentic Setup installs it from a prompt you paste into your coding assistant. If you already emit OpenTelemetry GenAI spans, point your exporter at Amplitude's OTLP endpoint and set gen_ai.conversation.id and enduser.id. Browsers, edge runtimes, and AI app builders can send [Agent] events through the HTTP API. To link replay, read amplitude.getSessionId() and amplitude.getDeviceId() in the browser and pass them when you open the agent session on the backend.

An illustrative example: a project management app ships an assistant that drafts sprint plans. Activation looks flat. In the Sessions view, the PM filters for conversations where Task Completed is false and sees a cluster of topics about importing from Jira. Opening one shows the agent called the import tool three times with the wrong project key. The linked replay shows the user pasting a Jira URL, waiting through two retries, then closing the panel. The PM saves a cohort of users with repeated failed import sessions and targets them with a short guide on connecting Jira first. Engineering ships a fix to the tool's input parsing behind a feature flag, and a funnel from First Agent Session to Sprint Created shows whether flagged users finish.

Best for: AI product teams that want every conversation scored, the failures one click from a replay, and the fix measured in the same funnels, guides, and flags

Pricing: Free includes 2M events a month, 10K monthly session replays, 5,000 monthly agent sessions, unlimited feature flags, 1 live guide or survey, and AI agents, with no credit card. Every plan includes trace analysis, topic clustering, out-of-the-box signals, custom LLM evaluators, calibration runs, and bring-your-own-key for LLMs. Plus starts at $0 for the first 2M events (card required), scales to 70M events, and adds custom events, 20 behavioral cohorts, heatmaps, and 2-year data retention. No punitive overage rates. Additional usage billed at same per-unit rate. Growth includes 10,000 agent sessions and 20K replays, Enterprise includes 20,000 agent sessions and 50K replays, both priced through sales with unlimited data access. Startups with under $10M in funding and fewer than 20 employees can apply for the Startup Scholarship: 1 year of Growth with 100M events or 200k MTUs. See Amplitude pricing.

Key features:

Signals and evaluators. Out-of-the-box signals such as Task Completed, plus custom LLM judges and code-based evaluators you calibrate against labeled datasets.

Sessions view. Filter conversations by agent, signal outcome, user, or review status, then read each turn with its tool calls, model, tokens, cost, and latency.

Replay link. Jump from an agent session to the recording of the user's visit, or to their full event stream in User Lookup.

Agent events everywhere. Agent events work in charts, funnels, retention, and cohorts, so you can chart retention by whether a user's first session completed its task.

Pros: Conversation quality, replay, and product outcomes in one tool; OpenTelemetry ingest without re-instrumenting; 5,000 agent sessions and 10K replays on Free; cohorts of failed sessions feed guides, surveys, and flag targeting

Cons / less ideal if: Agent session chats are retained 14 days on Free and Plus and 30 days on Growth and Enterprise (90 with an add-on), shorter than event data. Replay retention is 1 month on every plan, with an add-on for more on Growth and Enterprise. AI-based replay summaries are a Growth and Enterprise add-on. The replay link needs Amplitude Session Replay on the frontend.

Closest alternative: PostHog for an open source, self-hostable stack; Datadog if your engineers already live in APM

Try Amplitude for free today.

2. PostHog: best for open source, self-hostable LLM traces with a replay button

PostHog's AI Observability, part of its open source, self-hostable stack, wraps your LLM provider's SDK and logs each call as an $ai_generation event, grouped into traces and, when you set $ai_session_id, into conversations. To link replay, configure posthog-js to add an X-POSTHOG-SESSION-ID header to requests to your API, then pass that value as $session_id on the backend LLM event. A session replay button then appears on the generation or trace.

PostHog is MIT-licensed open source and can be self-hosted, which matters if prompts can't leave your infrastructure. Its docs are blunt about the two IDs: $ai_session_id is your conversation, $session_id is the browser visit, and they're different on purpose.

Best for: Engineering-led teams that want LLM traces, replay, and flags in one open source tool

Pricing: Free each month: 5K recordings, 100K AI Observability events, 1M analytics events, and 1M flag requests. Pay-as-you-go keeps the free tier and bills usage above it. Recordings are kept 1 month on Free and 90 days on pay-as-you-go.

Key features: Automatic header injection; traces, spans, generations, and embeddings; evaluations billed with AI Observability; error tracking and feature flags in the same project

Pros: Generous free AI event allowance; self-hosting; per-product billing limits so a spike doesn't surprise you

Cons / less ideal if: The link is per generation or trace, so you build conversation-level quality charts yourself. Free recordings expire after a month, before many teams finish reviewing an assistant launch.

Closest alternative: Amplitude for scored conversations next to product funnels; Sentry for a transcript view

3. Datadog: best for teams already on Datadog APM and RUM

Datadog links its LLM Observability product (now also called Agent Observability in the docs) to RUM by forwarding the RUM session ID from the browser to your agent endpoint. On the backend, LLMObs.annotate tags the span with that session ID. After that, a RUM session shows an "LLM Traces" button, and an LLM trace shows a "RUM Session" link that opens the replay.

Your LLM spans sit next to APM, logs, and infrastructure metrics, so a slow vector database shows up on the same trace as the slow answer. Datadog's agent skills include a session classifier that judges whether user intent was satisfied from LLM traces, RUM behavior, and audit events.

Best for: Platform and SRE teams that already run Datadog and want replay on the same trace as the model call

Pricing: Session Replay is an add-on at $2.50 per 1,000 sessions a month billed annually, or $3 month-to-month. RUM sessions bill separately. Agent Observability (formerly LLM Observability) is free up to 40K LLM spans a month, and Pro is $160 a month for up to 100K. Only LLM spans count; tool, workflow, and agent spans don't.

Key features: Two-way links between RUM and LLM traces; APM span correlation without extra setup on the Python SDK; LLM experiments and evaluations

Pros: Deepest backend context on this list; one bill if you're already a customer

Cons / less ideal if: Three products (RUM, Session Replay, LLM Observability) to enable and budget. Product analytics, guides, and surveys aren't part of the stack, so acting on what you find happens elsewhere.

Closest alternative: Dynatrace for enterprise OpenTelemetry; New Relic if you're on New Relic

4. Sentry: best for chat transcripts next to errors

Sentry's Conversations view shows past chats the way a user saw them: user messages, assistant replies, tool calls, reasoning rows, and evaluation results in order, with failed tool calls marked as errors. It groups spans by gen_ai.conversation.id, and some integrations such as OpenAI set it for you. The header sums cost, tokens, LLM calls, and tool calls, and Copy Transcript exports the conversation as Markdown.

Sentry also sells Session Replay, and Agent Tracing data connects to its errors, logs, and traces. The conversation header links to its underlying traces. The Conversations docs don't describe a link to the replay. Two setup details: in Python, prompt and response content is off until you set send_default_pii=True, and for streamed responses you keep the span open until the stream finishes.

Best for: Engineering teams that already use Sentry and want to read what the assistant said when an error fired

Pricing: A free Developer plan for one user. Team costs $26 a month billed annually ($29 monthly) with 50 replays included; extra replays start at $0.00375 each.

Key features: Conversations transcript; agent dashboards for tokens, latency, tool usage, and error rates; evaluation spans; Session Replay and error tracking in the same project

Pros: Readable transcripts with errors inline; automatic instrumentation for supported AI libraries

Cons / less ideal if: 50 included replays on Team is small for a chat feature with real traffic. Evaluations show on spans you emit; there's no product analytics to chart conversation outcomes against retention.

Closest alternative: PostHog for open source traces with replay; LaunchDarkly for transcripts tied to flag variations

5. LaunchDarkly: best for one platform for flags, AI configs, replay, and traces

LaunchDarkly's observability product records session replay and traces, and its LLM observability stitches spans that share gen_ai.conversation.id into one transcript. The Conversations tab shows messages grouped into "missions," one per user question, with a waterfall view for timing, estimated cost, and evaluation badges on each turn.

LaunchDarkly also ties traces to the prompts you ship. When you serve prompts and models through AgentControl configs, traces attach to the config and variation that produced them. You can roll out a new prompt to 10% of users and filter traces by variation. From a session replay, you jump to traces, errors, and logs from the same session.

Best for: Teams that already ship features and prompts through LaunchDarkly and want to see the effect of each variation

Pricing: The free Developer plan includes 5,000 session replays a month plus errors, logs, and traces. AgentControl includes 5,000 AI runs, and ingestion stops at that cap. Foundation is pay as you go after a 14-day trial: 5,000 replays are included, usage past that bills as you go, and service connections past the first 5 cost $10 each a month.

Key features: Conversation transcripts with missions; AgentControl config linking; evaluation scores on turns and conversations; OpenTelemetry GenAI conventions plus OpenLLMetry normalization

Pros: Prompt and model rollouts and their traces in one place; clear troubleshooting table for broken transcripts

Cons / less ideal if: The Conversations list covers the last seven days. Product analytics and in-app guides aren't in the box, so measuring whether a variation improved activation needs another tool.

Closest alternative: Amplitude for flags, replay, and agent quality signals next to product analytics

6. Dynatrace: best for enterprise OpenTelemetry pipelines

Dynatrace publishes a full tutorial for this job. Its RUM JavaScript injects a W3C traceparent header into each fetch(), so the backend LLM span becomes a child of the browser action. You set gen_ai.conversation.id to the RUM session ID (dt.rum.session.id), and the distributed trace view links straight to the RUM session. A DQL query then rebuilds a whole conversation across traces.

The sample app is a chatbot that routes between Amazon Bedrock and Azure OpenAI with pydantic-ai, a fair picture of enterprise multi-provider stacks. The AI Observability app adds prompt, token, latency, and agent topology views.

Best for: Enterprise teams on Dynatrace that route LLM traffic through OpenTelemetry and need it tied to real users

Pricing: The rate card lists $0.0045 per session with Session Replay capture ($4.50 per 1,000) and $0.00225 per standard RUM session. Trace ingest bills separately.

Key features: Automatic trace context from RUM; conversation ID aligned with the RUM session; DQL across spans; Session Replay for web frontends with masking and opt-in controls

Pros: Strong fit for multi-cloud, multi-model stacks; no proprietary SDK required on the LLM side

Cons / less ideal if: The pattern needs a custom span processor and exporter wrapper to stop the framework overwriting your conversation ID. It's built for platform teams, not PMs.

Closest alternative: Datadog for the same job with less custom code

7. New Relic: best for AI apps rendered inside ChatGPT

New Relic solved a narrow problem other tools skip: apps that render in an iframe inside ChatGPT. Browser agent v1.305.0 and later handle the iframe's security headers and storage limits, so session replay, page views, Ajax requests, JavaScript errors, and console logs come through. New Relic suggests custom events for AI-specific metrics, such as how often the LLM fills a chart correctly.

For your own web app, New Relic's browser agent records replay on the Pro or Pro + SPA agent, and New Relic AI can summarize a replay's event trail. New Relic also offers AI Monitoring for LLM calls in APM.

Best for: Teams shipping a ChatGPT app, or already on New Relic browser monitoring

Pricing: Free includes 100 GB of data ingest a month and one full platform user. Replay counts against ingest, and data beyond the free amount costs $0.40 per GB.

Key features: Replay inside ChatGPT iframes; rage, dead, and error clicks; layout shift tracking while AI content streams in; replay summaries

Pros: The only documented answer here for ChatGPT app iframes; generous free ingest

Cons / less ideal if: Full platform users are the main cost as your team grows. Conversation-level transcripts and LLM quality scores aren't part of the replay story.

Closest alternative: Datadog for RUM-to-LLM links in your own app

Datadog, Sentry, Dynatrace, New Relic, and LaunchDarkly cover what engineers need first: a trace for every model call, token and latency numbers, errors on the same timeline, and a replay one click away. If your question is "why did this request fail," any of them can answer it.

Product teams tend to need more than that:

• The question is product, not infrastructure. "Do users who get a good first answer come back?" needs agent quality signals joined to retention and funnels. Observability tools answer what happened to the request, not whether the user came back.
• Replay and LLM bills stack. RUM sessions, replay sessions, and LLM spans are often three separate meters.
• Someone has to act on the finding. A failing conversation pattern often calls for a guide, a survey asking what went wrong, or a prompt rollout. Observability tools don't ship in-app guides or surveys.
• The fix needs a flag. Shipping a new prompt or tool fix to part of your users takes feature flags. Teams use Statsig, LaunchDarkly, or Optimizely for that, or ship the prompt change from the same tool that scored the conversations.

These tools price on different units: events, agent sessions, replay sessions, LLM spans, GB, or users. One scenario makes them comparable.

Scenario: a B2B SaaS web app with an in-app assistant, 10,000 recorded sessions a month, 5,000 assistant conversations, about 50,000 LLM calls, and 1.5M product events.

Most of the published bills here stay under $200 a month at this size. What separates the tools is whether the replay, the conversation, and the product outcome land in the same place.

• You want open source and the option to self-host prompts: PostHog. You build conversation-level quality charts yourself.
• Your engineers already live in Datadog APM: Datadog. You budget for RUM, replay, and LLM spans separately.
• You want to read what the assistant said when an error fired: Sentry. You'll outgrow 50 included replays fast.
• You roll out prompts and models with flags: LaunchDarkly. You measure product impact somewhere else.
• You run multi-model LLM traffic through OpenTelemetry at enterprise scale: Dynatrace. You write a span processor to keep the conversation ID intact.
• You ship a ChatGPT app: New Relic. You don't get conversation transcripts in the replay.
• You want every conversation scored, the failures one click from a replay, and the fix shipped as a guide, survey, or flag: Amplitude. A failed conversation opens its replay, and the users who had it become a cohort you can send a guide or a flagged fix. Free covers 5,000 agent sessions and 10K replays.

Amplitude fits teams that judge an assistant by what users get done. Latency and token counts are part of it, but they don't tell you whether the answer helped. Agent Analytics scores each conversation, a failed one links to the session replay of the visit, and the outcome shows up in the same funnels and retention charts as the rest of the product. Users with failed conversations can then get a guide, a survey asking what went wrong, or a flagged fix, without exporting a list to another tool.

It's less ideal if you need conversation transcripts kept past 30 days without an add-on, or want LLM traces inside the APM tool that monitors your servers.