# France Government Data API (`lentic_clockss/france-data-search`) Actor

Search 36 French government data sources — company registries, building permits (DPE/RGE/cadastre), health establishments (FINESS/Ameli), legal databases (Judilibre/Légifrance/HATVP), and public procurement (BOAMP/TED). Official French open data.

- **URL**: https://apify.com/lentic\_clockss/france-data-search.md
- **Developed by:** [kane liu](https://apify.com/lentic_clockss) (community)
- **Categories:** Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN 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

## France Government Data Search

Search **36 official French government data sources** in a single API call — company registries (BODACC, Recherche Entreprises), building and property data (ADEME DPE energy diagnostics, APICarto cadastre, RNB buildings), health directories (FINESS, Ameli, ECLAIRE clinical trials), legal databases (Judilibre, Légifrance, HATVP lobby register, CNIL sanctions), and public procurement (BOAMP, TED). All data from official French government open data portals through the SIP Public Data Gateway.

### What is France Government Data Search?

France Government Data Search is an Apify Actor that queries official French government databases across business, construction, health, legal, and procurement domains. Instead of navigating data.gouv.fr, PISTE, Ameli, ADEME, and multiple ministry portals separately, you search them all at once.

The Actor calls the **SIP Public Data Gateway** — a unified API that normalizes responses from 36 French data products. No browser, no scraping — just HTTPS API calls.

### Why use France Government Data Search?

- **One search, 36 sources** — Query company registries, building diagnostics, health directories, court decisions, and procurement notices simultaneously
- **Official government data** — All sources are public databases from French ministries, ADEME, CNIL, Ameli, and the Justice Ministry
- **French and English** — Search in French (société, médicament) or English — SIP passes terms directly to government APIs
- **Property intelligence** — ADEME DPE energy performance for existing, new, and tertiary buildings plus RGE certified contractors
- **Legal research** — 13 legal sources including Judilibre (Cour de cassation), Légifrance, Constitutional Council, and HATVP

#### Use cases

| Who | What |
|-----|------|
| **Due diligence teams** | Cross-reference BODACC business announcements, company registries, and GLEIF entities |
| **Property professionals** | Access DPE energy diagnostics, cadastre parcels, urban planning zones, RGE contractors |
| **Healthcare researchers** | Search FINESS health establishments, Ameli professional directories, ECLAIRE clinical trials |
| **Legal professionals** | Query Judilibre court decisions, Légifrance legislation, CNIL sanctions, constitutional rulings |
| **Government contractors** | Monitor BOAMP and TED procurement notices for French public tenders |
| **Compliance teams** | Track HATVP lobby declarations, CNIL data protection sanctions, political signals |

### What data can France Government Data Search extract?

| Source | Data type | Example fields |
|--------|-----------|----------------|
| BODACC | Business creation/modification/liquidation notices | company_name, siren, event_type, date |
| Recherche Entreprises | French company registry | nom_complet, siren, siege, activite |
| GLEIF France | LEI-registered French entities | legal_name, lei, entity_status |
| ADEME DPE | Energy performance diagnostics | address, dpe_class, ghg_class, energy_kwh |
| ADEME RGE | Certified green energy contractors | company_name, qualification, city |
| APICarto cadastre | Land parcel boundaries | commune, section, numero, surface |
| APICarto GPU | Urban planning zones and documents | zone_type, commune, regulation |
| RNB buildings | National building registry | address, building_id, coordinates |
| FINESS | Health establishment directory | name, category, city, finess_number |
| Ameli professionals | Healthcare professional directory | name, specialty, city, convention |
| ECLAIRE | French clinical trials | title, sponsor, status, therapeutic_area |
| Judilibre | Cour de cassation decisions | decision_id, chamber, date, summary |
| Légifrance | French legislation and codes | title, article, code, text |
| HATVP | Lobby register declarations | organization, category, registration_date |
| CNIL | Data protection sanctions | organization, sanction_amount, date |
| BOAMP | Public procurement notices | title, buyer, amount, deadline |

### How to search French data

1. Open the Actor in Apify Console
2. Enter search terms (e.g. "Total Energies", "Paris", "hôpital", "contrat public")
3. Select categories — business, construction, and health are enabled by default
4. Click **Start** — the Actor queries all enabled sources in parallel
5. Download results as JSON, CSV, or Excel

#### Example input

```json
{
  "searchTerms": ["Total Energies", "Carrefour"],
  "includeBusiness": true,
  "includeConstruction": false,
  "includeHealth": false,
  "includeLegal": false,
  "includeProcurement": false,
  "maxResultsPerSource": 50
}
````

### Output

```json
{
  "nom_complet": "TOTALENERGIES SE",
  "siren": "542051180",
  "siege": "Courbevoie",
  "_product_id": "fr_recherche_entreprises_business",
  "_source": "recherche_entreprises_business",
  "_search_term": "Total Energies",
  "_collected_at": "2026-04-08T14:00:00Z"
}
```

### How much does it cost?

Pay-per-event pricing at $2.00 per 1,000 records returned.

- **Company lookup** (1 term, business only): ~$0.01–0.03
- **Comprehensive research** (5 terms, all 36 sources): ~$0.50–3.00

No browser overhead. Control costs with `maxResultsPerSource`.

### Data sources (36 French products)

| Category | Sources | Count |
|----------|---------|-------|
| Business | BODACC, GLEIF, Info Financière, Recherche Entreprises | 4 |
| Construction | ADEME DPE (existing/new/tertiary), RGE contractors, APICarto (cadastre/GPU docs/zones), Géoplateforme, RNB buildings | 10 |
| Health | Ameli (centers/professionals), DREES datasets, ECLAIRE trials, FINESS (establishments/legal entities), GéODAE | 7 |
| Legal | Administrative justice, Assemblée débats, CLAIR signals, CNIL sanctions, Constitutional decisions, HATVP lobby, Judilibre (search/detail), Légifrance (articles/codes/texts), Sénat | 13 |
| Procurement | BOAMP, TED France | 2 |

### FAQ

**Does APICarto require geographic parameters?**
Yes. APICarto cadastre and GPU endpoints require geographic parameters (code\_insee, coordinates) rather than text search. Use specific commune codes or coordinates as search terms for best results.

**How current is BODACC data?**
BODACC publishes business announcements daily. SIP fetches from the official API with brief caching.

**Can I search Judilibre in English?**
Judilibre decisions are in French. English search terms may match case references or party names but French terms will return more relevant results.

### Use as MCP Tool (AI Agent Integration)

This Actor works as an MCP tool — AI agents (Claude, GPT, Cursor) can discover and run it automatically.

#### Quick setup (Claude Desktop / Cursor / VS Code)

Add to your MCP config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Then ask your AI: *"Search for Total Energies in French government databases"*

#### Direct API call

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("lentic_clockss/france-data-search").call(
    run_input={"searchTerms": ["Total Energies"], "maxResultsPerSource": 50}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Other Data API Actors

- [EU Business & Company Registry API](https://apify.com/lentic_clockss/eu-business-data-search)
- [UK Government Data API](https://apify.com/lentic_clockss/uk-data-search)
- [Switzerland Government Data API](https://apify.com/lentic_clockss/switzerland-data-search)
- [US Business Entity Data API](https://apify.com/lentic_clockss/us-business-entity-search)

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search in French or English (e.g. 'Total Energies', 'Paris', 'contrat', 'médicament'). Each term is searched across all enabled French data sources in parallel.

## `includeBusiness` (type: `boolean`):

Search BODACC business announcements, GLEIF French entities, Info Financière, and Recherche Entreprises company registry (4 sources).

## `includeConstruction` (type: `boolean`):

Search ADEME energy performance diagnostics (DPE existing/new/tertiary), RGE certified contractors, APICarto cadastre parcels and urban planning, Géoplateforme geocoding, and RNB building registry (10 sources).

## `includeHealth` (type: `boolean`):

Search Ameli health centers and professionals directory, DREES health datasets, ECLAIRE clinical trials, FINESS health establishments and legal entities, and GéODAE public registry (7 sources).

## `includeLegal` (type: `boolean`):

Search Judilibre court decisions, Légifrance legislation, HATVP lobby register, Constitutional Council decisions, CNIL sanctions, Assemblée Nationale debates, Sénat legislative works, and administrative justice (13 sources).

## `includeProcurement` (type: `boolean`):

Search BOAMP French public procurement notices and TED EU procurement for France (2 sources).

## `maxResultsPerSource` (type: `integer`):

Maximum records to return per data source (gateway caps at 200).

## Actor input object example

```json
{
  "searchTerms": [
    "Total Energies"
  ],
  "includeBusiness": true,
  "includeConstruction": true,
  "includeHealth": true,
  "includeLegal": false,
  "includeProcurement": false,
  "maxResultsPerSource": 50
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing business, construction, health, legal, and procurement data from 36 French government sources.

# 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 = {
    "searchTerms": [
        "Total Energies"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lentic_clockss/france-data-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 = { "searchTerms": ["Total Energies"] }

# Run the Actor and wait for it to finish
run = client.actor("lentic_clockss/france-data-search").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 '{
  "searchTerms": [
    "Total Energies"
  ]
}' |
apify call lentic_clockss/france-data-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=lentic_clockss/france-data-search",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France Government Data API",
        "description": "Search 36 French government data sources — company registries, building permits (DPE/RGE/cadastre), health establishments (FINESS/Ameli), legal databases (Judilibre/Légifrance/HATVP), and public procurement (BOAMP/TED). Official French open data.",
        "version": "0.1",
        "x-build-id": "JazHwgj6BHTeHxnLX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lentic_clockss~france-data-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lentic_clockss-france-data-search",
                "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/lentic_clockss~france-data-search/runs": {
            "post": {
                "operationId": "runs-sync-lentic_clockss-france-data-search",
                "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/lentic_clockss~france-data-search/run-sync": {
            "post": {
                "operationId": "run-sync-lentic_clockss-france-data-search",
                "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",
                "required": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Keywords to search in French or English (e.g. 'Total Energies', 'Paris', 'contrat', 'médicament'). Each term is searched across all enabled French data sources in parallel.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeBusiness": {
                        "title": "Include business & company data",
                        "type": "boolean",
                        "description": "Search BODACC business announcements, GLEIF French entities, Info Financière, and Recherche Entreprises company registry (4 sources).",
                        "default": true
                    },
                    "includeConstruction": {
                        "title": "Include construction & property data",
                        "type": "boolean",
                        "description": "Search ADEME energy performance diagnostics (DPE existing/new/tertiary), RGE certified contractors, APICarto cadastre parcels and urban planning, Géoplateforme geocoding, and RNB building registry (10 sources).",
                        "default": true
                    },
                    "includeHealth": {
                        "title": "Include health & medical data",
                        "type": "boolean",
                        "description": "Search Ameli health centers and professionals directory, DREES health datasets, ECLAIRE clinical trials, FINESS health establishments and legal entities, and GéODAE public registry (7 sources).",
                        "default": true
                    },
                    "includeLegal": {
                        "title": "Include legal & legislative data",
                        "type": "boolean",
                        "description": "Search Judilibre court decisions, Légifrance legislation, HATVP lobby register, Constitutional Council decisions, CNIL sanctions, Assemblée Nationale debates, Sénat legislative works, and administrative justice (13 sources).",
                        "default": false
                    },
                    "includeProcurement": {
                        "title": "Include public procurement",
                        "type": "boolean",
                        "description": "Search BOAMP French public procurement notices and TED EU procurement for France (2 sources).",
                        "default": false
                    },
                    "maxResultsPerSource": {
                        "title": "Max results per source",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum records to return per data source (gateway caps at 200).",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
