Quantifying Avoided Emissions from Demand Response: An Energy API Workflow for ESG Reporting and Incentive Claims

Demand response (DR) has matured from a niche grid-balancing tactic into a mainstream climate and revenue strategy. But quantifying “avoided emissions” from DR—how many kilograms or tonnes of CO2 you actually prevented by shifting or curtailing load at a given hour—remains stubbornly hard for engineering and ESG teams. You need trustworthy granular electricity prices, grid carbon intensity curves, relevant commodity context (gas, oil, coal, carbon allowances), and a clean, developer-friendly way to stitch it all together so you can prove impact for ESG reporting, incentives, and settlement.

If you’ve tried to do this by scraping multiple national portals or public dashboards, you already know the pitfalls: different formats, different time zones, missing hours, duplicate rows, inconsistent naming, and “right when you need it” outages. Your team ends up spending more time on ETL band-aids than on quantifying real emissions impact and getting paid for flexibility events.

This post lays out a pragmatic, production-ready workflow to calculate avoided emissions from DR using Energy API. We’ll combine grid carbon intensity by country, intraday electricity curves for settlement-aligned pricing, and cross-commodity references like TTF gas and EUA carbon allowances to contextualize the marginal fuel mix. You’ll see how one normalized REST interface can power ESG disclosures, incentive claims, internal audits, and customer-facing sustainability dashboards—without the integration pain.

Why Energy API

As a developer advocate working with data and energy teams, I repeatedly see the same three blockers: fragmented sources, incompatible schemas, and brittle pipelines. Energy API removes those blockers so you can ship features in hours, not weeks.

• One normalized REST surface for everything that matters: electricity (day-ahead and intraday), natural gas (EU TTF, US Henry Hub), crude (Brent, WTI), coal (API2/Rotterdam, Newcastle), EU ETS allowances (EUA), and grid carbon intensity. You avoid juggling OMIE, ENTSO-E, EIA/FRED, and ESIOS formats—and get a single JSON shape across 39+ symbols.
• Time-aligned intraday electricity curves where available (15-minute or hourly): this is critical for DR settlement and avoided emissions attribution. The same /electricity/hourly schema applies whether you’re pulling OMIE_ES_DA or EPEX_DE_DA, so your allocation logic stays consistent across markets.
• A compact, consistent schema for aggregated queries: request multiple commodities and regions in one /latest or /timeseries call. This allows you to compute avoided emissions while simultaneously recording prevailing gas or EUA prices for audit trails, scenario analysis, and cost-benefit narratives.
• Practical operational visibility: a /status endpoint shows last fetch status per data provider, so you can wire health checks and circuit breakers into your ingestion jobs. You’ll know whether your upstream sources have posted and can implement smart retries instead of noisy alerts.

In short, Energy API gives you the right signals, aligned in time, through a predictable interface. That makes the difference between a fragile ESG prototype and a reliable system that underpins incentive claims and executive reporting.

Quick Start

Energy API exposes a unified base URL and a small set of parameters. You can pull multiple commodities in one request. Below is a minimal example that fetches Brent crude, EU TTF gas, and EU ETS allowances together—useful for annotating DR events with broader market context:

curl -G https://energy-api.com/api/v1/latest \
--data-urlencode "symbols=BRENT_CRUDE,TTF_GAS,EUA_CO2" \
--data-urlencode "api_key=YOUR_API_KEY"

Example JSON response:

{
"success": true,
"date": "2026-06-11",
"base": "MIXED",
"rates": {
"BRENT_CRUDE": 74.82,
"TTF_GAS": 38.15,
"EUA_CO2": 67.40
},
"dates": {
"BRENT_CRUDE": "2026-06-11",
"TTF_GAS": "2026-06-11",
"EUA_CO2": "2026-06-11"
},
"currencies": {
"BRENT_CRUDE": "USD",
"TTF_GAS": "EUR",
"EUA_CO2": "EUR"
}
}

Key fields:

• date: the most recent unified date for the response set.
• rates: last available price per symbol, with raw currency units preserved.
• dates: the effective publishing date per symbol—handy if one series publishes before another during trading hours.
• currencies: currency code per symbol; leave as-is for auditability or convert downstream for portfolio rolls.

