Instrumented.
Not Approximated.
To our knowledge, the first production carbon scoring tool -- as of February 2026 -- to swap the bytes-proxy for real CPU data from the browser. Built on peer-reviewed research, live grid data, and real metrics from Chrome DevTools Protocol (CDP).
--
gCO₂/kWh
Updates every 30 min
0. What Changed and Why
For over a decade, the web carbon industry has measured the wrong thing.
Every tool out there -- Website Carbon Calculator, Ecograder, Beacon, CO2.js -- rests on one idea: device energy scales with bytes sent. Multiply bytes by a constant. Call it a carbon score. Publish it as fact.
It is not fact. It never was. It was the best proxy when these tools were built. Credit to them -- it moved the talk forward when nothing else existed. But over time, a proxy became a standard. Agencies cite it in green reports. Standards bodies use it in guides. The industry treats it as real data when it is, at best, a rough guess -- and often a wildly wrong one.
Using bytes to guess device energy is like using a banana to measure a football pitch. You get a number. It does not tell you much.
Here is why: a 2MB page of compressed images and a 2MB page of heavy JavaScript look the same to a bytes model. They are not the same. The JS page forces the CPU to parse and run code for seconds. The image page decodes in moments on the GPU. These are very different energy profiles. No amount of tuning a bytes constant will tell them apart.
EcoPigs v2.0 replaces the proxy with real data.
On every scan, we open a Chrome DevTools Protocol (CDP) session. We capture real CPU time, layout work, and render steps from the V8 and Blink engines. We turn those into energy using device power profiles from hardware specs, research papers, and tested benchmarks. The result is a carbon score based on what the page actually did, not what a formula guessed from file size.
We tested this on our own site first. ebbb.io is a light, fast static site -- the kind the bytes-proxy should handle well. On desktop, the proxy guessed 12x too high. Across all device types, 71x too high. On mobile: 320x too high.
That is not a tuning problem. It is a method problem. It has sat at the heart of web carbon scoring for a decade. v2.0 fixes it.
1. Why We Built Something New
The web carbon industry has a data problem. Every tool -- Website Carbon Calculator, Ecograder, Beacon, CO2.js -- rests on one idea: device energy scales with bytes sent.
bytes transferred x energy intensity (kWh/GB) = device energy
SWD v4 gives user devices 0.080 kWh/GB of energy (Malmodin et al. 2023). This is a proxy, not a reading. A 2MB image page and a 2MB JavaScript page score the same, even though the JS page makes the CPU work far harder. In our tests, a light page used 12x less device energy than the proxy said it would.
EcoPigs v2.0 replaces that proxy with real browser data. On each scan, we capture CPU time, layout work, and render steps from the engine itself. We convert those into energy using device power profiles from hardware specs and research papers. The result is a carbon score based on what the browser did, not what we guessed from the file size.
Every other tool runs a version of the same formula with the same data. They will always agree on the same site. But agreement is not accuracy. EcoPigs gives a different number because it measures something different: what the browser did, not what a formula said it should do.
2. The Five-Score System
EcoPigs shows five carbon scores. Each adds one layer of detail. This clarity helps you see what drives your number and how different inputs change it.
Grid Intensity Values Used
| Score | Grid Intensity | Value | Source |
|---|---|---|---|
| Baseline | Global average (fixed) | 473 gCO2/kWh | Ember 2024 data (via Global Electricity Review 2025) |
| Traditional | SWD v4 default | 494 gCO2/kWh | CO2.js / Sustainable Web Design Model built-in |
| Live | Hosting country (live) | Varies | National Grid ESO API (UK), ENTSO-E (EU), Ember fallback |
| BEAM | Hosting country (live) | Varies | Same as Live |
| Measured | Per-segment | Varies | DC=hosting country, Network=global 473, Device=global 473 |
Baseline
A raw score for fair comparison. Uses a fixed global grid average (473 gCO2/kWh, Ember 2024) with no green hosting offset. Every site is judged on the same terms. Use this to compare against others.
Traditional
What other tools would show. Uses SWD v4 via CO2.js with its defaults (494 gCO2/kWh grid, 75/25 new/return visitor split). Green hosting is passed to CO2.js, which applies its own offset. This matches Website Carbon Calculator. We include it so you can compare with the industry standard.
Live
Real-time carbon using your hosting country's live grid data, refreshed every 30 minutes. Green hosting offsets applied. This is your main working score -- our best estimate of what your site emits right now.
BEAM (Behavioural Energy Adaptive Model)
Tweaks the live score based on how users really behave. The BEAM model uses smooth curves for resource type, session data, and engagement signals from the EcoPigs RUM pixel, plus device type factors. The combined factor usually falls between 0.7x and 1.3x.
| Factor | Range | Derivation |
|---|---|---|
| Duration (sigmoid) | 0.35 - 1.0 | 0.35 + 0.65 / (1 + e^(-0.08 x (t - 30))) |
| Scroll depth (linear) | 0.5 - 1.0 | 0.5 + 0.5 x clamp(d/100, 0, 1) |
| Engagement (tanh) | ~0.7 - 1.3 | 1.0 + 0.3 x tanh(2 x (r - 0.15)) |
| Bounce rate (linear) | 0.6 - 1.0 | max(0.6, 1.0 - 0.4 x b/100) |
| Confidence (linear) | 0.8 - 1.0 | max(0.8, 0.8 + 0.2 x c/100) |
| Device type | 0.61 - 1.95 | Device x screen x network factors combined |
| Combined (all) | 0.054 - 2.54 | Theoretical extremes; practical range ~0.7-1.3 |
Measured v2.0
Swaps the bytes-proxy for real CPU data from Chrome DevTools Protocol. Uses per-segment grid splitting -- separate grid values for the data centre, network, and user device -- because these three parts draw from three different power grids. Embodied energy (from making hardware) still uses the bytes-proxy, as it cannot be read at runtime.
3. Measured Device Energy: How It Works
On every scan, our tool opens a CDP session and turns on performance tracking. After the page loads, we pull metrics straight from the V8 JavaScript engine and the Blink renderer:
What CDP Measures (main thread only)
ScriptDuration
Seconds of JavaScript execution (V8 engine)
LayoutDuration
Seconds of layout/reflow work (Blink engine)
RecalcStyleDuration
Seconds of CSS style recalculation
These are real seconds of main-thread CPU work. They show what the chip actually did, not what we guessed from file size. Web Workers, Service Workers, and off-thread compositing are not included (see Limits).
Conversion to Energy
Energy (Wh) = (duration in seconds x power in watts) / 3600
Three energy parts are worked out:
1. CPU energy (directly measured via CDP)
(ScriptDuration + LayoutDuration + RecalcStyleDuration) x CPU watts / 3600
2. GPU energy (estimated)
estimated compositing duration x GPU watts / 3600
CDP has no direct GPU time metric. We estimate compositing as 30% of (LayoutDuration + RecalcStyleDuration). GPU energy is usually less than 5% of total device energy for normal pages.
3. Screen energy (calculated attribution)
page load duration x screen watts / 3600
The screen draws power for the full page load time. We also give an "incremental" figure that removes the idle baseline the device would use anyway.
Comparison with Bytes-Proxy
For ebbb.io (a light static site, 838 KB transfer, 0.22s script time, scanned as desktop via Puppeteer):
| Profile | Measured Operational | SWD v4 Proxy | Ratio |
|---|---|---|---|
| Desktop PC (measured) | 5.1 mWh | 64 mWh | 12x overestimate |
| Laptop (projected) | 0.9 mWh | 64 mWh | 71x overestimate |
| Mobile (projected) | 0.2 mWh | 64 mWh | 320x overestimate |
| Weighted avg (projected) | 0.9 mWh | 64 mWh | 71x overestimate |
Real data also shows the real difference. Two pages with the same byte size but different CPU loads get the same proxy score. Measured data shows the true gap:
- A 2 MB page with 0.1s script execution: ~5 mWh on desktop (screen-dominated)
- A 2 MB page with 3.0s script execution: ~25 mWh on desktop (CPU-dominated)
- The proxy gives both ~156 mWh
4. Per-Segment Grid Splitting
v1.0 used one grid value for all three segments. That is handy but not correct. Your server in London, the cables across the Atlantic, and the visitor's laptop in Berlin draw from three different grids with different carbon levels.
| Segment | Grid Used | Rationale |
|---|---|---|
| Data Centre | Hosting country (live) | Server energy comes from the local grid |
| Network | Global average (473 gCO2/kWh) | Network infrastructure spans many countries |
| User Device | Global average (473 gCO2/kWh) | Visitors are worldwide; individual location unknown |
5. Core Scientific Principles
The core equation stays the same:
Energy Consumed (kWh) x Grid Carbon Intensity (gCO2/kWh) = CO2 Emissions (g)
We track carbon across three segments and two emission types:
Operational Energy Intensity (kWh per GB transferred)
Data Centres
The energy required to host and serve data.
0.057 kWh/GB
IEA 2024
Networks
The energy used to send data across the global network.
0.059 kWh/GB
IEA 2022 / Malmodin 2023
User Devices
The energy the user's device draws. In v2.0 the running portion is replaced by real CDP data.
0.080 kWh/GB (proxy) / CDP measured
Malmodin 2023 / CDP
Total Operational: 0.196 kWh/GB
In the Measured score, the 0.080 kWh/GB user device proxy is replaced by CDP-instrumented energy for the operational portion.
Embodied Emissions
We include the carbon locked in the making of the hardware that runs the web. This is turned into an energy-like rate (0.106 kWh/GB) using the global grid average.
| Segment | Intensity |
|---|---|
| Data Centres | 0.012 kWh/GB |
| Networks | 0.013 kWh/GB |
| User Devices | 0.081 kWh/GB |
| Total | 0.106 kWh/GB |
How Server-Side Energy Is Estimated
EcoPigs does not read server CPU or memory use directly. Server energy is estimated as bytes sent x 0.057 kWh/GB. This is the same method used by SWD v4 and all other tools. Future versions may add server-side tracking where possible.
6. Updated Data Sources (February 2026)
What Changed from v1.0
| Data Point | v1.0 | v2.0 | Change | Source |
|---|---|---|---|---|
| Data centre global energy | 290 TWh | 415 TWh | +43% | IEA 2024 "Energy and AI" |
| Global grid intensity | 494 gCO2/kWh | 473 gCO2/kWh | -4.3% | Ember Global Electricity Review 2025 |
| UK electricity factor | 0.207 kgCO2/kWh | 0.177 kgCO2/kWh | -14.5% | DEFRA 2025 |
| DC operational intensity | 0.055 kWh/GB | 0.057 kWh/GB | +3.6% | IEA 2024 recalculation |
| Country reference grids | 16 countries | 24 countries | +8 | Ember 2024 data |
7. Live Grid Tracking
A key difference is that EcoPigs uses live, local grid data. A fixed global average (494 gCO2/kWh in the SWD model) can be far off. A site hosted in the UK has a very different impact than one in a coal-heavy region.
EcoPigs shows grid carbon and energy mix but does not say which source is "better." A low-carbon grid may run on nuclear, hydro, wind, or a blend. The choice between low-carbon and renewable power is a value call we leave to you. We give the data. You decide what it means for your hosting.
Our Data Integration
Data Sources
Country Reference Values (Ember 2024 data, via Global Electricity Review 2025)
8. Conservative Baseline Assumptions
Our baseline uses cautious, upper-bound values:
100% New Visitors
No cached assets are assumed. Our scanner uses a fresh browser profile with an empty cache for every scan.
100% Data Transfer
We account for the full payload of the page for every view.
10,000 Annual Page Views
A flat standardised reference point for comparison. Where real analytics data is available, actual traffic figures are used instead.
Wire Bytes, Not Decoded
All byte-based calculations use compressed on-the-wire transfer sizes via CDP Network.loadingFinished events. Using decoded sizes would overstate data centre and network energy by 3-5x for text-heavy sites with good compression.
This aligns with the GHG Protocol Corporate Standard (complete, clear, consistent, accurate, cautious) and follows ISO 14064-1 methods. EcoPigs reports have not been checked or verified against either standard by a third party.
9. Green Hosting: A Nuanced Approach
When a host is verified as "Green," we apply a 0.2 factor (an 80% cut) only to the Data Centre segment.
Green hosting does not reduce:
- Energy used by global network infrastructure
- Energy consumed by the end-user's device
- Embodied emissions from hardware manufacturing
This detail lowers the risk of over-counting the green hosting benefit. A green-hosted site still has network, device, and hardware-making emissions.
10. How We Compare
| Capability | EcoPigs v2.0 | SWD v4 / Website Carbon | Ecograder |
|---|---|---|---|
| Real browser scan | Yes (Puppeteer + CDP) | No (API / HEAD request) | No (Lighthouse) |
| Device energy model | Instrumented (CDP CPU + est. GPU/screen) | Bytes-proxy (0.080 kWh/GB) | Bytes-proxy |
| Grid intensity | Live, per-segment | 494 default (configurable) | Static global |
| Data sources | IEA 2024 / Ember 2024 | IEA 2022 | Varies |
| Embodied carbon | Included (bytes-proxy) | Included (v4) | Excluded |
| Accounting basis | Conservative (100% new) | 75/25 default (configurable) | Assumed caching |
| Behavioural adjustment | BEAM model | None | None |
| Per-segment grids | DC / Network / Device | Single global (configurable) | Single global |
| Score transparency | 5 distinct scores | 1 score | 1 score |
11. Scope and Boundaries
Included
- Page payload and all transferred resources (wire/compressed bytes via CDP)
- Data centre energy (estimated via bytes x 0.057 kWh/GB)
- Client-side main-thread rendering, scripting, and style recalculation (instrumented via CDP)
- Client-side GPU compositing energy (estimated from layout/style metrics)
- Client-side screen-on energy during page load
- Network transmission energy (estimated via bytes x 0.059 kWh/GB)
- Embodied emissions across all three segments (bytes-proxy)
- Green hosting verification and adjustment
Not Included
- Server-side CPU/memory measurement (estimated only)
- Web Worker and Service Worker execution
- Off-main-thread compositing and paint operations
- Email campaigns (separate analysis available)
- Video streaming (separate methodology required)
- Third-party API calls beyond the page load
- AI/ML inference workloads on the server side
- User interaction energy beyond initial page load
12. Versioning and Comparability
v2.0 uses the Ember 2024 global average (473 gCO2/kWh) for Baseline. v1.0 used 494. The grade bands (A+ to F) are the same, so grades still compare across versions. But raw gCO2 values from v2.0 will be a bit lower than v1.0 for the same page due to the updated grid value.
Grade Thresholds
Grades come from total emissions per view (gCO2), set against HTTP Archive page weight data:
| Grade | Threshold (gCO2) | Approx. Page Weight | Percentile |
|---|---|---|---|
| A+ | ≤ 0.095 | ~700 KB | Top ~12% |
| A | ≤ 0.186 | ~1,370 KB | Top ~28% |
| B | ≤ 0.341 | ~2,520 KB | Top ~50% (median) |
| C | ≤ 0.493 | ~3,640 KB | 65th percentile |
| D | ≤ 0.656 | ~4,840 KB | 77th percentile |
| E | ≤ 0.846 | ~6,250 KB | 85th percentile |
| F | > 0.846 | >6,250 KB | Bottom ~15% |
Every report shows which method version was used. When you compare reports over time:
- Grade comparisons are valid across v1.0 and v2.0 (same thresholds)
- Absolute gCO2 values should be compared within the same methodology version, or with awareness of the 4.3% reduction
- The Traditional score uses the SWD v4 built-in grid (494) and provides the closest comparison to v1.0 values
The measured score (v2.0) adds to the other four. It does not replace them. You can track your traditional score (for industry benchmarks) and your measured score (for accuracy) at the same time.
13. Device Power Profiles
v2.0 adds four device power profiles. These turn measured CPU time, estimated GPU compositing, and screen-on time into energy numbers.
Source types: Values come from Academic (peer-reviewed papers), Manufacturer (published specs), and Community (repeatable tests by hardware testers -- not peer-reviewed but consistent and reproducible).
Desktop PC
External monitor, integrated GPU
| Component | Power | Sources |
|---|---|---|
| CPU (active browsing) | 20W | Intel i5-13600K/14600K: 14-24W RAPL-measured during browsing. AMD Ryzen 7800X3D: ~20W browsing. |
| GPU (estimated compositing) | 2W | GPU+GMCH subsystem: 2.2-2.9W during web browsing (Microsoft IE team, 2011). Intel UHD 770 peak 12W; web compositing ~15-20% of peak. |
| Screen | 22W | 24" IPS LCD at 50-70% brightness: 18-25W range (EnergyStar display database). |
| System idle | 40W | Typical office PC idle: 30-50W plus monitor. Used for incremental energy calculation only. |
Academic References
- Carroll, A. & Heiser, G. (2010). An Analysis of Power Consumption in a Smartphone. USENIX ATC.
- Mahesri, A. & Vardhan, V. (2004). Power Consumption Breakdown on a Modern Laptop. PACS.
- Microsoft IE Team (2011). Browser Power Consumption: Leading the Industry.
- Torchbox (2024). How Much Power Do Web Assets Use? M1 MacBook powermetrics measurements.
- arXiv:2205.11399 (2022). Energy Efficiency of Web Browsers in the Android Ecosystem.
- arXiv:2401.15985 (2024). Dissecting software-based measurement of CPU energy consumption.
- Stanford/Boneh (2012). Who Killed My Battery? WWW 2012.
- ASE 2020. Energy Wars -- Chrome vs Firefox. RAPL-based browser energy comparison.
14. Relatable Metrics
Grams of carbon are hard to picture. We turn emissions into everyday examples so teams can share their impact clearly. All conversions use DEFRA 2025 UK grid data (0.177 kgCO2/kWh) where it applies.
| Metric | Value | Derivation | Source |
|---|---|---|---|
| Tree absorption | 60 g CO2/day | 22 kg/year / 365 days | USDA Forest Service / EPA |
| Kettle boil | 20 g CO2 | 0.11 kWh x 177 gCO2/kWh | Thermodynamic calculation |
| Car mile | 265 g CO2 | DEFRA 2025 avg passenger vehicle | DESNZ/DEFRA 2025 |
| Smartphone charge | 3 g CO2 | 0.018 kWh x 177 gCO2/kWh | 15 Wh battery / 0.85 efficiency |
| LED bulb hour | 2 g CO2 | 0.01 kWh x 177 gCO2/kWh | 10W LED equivalent |
These metrics are provided at both per-visit and annual (x10,000 page views) granularity. All relatable metrics use the same source constants defined in constants/carbonMethodology.mjs, ensuring consistency across all outputs.
15. Limitations
Being open about limits makes the method stronger, not weaker.
Measurement Scope
Main thread only
CDP Performance.getMetrics() captures main-thread CPU work. Web Workers, Service Workers, and off-main-thread paint/compositing operations are not included. For pages that offload significant computation to workers, measured CPU energy will be understated.
Desktop scan only
All scans run via Puppeteer using a desktop Chrome viewport (1920x1080). Mobile and laptop energy projections apply device-specific power profiles to the same desktop-captured durations. True mobile energy measurement would require on-device instrumentation.
Single page load
We measure the initial page load only. SPAs that load additional JavaScript during navigation will not have subsequent route changes captured.
Energy Estimation
GPU energy is estimated, not measured
We estimate compositing time as 30% of (LayoutDuration + RecalcStyleDuration). GPU energy is typically <5% of total device energy, so the impact on accuracy is limited.
Screen energy is attributed, not incremental
We attribute the screen's full power draw for the duration of the page load. Our API provides both "total" and "incremental" (subtracting idle baseline) figures.
Device power profiles are representative, not universal
A "20W desktop CPU" represents mid-range x86 processors. Apple Silicon desktops draw 0.1-1.5W for the same work. The traffic-weighted average mitigates this for population-level estimates.
Methodology
Embodied energy uses bytes-proxy
CDP cannot measure the manufacturing energy embedded in the user's device. The embodied portion (0.081 kWh/GB) still uses the standard bytes-proxy for all scores.
Server energy uses bytes-proxy
Data centre energy is estimated from bytes transferred x 0.057 kWh/GB. This does not distinguish between computationally intensive server-rendered pages and static file serving.
BEAM requires RUM data
The BEAM score is only calculated when ≥100 RUM sessions have been recorded. This prevents the model from generating scores based on default assumptions rather than observed behaviour.
16. References
Primary Research
- International Energy Agency (2024). Energy and AI. Updated data centre energy consumption to 415 TWh.
- International Energy Agency (2022). Data Centres and Data Transmission Networks.
- Malmodin, J. & Lunden, D. (2023). The energy and carbon footprint of the global ICT and E&M sectors 2010-2022. Telecommunications Policy.
- ITU (2024). Facts and Figures 2024. Global data transfer volumes.
- Ember (2025). Global Electricity Review. Country-level grid carbon intensity data for 2024. Source of 473 gCO2/kWh global average.
Standards and Frameworks
- GHG Protocol. Corporate Accounting and Reporting Standard.
- ISO 14064-1:2018. Greenhouse gases -- Specification with guidance.
- SBTi. Science Based Targets initiative -- ICT Sector Guidance.
Government Data
- DEFRA (2025). UK Government GHG Conversion Factors. Electricity factor: 0.177 kgCO2/kWh.
- National Grid ESO. Carbon Intensity API. carbonintensity.org.uk.
- U.S. EPA. Emissions & Generation Resource Integrated Database (eGRID).
- ENTSO-E. Transparency Platform. transparency.entsoe.eu.
Hardware Specifications
- Intel. ARK Product Specifications -- i5-12400. Package power and RAPL measurements.
- Qualcomm. Snapdragon 8 Gen 2 Product Brief. Big core cluster power consumption.
- EnergyStar. Display Product Database. Typical panel power consumption.
Industry Models (for comparison)
- The Green Web Foundation. CO2.js -- Sustainable Web Design Model v4. Uses 0.080 kWh/GB operational + 0.081 kWh/GB embodied for user device segment. 494 gCO2/kWh default global grid.
- Fershad Irani (2024). Exploring the Sustainable Web Design Model v4.
Run a Review Using EcoPigs v2.0
See how your site scores with our science-backed method and real browser data.