# Carbon Emission Factors Scraper - ADEME Base Carbone (CO2) (`dltik/base-carbone-fr-scraper`) Actor

Search the official ADEME Base Carbone - France's CO2 emission factor database (12K+ factors). Filter by keyword (electricity, beef, flight) or category. Get value in kgCO2e, unit, uncertainty, source, scope, validity and per-gas breakdown. For carbon accounting, CSRD/ESG, LCA. $2/1K.

- **URL**: https://apify.com/dltik/base-carbone-fr-scraper.md
- **Developed by:** [dltik](https://apify.com/dltik) (community)
- **Categories:** Business, AI, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 factor scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Carbon Emission Factors Scraper — ADEME Base Carbone (CO2) API

> Query the **official ADEME Base Carbone®** — France's reference database of **CO2 emission factors** used for every regulated carbon footprint (Bilan Carbone, BEGES, ACV/LCA). **12,800+ emission factors**. Search by keyword (electricity, beef, flight, cement, diesel...) or by category, and get the **value in kgCO2e, unit, uncertainty, data quality, source, geographic scope, validity period, ADEME id and per-gas breakdown**. **HTTP-only, $0.002 per factor**.

⭐ **Bookmark this Carbon Emission Factors Scraper** — Apify ranks actors by bookmarks, so it directly helps the visibility of this scraper on the Apify Store.

### What is the Carbon Emission Factors Scraper?

The **Carbon Emission Factors Scraper** is an Apify actor that turns the [official ADEME Base Carbone](https://base-empreinte.ademe.fr/) into a clean, queryable, exportable dataset. Base Carbone is the French government's authoritative emission-factor database, maintained by ADEME (Agence de la transition écologique). It is the source every French carbon-accounting tool, consultancy and Bilan Carbone® study draws on.

This scraper hits the free official ADEME open-data API — no authentication, no API key, no rate limits to fight. Pass a keyword and/or a category, set how many factors you want, and receive one structured row per emission factor with its value in kgCO2 equivalent, the unit it applies to, the uncertainty, the underlying programme (AGRIBALYSE, ADEME, etc.) and a per-greenhouse-gas breakdown (CO2, CH4, N2O...).

### Why it matters: CSRD, ESG and carbon accounting

EU sustainability regulation (CSRD, the Corporate Sustainability Reporting Directive) now forces tens of thousands of companies to measure and report their greenhouse-gas emissions. Every one of those calculations multiplies an activity (kWh of electricity, kg of beef, km flown) by an **emission factor**. Base Carbone is the reference for those factors in France. Having the catalog as structured data is the difference between hand-copying numbers from a web UI and powering an automated carbon-accounting pipeline.

### Use cases

- **Carbon-accounting SaaS** — seed or refresh your emission-factor library from the authoritative source.
- **ESG / CSRD reporting** — pull the exact kgCO2e factors and uncertainty for a Bilan Carbone or BEGES.
- **LCA / ACV tooling** — enrich life-cycle models with AGRIBALYSE food factors and ADEME energy factors.
- **Sustainability consultancies** — build a searchable internal factor database, filtered by category.
- **Research & data science** — analyse emission-factor distributions across categories, programmes and time.

### Input

```json
{
  "query": "electricity",
  "category": "",
  "maxResults": 200
}
````

- `query` — full-text keyword (matches French and English names + tags). Examples: `electricity`, `beef`, `flight`, `cement`, `diesel`.
- `category` — filter by ADEME category path; every word must appear, e.g. `Combustibles`, `Transport`, `agro alimentaires`.
- `maxResults` — cap on factors returned (aliases: `limit`, `max`). The full catalog is ~12,800 factors.

### Output

```json
{
  "type": "emission_factor",
  "ademe_id": "14034",
  "name_en": "Electricity",
  "name_fr": "Electricité",
  "category": "Energie > Electricité > Usages",
  "value_kgco2e": 0.0742,
  "unit_en": "kgCO2e/kWh",
  "uncertainty_pct": 30,
  "geo_scope": "France continentale",
  "programme": "ADEME",
  "source": "https://www.bilans-ges.ademe.fr/",
  "valid_until": "31/12/2025",
  "status": "Valide",
  "ghg_breakdown": { "CO2f": 0.06, "CH4f": 0.001, "N2O": 0.0002 }
}
```

The `status` field (`Valide` / `Archivé`) lets you keep only current factors.

### Pricing

**PAY\_PER\_EVENT — $0.002 per emission factor** (= $2 per 1,000 factors). Free actor starts. No charge when nothing matches.

### FAQ — ADEME Base Carbone API

**Where does the data come from?** The official ADEME Base Carbone, served through the free ADEME open-data API (data.ademe.fr). All public open data, no key required.

**Does it include AGRIBALYSE food factors?** Yes — AGRIBALYSE food/agriculture factors are part of Base Carbone and are returned, tagged by programme.

**Can I export the whole catalog?** Yes — leave `query` and `category` empty and set `maxResults` high; the actor paginates through all ~12,800 factors.

**FR or EN?** Each factor row includes both French and English names, units and tags.

***

⭐ **Found this useful? Bookmark this Carbon Emission Factors Scraper** — it's the strongest signal for Apify Store ranking.

#### Related actors

- [ADEME DPE Scraper](https://apify.com/dltik/ademe-dpe-scraper) — 25M+ French energy performance diagnostics
- [data.gouv.fr MCP Server](https://apify.com/dltik/mcp-server-data-gouv) — French open-data catalog for AI agents
- [Eurostat MCP Server](https://apify.com/dltik/mcp-server-eurostat) — EU statistics for AI agents

License: MIT · Author: [dltik](https://apify.com/dltik)

# Actor input Schema

## `query` (type: `string`):

Full-text keyword to search emission factors (matches French + English names and tags). Examples: 'electricity', 'beef', 'flight', 'cement', 'diesel'. Leave empty to browse by category or export everything.

## `category` (type: `string`):

Filter by ADEME category path. Every space-separated word must appear in the category, e.g. 'Combustibles', 'Transport', 'agro alimentaires', 'Achats services'. Combine with the keyword for precise targeting.

## `maxResults` (type: `integer`):

Max emission factors to return. Aliases accepted: 'limit', 'max'. Each factor is charged at the per-event price - start small to validate output. The full catalog is ~12,800 factors.

## `proxyConfig` (type: `object`):

Optional. The ADEME open API has no anti-bot, so proxy is rarely needed.

## Actor input object example

```json
{
  "maxResults": 50,
  "proxyConfig": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Emission-factor records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("dltik/base-carbone-fr-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("dltik/base-carbone-fr-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call dltik/base-carbone-fr-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dltik/base-carbone-fr-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Carbon Emission Factors Scraper - ADEME Base Carbone (CO2)",
        "description": "Search the official ADEME Base Carbone - France's CO2 emission factor database (12K+ factors). Filter by keyword (electricity, beef, flight) or category. Get value in kgCO2e, unit, uncertainty, source, scope, validity and per-gas breakdown. For carbon accounting, CSRD/ESG, LCA. $2/1K.",
        "version": "1.0",
        "x-build-id": "szl6Kxaic0GAykr8p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dltik~base-carbone-fr-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dltik-base-carbone-fr-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/dltik~base-carbone-fr-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dltik-base-carbone-fr-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/dltik~base-carbone-fr-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dltik-base-carbone-fr-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "query": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Full-text keyword to search emission factors (matches French + English names and tags). Examples: 'electricity', 'beef', 'flight', 'cement', 'diesel'. Leave empty to browse by category or export everything."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Filter by ADEME category path. Every space-separated word must appear in the category, e.g. 'Combustibles', 'Transport', 'agro alimentaires', 'Achats services'. Combine with the keyword for precise targeting."
                    },
                    "maxResults": {
                        "title": "Max factors",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Max emission factors to return. Aliases accepted: 'limit', 'max'. Each factor is charged at the per-event price - start small to validate output. The full catalog is ~12,800 factors.",
                        "default": 50
                    },
                    "proxyConfig": {
                        "title": "Proxy (rarely needed)",
                        "type": "object",
                        "description": "Optional. The ADEME open API has no anti-bot, so proxy is rarely needed.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```