For DR workflows, pair global market context with country-specific electricity and carbon intensity series pulled below.

Core Endpoints for Demand Response and Avoided Emissions

This section focuses on endpoints you’ll actually wire into avoided emissions attribution, settlement checks, and ESG reporting.

1) Discoverability with /symbols

Before you hardcode any symbol, discover available instruments and metadata via /symbols. This is useful for rendering pickers in your app or programmatically validating you’re calling the right exchange-based series.

curl -G https://energy-api.com/api/v1/symbols \
--data-urlencode "category=electricity" \
--data-urlencode "api_key=YOUR_API_KEY"

Example JSON response (truncated to illustrate structure):

{
"success": true,
"count": 3,
"symbols": [
{
"symbol": "OMIE_ES_DA",
"name": "OMIE Spain Day-Ahead Electricity",
"category": "electricity",
"country_code": "ES",
"currency_code": "EUR",
"frequency": "hourly",
"description": "OMIE day-ahead auction prices for Spain."
},
{
"symbol": "EPEX_DE_DA",
"name": "EPEX Germany Day-Ahead Electricity",
"category": "electricity",
"country_code": "DE",
"currency_code": "EUR",
"frequency": "hourly",
"description": "Day-ahead auction results for Germany."
},
{
"symbol": "PVPC_ES_2TD",
"name": "Spain PVPC Retail Reference (2.0TD)",
"category": "electricity",
"country_code": "ES",
"currency_code": "EUR",
"frequency": "hourly",
"description": "Spanish retail reference tariff for hourly pricing."
}
]
}

What to do with it:

• Use category and country_code to map DR portfolios to the correct electricity market index.
• frequency tells you whether you should expect hourly or 15-minute granularity.
• description provides an audit-friendly label you can surface in dashboards.

2) Hourly Electricity Curves with /electricity/hourly

For avoided emissions, you need the price of energy in each curtailed hour (or 15-minute block) to align with settlement and to support cost-benefit narratives. The /electricity/hourly endpoint returns the full intraday curve for a given symbol and date.

curl -G https://energy-api.com/api/v1/electricity/hourly \
--data-urlencode "symbol=OMIE_ES_DA" \
--data-urlencode "date=2026-06-12" \
--data-urlencode "api_key=YOUR_API_KEY"

Illustrative JSON (structure example):

{
"success": true,
"symbol": "OMIE_ES_DA",
"date": "2026-06-12",
"currency": "EUR",
"interval": "hourly",
"points": [
{"start": "2026-06-12T00:00:00+02:00", "end": "2026-06-12T01:00:00+02:00", "price": 52.31},
{"start": "2026-06-12T01:00:00+02:00", "end": "2026-06-12T02:00:00+02:00", "price": 48.77},
{"start": "2026-06-12T02:00:00+02:00", "end": "2026-06-12T03:00:00+02:00", "price": 46.55}
/* … remaining hours … */
],
"provider_status_time": "2026-06-11T13:05:33Z"
}

Key fields:

• interval: “hourly” or “15min”, so you can pick the right aggregation.
• points[i].start/end: ISO timestamps with timezone; line these up with your DR event’s operating interval and metered load.
• price: price per MWh in the given currency.
• provider_status_time: when the upstream auction results were last confirmed.

Best practice: Always store the raw currency and symbol with each interval. If you convert currencies later, also store the FX rate used to preserve auditability.

3) Grid Carbon Intensity with /carbon-intensity

To turn kWh shifted into avoided emissions, multiply your curtailed energy in each interval by the grid carbon intensity (gCO2eq/kWh) for the same time and country. Energy API provides intensity values via /carbon-intensity.

curl -G https://energy-api.com/api/v1/carbon-intensity \
--data-urlencode "country=DE" \
--data-urlencode "api_key=YOUR_API_KEY"

Example JSON response (illustrative):

{
"success": true,
"country": "DE",
"unit": "gCO2eq/kWh",
"interval": "hourly",
"points": [
{"timestamp": "2026-06-12T00:00:00+02:00", "intensity": 312},
{"timestamp": "2026-06-12T01:00:00+02:00", "intensity": 298},
{"timestamp": "2026-06-12T02:00:00+02:00", "intensity": 285}
/* … remaining hours … */
],
"source_note": "National TSO/ENTSO-E derived intensity"
}

