rtcStats vs webrtc-internals in 2026: a real comparison

webrtc-internals is Chrome's built-in tool for inspecting a live WebRTC session on your own machine. rtcStats is a cloud platform that stores, analyzes, and summarizes WebRTC data from real user sessions on any web browser in production. If you're debugging your own browser tab right now, webrtc-internals is enough. If you're trying to debug a call your user had yesterday, you need rtcStats.

Quick comparison

What is webrtc-internals?

webrtc-internals is a developer tool built into Chrome and Edge. Open it at chrome://webrtc-internals and it shows you live stats for any WebRTC session running in your browser - bitrate, packet loss, jitter, ICE state, codec parameters, the full getStats() output. It gets its data by tracking WebRTC API calls from the moment you open it.

It ships with every copy of Chrome, requires no setup, and costs nothing. For a developer testing their own app on their own machine, it's genuinely powerful - probably the most useful built-in developer tool in any web browser.

What is rtcStats?

rtcStats is a WebRTC observability platform built from three parts: rtcstats-js (an open-source client SDK you drop into your JavaScript app), rtcstats-server (an open-source collection server that runs inside your own infrastructure), and rtcstats.com (the hosted analysis layer).

You install rtcstats-js once. It captures the same stats webrtc-internals captures - and more - from every session you configure it to monitor. That data flows through to your rtcstats-server and gets stored there. Any session you want can then be uploaded to rtcstats.com, where rtcStats reads it and gives you Observations (the moments that mattered), Deductions (what those signals mean for the user's experience), an Experience Score, and an AI Summary in plain English.

The collection layer runs in your infrastructure. You control what gets sent.

Key differences

Where the data lives

webrtc-internals data lives in your browser tab. It starts collecting from the moment you open it - nothing before that. When the peer connection closes, that data is gone. When the tab closes, everything is gone. You can download a dump file manually, but that's one session, one user, and you have to ask them to do it.

rtcStats stores session data for every user you instrument. Search by user ID, date range, Experience Score, or any metric. Pull up a session from last Tuesday. Compare ten calls from the same user to spot a pattern. Debug and troubleshoot at a fraction of the time it takes without it.

Who can see it

webrtc-internals is one person, one browser, one session. You can't share a view with your team. You can't say "go look at what happened with user X at 2:14 yesterday."

With rtcStats, anyone on your team with access can pull the same session. Your support engineer sees what your on-call sees. Share a link to a specific call in a Slack thread and everyone's looking at the same data. Generate and share a public link for a session or embed the session view in your own app.

What the output looks like

webrtc-internals gives you raw getStats() output in charts and tables. Accurate, complete, and dense - roughly 200 stats per second with no prioritization. It doesn't tell you what matters. You have to know.

rtcStats reads the session for you. Observations surface the moments that mattered. Deductions explain what those moments meant for the experience, getting you closer to a root cause. The Experience Score gives you the whole call in a single number. The AI Summary tells you the full story in two paragraphs. You get the answer, not the haystack.

Development vs production

webrtc-internals is a development tool. It was built for engineers inspecting their own sessions. There's no way to deploy it to your users' browsers or capture their sessions with it. The user needs to be a WebRTC expert to make sense of the data.

rtcStats is built for production. You capture real user sessions at scale, debug real complaints, and monitor quality trends across thousands of calls - without asking users to open any tool. It explains things in plain English making it useful for non-experts as well.

When webrtc-internals is enough

• You're building a WebRTC feature and testing it on your own machine
• You need to quickly verify codec negotiation or ICE candidate gathering on a specific connection
• You want to confirm your getStats() implementation is outputting what you expect
• You're debugging a one-off issue in a browser tab you control
• You don't have users in production yet

If any of these fits, chrome://webrtc-internals is the right tool and it's free.

When you need rtcStats

• A user reported a bad call and you need to know what actually happened
• The session already ended by the time you heard about the complaint
• You're trying to determine whether a quality issue is isolated or widespread
• Your team needs to collaborate on a call-quality incident without emailing dump files
• You're monitoring production and want to catch problems before users report them
• You're spending hours manually scrolling through webrtc-internals exports looking for the root cause
• You want AI to read the session and tell you what went wrong instead of doing it yourself

rtcStats doesn't replace webrtc-internals for local development. It replaces the painful part: trying to debug a production complaint from a vague user report with no persistent data. And yes... if you add it to your own development lifecycle, it will speed up and replace most of your direct use of webrtc-internals - it is THAT good.

Pricing

webrtc-internals: Free. Included in Chrome and Edge. No account needed.

rtcStats: Free plan, no credit card. Free plan includes awesome visualization of the data. Every new account runs at full Developer-level analysis for the first month - so you see what the paid product actually does before you commit. Paid plans start at $199/mo (Developer, annual) for production monitoring with Observations, Deductions, Experience Score, and AI Summary. Enterprise starts at $999/mo for 50 seats, embedded viewer, and third-party storage options for regulated industries.

Full details at rtcstats.com/pricing.

Frequently asked questions

Can webrtc-internals be used in production? Not directly. webrtc-internals runs in a specific browser tab on a specific machine. You can't instrument your users' sessions with it. For production monitoring you need a client SDK like rtcstats-js that captures getStats() data and sends it to a collection server.

Does rtcStats replace webrtc-internals? In many cases it can. rtcStats can be used locally to speed up your debugging simply by the way it orders and analyzes the data. webrtc-internals excels when what you need is to look at the metrics in real-time during the session itself - quick inspections in your own browser. rtcStats handles the production layer: capturing, storing, and analyzing sessions from real users at scale. Most teams use both.

Is rtcStats open source? The collection layer is. rtcstats-js and rtcstats-server are both open source. rtcstats.com is the hosted analysis platform. You can run the collection entirely inside your own infrastructure and only send session data to rtcstats.com for analysis - or not at all if you build your own analysis layer on top. The analysis layer itself has a free tier you can use.

What happened to callstats.io? Callstats.io was acquired by 8x8, then by Spearline. It then got shut down. If you're looking for a callstats.io alternative, rtcStats has a free plan and an open-source collection layer.

Does rtcStats work with all WebRTC frameworks? rtcstats-js works with any JavaScript WebRTC application. Whether you're using Daily, LiveKit, Jitsi, or a raw RTCPeerConnection implementation, the SDK captures the same getStats() data that webrtc-internals does.

The bottom line

Use webrtc-internals when you're developing. Use rtcStats when you're debugging production.

If you've ever gotten a vague complaint - "the video froze around 2:14" - and spent an hour scrolling through a webrtc-internals dump, that's the problem rtcStats solves. Upload the session, get Observations, Deductions, an Experience Score, and a plain-English summary. In under 30 seconds.

Start free at https://rtcstats.com - no credit card needed.