# Sirene / SIREN French Company Search — INSEE Register (`publicdata/sirene-siren-french-company-search`) Actor

Scrape French companies (entreprises) from the official French government open-data API: SIREN, SIRET, legal form, NAF activity, address, employees, executives and financials. French company register and business data by department, activity, size and creation date.

- **URL**: https://apify.com/publicdata/sirene-siren-french-company-search.md
- **Developed by:** [PublicData](https://apify.com/publicdata) (community)
- **Categories:** Lead generation, Other
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 companies

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

**Stop rebuilding French prospect and due-diligence lists by hand: get companies from the France company register — with their directors (dirigeants), their SIREN and SIRET, and the exact date they were registered — as a spreadsheet, or as a feed that refreshes every morning.**

This Actor calls the French government's own open-data API (`recherche-entreprises.api.gouv.fr`, fed by INSEE/SIRENE and INPI/RNE), so what you export is the register itself: no API key, no login, no broken selectors.

Base identity data on french companies is public everywhere. What most sources do not give you is the **named executives**, a **creation-date filter** that surfaces newly registered companies, and the **official labels** that let you segment a list before contacting anyone.

### What you get

Every record is one company, with up to 36 fields:

- **SIREN** (9 digits) and the head-office **SIRET** (14 digits), plus the intra-community **VAT number**
- **Executives (dirigeants)** — role, name and birth year for individuals, or company name and SIREN for corporate officers. INSEE alone does not publish these.
- **Official labels** — certified organic, RGE, Qualiopi, training provider, social economy, mission-driven, public service and more
- **Creation date** and closure date, plus an active flag — the basis for tracking newly registered businesses
- Legal name, trade name, **legal form** (SAS, SARL, SA, auto-entrepreneur…) with its INSEE code
- **NAF/APE activity code** and a readable activity label
- Full postal address, postal code, city, department, region, and latitude/longitude of the **head office**, where published
- The **establishment that matched your filters** — its SIRET, address, postal code and city, plus up to ten more matching establishments, which is all the source returns per company. A department search matches any establishment, so this is the address inside the department you asked for; the head-office one often is not
- Employee bracket and its reference year, INSEE size category (SME, mid-cap/ETI, large enterprise), sole-trader flag
- Number of establishments, total and currently open
- **Filed financials** where the company publishes them: revenue and net result, per year
- Last INSEE update timestamp, the `source` attribution string, and a link to the official `annuaire-entreprises.data.gouv.fr` page

### Who uses this

- A **sales team** pulls the companies registered in their department and activity in the last 30 days and calls them before anyone else does — using the matched-establishment address, which is the one in their department.
- A **compliance officer** resolves a SIREN or SIRET to the full legal identity, the officers behind it and the filed accounts, for a KYB file.
- A **market analyst** maps french business data by activity code and region, with coordinates ready for a GIS or a dashboard.
- A **researcher** builds a segmented company database of France — all Qualiopi training providers, or all certified-organic producers — from official labels rather than guesswork.
- A **developer or AI agent** enriches a CRM list of identifiers, or calls the Actor as an MCP tool to answer questions about entreprises France on demand.

### Example output

```json
{
  "siren": "478455793",
  "siret": "47845579305205",
  "name": "BOULANGERIES BG (B B G)",
  "legalForm": "SAS - simplified joint-stock company",
  "legalFormCode": "5710",
  "nafCode": "56.10C",
  "nafLabel": "Food and beverage service",
  "vatNumber": "FR94478455793",
  "isActive": true,
  "creationDate": "2004-08-25",
  "closureDate": null,
  "employeeRange": "5000-9999 employees",
  "sizeCategory": "Large enterprise",
  "isSoleTrader": false,
  "address": "615 AVENUE DE LA CHAFFINE 13160 CHATEAURENARD",
  "postalCode": "13160",
  "city": "CHATEAURENARD",
  "department": "13",
  "latitude": 43.89036,
  "longitude": 4.82613,
  "matchedSiret": "47845579301014",
  "matchedAddress": "ZONE COMMERCIALE VAUBAN RUE DE GUESNAIN 59500 DOUAI",
  "matchedPostalCode": "59500",
  "matchedCity": "DOUAI",
  "establishments": 601,
  "openEstablishments": 579,
  "labels": null,
  "executives": [
    { "role": "Président de SAS", "type": "personne physique", "lastName": "…", "firstName": "…", "birthYear": "1956" }
  ],
  "sourceUrl": "https://annuaire-entreprises.data.gouv.fr/entreprise/478455793",
  "source": "recherche-entreprises.api.gouv.fr (INSEE/INPI open data)"
}
```

Officer names come back in full; they are elided in this sample. `labels` is null here because this particular company carries none of the official qualifiers; it lists them — certified organic, Qualiopi, RGE, training provider and the rest — for the companies that do. The matched columns are filled when a filter matched a specific establishment; a plain SIREN lookup leaves them null. Labels, legal forms and employee brackets are emitted in English, as shown. `matchedEstablishments` (omitted here for length) repeats the matching establishments the source hands back, with their own SIRET, address and coordinates. The source returns **at most ten per company** and gives no way to ask for more: this company has 601 establishments and the export carries ten of them (measured 2026-08-21), which is why the matched address is a shop in Douai (59) while the head office is in Châteaurenard (13). For a single-site company the list is complete; for a chain it is a sample. `matchedSiret` / `matchedAddress` describe the first of the matches, and when you searched by department every match returned is inside that department, so the truncation does not affect them. `financials` carries one entry per published year and is empty for companies that do not file.

### Input

| Field | What it does |
|---|---|
| `query` | Company name, SIREN, SIRET or keywords. Leave empty to browse with the filters below. |
| `sirenList` | Exact identifiers to fetch (9-digit SIREN or 14-digit SIRET). **This is a lookup mode, not a filter: when it is non-empty the Actor fetches exactly these identifiers and applies no other criterion.** `query`, `departments`, `nafCodes`, `legalStatus`, `minEmployees` and `createdAfter` are all ignored — the run log names the ones it dropped — so a company that contradicts them is still returned and still charged. Run the filters as a separate run if you meant to search. Identifiers the register does not resolve are named in the log and counted in the run's status message. |
| `departments` | Department codes to filter by, e.g. `75`, `13`, `2A`. Empty = all France. Matches a company when **any** of its establishments is there — read `matchedAddress`, not `address`, for the location in your department. |
| `nafCodes` | NAF/APE activity codes, e.g. `47.11F` supermarkets, `62.01Z` software. Empty = all activities. |
| `legalStatus` | Restrict to active (default) or ceased companies. `all` is not a criterion the source accepts on its own: combine it with another filter. |
| `minEmployees` | INSEE employee-bracket floor. **Leave it empty for "no minimum": any value, `0` included, keeps only companies whose headcount bracket is published and drops every company whose bracket is `NN` (not disclosed), which was most of the result set in every search measured below.** The filter asks the source for the brackets at or above your floor, and `NN` is not one of them. Measured 2026-08-21: active software companies in Corsica (2A) are 202 unfiltered and 18 with `minEmployees: "0"`, because 184 of the 202 are `NN`; restaurants in Lozère (48) go 189 → 35, with 154 `NN`. Where a value is what you want, it must be a bracket boundary: `0`, `1`, `3`, `6`, `10`, `20`, `50`, `100`, `200`, `250`, `500`, `1000`, `2000`, `5000`, `10000`. Anything larger means the 10,000+ bracket, the largest the register has. A value in between — `15` — is refused with an error instead of being rounded: rounding `15` up to the 20+ bracket drops the 10-19 bracket, and on active Paris software companies that discards 429 of 1,051 (measured 2026-08-21), some of which do have 15 or more employees. |
| `createdAfter` | Only companies created on or after this date (YYYY-MM-DD, a real calendar date — `2026-02-30` is refused rather than quietly matching nothing). Filtered by the Actor — see the note below. |
| `scanLimit` | How many search results to read through while applying `createdAfter`. Defaults to 10,000, which is everything a single search can return. Only matching companies are exported and charged. |
| `onlyWithExecutives` | Keep only companies whose directors are published. |
| `includeExecutives` | Include directors and officers. Default on; turn it off if you only need company-level data. |
| `maxItems` | Safety cap on the companies **read from the source**. `0` = unlimited. Default 200. With `onlyWithExecutives` on, companies dropped for having no published directors are read and counted against the cap without being exported, so the export can be smaller than the cap: `{"query": "carrefour", "onlyWithExecutives": true, "maxItems": 5}` exported 3 companies and skipped 2 (measured 2026-08-21). Only exported companies are charged, and the status message says how many were skipped. Raise the cap if you need a set number of companies with executives. |

Software companies registered in Bouches-du-Rhône since the start of the month, with a named director to call:

```json
{ "departments": ["13"], "nafCodes": ["62.01Z"], "createdAfter": "2026-08-01", "onlyWithExecutives": true, "maxItems": 0 }
```

Pair `createdAfter` with filters narrow enough that the search reports fewer than 10,000 matches, and check the run's status message for `PARTIAL COVERAGE`: see *How the creation-date filter works* below for why both matter.

Software companies in Paris with at least 10 employees:

```json
{ "nafCodes": ["62.01Z"], "departments": ["75"], "minEmployees": "10", "legalStatus": "active" }
```

Enrich identifiers you already hold, company data only:

```json
{ "sirenList": ["478455793", "50393256800010"], "includeExecutives": false }
```

### Run it on a schedule

Save your filters as a Task, set `createdAfter` to a recent date, and schedule it daily. Each run returns the companies registered since that date, so the dataset becomes a rolling feed of newly registered companies rather than a one-off export. Watch the run's status message: if it ends in `PARTIAL COVERAGE` the feed missed part of that day's registrations, and the message says how many records went unread — see *How the creation-date filter works* for the two reasons that happens and what to narrow.

From the run, Apify integrations push the results straight to **Google Sheets, Slack, e-mail, a webhook, Make or Zapier** — or into your CRM through the webhook. Deduplicate on **`siren`**: it is stable, unique per company and never reused, so a daily run appends only genuinely new records.

### Use it from code or from an AI agent

Start runs and read the dataset through the Apify API or CLI in any language; results come out as JSON, CSV, Excel or XML. The Actor is also exposed as an **MCP tool** through the Apify MCP server, so an AI agent can query the French company register directly — by name, by SIREN, or by department and activity.

### Pricing

Pay per event: a small fee for each company exported, and nothing for a run that returns no matches. Platform usage on top of that is negligible, because the Actor makes plain API calls and never starts a browser. Current rates are on the Actor's Pricing tab.

### How the creation-date filter works

The government's search API has **no creation-date parameter** — that is a limit of the source, not of this Actor, and it silently ignores any parameter it does not know. So `createdAfter` is applied here instead: the Actor reads through the search results and exports only the companies created on or after your date. You are charged for exported companies, not for scanned ones.

Three consequences worth knowing before you rely on it:

- **Results are ranked by company size, never by date.** The register hands out the biggest, oldest companies first, and its only sort parameter — `sort_by_size`, a boolean — sorts by number of establishments, so there is no way to ask for newest-first. Recent registrations therefore sit deep in the stream. In `departments: ["75"] + nafCodes: ["62.01Z"]`, the first company created since 2024 is the 248th record read: a scan stopping at 200 exports none of them, one stopping at 300 exports 12 (measured 2026-08-21). That is why `scanLimit` defaults to the full 10,000.
- **The source truncates any single search at 10,000 results, and that ceiling cannot be raised.** A search reporting exactly 10,000 matches is showing you a slice, not the set — Paris software companies do this, so even a department *plus* an activity code is not always enough, and a full scan of it finds 2,994 post-2024 companies out of an unknown larger true number (measured 2026-08-21). Narrowing until the reported total is below 10,000 gets you most of the way, but not all: see the next point.
- **The source can also stop delivering before the total it advertises.** `departments: ["13"] + nafCodes: ["62.01Z"]` reports 3,972 matches across 159 pages, yet returns nothing from page 158 onwards, so a complete scan reads 3,925 of them and 47 are unreachable by any paging — 1.2% of that search, measured 2026-08-21. The withheld tail is the small-company end, which is exactly where new registrations live: that scan exports 22 companies created since 2026-08-01, and the 47 it never saw could hold more. Splitting the search further (by NAF sub-code, or department by department) is the only way to reach them.

The run log warns whenever a search hits the 10,000 cap, the scan stops early, **or the source delivers fewer records than it reported**, and the run's status message ends with `PARTIAL COVERAGE` and the numbers in each case. A run that does not say `PARTIAL COVERAGE` read every record the source handed over, and the source handed over as many as it said it had.

If you need every new French registration nationwide rather than a filtered slice, the registration announcements in **BODACC** are the right source for that, and the register search is the wrong tool for it.

### Where the data comes from

One practical ceiling to know about: a single search returns at most 10,000 records — the source refuses to page past that, whatever the page size. For a bigger sweep, split the run by department or by activity code: each slice is its own search with its own 10,000-record window.

`recherche-entreprises.api.gouv.fr` is the official search API operated by the French government (DINUM), built on the **SIRENE** database (INSEE) and the **Registre National des Entreprises** (INPI). Both are published as open data and may be reused, including commercially, under the French open licence, with attribution — every record carries the `source` field for exactly that.

Honest limits. The administration refreshes the data rather than streaming it, so treat it as daily, not real-time. A handful of records carry an implausible creation date (occasionally a future one); those come from the register itself and are passed through unchanged rather than silently dropped. There are no e-mail addresses or phone numbers: the register does not publish them. Coordinates, region, employee year, financials and executives appear only where the source publishes them, and are `null` otherwise. Companies that opted out of public distribution (`statut_diffusion: "P"`) are **not** excluded by the source: they come back like any other record, but with their address withheld. `address` and `postalCode` then carry the source's literal marker `[NON-DIFFUSIBLE]` instead of a value — as can `matchedAddress` and `matchedPostalCode`, though those prefer a matched establishment whose address is published — while the identity fields (SIREN, name, activity, dates) are normal. In a sample of 200 active Paris companies read on 2026-08-21, 2 were in this state (SIREN 339930984 and 312285901); both still carried their municipality in `city`. The Actor passes the marker through unchanged rather than blanking it, so you can tell a withheld address from a missing one; drop those rows with `postalCode != "[NON-DIFFUSIBLE]"` if your pipeline needs real addresses only.

Officer names are published by the French register itself for corporate-transparency purposes; set `includeExecutives: false` if you do not need them. This Actor is independent and not affiliated with the French administration.

### Frequently asked questions

**Where does this data come from and can I reuse it?**

From `recherche-entreprises.api.gouv.fr`, the French government's own search API built on INSEE's SIRENE database and INPI's Registre National des Entreprises. Both are open data, reusable commercially under the French open licence with attribution.

**Can I get companies created in the last 30 days?**

Yes, with `createdAfter` — but read the note on this page first: the source API has no creation-date parameter, so the France Company Register Scraper filters the results itself. Pair it with a department and an activity code so the scan covers the whole set.

**Are directors' names included?**

Yes, where the register publishes them, because the French register publishes them for corporate-transparency purposes. Set `includeExecutives: false` if you do not need them.

**Why are there no e-mail addresses or phone numbers?**

The register does not publish them. This Actor returns what the source contains and never invents contact data.

### Related Actors

Same engine, same official-source approach:

- [**AusTender (Australia)**](https://apify.com/publicdata/austender-australian-government-contracts) — federal contracts, winners and expiry dates
- [**UK Public Tenders**](https://apify.com/publicdata/uk-contracts-finder-find-a-tender) — Contracts Finder and Find a Tender in one run
- [**Swiss Public Tenders (simap.ch)** — tenders and awards with prices, bid counts and weighted criteria](https://apify.com/publicdata/simap-swiss-public-tenders)
- [**Swiss Commercial Register (SHAB)** — new companies, changes, deletions and bankruptcies](https://apify.com/publicdata/shab-swiss-company-gazette)
- [**EU Tenders (TED)** — European procurement notices and contract awards](https://apify.com/publicdata/ted-tenders-eu-procurement)
- [**GLEIF LEI** — LEI lookup, lapsed-LEI screening, parent companies](https://apify.com/publicdata/gleif-lei-scraper)
- [**Brazil CNPJ** — Receita Federal company data and partners](https://apify.com/publicdata/cnpj-lookup-receita-federal)

# Actor input Schema

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

Company name, SIREN, SIRET, or keywords. Leave empty to browse using the filters below.

## `sirenList` (type: `array`):

Exact identifiers to fetch (9-digit SIREN or 14-digit SIRET). This is a lookup mode, not a filter: when it is non-empty the Actor fetches exactly these identifiers and applies no other criterion, so query, departments, nafCodes, legalStatus, minEmployees and createdAfter are all ignored and a company that contradicts them is still returned and still charged. The run log names the filters it dropped. Identifiers the register does not resolve are named in the log and counted in the run's status message.

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

French department codes to filter by, e.g. 75, 13, 2A. Empty = all France. The source matches a company when ANY of its establishments is in the department, so a company head-officed elsewhere can appear: the address columns describe the head office, and the matchedAddress / matchedCity / matchedPostalCode columns describe the establishment that matched.

## `nafCodes` (type: `array`):

Activity codes, e.g. 47.11F (supermarkets), 62.01Z (software). Empty = all activities.

## `legalStatus` (type: `string`):

Restrict to active or ceased companies. "All" is not a criterion the source accepts on its own, so combine it with a query, a department, an activity code or an employee floor.

## `minEmployees` (type: `string`):

INSEE employee bracket floor. Leave empty for no minimum: any value here, 0 included, keeps only companies whose headcount bracket is published and drops every company whose bracket is NN (not disclosed), which was most of the result set in every search measured. Measured 2026-08-21: active software companies in Corsica (2A) are 202 unfiltered and 18 with minEmployees=0, because 184 of them are NN; restaurants in Lozere (48) go from 189 to 35, with 154 NN. When you do want a floor, the register publishes brackets rather than exact headcounts, so it must be a bracket boundary: 0, 1, 3, 6, 10, 20, 50, 100, 200, 250, 500, 1000, 2000, 5000 or 10000. Any larger number means the 10,000+ bracket, which is the largest the register has. A value in between (15, for instance) is refused with an explanatory error rather than silently rounded, because rounding up would drop the bracket that contains the headcount you asked for.

## `createdAfter` (type: `string`):

Only companies created on or after this date (YYYY-MM-DD, a real calendar date; anything else is refused). The source API has no creation-date parameter, so the Actor reads the search results and filters them here. The source ranks results largest-company-first, never newest-first, and truncates any single search at 10,000 records, so a search that reports 10,000 matches is a partial view of it: narrow it until it reports fewer, and keep scanLimit at its 10,000 maximum. The source can also stop delivering short of the total it advertises; when that happens the run's status message says PARTIAL COVERAGE and gives the numbers.

## `onlyWithExecutives` (type: `boolean`):

Keep only companies whose directors are published.

## `includeExecutives` (type: `boolean`):

Include directors and officers (names are published by the French register itself). Turn off if you only need company-level data.

## `maxItems` (type: `integer`):

Safety cap on the companies read from the source (0 = unlimited). With onlyWithExecutives on, companies dropped for having no published directors are read and counted against this cap without being exported, so the export can be smaller than the cap: query=carrefour with onlyWithExecutives and maxItems=5 exported 3 and skipped 2 (measured 2026-08-21). Only exported companies are charged, and the status message reports the skipped ones.

## `scanLimit` (type: `integer`):

How many search results to read through while looking for companies that match `createdAfter`. Only matching companies are exported and charged. The source refuses to page beyond its 10,000-record ceiling, so 10,000 (the default) reads everything a single search can return; lower it to keep runs short.

## Actor input object example

```json
{
  "query": "boulangerie",
  "legalStatus": "active",
  "onlyWithExecutives": false,
  "includeExecutives": true,
  "maxItems": 200,
  "scanLimit": 10000
}
```

# Actor output Schema

## `dataset` (type: `string`):

Companies from the French national register (INSEE/INPI open data). Every exported row is one dataset item.

# 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 = {
    "query": "boulangerie",
    "scanLimit": 10000
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicdata/sirene-siren-french-company-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 = {
    "query": "boulangerie",
    "scanLimit": 10000,
}

# Run the Actor and wait for it to finish
run = client.actor("publicdata/sirene-siren-french-company-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 '{
  "query": "boulangerie",
  "scanLimit": 10000
}' |
apify call publicdata/sirene-siren-french-company-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicdata/sirene-siren-french-company-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/UvamFwQYMSCNJzGYg/builds/BesrEbq7PLwBRVJJL/openapi.json