How to use:

• Multiply metered load reduction (kWh) in each hour by intensity/1000 to get kgCO2eq avoided for that hour.
• Sum over the DR event window for total avoided emissions.
• Keep the source_note for disclosure sections in ESG reporting.

4) Day-Ahead Forecast with /forecast

Many DR programs rely on published day-ahead auction outcomes to plan shifts. Use /forecast to fetch the next published day-ahead price for supported symbols. This is not a predictive model; it’s a deterministic fetch of official results once available for the next operating day.

curl -G https://energy-api.com/api/v1/forecast \
--data-urlencode "symbol=EPEX_DE_DA" \
--data-urlencode "api_key=YOUR_API_KEY"

Example response:

{
"success": true,
"symbol": "EPEX_DE_DA",
"forecast_date": "2026-06-13",
"currency": "EUR",
"interval": "hourly",
"points": [
{"start": "2026-06-13T00:00:00+02:00", "end": "2026-06-13T01:00:00+02:00", "price": 57.11},
{"start": "2026-06-13T01:00:00+02:00", "end": "2026-06-13T02:00:00+02:00", "price": 53.02}
/* … */
],
"note": "Published auction results for the next day"
}

Use this to:

• Pre-compute next-day DR opportunity windows where prices and expected intensity imply high marginal emissions.
• Generate customer-facing “shift recommendations” before the operating day starts.

5) Historical Series with /timeseries

To show trend lines of EUA carbon prices vs DR program performance, or to train heuristics that favor high-avoidance windows, pull multi-symbol historical series in one call.

curl -G https://energy-api.com/api/v1/timeseries \
--data-urlencode "start=2026-05-01" \
--data-urlencode "end=2026-06-11" \
--data-urlencode "symbols=EUA_CO2,TTF_GAS,BRENT_CRUDE" \
--data-urlencode "api_key=YOUR_API_KEY"

Example JSON:

{
"success": true,
"base": "MIXED",
"start_date": "2026-05-01",
"end_date": "2026-06-11",
"rates": {
"EUA_CO2": {
"2026-05-02": 69.10,
"2026-05-03": 68.72
/* … */
},
"TTF_GAS": {
"2026-05-02": 35.85,
"2026-05-03": 36.15
/* … */
},
"BRENT_CRUDE": {
"2026-05-02": 76.22,
"2026-05-03": 76.01
/* … */
}
},
"frequencies": {
"EUA_CO2": "daily",
"TTF_GAS": "daily",
"BRENT_CRUDE": "daily"
},
"currencies": {
"EUA_CO2": "EUR",
"TTF_GAS": "EUR",
"BRENT_CRUDE": "USD"
}
}

Practical uses:

• Correlate DR event savings with EUA or gas price regimes to explain why avoided emissions varied month-to-month.
• Build dashboards that overlay DR performance on top of macro energy signals for stakeholders.

6) Price Volatility Windowing with /fluctuation

To rapidly assess whether your DR windows coincided with meaningful price swings (supporting incentive optimization), use /fluctuation for start/end values, absolute change, and percent change over any period.

curl -G https://energy-api.com/api/v1/fluctuation \
--data-urlencode "start=2026-06-01" \
--data-urlencode "end=2026-06-10" \
--data-urlencode "symbols=OMIE_ES_DA,EUA_CO2" \
--data-urlencode "api_key=YOUR_API_KEY"

Example JSON:

{
"success": true,
"base": "MIXED",
"fluctuations": {
"OMIE_ES_DA": {
"start_value": 49.12,
"end_value": 58.30,
"change": 9.18,
"change_pct": 18.69
},
"EUA_CO2": {
"start_value": 66.25,
"end_value": 67.40,
"change": 1.15,
"change_pct": 1.74
}
}
}

Pair this with carbon intensity changes to justify where shifting load delivered outsized climate benefit.

7) Provider Health with /status

Production systems need observability. The /status endpoint surfaces last fetch status per data provider so you can implement retries and alarms only when they matter.

curl -G https://energy-api.com/api/v1/status \
--data-urlencode "api_key=YOUR_API_KEY"

Example JSON:

