Session Replay Solutions

Research & comparison — updated May 2026. Focused on session replay as the primary use case.

TL;DR for Team Review

We evaluated 6 session replay providers across features, pricing at scale (100K–1M sessions/mo), setup complexity, and data confidence. Here is the bottom line:

Best Value (Managed)
PostHog
~$21K/yr at 1M sessions
Published pricing, open source
Best Value (Self-Host)
OpenReplay
~$6K/yr (infra only)
Open source, co-browsing
Best If Using Datadog
Datadog RUM
~$22K/yr at 1M sessions
Full-stack trace correlation

Pricing confidence varies. PostHog numbers are exact (published rate card). Datadog has conflicting sources ($1.80 vs $2.50/1K). LogRocket and FullStory require sales quotes at scale — ranges are wide. See the confidence column in each pricing table.

Decision Wizard

Answer these questions as a team. Your answers map directly to a shortlist.

Question 1

What is our expected monthly recorded session volume?

Under 5K→ FullStory or PostHog free tier covers you
5K–50K→ All options viable, price differences are small
50K–250K→ PostHog, Datadog, Sentry lead on cost
250K+→ PostHog or OpenReplay; others get expensive
Question 2

What tools are we already paying for?

Datadog (APM/logs)→ Add Datadog RUM — correlation is the value
Sentry (errors)→ Add Sentry replay — cheapest path to error context
Neither→ PostHog or standalone tool (no existing lock-in)
Question 3

What is the primary use case for replay?

Bug reproduction→ Sentry (error-linked) or LogRocket (state replay)
UX/product insight→ FullStory (frustration signals) or PostHog (funnels)
Customer support→ OpenReplay (co-browsing) or FullStory (search)
All of the above→ PostHog (broadest feature set for the price)
Question 4

Do we need data sovereignty / self-hosting?

Yes, required→ OpenReplay (best OSS) or PostHog (self-host option)
Nice to have→ PostHog EU cloud, or OpenReplay 35+ regions
Not a concern→ All options are on the table

Contents

  1. Executive Summary
  2. Decision Wizard
  3. Quick Overview Cards
  4. Feature Comparison Table
  5. Pricing — Session Replay Only
  6. Pricing — All-In Cost Context
  7. PostHog — Deep Dive
  8. Datadog — Deep Dive
  9. Sentry — Deep Dive
  10. LogRocket — Deep Dive
  11. FullStory — Deep Dive
  12. OpenReplay — Deep Dive
  13. Live Demo Pages
  14. Recommendation & Decision Matrix
  15. Next Steps for Team
Provider Overview

Quick Overview

PostHog

Open Source
Free up to 5K replays/mo • then $0.005/replay

All-in-one product analytics platform with session replay, feature flags, A/B testing, and surveys. Strong open-source ethos with self-host option. Best value for startups and mid-size teams that want a single tool.

Product Analytics Feature Flags A/B Testing Heatmaps Self-host
View demo page →

Datadog

Enterprise
$1.80 per 1K sessions/mo (RUM + Replay)

Enterprise observability platform where session replay is part of Real User Monitoring (RUM). Best for teams already deep in the Datadog ecosystem who want frontend replay correlated with backend traces, logs, and APM.

APM Logs Infrastructure RUM Synthetics
View demo page →

Sentry

Open Source
Free: 50 replays/mo • Team $26/mo: 50 replays + $0.003/replay overage

Error-monitoring-first platform where session replay is designed to help reproduce bugs. Replay is tightly linked to error events — ideal if your primary goal is debugging, not product analytics.

Error Tracking Performance Profiling Crons
View demo page →

LogRocket

SaaS
Free: 1K sessions/mo • Team from $69/mo

Session-replay-first platform with strong Redux/state integration. Captures network requests, console logs, and application state alongside replays. Good for frontend-heavy debugging workflows.

Session Replay Error Tracking Product Analytics Performance
View demo page →

FullStory

Enterprise
Free: 5K sessions/mo • Paid from ~$2K/yr

Digital experience intelligence platform with auto-capture and frustration signals (rage clicks, dead clicks, error clicks). Strong UX/product analytics focus. Expensive at scale but generous free tier.

Auto-capture Frustration Signals Heatmaps Journeys Conversions
View demo page →

OpenReplay

Open Source
Free: 1K sessions/mo • $5.95 per 1K sessions

