rtcStats is a focused, well-built tool that turns raw WebRTC dumps (webrtc-internals or rtcstats files) into an Experience Score, severity-ranked Observations, root-cause Deductions, and a plain-English AI summary in seconds. It solves a genuinely painful problem for a niche audience of real-time-communications engineers, is built by three widely recognized WebRTC experts, and ships unusually strong machine-readability for AI tools. The main gaps are business-side: a steep jump from free to $199/mo, almost no customer proof on the site, and some repeated 400 errors in the dashboard.
Scorecard
ux: 8.0/10 — Signup, email verification, and login worked smoothly, the dashboard has a clear empty state and honest trial banner, and the analysis viewer is well organized across overview, connections, streams, devices, and logs. Repeated 400 console errors and a couple of copy inconsistencies hold it back slightly.
trust: 7.0/10 — Credibility is high thanks to three independently verified WebRTC authorities, open-source tooling, strong security headers, and clear data-privacy options. It loses points because the prominent LiveKit, NVIDIA, and Netflix mentions are analyses, not customers, which could be misread as endorsements.
demand: 7.0/10 — WebRTC debugging is a real if niche need, and the founders' standing plus monthly product updates suggest genuine traction. Still, the site shows no named customers, usage counts, or testimonials to prove paying demand.
design: 8.0/10 — Clean, consistent, professional look across marketing and dashboard, with clear typography and well-structured analysis cards. Nothing flashy but it reads as a serious developer tool.
use case: 9.0/10 — Use cases are concrete and well-targeted: upload a dump or stream stats, then get scores, observations, and deductions, with a showcase of real services like Zoom, Google Meet, and LiveKit. It is very clear who this is for and what they get.
innovation: 8.0/10 — An AI root-cause analysis layer on top of WebRTC stats, structured as a five-layer pipeline and exposed to AI agents via an MCP server, is genuinely differentiated versus raw webrtc-internals. The concept is novel within its niche.
performance: 7.0/10 — The site is fast and Vercel-hosted with quick page loads, but the logged-in dashboard repeatedly logs 400 errors loading resources, which signals a backend or data-fetch issue worth fixing.
problem fit: 9.0/10 — Debugging why WebRTC calls fail is a well-known, time-consuming pain, and the product maps directly onto it by converting dumps into root causes. The five-layer model and AI summary match how engineers actually troubleshoot.
docs policies: 9.0/10 — It ships a deep knowledge base, an active monthly blog, full API docs with an OpenAPI spec, plus Terms of Service and a privacy and compliance guide. Only a dedicated changelog is missing, and release notes already live in the blog.
discoverability: 9.0/10 — Outstanding AI and search findability: llms.txt and llms-full.txt, machine-readable OpenAPI, MCP endpoint, api-docs.md, JSON-LD structured data on the home page, and a 418-route sitemap. Machine-readable pricing on the pricing page itself is the one missing piece.
The standout: An AI-native root-cause layer for WebRTC that an AI agent can query directly through an MCP server instead of choking on raw getStats JSON.
The genuinely new part is reframing WebRTC monitoring from charts and raw metrics into a structured pipeline of Observations, Deductions, and an Experience Score, topped with a plain-English AI summary that explains what went wrong and why. The five-layer model (Foundations, Calculations, Aggregations, Observations, Deductions) is a thoughtful way to make analysis legible. Exposing all of this to AI agents via MCP, so an assistant gets actionable analysis rather than an unparseable dump, is forward-looking and rare in this niche. Where it plays it safe is the underlying data collection and charting, which is conventional WebRTC stats tooling, and the open-source SDK builds on long-standing rtcstats patterns. The novelty is in the interpretation and AI-access layers, not the collection.
Genuinely new:
Observations and Deductions root-cause framing instead of raw charts
Plain-English AI session summaries
MCP server so AI agents can query analysis directly
Five-layer analysis model from raw metrics to deductions
Plays it safe:
WebRTC stats collection via SDK and server
Time-series charts for bitrate, jitter, packet loss
webrtc-internals dump upload
REST API for sessions
How to push the edge further:
Ship live, automated alerting: Move beyond after-the-fact dump analysis to real-time detection and alerts on quality regressions, which would differentiate it from upload-and-review tools.
Add cross-session trend intelligence: Aggregate observations across many sessions to surface fleet-wide patterns (a bad TURN region, a regressing codec config) rather than analyzing one call at a time.
Benchmark against the field: Let users compare a session's Experience Score against anonymized industry baselines so the score carries external meaning, not just an internal number.
Disrupt factor
What it is: rtcStats is a WebRTC debugging and monitoring platform. You collect call statistics with its open-source SDK and server (or upload a webrtc-internals dump), and the cloud reads the data and returns an Experience Score, audio/video/connectivity scores, severity-ranked Observations, root-cause Deductions, and a plain-English AI summary of what went wrong on the call.
Who it is for: The user is a WebRTC or real-time-communications engineer at companies building video conferencing, telehealth, contact centers, cloud gaming, or AI voice agents. The buyer is an engineering lead or platform team that owns call quality and support escalations.
Competes with: Raw webrtc-internals (Chrome built-in), callstats.io (legacy), testRTC / Spearline, Cyara, Generic APM tools like Datadog applied to WebRTC, In-house homegrown dashboards
Disruption potential (7.0/10): The wedge is sharp: it compresses 30 to 60 minutes of manual getStats reading into a few minutes of structured root cause, and it does so in a niche where almost no purpose-built, AI-native tool exists. The unfair advantage is the founders' deep WebRTC standing plus an open-source collection layer that lowers adoption friction and addresses data-ownership worries. The newest angle, an MCP server so AI agents can query analysis directly instead of choking on raw JSON, positions it well for the agentic-debugging shift. Potential is real, but it depends on landing the teams who feel this pain often enough to pay $199/mo.
Roadmap to disrupt:
Publish named customer outcomes: Convert a few design-partner teams into named case studies with before-and-after debugging time, so the wedge is backed by proof rather than founder reputation alone.
Add a low-priced individual tier: A cheap solo or small-team plan between free and $199/mo would capture the many engineers who hit this pain occasionally and could become champions inside larger accounts.
Lean into the agent-debugging story: Make the MCP integration a headline use case with concrete demos of an AI coding assistant calling rtcStats, since that is the most defensible and forward-looking part of the wedge.
Hallucination factor (2.0/10, lower is better)
Reality check: This solves a real, demonstrated problem that real WebRTC engineers clearly have. Debugging failed calls from raw getStats data is a known time sink, and the showcase of real services proves the analysis produces concrete findings. The demand is niche but genuine, not invented.
Anyone who has shipped a WebRTC product knows the 11pm 'why did the call freeze' problem, and the comparison to manually scrolling thousands of getStats entries is accurate. The showcase demonstrates the tool surfacing real issues (echo loops, misconfigured TURN, unused streams) on actual services, which is strong evidence the output is useful rather than decorative. The scope does sprawl a bit, with five analysis layers, an MCP server, an embeddable viewer, and bring-your-own-storage all at once, but each maps to a plausible engineer or enterprise need rather than feeling padded.
Reads as invented:
No named paying customers or testimonials shown
Showcase brands could be misread as customers rather than analyzed samples
Steep free-to-$199 gap suggests demand at that price is still being validated
Grounded in real demand:
Concrete, real failure modes surfaced in the showcase analyses
Founders are verified, widely recognized WebRTC authorities
Direct comparison to the real pain of reading webrtc-internals dumps
Open-source SDK and server already exist and are self-hostable
How to lower it: Talk to 15 to 20 target teams about how often they actually debug WebRTC calls and what they would pay, then use that to price a tier between free and Developer and to gather named proof.
Social & marketing strength (6.0/10)
rtcStats markets itself with clear, confident positioning ('AI reads the dump so you don't have to'), a strong showcase of real-world session analyses, an active monthly blog, and excellent machine-readability for AI tools, which is a smart distribution bet. Where it is weak is conventional social proof: there are no customer logos, testimonials, ratings, or usage numbers, and no visible email capture or community presence on the site, so the marketing leans almost entirely on founder credibility and content. For a developer tool this is a reasonable foundation, but the conversion path from free curiosity to a $199/mo plan is under-supported by proof.
Social proof:
Three named, genuinely recognized WebRTC founders
Showcase of analyses on real services (Zoom, Google Meet, LiveKit, ElevenLabs)
Active monthly product-update blog
Channels:
Content and blog
Knowledge base and API docs as SEO surface
llms.txt and MCP for AI-assistant discovery
Showcase page as a lead magnet
Strengths:
Sharp, memorable positioning and messaging
Concrete showcase that demonstrates real output
Strong content and AI-discoverability surface
Gaps:
No customer testimonials, logos, or usage counts
No visible email capture or newsletter signup
No visible social or community links on the site
Large free-to-paid pricing gap with little proof to justify it
How to grow reach and conversion:
Add real social proof above the fold: Place named customer quotes, logos with permission, or concrete metrics like 'time-to-root-cause cut from 45 minutes to 3' near the primary call to action to lift trust and conversion.
Capture email with a debugging resource: Offer a WebRTC debugging cheat sheet or sample-dump walkthrough in exchange for an email so the site builds a pipeline instead of relying on immediate signups.
Clarify the showcase framing: Label showcase entries clearly as independent analyses, not customers, to stay honest while still using the recognizable brands as a draw.
Build distribution in WebRTC communities: Lean on the founders' reach (BlogGeek.me, webrtcHacks, Kranky Geek) with tutorials and shareable session breakdowns to drive qualified developer traffic.
Pivot factor
The same collection pipeline and analysis engine could serve audiences and revenue streams beyond individual developer debugging.
Support-desk quality triage (new audience): The embeddable iframe viewer already lets support agents see call analysis next to tickets. Packaged as a CX add-on for telehealth and contact-center platforms, this targets support and QA teams rather than just engineers.
WebRTC benchmark and industry reports (revenue stream): The showcase shows the team can analyze any public service's WebRTC behavior. Recurring 'state of WebRTC quality' reports or a public benchmark could become lead generation and a paid data product.
Embedded analysis for CPaaS and SFU vendors (partnership): LiveKit, Daily, Jitsi, and similar providers could embed rtcStats analysis for their own customers. The open-source SDK and MCP server make a white-label or OEM partnership a natural extension.
Agent-native debugging tool (new application): The MCP server lets AI coding assistants query structured WebRTC analysis instead of parsing raw JSON. Positioning rtcStats as the default WebRTC tool inside Cursor or Claude workflows could open a developer-tools distribution channel.
Screenshots
Landing page (9.0/10)
Bold headline 'Stop guessing why WebRTC calls fail' with a clear subhead, a strong 'Start Analyzing For Free' CTA, product screenshots, and trust cues like '20+ years' and LiveKit, NVIDIA, Netflix references.
Product page (9.0/10)
Clear 'WebRTC debugging from dump to diagnosis' header with a three-card How It Works section, an architecture diagram, and an annotated analysis screenshot that explains the value well.
Signup page (8.0/10)
Clean Create Account form with display name, email, password rules, confirm password, plus Google and GitHub options and a link to sign in.
Login page (8.0/10)
Simple, trustworthy sign-in card with email and password fields, forgot password link, Google and GitHub options, and a register link.
Pros
Solves a real, sharp pain: turning raw WebRTC dumps into root-cause analysis in seconds
Built by three genuinely recognized WebRTC experts (Tsahi Levent-Levi, Philipp Hancke, Olivier Anguenot), confirmed via independent research
Rich, layered analysis output: Experience Score, audio/video/connectivity scores, observations, deductions, charts, and plain-English AI summary
Excellent machine-readability and AI discoverability: llms.txt, llms-full.txt, OpenAPI spec, MCP server, api-docs.md, JSON-LD on the home page
Strong security headers (HSTS preload, CSP frame-ancestors, X-Frame-Options DENY, nosniff, tight permissions-policy) and no version disclosure
Open-source collection layer (SDK and server) with IP anonymization and bring-your-own-storage, giving real data-ownership credibility
Clean signup, working email verification, and a clear first-run empty state with trial messaging
Cons
Repeated 400 errors load in the dashboard console on multiple pages
Big pricing cliff: free plan is full-featured only the first month, then $199/mo Developer with little in between
Almost no customer proof: showcase companies (LiveKit, NVIDIA, Netflix) are sessions rtcStats analyzed, not customers or testimonials
Signup copy is inconsistent: help text requires 8+ char complex passwords while the field placeholder says min 6 characters
Monthly billing is PayPal-only, which can read as less enterprise-ready
Minor typo in the pricing FAQ ('the exensive knowledge base')
Best for
WebRTC and real-time-communications engineers who need to debug why voice or video calls fail and want root-cause analysis instead of raw getStats dumps.
Not for
General developers or non-technical teams who do not build on WebRTC, or small teams unable to justify the $199/mo Developer plan after the free tier's first month.
FAQ
What is rtcStats?
It is a WebRTC debugging and monitoring tool. You collect call statistics with its open-source SDK or upload a webrtc-internals dump, and it returns an Experience Score, observations, root-cause deductions, and a plain-English AI summary of what went wrong on the call.
Who is it for?
Engineers building real-time communications products (video conferencing, telehealth, contact centers, cloud gaming, AI voice agents) who need to find why WebRTC calls fail without manually reading raw getStats dumps.
How much does it cost?
There is a free plan with 10 credits per month and full Developer-level analysis for the first month. After that the Developer plan is $199/mo (with a yearly discount) and Enterprise is $999/mo. Monthly billing uses PayPal.
Is there a free trial?
Yes. You can sign up with no credit card, and every new account gets full Developer features for its first month before reverting to basic free-tier analysis.
Can I integrate it with my own tools?
Yes. It offers a REST API, an MCP server for AI agents like Claude and Cursor, and an embeddable iframe viewer, plus open-source rtcstats-js and rtcstats-server for collection.
Is my call data private?
The open-source collector anonymizes IP addresses before data leaves your infrastructure, Enterprise accounts can bring their own storage, and self-hosted deployment is available. Treat this as a business-credibility signal, not legal advice.