{
"success": true,
"providers": [
{"provider": "omie", "last_success": "2026-06-11T12:55:10Z", "status": "ok"},
{"provider": "entso-e", "last_success": "2026-06-11T12:50:23Z", "status": "ok"},
{"provider": "eia", "last_success": "2026-06-11T04:15:01Z", "status": "ok"}
]
}

Tip: Create a small watchdog that calls /status and only triggers reruns for data providers that changed state since your last pull. Combine with idempotent writes to keep your warehouse clean.

A Practical Workflow to Quantify Avoided Emissions from DR

Avoided emissions = sum over event intervals of (curtailed kWh × grid carbon intensity). That’s the core. To make it robust for audits and incentives, add the corresponding wholesale price and macro signal context (gas and EUA), then persist everything with timestamps. Here’s how to wire it end-to-end with Energy API.

1. Identify the operating day and market: Use /symbols to validate your electricity symbol (e.g., OMIE_ES_DA for Spain, EPEX_DE_DA for Germany).
2. Fetch the intraday price curve: Call /electricity/hourly for the exact date of your DR event. Store start/end timestamps and price for each interval.
3. Fetch the country’s carbon intensity: Call /carbon-intensity for the same date and country. Align timestamps by hour (or 15-min) and interpolate if needed, but prefer exact matches for auditability.
4. Join with metered load reduction: For each interval, multiply curtailed kWh by intensity/1000 to get kgCO2eq avoided. Keep the raw inputs so your calculations are reproducible.
5. Annotate with macro signals: Call /latest or /timeseries for TTF_GAS and EUA_CO2 during the event window. This adds valuable narrative: “We curtailed 3.2 MWh during hours when intensity averaged 312 gCO2eq/kWh and gas/EUA were elevated, implying higher marginal emissions avoided.”
6. Validate data freshness: Use /status to confirm your upstream sources are up-to-date. If not, flag the report as preliminary and schedule an automatic refresh.

Below is a compact Python example that fetches inputs and computes avoided emissions for a single event window.

import requests
from datetime import datetime, timezone

API = "https://energy-api.com/api/v1"
KEY = "YOUR_API_KEY"

def get_hourly(symbol, date):
r = requests.get(f"{API}/electricity/hourly", params={
"symbol": symbol,
"date": date,
"api_key": KEY
})
r.raise_for_status()
return r.json()["points"]

def get_intensity(country):
r = requests.get(f"{API}/carbon-intensity", params={
"country": country,
"api_key": KEY
})
r.raise_for_status()
return {p["timestamp"]: p["intensity"] for p in r.json()["points"]}

# Example DR event: 2026-06-12 17:00–19:00 local, Spain
symbol = "OMIE_ES_DA"
country = "ES"
date = "2026-06-12"

price_points = get_hourly(symbol, date)
intensity_map = get_intensity(country)

# Simulated metered reduction per hour (kWh)
curtailment = {
"2026-06-12T17:00:00+02:00": 1200.0,
"2026-06-12T18:00:00+02:00": 1000.0
}

total_kg = 0.0
for p in price_points:
ts = p["start"] # hourly boundary
if ts in curtailment:
kwh = curtailment[ts]
intensity = intensity_map.get(ts)
if intensity is None:
continue
kg = (kwh * intensity) / 1000.0
total_kg += kg

print(f"Total avoided emissions (kgCO2eq): {total_kg:.2f}")

You would enhance this by:

• Handling 15-minute intervals (sum or aggregate to your reporting cadence).
• Persisting EUA_CO2 and TTF_GAS from /latest for supporting context.
• Recording the exact JSON responses and timestamps in blob storage for audit trails.

Additional Endpoints That Strengthen ESG and DR Workflows

Depending on how far you want to take your product, the following endpoints add depth and reliability.

/electricity/latest

Fetch the latest published values for all electricity symbols or filter by country. Perfect for quick dashboards and sanity checks.

curl -G https://energy-api.com/api/v1/electricity/latest \
--data-urlencode "country=ES" \
--data-urlencode "api_key=YOUR_API_KEY"

You’ll get the most recent prices across relevant Spanish electricity indices, helping you compare OMIE day-ahead with PVPC retail references for end-customer messaging.

/electricity/pvpc