Open-source session replay with co-browsing, DevTools integration, and full self-host option. Best for developer-centric teams that need deep debugging and want data sovereignty.

Co-browsing DevTools Self-host Heatmaps Funnels
View demo page →
Feature Analysis

Feature Comparison

Feature PostHog Datadog Sentry LogRocket FullStory OpenReplay
Session Replay (Web)
Session Replay (Mobile) Beta
Heatmaps Via RUM
Error Tracking
Product Analytics Basic
Feature Flags
Network Request Capture
Console Log Capture
Redux / State Replay
Co-browsing Add-on
Rage Click Detection
Privacy / Masking Controls
Self-host Option
Open Source
Backend Trace Correlation
Setup Complexity Low
1 script tag, ~5 min
Medium
CDN + init config, ~15 min
Low
Add to existing Sentry SDK, ~5 min
Low
1 script tag, ~5 min
Low
1 script tag, auto-capture, ~5 min
Medium
CDN + tracker init, ~10 min
Time to First Replay ~10 min ~20 min (needs DD account) ~10 min (if Sentry exists) ~10 min ~10 min ~15 min (cloud) / hours (self-host)
Cost Analysis

Pricing Comparison — Session Replay Only

These are session replay costs only — what you'd pay for the replay feature. Some providers (PostHog, Sentry) bill other products separately — see the "All-In" section below for the full picture.
"Sessions" = recorded sessions sent to the provider. Most teams sample 10–100% of traffic, so 1M recorded sessions may represent 1M–10M actual users.

Confidence key: ● HIGH — verified from published rate card ● MEDIUM — confirmed source but some ambiguity ● LOW — third-party reports, custom quotes, or unverified

Starter & Growth (10K – 100K sessions/mo)

Provider Free Tier 10K sessions/mo 50K sessions/mo 100K sessions/mo Billing Model Conf.
PostHog 5,000 replays/mo $25/mo $148/mo $273/mo Per replay, published tiered rates ● HIGH
Datadog None $18–25/mo $90–125/mo $180–250/mo $1.80/1K (annual) or $2.50/1K (on-demand) ● MED
Sentry 50 replays/mo $110/mo $223/mo $366/mo $0.003/replay (reserved) + $80 base plan ● MED
LogRocket 1,000 sessions/mo $69/mo (Team) ~$295/mo (Pro) Custom (Enterprise) Plan-based: 10K=$69, 25K=$139, Pro=$295 ● MED
FullStory 5,000 sessions/mo Free (within 5K) ~$200+/mo ~$400–600/mo Custom quotes, contract-based ● LOW
OpenReplay None on Dedicated $179/mo $179/mo $179–400/mo Dedicated instance from $179/mo (flat, not per-session) ● MED

Scale-Up (100K – 1M sessions/mo)

Provider 100K sessions/mo 250K sessions/mo 500K sessions/mo 1M sessions/mo Annual at 1M Conf.
PostHog $273/mo $543/mo $968/mo $1,718/mo ~$21K/yr ● HIGH
Datadog
annual committed
$180/mo $450/mo $900/mo $1,800/mo ~$22K/yr ● MED
Datadog
on-demand / restructured
$250/mo $625/mo $1,250/mo $2,500/mo ~$30K/yr ● MED
Sentry
reserved pricing + $80 base
$366/mo $751/mo $1,394/mo ~$2,672/mo ~$32K/yr ● MED
LogRocket ~$500+/mo ~$2,000–3,000/mo ~$4,000–8,000/mo ~$8,000–10,000/mo ~$96K–120K/yr ● LOW
FullStory ~$400–600/mo ~$2,500–5,800/mo ~$4,000–8,300/mo ~$6,700–16,700/mo ~$80K–200K/yr ● LOW
OpenReplay
dedicated cloud instance
~$179–400/mo ~$400–800/mo ~$800/mo ~$1,200+/mo ~$10–14K/yr ● MED
OpenReplay (self-host)
$0 software
$0 software cost — you pay for cloud infrastructure only (VMs + storage: ~$200–800/mo scaling with volume) ~$2.4K–10K/yr ● HIGH

● PostHog — Exact Math (verified from published rate card)

Cumulative tiered pricing, each tier applies only to recordings within that band:

