# French DPE Energy Rating Search — Find Homes by Class (`dalbian/french-dpe-energy-search`) Actor

Search ADEME's 15.6-million-record energy-performance register by commune, postcode, department or radius, filtered by energy class, GES class, building type, floor area and construction year. Returns a full statistical profile plus the individual certificates.

- **URL**: https://apify.com/dalbian/french-dpe-energy-search.md
- **Developed by:** [Benjamin Jerez](https://apify.com/dalbian) (community)
- **Categories:** Real estate, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## French DPE Energy Rating Search — Find Homes by Class

Search ADEME's national energy-performance register — **15.6 million certificates** — by area and by criteria, and get both the shape of a local housing market and the individual records behind it.

The register is open data, but it is not easy data: 230 columns, French field names, a query syntax of its own, and no way to ask a simple question like *how much of this commune is poorly rated?* This Actor asks it for you.

### What comes back

**A statistical profile of every area you search.** How many certificates match, the full distribution across the seven classes in counts and percentages, average floor area, average energy use per square metre and average emissions.

**The local market as context, not just your filter.** If you filter on F and G, the share of poorly rated stock is trivially 100% — useless. So the Actor also computes the same area *without* your class filter and reports the real figure. Ask for pre-1975 houses rated F or G in Avignon and you get: 304 matches out of a local stock of 1 481, **20.5%**. The Vaucluse as a whole sits at 22.7%; Vedène at 13.5%. That comparison is the product.

**The individual certificates**, each with address, energy and greenhouse class, building type, year built, habitable area, energy use, assessment date and coordinates — ready to map or to join onto your own data.

### Four ways to define an area

| Scope | When to use it |
| --- | --- |
| **Commune INSEE code** | The sharpest scope — one commune is one local market |
| **Postcode** | Looser: a postcode can span several communes |
| **Department** | Regional studies; expect large counts |
| **Around an address** | A radius that follows real neighbourhoods rather than administrative lines |

### Filters

Energy class, greenhouse-gas class, building type (maison, appartement, immeuble), construction year range, habitable floor area range, and assessment date. Combine them freely — every filter applies to the statistics as well as the records.

Two cut-offs worth knowing. **1975** is the usual dividing line for pre-insulation housing stock. **July 2021** is when the current method came in, with a further revision in July 2024, so certificates issued before then are not directly comparable — `assessedAfter` lets you exclude them.

### Why F and G

French law now restricts the worst-rated homes: class G can no longer be let, and class F follows in 2028. That single fact is why insulation, heat-pump and renovation businesses filter on exactly these two classes, and why a commune's F+G share is a market size rather than a statistic.

### Who uses this

Renovation, insulation and heating businesses sizing a territory before opening in it. Energy consultants and *bureaux d'études* profiling a housing stock. Local authorities and social landlords planning retrofit programmes. Estate agencies and valuers who need to know how a property sits against its neighbours. Researchers and journalists working on housing and energy.

### On personal data

The register describes **buildings, not people**. It carries no owner names and no contact details. Addresses are published by ADEME as open data under the Licence Ouverte.

If you go on to use individual records for commercial prospecting, you become the data controller for that use and French and EU rules apply to you — legitimate-interest assessment, the information notice required at first contact, and the *Bloctel* opposition list. This Actor runs on your own Apify account and keeps nothing; what you do with the output is yours to govern. If you only need to size a market, turn `includeRecords` off: the statistics are computed over every match regardless.

### Data source

**ADEME — DPE Logements existants (depuis juillet 2021)**, queried live, so results reflect the register as it stands today. Published under the Licence Ouverte / Etalab. No credentials needed.

### Frequently asked

**Do the statistics depend on how many records I request?**
No. They are computed over every certificate that matches, whatever `maxRecordsPerArea` is set to. A low value gives you the full picture cheaply.

**Why do two certificates share one address?**
Because a building can hold several dwellings, and a dwelling can be assessed more than once. Both are normal.

**Does it cover new builds?**
This Actor reads the register of existing housing. New-build certificates live in a separate ADEME dataset.

**Is a 2022 certificate comparable with a 2025 one?**
Not exactly. The method was revised in July 2024, mainly affecting small dwellings. Use `assessedAfter` when comparability matters.

# Actor input Schema

## `communes` (type: `array`):

Five-character INSEE codes, one per line. This is the sharpest scope: one commune is one local market. Corsican codes such as 2A004 work. Example: 84007 for Avignon.

## `postcodes` (type: `array`):

Five-digit postcodes, one per line. Looser than an INSEE code — a postcode can span several communes, and a large city can hold several postcodes.

## `departments` (type: `array`):

Two- or three-character department codes such as 84, 2A or 974. Use these for regional market studies; expect large counts.

## `aroundAddresses` (type: `array`):

French addresses, one per line. Each is geocoded and searched within the radius below, which follows real neighbourhoods rather than administrative boundaries.

## `radiusMeters` (type: `integer`):

Search radius around each address. Only applies to the addresses above. 1000 m covers a neighbourhood; 200 m covers a street and its surroundings.

## `energyClasses` (type: `array`):

Keep only these energy classes. Leave empty for all. F and G are the classes the law now restricts: G homes can no longer be let, and F follows in 2028, which is why renovation and insulation businesses filter on exactly these two.

## `gasClasses` (type: `array`):

Keep only these greenhouse-gas classes. Leave empty for all. A property can be decent on energy and poor on emissions, typically when it burns fuel oil or gas.

## `buildingTypes` (type: `array`):

Keep only these building types. Leave empty for all.

## `builtAfter` (type: `integer`):

Keep only buildings constructed in or after this year. Leave empty for no lower bound.

## `builtBefore` (type: `integer`):

Keep only buildings constructed in or before this year. 1975 is the usual cut-off for pre-insulation housing stock.

## `minFloorArea` (type: `integer`):

Keep only dwellings at or above this habitable area. Leave empty for no lower bound.

## `maxFloorArea` (type: `integer`):

Keep only dwellings at or below this habitable area. Leave empty for no upper bound.

## `assessedAfter` (type: `string`):

Keep only certificates issued on or after this date, as YYYY-MM-DD. The method changed in July 2021 and again in July 2024, so older certificates are not directly comparable with newer ones.

## `includeStatistics` (type: `boolean`):

Return one summary row per area: how many certificates match, the full class distribution in counts and percentages, the share of poorly rated stock, and average floor area, energy use and emissions. This is market analysis and contains no individual record.

## `includeRecords` (type: `boolean`):

Also return the individual certificates behind the statistics, each with its address, classes, area, year and coordinates. Turn this off when you only need the shape of a market.

## `maxRecordsPerArea` (type: `integer`):

How many individual certificates to return per area. The statistics are always computed over every match, no matter what this is set to, so a low value gives you the full picture cheaply.

## Actor input object example

```json
{
  "communes": [
    "84007"
  ],
  "radiusMeters": 1000,
  "energyClasses": [],
  "gasClasses": [],
  "buildingTypes": [],
  "includeStatistics": true,
  "includeRecords": true,
  "maxRecordsPerArea": 100
}
```

# Actor output Schema

# 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 = {
    "communes": [
        "84007"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dalbian/french-dpe-energy-search").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 = { "communes": ["84007"] }

# Run the Actor and wait for it to finish
run = client.actor("dalbian/french-dpe-energy-search").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "communes": [
    "84007"
  ]
}' |
apify call dalbian/french-dpe-energy-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dalbian/french-dpe-energy-search"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cyRTIpuUCLuo1o7Fz/builds/NFrh23iIq2IoCADVb/openapi.json