If you support Spanish retail customers, PVPC hourly references help explain bill impacts of DR participation. Use this endpoint for customer-facing summaries without mixing it into settlement-grade wholesale calculations.

curl -G https://energy-api.com/api/v1/electricity/pvpc \
--data-urlencode "date=2026-06-12" \
--data-urlencode "api_key=YOUR_API_KEY"

/gas/latest, /coal/latest, /emissions/latest

One-call snapshots for TTF/Henry Hub, API2/Newcastle coal, and EUA. Embedding these in your reports can show stakeholders why certain hours were “dirty” or expensive—e.g., when gas tightness pushes marginal generators to higher-emission stacks.

curl -G https://energy-api.com/api/v1/gas/latest \
--data-urlencode "api_key=YOUR_API_KEY"

curl -G https://energy-api.com/api/v1/emissions/latest \
--data-urlencode "api_key=YOUR_API_KEY"

/historical and /ohlc

Use /historical to snapshot prices on a specific date even if it’s a weekend or holiday (the endpoint returns the nearest prior publishing day). /ohlc gives you weekly, monthly, or quarterly candles for volatility analysis or executive summaries.

curl -G https://energy-api.com/api/v1/ohlc \
--data-urlencode "symbols=EUA_CO2,TTF_GAS" \
--data-urlencode "period=monthly" \
--data-urlencode "start=2025-01-01" \
--data-urlencode "end=2026-06-01" \
--data-urlencode "api_key=YOUR_API_KEY"

Sample response fragment:

{
"success": true,
"candles": {
"EUA_CO2": [
{"period": "2025-01", "open": 72.5, "high": 75.2, "low": 68.1, "close": 70.3, "data_points": 21},
{"period": "2025-02", "open": 70.3, "high": 73.0, "low": 66.8, "close": 69.2, "data_points": 20}
/* … */
],
"TTF_GAS": [
{"period": "2025-01", "open": 41.8, "high": 48.4, "low": 39.6, "close": 45.1, "data_points": 21}
/* … */
]
}
}

Field meanings:

• period: aggregation bucket.
• open/high/low/close: canonical candle values for the chosen period.
• data_points: number of raw publishing days included—helpful for identifying holidays/trading anomalies.

Error Handling and Reliability Patterns

Even with normalized data, solid error handling is non-negotiable for ESG-grade systems. Energy API emits consistent HTTP status codes and a clear error payload. Your ingest and calculation layers should implement retries and circuit breakers around these.

• 401: Missing or invalid credentials—log securely, alert, and pause ingestion for this app until resolved.
• 404: No data for the symbols or date—fall back to nearest available date (where appropriate) or flag the report as preliminary.
• 422: Validation error—check your parameters (symbol names, date formats).
• 429: Back off with exponential retry and jitter. Consider staggering non-urgent refresh jobs.

Error response shape:

{
"success": false,
"error": "Human-readable message."
}

Operational best practices:

• Health checks with /status before batch pulls. If a provider is degraded, mark the dataset as delayed and auto-resume later.
• Idempotent writes to your warehouse keyed by (symbol, timestamp) to avoid duplication.
• Store raw JSON alongside normalized tables for audit playback and reconciling disputes.
• Implement a “data freshness SLA” per dataset in your monitoring to surface stale series in dashboards.

Real-World Use Cases You Can Ship This Week

1) ESG Avoided Emissions Dashboard for C&I Customers

Show each customer’s DR events, metered curtailment, hourly price, and avoided emissions. Use /electricity/hourly for the wholesale curve, /carbon-intensity for the country, and /latest for EUA_CO2 and TTF_GAS context. Provide exports with timestamps, units, and sources to streamline assurance.

2) Incentive Claim Packager for Aggregators

Automatically assemble settlement-ready bundles per event: curtailed kWh by interval, matched prices, intensity values, and a summary analysis of macro conditions. Use /forecast to pre-stage next-day candidate windows, /fluctuation to show volatility relevance, and /status to certify provider data freshness at the time of claim generation.

3) Portfolio Planning with Carbon-Aware Scheduling

For fleets of flexible assets, schedule dispatch where marginal emissions are highest. Combine /forecast for next-day prices with /carbon-intensity and historical /timeseries of EUA_CO2 and TTF_GAS to bias schedules toward windows that maximize avoided emissions without unduly sacrificing revenue.