0–5KFree= $0
5K–15K$0.0050/rec10K × $0.005 = $50
15K–50K$0.0035/rec35K × $0.0035 = $122.50
50K–150K$0.0020/rec100K × $0.002 = $200
150K–500K$0.0017/rec350K × $0.0017 = $595
500K+$0.0015/rec500K × $0.0015 = $750
1M total= $1,717.50/mo

● Sentry — Corrected Math (verified tiered overage rates)

Requires a base plan ($26 Team or $80 Business). Reserved replay pricing tiers (pay-as-you-go is ~25% more):

0–50Included in plan= $0
50–5K$0.00300/replay4,950 × $0.003 = $14.85
5K–100K$0.00285/replay95K × $0.00285 = $270.75
100K–900K$0.00257/replay900K × $0.00257 = $2,313 (at max tier)
1M total= ~$2,592 replays + $80 base = ~$2,672/mo

Previous version had ~$0.006/replay — that was wrong. Actual reserved rate is ~$0.003, roughly half. Sentry is more competitive at scale than initially estimated.

● Datadog — Two Price Points Found

Multiple sources conflict: $1.80/1K sessions (annual committed, widely cited) vs $2.50/1K sessions (on-demand or post-2025 restructuring). I could not confirm which is current from their pricing page directly — it requires a login or specific URL path that didn't render. Both rows are shown. Verify by checking your Datadog dashboard or asking sales for a quote.

● LogRocket & FullStory — Low Confidence at Scale

LogRocket: Confirmed Team plan at $69/mo (10K sessions) and $139/mo (25K) from their pricing page. Professional starts at $295/mo. Enterprise (100K+) is fully custom-quoted — the $96K–120K/yr range comes from Vendr contract reports, not published rates. Actual cost depends heavily on negotiation.

FullStory: Zero published per-session pricing. All numbers are from ~400 reported Vendr contracts (median $27.5K/yr). Range is $10K–$200K+/yr. Your quote will depend on volume, contract term, and how hard you negotiate (20–35% off initial quotes is common).

OpenReplay: Earlier "$5.95/1K sessions" serverless plan was not found on their current pricing page. Current model is instance-based: Dedicated from $179/mo (flat monthly, not per-session). Capacity depends on instance size (O1/O2/O3) — use their pricing calculator for exact numbers.

Data Retention by Provider

Provider Default Retention Max Retention Extended Retention Cost
PostHog 30 days Configurable Included in plan (self-host: unlimited)
Datadog 30 days (replay), 15 days (resources) 30 days Not extendable beyond 30 days
Sentry 30 days (Team), 90 days (Business) 90 days Upgrade to Business plan
LogRocket 1 month (Free/Team) 3 months (Enterprise) Enterprise plan upgrade
FullStory 12 months (Free), varies on paid 12 months Included in plan tier
OpenReplay 30 days (cloud) Configurable (Dedicated/self-host) Dedicated plan or self-host (storage cost only)

Additional Context: What Else Gets Billed?

The tables above are session replay only. Some providers (PostHog, Sentry) bill analytics events and error tracking separately. Others (LogRocket, FullStory, OpenReplay) bundle everything into one session price. Datadog bundles within RUM but most teams add APM/logs/infra on top. Below is context on what else you might pay for — skip this if you're comparing replay costs apples-to-apples.

What's Actually Included in the Session Price?

Understanding which costs are bundled vs. billed separately is critical. This is where the sticker shock comes from.

Provider Session Replay Cost Analytics Events Error Tracking Base Platform Fee Other Hidden Costs
PostHog $0.0015–0.005/replay Billed separately
$0.000248/identified event
$0.00005/anonymous event
1M free/mo
Billed separately
$0.00037/exception
100K free/mo
None — $0 Feature flags: $0.0001/request (1M free). Data pipelines: $0.0005/event. Each product metered independently with own free tier.
Datadog $1.80/1K sessions
(RUM + Replay bundle)
Included in session price Included in RUM None for RUM alone
But most teams add APM ($31/host), logs ($0.10/GB), infra ($15–23/host)
RUM alone is clean. But the total Datadog bill (APM + logs + infra + RUM) commonly hits $5K–15K+/mo. Custom metrics overages are common.
Sentry ~$0.006/replay
Only 50 included on all plans
N/A (not an analytics tool) Included in base plan
50K errors included, overages billed
$26/mo (Team) or $80/mo (Business) Performance spans: 5M included, overages billed. Logs: 5GB included, +$0.50/GB. Attachments: 1GB included.
LogRocket Bundled in plan tier Included in session price Included in session price $99–350/mo (plan tier) Session overage fees (unpublished rates). Conditional recording & feedback widget are paid add-ons. Extended retention costs extra.
FullStory Bundled in plan tier Included (auto-captured) Included ~$2K+/yr (quoted) Mobile sessions may be a separate SKU. Retention extensions add 10–20%. Implementation services $5K–15K. Annual price escalators 3–7%.
OpenReplay $5.95/1K sessions Included Included None (cloud)
Self-host: infra costs only
Dedicated plan: flat ~$800/mo. Self-host: your cloud infra ($200–800/mo). No surprise line items.

