Live · Updated continuously

Every climate methodology. Ask it, or build on it.

One graph of 1,130 climate methodologies across five kinds: formulas, lookup tables, umbrella standards, governance frameworks, and credit registries. Parsed from primary sources, version-tracked, and dependency-mapped. Ask it in plain English and get an answer that names its sources, or call the same graph over REST and MCP to build it into your own products.

Ask the graph Beta Open the graph

Try the API Explorer → Get a free API key →

1,130

Methodologies tracked

447

Organisations mapped

1,835

Relationships mapped

905

Calculators ready to run

169,131

Emission factors

Plain English, grounded in the graph

Ask about a standard, a dependency, or how to report Open Ask

Try Which standards govern Scope 2 electricity emissions? What does GHG Protocol Corporate depend on? What breaks if IPCC updates its GWP values?

Every answer is assembled only from the graph, names the standards and sources behind it, and shows which models and graph version produced it.

POST /v1/calculate/ghgp-s2

Country:

Request body caller gives kWh, country, year. The engine looks up the grid factor.

Response watch resolved_from_datasets for the Ember grid factor

Pick a country above and click Run. The response carries the result, the formula, the grid factor resolved from Ember country-year data, and the CC BY 4.0 attribution chain.

Live, calls the deployed API Open in API Explorer →

Tracking standards from

IPCC GHG Protocol ISO Verra Gold Standard SBTi IFRS · ISSB CDP ICAO CORSIA EnergyTag PCAF SAFc

The problem

Climate methodologies are fragmented, slow to update, and hard to compute

Hundreds of standards, dozens of registries, thousands of pages of methodology spread across PDFs, HTML annexes, XML schedules, and spreadsheets. Each one defines a calculation, a factor table, a disclosure requirement, or a ledger of credits. Almost none are machine readable. No two are integrated with each other.

Methodologies live in documents, not code

The actual calculation is buried in prose, footnotes, and annexes across PDFs, HTML pages, and supplementary tables. Reading it is a job. Encoding it is a project.

Standards change quietly

A version bumps. An annex gets revised. A factor table is replaced. Downstream users find out months later, often by accident.

Every team builds the same wheel

Consultancies, auditors, and platforms re-implement the same formulas, with no consensus on edge cases.

Provenance is fragile

A number reported in a sustainability disclosure rarely carries the exact formula version and inputs that produced it. Auditors cannot replay it.

Who uses it

One graph, four very different jobs

Climate accounting is a different conversation depending on which side of the desk you sit on. Methodology Graph is built to be the single source of truth across all four.

Climate-tech engineering

Ship the calculator. Skip becoming a standards expert.

One POST /v1/calculate/<id> returns the result, the formula, the factor values, and the source citation. Wire it up, move on.

For: product engineers · climate platforms · CRM emissions modules

Auditors & assurance

Every number replayable, years later.

Pin to a methodology version, store the response, replay it in 2030 against the standard as it stood in 2026. Audit trail, not audit panic.

For: assurance providers · VVBs · internal audit teams

Climate consultancies

Stop re-implementing the same formula.

GHG Protocol, IPCC GWP, ISO 14067, PCAF, encoded once. You call our endpoint and spend the engagement on judgment, not on re-encoding standards.

For: climate consultancies · sustainability advisors · LCA practitioners

Standards & regulators

See who depends on your methodology.

The dependency tree shows every downstream methodology, framework, and registry that references your standard. Useful for revision planning and impact analysis.

For: standards bodies · regulators · framework authors

The catalog

Five kinds of methodology, one graph

Climate methodologies are not a single shape. Some are calculations, some are lookup tables, some are governance frameworks, some are credit registries, and some are umbrella standards that decompose into named parts. Each kind has its own URL space, served by the same engine, queryable through the same graph.

FORMULA

Executable calculations

Math expressions and boolean rules. Call them with your inputs, receive the result with provenance attached. Examples: ICAO CORSIA LCA, PCAF financed emissions, SAFc CO2e abatement, EnergyTag matching.

POST /v1/calculate/:id

DATASET

Factor lookup tables

Map a key to a value. Examples: IPCC AR6 GWP100 by gas (22 entries), ICAO CORSIA SAF default LCA by pathway (27 entries). Auto-resolved inside formulas that declare a dependency.

POST /v1/lookup/:id

COMPOSITION

Umbrella standards with parts

One named umbrella decomposes into typed components, each a callable methodology in its own right. Examples: EU RED III lifecycle (8 components), ISO 14067 product carbon footprint. Call the umbrella and the engine resolves each part recursively.

POST /v1/calculate/:id

FRAMEWORK

Governance & disclosure rules

No calculation, just principles and requirements. Examples: TCFD, ISSB S1/S2, CSRD ESRS, ICVCM Core Carbon Principles. Detail endpoint includes upstream and downstream dependency context.

GET /v1/frameworks/:id

REGISTRY

Credit issuance ledgers

