# French RGE Certified Contractors Finder (ADEME) (`fit_melon/french-rge-certified-contractors-finder-ademe`) Actor

Search 60,000+ French RGE certified contractors from the official ADEME registry: heat pump, insulation, solar. Filter by trade & location, get phone/email/SIRET, or verify RGE status of a SIRET list (KYB). Free — artisan RGE, MaPrimeRenov leads.

- **URL**: https://apify.com/fit\_melon/french-rge-certified-contractors-finder-ademe.md
- **Developed by:** [D N](https://apify.com/fit_melon) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## French RGE Certified Contractors Finder (ADEME) 🇫🇷

**Search, export and verify French RGE certified contractors** (Reconnu Garant de l'Environnement) straight from the **official ADEME open data registry** — the same database behind france-renov.gouv.fr. RGE certification is mandatory for homeowners to receive French state renovation aid (**MaPrimeRénov'**, éco-PTZ, CEE), which makes this registry the single source of truth for **energy renovation lead generation** and **contractor verification (KYB)** in France: **artisan RGE, pompe à chaleur, isolation, photovoltaïque, chauffage, audit énergétique** and more. The registry is updated **daily** by ADEME and covers 60,000+ companies (160,000+ qualification certificates). This Actor is **free** — you only pay your own Apify platform consumption.

### What it does

Two modes in one Actor:

- **Search mode** — filter the national registry by work domain (heat pump, insulation, solar…), department, postal code or city, and export companies with **SIRET, address, GPS coordinates, phone, email, website** and the full list of their qualifications with validity dates.
- **Verify mode** — paste a list of **SIREN/SIRET** numbers and get the RGE status of each one: `rge_active`, `rge_expired` or `not_rge`, with every certificate and its validity period. Inputs are Luhn-validated. Ideal for marketplaces and platforms that must check RGE status before MaPrimeRénov' work.

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | select | `search` (default) or `verify` |
| `workDomain` | string | Keyword matched on the certified domain, accent-insensitive: `isolation`, `pompe à chaleur`, `photovoltaïque`, `chauffage`, `fenêtres`, `ventilation`, `audit énergétique`, `architecte`… |
| `departments` | array | Department codes, e.g. `75`, `59`, `69` |
| `postalCodes` | array | Exact 5-digit postal codes |
| `communes` | array | City names, e.g. `LILLE`, `ANNECY` |
| `searchQuery` | string | Optional free-text search (company name…) |
| `sirets` | array | SIREN (9 digits) or SIRET (14 digits) — required in verify mode |
| `activeOnly` | boolean | Keep only currently valid certificates (default `true`) |
| `groupByCompany` | boolean | One item per company with aggregated certificates (default `true`); off = one row per certificate |
| `maxResults` | integer | Cap on dataset items (default 200) |

### Output

One item per company (search mode, grouped):

```json
{
  "status": "found",
  "siret": "82454695600023",
  "siren": "824546956",
  "companyName": "EL ARCHITECTURE",
  "address": "4 RUE D'HALLENNES",
  "postalCode": "59320",
  "city": "ENGLOS",
  "department": "59",
  "latitude": 50.622205,
  "longitude": 2.957894,
  "phone": "06 37 51 96 32",
  "email": "e.lannoyarchitecture@gmail.com",
  "website": "",
  "worksWithIndividuals": true,
  "domains": ["Architecte"],
  "metaDomains": ["Rénovation globale"],
  "certificates": [
    {
      "domain": "Architecte",
      "metaDomain": "Rénovation globale",
      "qualificationName": "Architecte sur le site faire.fr (2)",
      "certificateName": "Tableau de l´Ordre",
      "certifyingBody": "cnoa",
      "validFrom": "2019-10-16",
      "validTo": "2099-01-01",
      "isActive": true,
      "attestationUrl": "https://ws-api.architectes.org/faire/v2/attestation/…"
    }
  ],
  "activeCertificatesCount": 1,
  "hasActiveCertificate": true,
  "source": "ADEME liste-des-entreprises-rge-2"
}
````

Verify mode adds `input`, `inputType`, `luhnValid` and `rgeStatus` (`rge_active` / `rge_expired` / `not_rge`). Every input always produces exactly one item — invalid numbers yield `status: "error"` with an explicit message, the run never crashes.

### Use cases

- **Lead generation** — export every RGE heat-pump installer of a department with phone and email, ready for your CRM or cold outreach (manufacturers, brokers, courtiers en travaux, insulation material suppliers).
- **KYB / compliance** — verify that a contractor's RGE certification is active before subcontracting MaPrimeRénov'-eligible work; batch-check your whole supplier list.
- **Marketplace enrichment** — auto-badge "RGE certified" profiles on home-improvement platforms, with the attestation URL as proof.
- **Market mapping** — count and map RGE companies per domain and region (GPS coordinates included) to spot under-served areas.

### Limitations & fair use

- Data comes from the official ADEME dataset [liste-des-entreprises-rge-2](https://data.ademe.fr/datasets/liste-des-entreprises-rge-2), published under the **Licence Ouverte / Etalab open licence** and refreshed daily. This Actor queries it politely (throttled, identified User-Agent).
- A company can hold several certificates; use `groupByCompany` (default) for one row per SIRET.
- `rge_expired` means the company had RGE qualifications that are no longer valid — always check `certificates[].validTo` for details.
- The registry only contains companies in the RGE scheme; `not_rge` does not mean the company doesn't exist, only that it holds no RGE qualification.

### More actors by this developer

More French B2B data tools (SIRENE company search, SIREN enrichment, legal notices, EU VAT validation, IDCC collective agreements…) on my profile: **[apify.com/fit\_melon](https://apify.com/fit_melon)** — issues and feature requests welcome on the Issues tab.

# Actor input Schema

## `mode` (type: `string`):

search: find RGE contractors by work domain and location. verify: check the RGE status of a list of SIREN/SIRET numbers (KYB).

## `workDomain` (type: `string`):

Keyword matched against the certified work domain, accent-insensitive. Examples: isolation, pompe à chaleur, photovoltaïque, chauffage, fenêtres, ventilation, chaudière bois, audit énergétique, forage, architecte.

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

French department codes to filter on, e.g. 75, 59, 69, 13. Matched on the postal code prefix.

## `postalCodes` (type: `array`):

Exact 5-digit postal codes, e.g. 59000, 74470. Combined with departments (OR).

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

City names as written in the registry (case-insensitive), e.g. LILLE, LYON, ANNECY.

## `searchQuery` (type: `string`):

Optional full-text search across all fields (company name, qualification…).

## `sirets` (type: `array`):

9-digit SIREN or 14-digit SIRET numbers to verify. In verify mode: one result item per number with rgeStatus = rge\_active / rge\_expired / not\_rge. Also usable in search mode to fetch certificates of specific companies.

## `activeOnly` (type: `boolean`):

Keep only certificates that are currently valid (recommended). Turn off to include expired qualifications.

## `groupByCompany` (type: `boolean`):

One dataset item per company (SIRET) with all its certificates aggregated. Turn off for one flat row per certificate.

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

Maximum number of items pushed to the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "workDomain": "isolation",
  "departments": [
    "75"
  ],
  "activeOnly": true,
  "groupByCompany": true,
  "maxResults": 50
}
```

# 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 = {
    "mode": "search",
    "workDomain": "isolation",
    "departments": [
        "75"
    ],
    "activeOnly": true,
    "groupByCompany": true,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("fit_melon/french-rge-certified-contractors-finder-ademe").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 = {
    "mode": "search",
    "workDomain": "isolation",
    "departments": ["75"],
    "activeOnly": True,
    "groupByCompany": True,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("fit_melon/french-rge-certified-contractors-finder-ademe").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 '{
  "mode": "search",
  "workDomain": "isolation",
  "departments": [
    "75"
  ],
  "activeOnly": true,
  "groupByCompany": true,
  "maxResults": 50
}' |
apify call fit_melon/french-rge-certified-contractors-finder-ademe --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fit_melon/french-rge-certified-contractors-finder-ademe",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "French RGE Certified Contractors Finder (ADEME)",
        "description": "Search 60,000+ French RGE certified contractors from the official ADEME registry: heat pump, insulation, solar. Filter by trade & location, get phone/email/SIRET, or verify RGE status of a SIRET list (KYB). Free — artisan RGE, MaPrimeRenov leads.",
        "version": "0.0",
        "x-build-id": "S25r51itIalLfHY9t"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fit_melon~french-rge-certified-contractors-finder-ademe/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fit_melon-french-rge-certified-contractors-finder-ademe",
                "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/fit_melon~french-rge-certified-contractors-finder-ademe/runs": {
            "post": {
                "operationId": "runs-sync-fit_melon-french-rge-certified-contractors-finder-ademe",
                "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/fit_melon~french-rge-certified-contractors-finder-ademe/run-sync": {
            "post": {
                "operationId": "run-sync-fit_melon-french-rge-certified-contractors-finder-ademe",
                "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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "verify"
                        ],
                        "type": "string",
                        "description": "search: find RGE contractors by work domain and location. verify: check the RGE status of a list of SIREN/SIRET numbers (KYB).",
                        "default": "search"
                    },
                    "workDomain": {
                        "title": "Work domain (search mode)",
                        "type": "string",
                        "description": "Keyword matched against the certified work domain, accent-insensitive. Examples: isolation, pompe à chaleur, photovoltaïque, chauffage, fenêtres, ventilation, chaudière bois, audit énergétique, forage, architecte."
                    },
                    "departments": {
                        "title": "Departments (search mode)",
                        "type": "array",
                        "description": "French department codes to filter on, e.g. 75, 59, 69, 13. Matched on the postal code prefix.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "postalCodes": {
                        "title": "Postal codes (search mode)",
                        "type": "array",
                        "description": "Exact 5-digit postal codes, e.g. 59000, 74470. Combined with departments (OR).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "communes": {
                        "title": "Cities (search mode)",
                        "type": "array",
                        "description": "City names as written in the registry (case-insensitive), e.g. LILLE, LYON, ANNECY.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Free-text query (search mode)",
                        "type": "string",
                        "description": "Optional full-text search across all fields (company name, qualification…)."
                    },
                    "sirets": {
                        "title": "SIREN/SIRET list (verify mode)",
                        "type": "array",
                        "description": "9-digit SIREN or 14-digit SIRET numbers to verify. In verify mode: one result item per number with rgeStatus = rge_active / rge_expired / not_rge. Also usable in search mode to fetch certificates of specific companies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activeOnly": {
                        "title": "Active certificates only",
                        "type": "boolean",
                        "description": "Keep only certificates that are currently valid (recommended). Turn off to include expired qualifications.",
                        "default": true
                    },
                    "groupByCompany": {
                        "title": "Group results by company",
                        "type": "boolean",
                        "description": "One dataset item per company (SIRET) with all its certificates aggregated. Turn off for one flat row per certificate.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of items pushed to the dataset.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