All-In Cost at Scale (100K – 1M sessions/mo)

These estimates include everything: session replay + analytics events + error tracking + base platform fees. Assumes a typical web app generating ~30 events per session with identified users, moderate error rates (~0.5% of sessions), and standard retention.

Provider 100K sessions/mo 250K sessions/mo 500K sessions/mo 1M sessions/mo Annual All-In at 1M
PostHog
replay + events + errors
~$520/mo
replay $248 + events ~$240 + errors ~$32
~$1,200/mo
replay $503 + events ~$610 + errors ~$80
~$2,200/mo
replay $928 + events ~$1,100 + errors ~$160
~$3,900/mo
replay $1,678 + events ~$2,000 + errors ~$300
~$47K/yr
Datadog
RUM + replay (standalone)
~$180/mo
$1.80/1K sessions, all-inclusive
~$450/mo ~$900/mo ~$1,800/mo ~$22K/yr
Datadog
realistic full-stack (RUM + APM + logs + infra)
~$3,000–6,000/mo
RUM $180 + APM + logs + infra
~$4,000–8,000/mo ~$6,000–12,000/mo ~$8,000–15,000+/mo ~$96K–180K/yr
Sentry
replays + errors + spans + base
~$440/mo
base $80 + replays ~$286 + error overages ~$70
~$900/mo ~$1,600/mo ~$2,900/mo ~$35K/yr
LogRocket
all-inclusive session price
~$500+/mo ~$2,000–3,000/mo ~$4,000–8,000/mo ~$8,000–10,000+/mo ~$96K–120K/yr
FullStory
all-inclusive + implementation
~$400–600/mo ~$2,500–5,800/mo ~$4,000–8,300/mo ~$6,700–16,700/mo ~$80K–200K/yr
OpenReplay
cloud (all-inclusive)
~$590/mo ~$800/mo
dedicated instance
~$800/mo
dedicated instance
~$1,200+/mo
larger dedicated
~$10–14K/yr
OpenReplay (self-host)
infra only, $0 software
$0 software — cloud infra estimate: $200–800/mo scaling with volume and storage needs ~$2.4K–10K/yr

PostHog: Showing the Math

PostHog bills replay, analytics events, and errors as three separate meters — each with its own free tier. Here's the breakdown at 1M sessions/mo:

Session Replay
~$1,678/mo
1M replays, tiered pricing
5K free, then $0.005→$0.0015
Product Analytics Events
~$2,000/mo
~30M identified events
(~30 events/session × 1M sessions)
1M free, then $0.000248/event
Volume discounts apply
Error Tracking
~$300/mo
~5K errors @ 0.5% session error rate
+ related exceptions
100K free/mo

Total: ~$3,900/mo (~$47K/yr) — replay is only 43% of the bill. Events are the bigger cost at scale.

You can reduce this: use anonymous events ($0.00005 — 5x cheaper), lower the replay sample rate, or set per-product billing caps. PostHog with anonymous-only events at 1M sessions drops to ~$2,100/mo ($25K/yr).

Datadog: Why There Are Two Rows

Datadog RUM + Session Replay is genuinely cheap standalone ($1.80/1K sessions, everything included). But nobody buys Datadog just for session replay — the value is correlating frontend sessions with backend traces. A realistic Datadog deployment includes:

If you truly only want session replay and nothing else, the standalone RUM row is your cost. If you want the full-stack correlation that makes Datadog worthwhile, budget for the full-stack row.

Assumptions Used in All-In Estimates

Session Replay Only — Annual Cost at 1M sessions/mo