Credit and certificate registries that other methodologies depend on. Examples: Verra, Gold Standard, ACR, I-REC. Detail endpoint returns the list of consumers depending on the registry.

GET /v1/registries/:id

Composition

When standards have parts, the graph keeps them apart

Lifecycle standards like EU RED III, ISO 14067, and GHG Protocol Product define a calculation as a sum of named components. The umbrella is a methodology; each part is a methodology in its own right; they are linked by typed edges. Call the umbrella with whatever you have, the engine walks the graph for the rest, and the response shows the full chain.

From the live graph: eu-red3 umbrella has 8 typed component edges into 8 sub-methodologies, each independently callable.

Three ways to use it

Inspect the umbrella's structure, run the umbrella with whatever subset of components you have, or call any component standalone as its own methodology. Symbols you skip get resolved from their sub-methodology if a live one exists; optional symbols default to zero. The provenance trace shows where every number came from.

GET /v1/compositions/eu-red3 inspect structure

POST /v1/calculate/eu-red3 run umbrella

POST /v1/calculate/eu-red3-cultivation run any component

What you get

One API call instead of two months of integration

Pass the inputs you have. The engine resolves the rest from the published source. The response carries the formula, the version, and every factor it substituted for you.

No factor table lookups

Calling GHG Protocol Scope 2? Pass the country and the year. The engine pulls the grid emission factor from Ember's 3,259 country-year electricity intensities, converts the unit, and substitutes it for the caller. The resolved value, the raw upstream value, and the multiplier are all in the response.

No formula encoding

The formula text comes back with every result. So does the standard reference and the methodology version. No need to maintain a local copy of every standard you depend on.

License chain attached

Every factor carries its license forward. Ember's CC BY 4.0 attribution lands in the response automatically, alongside any other sources the calculation touched. Compliance and audit get the citation chain for free.

curl · /v1/calculate/ghgp-s2

# caller provides kWh, country, year, method
# engine resolves emission_factor_kgCO2e_per_kWh from Ember

POST /v1/calculate/ghgp-s2
{
  "inputs": {
    "electricity_consumed_kWh": 1000,
    "country": "GBR",
    "year": "2023",
    "method": "location_based",
    "contractual_instrument_quality_passes": false
  }
}

200 OK
{
  "result": { "scope2_emissions_tCO2e": 0.217 },
  "provenance": {
    "formula": "(electricity_consumed_kWh * emission_factor_kgCO2e_per_kWh) / 1000",
    "standard_reference": "WRI/WBCSD GHG Protocol Scope 2 Guidance (2015)",
    "resolved_from_datasets": {
      "emission_factor_kgCO2e_per_kWh": {
        "dataset": "factor-set:ember-yearly-electricity-2025",
        "key": "GBR_2024",
        "raw_value": 216.5,
        "applied_multiplier": 0.001,
        "value": 0.2165
      }
    }
  },
  "license_chain": {
    "attributions_required": [
      { "source_name": "Ember Yearly Electricity Data",
        "license_short_name": "CC BY 4.0" }
    ]
  }
}

How it stays current

An autonomous loop, watching every source

The calculator you depend on has to stay correct when the standard issues a revision six months later. Methodology Graph treats catalog growth, change detection, and confidence review as continuous loops, run by typed agents on a fixed schedule.

ROLE 01

Discovery

Proposes new methodologies the catalog does not yet hold, and walks every known source for revisions. Runs on a fixed schedule, twice weekly for deep discovery, every few hours for incremental seed walks. The catalog grows without operator action.

ROLE 02

Parser synthesis

For every newly classified methodology, a typed agent reads the document and writes a parser definition: formula, input schema, output schema, factor table references, and citations. The parser becomes machine executable. The source stays the authority.

ROLE 03

Independent review

A separate agent, run in isolation, audits the synthesizer's draft against the published standard. Returns a confidence score from 0 to 1 plus a verdict. Above threshold the calculator goes live. Below threshold it sits in a queue for operator review. Two passes by two agents, by design.

ROLE 04

Drift watch

An hourly machine-correctness sweep over every live calculator and a continuous watch on every active source. Spots stale extractions, malformed outputs, schema mismatches, and dependency cascades. Re-feeds affected items into discovery, and fans out events to webhook subscribers so dependents hear about a revision before their next audit, not after.

The four roles run on Energy Web's globally distributed serverless runtime. Each role has a precise input contract and a structured response. Each role is run by a separate model chosen for the role's shape, fast and cheap for classification, deep and careful for synthesis, independent and conservative for review. Reliability comes from the surrounding plumbing, schema validation, idempotent writes, retryable queues, multi-stage consensus, not from making any single component cleverer.

The pipeline

Nine stages between a primary source and a callable endpoint

Each stage reads from a typed queue, writes to the next, and acknowledges its message only on success. Any stage can be restarted, replayed, or scaled independently. The whole pipeline runs on Energy Web's globally distributed serverless runtime. Multi-format ingestion, multi-pass review, dependency cascades, and an hourly watch loop all sit on top.