Developer Snippets: Pull, Join, and Calculate

A concise JavaScript example that pairs hourly electricity prices with carbon intensity and computes avoided kilograms per hour.

async function fetchJSON(url, params) {
const qs = new URLSearchParams(params);
const res = await fetch(url + "?" + qs.toString());
if (!res.ok) throw new Error("HTTP " + res.status);
return res.json();
}

const API = "https://energy-api.com/api/v1";
const KEY = "YOUR_API_KEY";

async function avoidedKgCO2(symbol, country, date, curtailedKwhByTs) {
const [curve, intensity] = await Promise.all([
fetchJSON(API + "/electricity/hourly", { symbol, date, api_key: KEY }),
fetchJSON(API + "/carbon-intensity", { country, api_key: KEY })
]);

const intensityMap = new Map(intensity.points.map(p => [p.timestamp, p.intensity]));
let total = 0;

for (const p of curve.points) {
const ts = p.start;
const kwh = curtailedKwhByTs[ts] || 0;
const gPerKwh = intensityMap.get(ts);
if (kwh > 0 && typeof gPerKwh === "number") {
total += (kwh * gPerKwh) / 1000.0;
}
}
return total; // kgCO2eq
}

const curtailed = {
"2026-06-12T17:00:00+02:00": 800,
"2026-06-12T18:00:00+02:00": 650
};

avoidedKgCO2("EPEX_DE_DA", "DE", "2026-06-12", curtailed)
.then(kg => console.log("Avoided:", kg, "kgCO2eq"))
.catch(console.error);

And a small cURL-to-Python pattern for archiving multi-commodity snapshots with one call:

curl -G https://energy-api.com/api/v1/latest \
--data-urlencode "symbols=OMIE_ES_DA,EUA_CO2,TTF_GAS,BRENT_CRUDE" \
--data-urlencode "api_key=YOUR_API_KEY" \
> snapshot-2026-06-11.json

This single file can be attached to claims or included in your ESG appendix to document the market state during DR events.

FAQ

How do I align day-ahead auction curves with my DR event windows?

Use /electricity/hourly for the exact market symbol and date. Each point includes start/end timestamps with timezone. Match your metered interval boundaries to these timestamps; if your meters are 15-minute and the market is hourly, prorate or aggregate consistently and document the method in your ESG notes.

Can I query multiple commodities in one call?

Yes. Endpoints like /latest and /timeseries accept comma-separated symbols. This is ideal for correlating DR performance with EUA_CO2, TTF_GAS, or BRENT_CRUDE without issuing separate requests or juggling different schemas.

How often do electricity and intensity values update?

Electricity curves reflect new publication schedules from official sources (e.g., day-ahead auctions). Carbon intensity is provided with hourly (or available) cadence aligned to the country’s reporting. Use /status to verify provider freshness before generating final reports.

What if my requested date is a holiday or there’s no publication?

For daily series (e.g., commodities like gas or oil), /historical returns the most recent value before your date. For intraday electricity curves, request the exact operating day; if an official curve is absent, flag as pending and retry once the provider updates.

How should I handle currencies in multi-commodity snapshots?

Energy API returns native currencies per symbol. Store the original units (see currencies in responses) for auditability. If you must convert, record the FX source and timestamp alongside your converted values to maintain a transparent chain of custody in ESG disclosures.

Conclusion + CTA

Quantifying avoided emissions from demand response shouldn’t require weeks of ETL glue and fragile scraping against multiple national portals. With Energy API, you can pull settlement-aligned electricity curves, country-level carbon intensity, and the commodity context needed to tell a complete, defensible climate story—all via a cohesive JSON interface designed for production systems.

Whether you’re building an ESG dashboard, preparing incentive claims, or operating a DR portfolio across multiple regions, the workflow above gives you a fast path from raw signals to auditable avoided emissions. Pair hourly price curves with intensity, annotate with EUA and TTF, and maintain operational rigor using provider health checks and robust error handling.

Start implementing your avoided emissions workflow today. Explore the endpoints, wire the examples into your data stack, and ship a reliable DR and ESG experience your stakeholders can trust. Try Energy API for free.