OpenReplay SH
~$6K ●
OpenReplay Ded.
~$14K ●
PostHog
$21K ●
Datadog (annual)
$22K ●
Datadog (on-demand)
$30K ●
Sentry (reserved)
$32K ●
FullStory
$80K–200K ●
LogRocket
$96K–120K ●

Session replay costs only — no analytics events, error tracking, or platform fees included. ● = confidence dot (see legend above tables). Enterprise discounts (15–35%) not applied.

Data Retention by Provider

Provider Default Retention Max Retention Extended Retention Cost
PostHog 30 days Configurable Included in plan (self-host: unlimited)
Datadog 30 days (replay), 15 days (resources) 30 days Not extendable beyond 30 days
Sentry 30 days (Team), 90 days (Business) 90 days Upgrade to Business plan
LogRocket 1 month (Free/Team) 3 months (Enterprise) Enterprise plan upgrade
FullStory 12 months (Free), varies on paid 12 months Included in plan tier
OpenReplay 30 days (cloud) Configurable (Dedicated/self-host) Dedicated plan or self-host (storage cost only)
Deep Dives

PostHog

Overview

PostHog is an open-source, all-in-one product analytics platform. Session replay is one of several integrated tools (alongside product analytics, feature flags, A/B testing, surveys, and a CDP). The replay experience is tightly coupled with analytics — you can jump from a funnel drop-off directly into a session recording to see why users dropped.

Key Strengths

  • Generous free tier (5K recordings/mo)
  • Usage-based pricing with automatic volume discounts up to 82%
  • All-in-one: analytics + replay + flags + experiments
  • Open source with self-host option
  • Per-product billing caps — you can cap replay spend independently
  • Mobile session replay (iOS/Android), priced at 2x web
  • Console logs, network requests, and DOM snapshot capture

Pricing Details

  • 0–5K replays/mo: Free
  • 5K–15K: $0.005/replay
  • 15K–50K: $0.0035/replay
  • 50K–150K: $0.002/replay
  • 150K–500K: $0.0017/replay
  • 500K+: $0.0015/replay (70% off)
  • Mobile: 2x web pricing at each tier
  • Example — 1M replays/mo: $1,718/mo (~$21K/yr)

Pros

  • Best value at moderate scale
  • No seat-based pricing
  • Transparent, predictable costs
  • Strong privacy controls

Cons

  • Replay UI less polished than FullStory
  • No co-browsing
  • No Redux/state replay
Best for: Startups and mid-size teams wanting an all-in-one product analytics suite with session replay. Excellent cost-efficiency and the open-source option provides an exit strategy.

Datadog

Overview

Datadog's session replay is part of its Real User Monitoring (RUM) product. The key differentiator is correlation: you can trace a user session from the browser click through frontend errors, backend traces, logs, and infrastructure metrics — all in one platform. Session replay is an add-on to RUM, not a standalone product.

Key Strengths

  • Full-stack correlation: session replay ↔ APM ↔ logs ↔ infra
  • Frustration signals (rage clicks, error clicks, dead clicks)
  • Developer-focused debugging with waterfall views
  • Built-in performance monitoring (Core Web Vitals)
  • Session expires after 15 min inactivity (capped at 4 hrs)
  • Strong enterprise compliance and security controls

Pricing Details

  • RUM + Session Replay: $1.80/1K sessions (annual) or ~$2.50/1K (on-demand)
  • Replay retention: 30 days
  • Commitment discounts: Available for annual/multi-year
  • No free tier for session replay (14-day trial only)
  • Note: conflicting sources on exact rate — verify with Datadog sales

Pros

  • Unmatched full-stack observability
  • Competitive per-session price
  • Excellent for debugging infra-related frontend issues

Cons

  • No free tier
  • Costs compound with other DD products
  • Session replay is an add-on, not standalone
  • Bills can grow unpredictably
Best for: Teams already invested in the Datadog ecosystem who need frontend-to-backend correlation. Not ideal as a standalone session replay solution — the value comes from the integration with APM, logs, and infra monitoring.

Sentry

Overview

Sentry is an error-monitoring platform where session replay was added to help teams reproduce bugs visually. Unlike other tools where replay is the primary product, Sentry's replay is designed to complement error tracking — you see the replay of what happened around an error. The recommended approach is to sample lightly (1–5%) for general sessions but capture 100% of sessions where errors occur.

