Those pageviews are still real user experiences, but they may not always be representative of how your website normally performs.
That is the problem PerformanceNavigationTiming.confidence is trying to address. The experimental API adds a high or low confidence value to navigation timing data, giving developers another signal when trying to understand why some real-world navigations are slower than others.
We recently started collecting this value in RUMvision. The API looked interesting, but its practical value only became clear after combining it with other RUM dimensions.
What does navigation timing confidence tell us?
High and low confidence
The confidence information is exposed on PerformanceNavigationTiming:
const navigation = performance.getEntriesByType("navigation")[0]; console.log(navigation.confidence.value); console.log(navigation.confidence.randomizedTriggerRate); The value can currently be high or low.
A high value means the browser has more confidence that the timing is representative of normal application performance. Low confidence indicates that the navigation may have happened under less representative browser conditions.
[..] indicates whether a performance record reflects typical application performance, or is likely affected by external factors
MDN
One of the main use cases behind the proposal is browser startup. When a browser launches, it performs initialization work that can compete with the page for resources. Session restore is another example. The original proposal specifically calls out the difficulty of distinguishing those situations from actual application performance problems.
That does not mean that low tells you what caused a slow pageview. It only gives you extra context around the measurement.
Confidence is not a root-cause indicator
That distinction is important.
If low-confidence pageviews have a slower FCP, you cannot conclude that browser startup caused the slower FCP. What you can say is that slower FCP values are more common among navigations the browser considers less representative.
So I would treat confidence as an additional diagnostic dimension, not as a new performance metric.
A question such as: "What percentage of pageviews has low confidence?"
is less useful than: "Is this performance issue still present on high-confidence navigations?"
That second question is where the API starts becoming interesting.
Using confidence in real-world RUM data
First pageviews versus successive pageviews
We looked at one week of mobile RUM data, using p75 and normal navigate navigations.
For first pageviews, the difference between high and low confidence was quite visible:
| Metric p75 | High | Low | Delta |
|---|---|---|---|
| TTFB | 1439 ms | 1583 ms | +144 ms (+10%) |
| FCP | 1974 ms | 2318 ms | +344 ms (+17%) |
| LCP | 2606 ms | 3020 ms | +414 ms (+16%) |
When looking at successive pageviews, the pattern was almost gone:
| Metric p75 | High | Low | Delta |
|---|---|---|---|
| TTFB | 2024 ms | 2048 ms | +24 ms (+1%) |
| FCP | 2303 ms | 2319 ms | +16 ms (+1%) |
| LCP | 2495 ms | 2526 ms | +31 ms (+1%) |
That is much more useful than knowing the overall percentage of high and low confidence values.
The first-pageview population shows a clear difference, while successive pageviews barely do. This does not establish causality, but it does suggest that the slow first-pageview population behaves differently from otherwise similar navigations.
We repeated the same analysis for another period and saw a similar pattern again, making it less likely that we were just looking at a one-off result.
Looking at metric breakdowns
The comparison becomes even more useful when you combine confidence with metric breakdowns.
For FCP, we saw:
| FCP component p75 | High | Low | Delta |
|---|---|---|---|
| Document TTFB | 1784 ms | 1808 ms | +24 ms (+1%) |
| JavaScript work | 256 ms | 712 ms | +456 ms (+178%) |
Document TTFB barely changes, while browser-side work changes substantially.
Again, this does not prove that the browser added 456 ms of JavaScript work. But when deciding where to investigate next, that is still useful information. The difference is far more visible in work happening in the browser than in the document response itself.
Confidence works best as a comparison
Compare within the same segment
One thing that became clearer while analysing the data is that confidence is most useful as the last dimension in an investigation.
For example, first select:
mobile
first pageview
product template and then compare:
high confidence
vs.
low confidence That tells you whether two otherwise comparable populations behave differently.
Filtering on confidence = high first and then grouping by another dimension is possible, but you lose the comparison that makes the signal useful.
There is still a use case for filtering only on high-confidence traffic. It can give you a cleaner baseline for asking what performance looks like when the browser considers navigations more representative. But for investigating the confidence signal itself, comparing high and low is much more practical.
This can help distinguish different types of problems
Imagine LCP is poor. If LCP remains just as poor on high-confidence successive navigations, browser startup conditions probably do not explain much of the issue. A structural website problem becomes a stronger hypothesis.
If LCP is mainly worse on low-confidence first pageviews, while the difference disappears on successive pageviews, the situation is different. The website can still be part of the problem, but browser navigation state appears to be associated with the slower experiences.
That is where I see the main value of confidence: not telling you what caused a problem, but helping you decide which explanation is more plausible.
There is one complication: the values contain noise
Why high does not always mean high
The API has an important privacy feature.
The browser intentionally adds noise to the confidence value using local differential privacy. The original proposal describes a randomized response mechanism so aggregated data can still be analysed without making individual records reliable indicators of browser state.
That is why the API exposes both:
confidence.value
confidence.randomizedTriggerRate With a randomized trigger rate around 0.5, some reported high values will actually originate from low-confidence navigations, and vice versa.
So a raw:
GROUP BY confidence.valueshould not be treated as the final statistical interpretation of the API.
Store both values and debias aggregates
If you collect confidence in RUM, store both value and randomizedTriggerRate.
MDN documents how the randomized values can be debiased when calculating aggregates. This becomes especially important for customer-facing statistics.
For exploratory analysis, raw high-versus-low groups can still be useful. In fact, randomization tends to blur differences between the groups, so a clear raw difference is a good reason to investigate further.
But when confidence becomes part of a real reporting feature, the privacy noise should be accounted for.
Exploring confidence with RUM
Conversational analysis is a good fit
Confidence is also a good example of a metric that creates follow-up questions.
You might start with:
- Is low confidence slower than high confidence?
and quickly continue with:
- Does that only happen on first pageviews?
- Is the difference stronger on certain devices?
- Is the delta coming from TTFB, rendering or JavaScript work?
That normally means repeatedly changing filters, dimensions and metrics in a dashboard.
If your preferred RUM solution exposes an MCP or another conversational interface, this is a practical use case for it. You can keep asking questions against the same field data and follow the pattern without rebuilding every query manually.
That is how we found the examples in this article as well. We queried our RUM data through the RUMvision MCP (which became part of our RUMvision 2.0 launch), then combined confidence with pageview type, individual performance metrics and their breakdowns.
Especially for a new API where the useful patterns are not yet obvious, that kind of exploratory workflow can save quite a bit of time.
Do not remove low-confidence pageviews
Low confidence also does not mean bad data.
The user still experienced that pageview. Removing it from regular performance reporting would make your RUM data less representative of what users actually experienced.
I would therefore make a distinction between reporting and diagnosis.
For reporting, keep all pageviews.
For diagnosis, use confidence to understand whether a problem is also present on navigations that the browser considers more representative.
Where I think this API becomes useful
Better context for existing performance metrics
I do not think confidence needs to become another prominent KPI in a RUM dashboard.
A number such as:
28% low-confidence navigationsdoes not tell a performance team much.
Something like this is far more useful:
<p>FCP is 17% slower on low-confidence first pageviews, while the difference is only 1% on successive pageviews. Most of the difference is visible in browser-side work rather than Document TTFB.</p> That adds context to an existing performance problem without pretending to know its root cause.
A useful signal for automated diagnostics
The same principle could also work behind automated health checks.
For example, if poor LCP remains visible during high-confidence navigations, that strengthens the case for investigating the website itself.
If most of the difference appears only during low-confidence first pageviews, a diagnostic could mention that the slow tail is associated with less representative navigation conditions.
Neither conclusion is absolute, but both are more useful than looking at the performance metric alone.
Browser support and implementation
Collect it where available
PerformanceNavigationTiming.confidence is still experimental, so browser support should be checked before relying on it.
Collection itself is straightforward:
const navigation = performance.getEntriesByType("navigation")[0]; if (navigation?.confidence) { const { value, randomizedTriggerRate } = navigation.confidence; // send both values to your RUM endpoint } Because the values are privacy-noised, make sure you keep randomizedTriggerRate as well.
Think of it as evidence, not an answer
A high-confidence navigation can still be slow. A low-confidence navigation can still be fast.
And low confidence does not mean the browser caused a slow experience.
The API is better understood as another piece of evidence that can be combined with pageview type, device information, metric breakdowns and other RUM dimensions.
That makes it especially interesting for real user monitoring. The web is messy, and RUM captures all of it. PerformanceNavigationTiming.confidence does not remove that messiness, but it may help us understand which measurements are representative of normal browsing and which ones deserve a little more context.
