How to Use Chrome 152’s CPU Performance API

Chrome 152, released on August 25, 2026, gives web developers a new way to adapt an application to the hardware running it. The CPU Performance API exposes a small performance tier through navigator.cpuPerformance, so your application can choose a lighter or heavier experience before expensive work begins.

The useful part is that this is not a live CPU monitor. It describes the device's general CPU performance class, while the Compute Pressure API can provide information about current CPU pressure. Used together, they let you make an initial capability decision and then react when the machine becomes busy. 

What the CPU Performance API actually tells you

The API adds a read-only cpuPerformance property to Navigator. It returns a small integer representing the device's CPU performance tier rather than exposing the processor model or detailed hardware characteristics. The current specification defines values from 0 through 4, with 0 representing an unknown result. The API is restricted to secure contexts, so production use requires HTTPS.

That distinction matters when you design your application. A performance tier is a relatively stable signal about what the device is capable of, not a measurement of how much CPU is available at this exact moment. A powerful laptop running several demanding applications can still have a high performance tier even while its current CPU pressure is elevated.

Start with a capability check

Because the API is new, feature detection should come before reading the property. This keeps older browsers on a working fallback path instead of treating the new API as a requirement.

function getCpuTier() {
  if ('cpuPerformance' in navigator) {
    return navigator.cpuPerformance;
  }

return 0;
}

const cpuTier = getCpuTier();
console.log('CPU performance tier:', cpuTier);

The fallback should represent an intentional product decision. An unknown result does not mean the device is slow; it means your application does not have a CPU performance tier from this API. You can therefore combine the value with existing signals rather than making the new API a hard requirement.

Use tiers to choose the experience

The strongest use case is adaptive loading. Instead of sending the same expensive experience to every device, define several working levels and select one during startup. A lower tier might receive fewer visual effects or a smaller workload, while higher tiers can receive more demanding features.

function getExperience() {
const tier = navigator.cpuPerformance ?? 0;

if (tier === 1) {
return {
animations: false,
effects: false,
quality: 'low'
};
}

if (tier === 2) {
return {
animations: true,
effects: false,
quality: 'medium'
};
}

return {
animations: true,
effects: true,
quality: 'high'
};
}

const experience = getExperience();

The important design choice is to treat these levels as complete experiences rather than simply switching individual features on and off. A slower device should still get a useful application. The tier should help you decide how much work to ask the device to perform, not whether the application is allowed to function.

Keep static capability separate from live CPU pressure

The CPU Performance API becomes more useful when you understand what it does not measure. The Compute Pressure API is designed to expose changing CPU pressure or utilization, allowing an application to react to current conditions. The CPU Performance API answers a different question: roughly how powerful is this device? ([WICG][1])

For example, you could use the performance tier when deciding whether to enable a demanding visual effect during application startup. If that effect is enabled, CPU pressure can then be monitored separately and used to reduce the workload when the machine becomes heavily loaded. This avoids trying to use a single signal for two different decisions.

Do not treat tier 4 as a permanent maximum

The current specification defines the returned tier as a value between 0 and 4, but developers should avoid building application logic around the assumption that 4 will always be the highest possible tier. A future version can introduce additional tiers as hardware changes. ([WICG][1])

That makes range-based logic safer than a long list of exact values. For example, code that treats tier 1 as the lowest capability and tiers 3 and above as higher capability is easier to extend than code that assumes every future device must fit into four fixed categories.

Use the API for progressive performance decisions

A practical implementation is to use the tier before loading optional resources. A graphics-heavy application could choose a simpler rendering mode on weaker hardware, while an application using local computation could defer or avoid an expensive workload. The same principle can apply to animations, media quality, background processing, and other optional work.

It is better to make these choices at natural application boundaries than to constantly change the interface because of a performance number. The CPU tier is intended to provide stable information for experience selection, while dynamic APIs are better suited to responding to conditions that change during a session. ([Chrome for Developers][2])

Remember the privacy boundary

The API deliberately provides a coarse performance tier instead of exposing detailed CPU characteristics. The specification also limits the API to secure contexts and considers fingerprinting in its security and privacy design. ([WICG][1])

That makes the API more appropriate for broad product decisions than for identifying individual hardware. Your code should use the value to select an experience, not attempt to reconstruct the user's processor or device from it.

Test fallbacks before shipping

Chrome 152 is the release that introduces the CPU Performance API, but a production web application should still work when the property is unavailable. Test the new path in Chrome 152 and test the fallback in browsers or environments that do not expose the API. Chrome also provides a setting that lets users override the reported CPU performance tier, and administrators can control the behavior through the CpuPerformanceTierOverride enterprise policy. ([Chrome for Developers][2])

The safest implementation is therefore simple: feature-detect the API, define useful experience levels, handle unknown results deliberately, and keep live CPU-pressure decisions separate. That gives you a new performance signal without making your application dependent on a single browser feature.