Key Strengths

  • Tight integration with error events and stack traces
  • Smart sampling: low general rate + 100% on errors
  • Captures ~30 seconds of context around each error
  • Open source with self-host option
  • Affordable for error-focused replay use cases
  • Canvas recording support
  • Privacy masking on by default (text, inputs, media)

Pricing Details

  • Free: 50 replays/mo
  • Team ($26/mo): 50 replays included
  • Business ($80/mo): 50 replays included
  • Reserved overage: $0.003/replay (50–5K), $0.00285 (5K–100K), $0.00257 (100K–900K)
  • Pay-as-you-go: ~25% more than reserved rates
  • Replay is billed as a separate event type

Pros

  • Very affordable for error debugging
  • Error-replay correlation is seamless
  • Privacy-first defaults
  • Easy to add if already using Sentry

Cons

  • Low free/included replay volumes
  • Not designed for product analytics use
  • No heatmaps or funnel analysis
  • Replay is secondary to error monitoring
Best for: Teams already using Sentry for error monitoring who want visual replay around errors without adding another vendor. Not ideal if your primary goal is product analytics or broad session coverage.

LogRocket

Overview

LogRocket is a session-replay-first platform with strong frontend debugging capabilities. Its standout features include Redux/Vuex/ngrx state replay (see the exact state at any point in the session) and network request inspection. It also includes product analytics, error tracking, and performance monitoring.

Key Strengths

  • Redux/Vuex/ngrx state replay — unique among competitors
  • Full network request/response capture
  • Console log and JavaScript error capture
  • Frustration scoring and rage click detection
  • Conditional recording (record only when conditions are met)
  • Performance monitoring with Largest Contentful Paint, etc.
  • Simple 2-line setup

Pricing Details

  • Free: 1,000 sessions/mo, 1-month retention
  • Team ($69/mo): 10K sessions; $139/mo for 25K
  • Professional ($295/mo): custom session volume, annual commitment
  • Enterprise: custom pricing, 1M+ sessions
  • Annual billing saves 10–15%
  • Add-ons: conditional recording, feedback widget

Pros

  • Best-in-class state management replay
  • Excellent frontend debugging tools
  • Good free tier for small teams
  • Very easy integration

Cons

  • Gets expensive fast (10K+ sessions)
  • Closed source, no self-host
  • Pricing tiers are opaque
  • Retention is limited on lower plans
Best for: Frontend-heavy teams (especially React/Redux) who want deep application-state debugging alongside session replay. The state replay capability is genuinely unique. Cost becomes a concern past 10K sessions/mo.

FullStory

Overview

FullStory is a digital experience intelligence platform focused on understanding user behavior. It auto-captures every interaction without manual instrumentation. Its frustration signals (rage clicks, dead clicks, error clicks, thrashed cursor) are industry-leading. The free tier (5K sessions, 12-month retention) is surprisingly generous.

Key Strengths

  • Auto-capture everything — no manual event instrumentation
  • Industry-leading frustration signals
  • Free tier: 5K sessions/mo with 12-month retention
  • Heatmaps, journeys, conversion funnels
  • Omnisearch: search across all captured interactions
  • Mobile replay (iOS, Android)
  • Strong privacy controls and GDPR compliance

Pricing Details

  • Free: 5,000 sessions/mo, 12-month retention, 10 users
  • Paid: Starts ~$2,000/yr (custom quoted)
  • Enterprise: $12K–$150K+/yr
  • No published per-session pricing
  • Negotiation common: 20–35% off initial quotes
  • Multi-year contracts save 15–25% more

Pros

  • Best frustration signal detection
  • Generous free tier with long retention
  • Zero-config auto-capture
  • Polished, mature UI

Cons

  • Opaque pricing, requires sales call
  • Very expensive at scale
  • Closed source, no self-host
  • Vendor lock-in risk
Best for: UX/product teams focused on understanding user behavior and conversion optimization. The free tier is a great starting point. Be prepared for sticker shock when you outgrow it — get competitive quotes before negotiating.

OpenReplay

Overview

OpenReplay is an open-source session replay tool that emphasizes developer experience and data sovereignty. Its standout feature is co-browsing — you can share a live session with a user for real-time support. The self-hosted option means unlimited replays at zero marginal cost (just your infrastructure). The cloud version is competitively priced.

Key Strengths

  • Fully open source (GitHub) with self-host option
  • Co-browsing via WebRTC — unique feature
  • DevTools integration: see the session as if in your own browser
  • Application state replay (Redux, Vuex, ngrx, GraphQL)
  • Heatmaps, funnels, journey analysis
  • 35+ cloud regions for data residency
  • Spot Chrome extension for bug reporting