Stages 1 to 5 keep the methodology graph current. Stages 6 to 8 turn each methodology's calculation into a callable endpoint and gate it against confidence thresholds. Stage 9 propagates changes downstream to dependent methodologies and feeds drift signals back into discovery, closing the loop without operator action.

The thing only a graph can do

When a standard moves, we know what breaks.

Every methodology is a node; every reference is a typed edge. When IPCC publishes a revision to AR6 GWP100, we know automatically which of your live calculations it invalidates. Pick a methodology to see its downstream cascade.

Revise →

Loading…

A revision to IPCC GWP values would cascade into

… downstream methodologies

…Direct (depth 1)

…Transitive (depth 2+)

…Frameworks affected

Sample of affected methodologies

The webhook closes the loop. Drift watch (stage 9 above) runs hourly. When a source revision is detected, the graph re-emits a plan.published webhook to every subscriber with the list of affected methodology ids. The auditor finds out before they ask.

Quality controls, tunable

Two independent gates decide what goes live

A calculator only becomes callable if it passes two independent checks. The critic is an LLM scoring how faithfully the extracted formula matches the published standard. The machine-correctness check is a deterministic structural verifier that confirms the formula parses, evaluates to a real number, and has no divide-by-zero risks, no chained outputs, no schema gaps. Both must pass.

Critic gate

Semantic faithfulness

A second LLM, run independently from the extractor, scores how faithfully the extracted formula matches the published standard. Returns a 0 to 1 score plus a structured verdict. Below threshold rejects; above threshold passes to the next gate.

Machine gate

Structural correctness

A deterministic check verifies the formula parses, evaluates to a real number against neutral inputs, has consistent input and output schemas, no unguarded divisions, no chained outputs. The structural gate catches what the critic can miss: a formula that reads correctly but cannot run.

Both gates pass

Auto-promoted, live

The calculator becomes callable as a public API endpoint with full provenance metadata. Any drift detected later by the hourly sweep demotes it back to review and queues an autonomous re-extraction. Live means it works, today.

Thresholds are tunable per stage. Tighter thresholds mean fewer auto-promotions and more operator review. Looser thresholds mean faster coverage at the cost of more borderline cases reaching production. The two-gate design means a high critic score alone is not enough to go live; the formula must also be structurally executable.

Four ways to use it

Same graph. Four surfaces. Pick the one that fits your stack.

FOR ANYONE

Ask Beta

Ask in plain English and get an answer assembled only from the graph, with the standards and sources it used and the models and graph version that produced it. The fastest way in if you want an answer before a tool.

ask.methodology.energyweb.org →

FOR DEVELOPERS

REST API

Standard HTTPS endpoints, JSON in and out, free for individual use with an email-signup key. List methodologies, fetch dependency trees, call calculators, look up datasets, traverse frameworks and registries.

api.methodology.energyweb.org/v1/ →

FOR AI AGENTS

MCP server

Model Context Protocol endpoint. Plug it into Claude with one click, into Cursor, into your in-house agent. Typed tools for every calculator, the graph, and the catalog. Ask in natural language, get authoritative numbers.

mcp.methodology.energyweb.org →

FOR HUMANS

Interactive viewer

Browse the full graph visually. Drill into any methodology to see its inputs, dependencies, versions, and primary sources. Try calculations in-place without writing code.

methodology.energyweb.org/viewer →

Provenance and verification

Every result carries its receipt

A calculation that nobody can audit is barely a calculation. The Methodology Graph engine returns the exact formula text, the inputs used, the resolved factor values, the methodology version, and the source standard reference, on every successful call. Auditors can replay any result.

Formula text returned with every result

The exact expression that produced the number. No reverse engineering required.

Resolved factor values disclosed

If the engine pulled a GWP or LCA default from a dataset, it tells you which row, from which version, with the citation.

Methodology version pinned

The version of the standard that ran is locked into the response, so the same call yields the same answer years later.

Source reference in the payload

A citation pointing to the source document, section, and where in the published text the calculation was defined.

COMING NEXT

Verified Compute receipts

The next phase signs every result with a Verified Compute attestation: a cryptographic proof that the calculation ran on the published standard, executed by a named runtime, against the inputs disclosed in the receipt. Audit-grade provenance, not just metadata. Methodology Graph becomes the public, machine-readable ground truth that other Energy Web products execute against.

Get started

Four doors in

Free for individual use, 60 seconds to set up via email. No password, no credit card.

Get your free API key

Enter your email. We send you a one-time confirmation link. Click it, get your key. One key per email. Manage at /account if you lose it.

Tier	Rate limit	How to get it
demo	300 req/min	Shared public key, baked into the explorer. For trying things out.
free	600 req/min	Sign up above with email. One key per email.
enterprise	Custom	For partner integrations. Contact methodology@energyweb.org.