Pricing Details

  • Open Source: Free, self-hosted, unlimited everything
  • Dedicated (cloud): From $179/mo (instance-based, not per-session)
  • Enterprise: Custom pricing, self-hosted at scale with SAML/SCIM
  • Note: earlier "Serverless $5.95/1K" plan not confirmed on current pricing page
  • Retention configurable on Dedicated and self-hosted

Pros

  • Co-browsing is a killer feature
  • Self-host = zero marginal cost
  • Full data sovereignty
  • State replay like LogRocket but OSS

Cons

  • No mobile replay
  • Self-hosting requires infra investment
  • Smaller community than PostHog
  • Cloud pricing less competitive than PostHog
Best for: Developer-centric teams that need co-browsing, state replay, and full data sovereignty. The self-hosted option is compelling for regulated industries or teams that need unlimited replay volume.
Try It

Live Demo Pages

Each page below has the provider's session replay SDK loaded with a placeholder configuration. Replace the placeholder tokens with your real project credentials to activate recording.

PostHog

HTML snippet with posthog-js, session replay enabled by default.

sample-posthog.html →

Datadog

CDN async loader with DD_RUM init, sessionReplaySampleRate set to 100%.

sample-datadog.html →

Sentry

Sentry Browser SDK via CDN with replayIntegration and error sample rates.

sample-sentry.html →

LogRocket

CDN script tag with LogRocket.init(), simplest setup of all providers.

sample-logrocket.html →

FullStory

FullStory browser snippet with org ID placeholder.

sample-fullstory.html →

OpenReplay

OpenReplay tracker via CDN with project key placeholder.

sample-openreplay.html →
Final Analysis

Recommendation & Decision Matrix

Scenario-Based Shortlist

Find your team's situation below. Each row narrows to 1–2 providers.

If your team... Go with Runner-up Why
Wants one tool for replay + analytics + flags PostHog FullStory All-in-one, transparent pricing, open source
Already pays for Datadog APM/logs Datadog RUM PostHog Frontend-to-backend trace correlation is the value
Already uses Sentry for error tracking Sentry Replay PostHog Cheapest path, error-linked replay, 5-min setup
Needs deep Redux/Vuex state debugging LogRocket OpenReplay Only tools with application state replay
Needs UX insight, frustration signals, conversion funnels FullStory PostHog Best auto-capture and frustration detection
Needs data sovereignty / must self-host OpenReplay PostHog (self-host) $0 software cost, full control, co-browsing
Has less than 5K sessions and wants to start free PostHog or FullStory Sentry, LogRocket Both have generous free tiers (5K sessions, no card)
Expects 500K–1M+ sessions, budget matters PostHog OpenReplay (dedicated) ~$21K/yr vs $80K–200K for FullStory/LogRocket
Overall: PostHog appears in 6 of 8 scenarios — it's the safest default for most teams. The exceptions are (a) teams deep in Datadog/Sentry who get more value from correlation, and (b) teams that specifically need Redux state replay (LogRocket) or enterprise UX intelligence (FullStory).

Next Steps for Team

Before the meeting

  • Each team member reviews the TL;DR and decision wizard (2 min)
  • Agree on our expected session volume range
  • List tools we already pay for (Datadog? Sentry? Neither?)
  • Decide: is self-hosting a requirement or a nice-to-have?

During the meeting

  • Walk through the decision matrix — find our row
  • Review the pricing tables for our volume range
  • Note which numbers are HIGH vs LOW confidence
  • Pick top 2 candidates for a proof-of-concept

After the meeting

  • Request sales quotes for the top 2 (especially FullStory/LogRocket/Datadog where pricing is opaque)
  • Run a 1-week proof-of-concept using the sample pages — replace placeholder tokens with real credentials
  • Evaluate: replay quality, dashboard UX, integration friction
  • Final decision + procurement

Proof-of-concept checklist

  • Can we find a specific user session within 30 seconds?
  • Does replay capture our SPA navigation correctly?
  • Are sensitive fields masked by default?
  • What is the page load impact? (check Core Web Vitals before/after)
  • Does the SDK play nicely with our CSP and build pipeline?
  • How good is the replay scrubber / timeline UX?