# French Company Data API: SIREN, SIRET, Entreprises (`actose/french-companies`) Actor

French company data (entreprises) from the official register: SIREN, SIRET, address, NAF, headcount, creation date, establishments, managers, revenue, VAT. Search by name, NAF, department. No API key, no login. MCP-ready for AI agents. Pay per result. Errors are free. $6.40 per 1,000 companies

- **URL**: https://apify.com/actose/french-companies.md
- **Developed by:** [ABM](https://apify.com/actose) (community)
- **Categories:** Lead generation, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.44 / 1,000 company delivereds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

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

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

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

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

# README

## French Company Data API: SIREN, SIRET, Entreprises

**$6.40 per 1,000 companies. You pay only for companies actually delivered.** Invalid or unknown SIREN numbers, duplicates, empty searches and API errors are free.

This actor searches and enriches **French companies (entreprises françaises)** from the official French government register (INSEE Sirene + RNE, via the public `recherche-entreprises.api.gouv.fr` service). Look companies up by **SIREN** or **SIRET**, or search them by **name, NAF/APE code, department, postal code, city, region, headcount range, legal form, size category, revenue and creation date**.

Each company comes back as one clean JSON object with: legal name, trade names, SIREN, head-office SIRET, status, address with GPS, NAF code, headcount range, creation and closure dates, VAT number, number of establishments, matching establishments (SIRET), public managers (dirigeants) and auditors, published revenue and net income, collective agreements, labels (ESS, RGE, Qualiopi, Bio...) and a ready-to-use text summary for LLMs.

- No API key, no login, no captcha: official open data (Licence Ouverte 2.0)
- Stable: a government JSON API, not a fragile HTML scraper
- `onlyNew` mode for scheduled monitoring of new registrations
- MCP-ready for Claude, Cursor, ChatGPT and AI agents
- Pay per result, no monthly rental

### How much does it cost?

One `company` event = **$0.0064**. There is no start fee and no monthly fee.

| Companies delivered | Price |
|---|---|
| 100 | $0.64 |
| 1,000 | **$6.40** |
| 10,000 | $64.00 |

Example: all active bakeries (NAF 10.71C) in Haute-Garonne is roughly 1,000 companies, so about $6.40. Companies that are not found are never charged. You can set a maximum charge per run in Apify, and the actor stops cleanly when that limit is reached.

### Input

You can combine **direct lookups** (`identifiers`) and **one search** (text and/or filters) in the same run.

```json
{
  "identifiers": ["552032534", "356 000 000 00048"],
  "query": "boulangerie",
  "communeCodes": ["31555"],
  "nafCodes": ["10.71C"],
  "status": "active",
  "createdAfter": "2024-01-01",
  "maxResults": 100,
  "maxEstablishments": 10,
  "onlyNew": false
}
```

| Field | What it does |
|---|---|
| `identifiers` | SIREN (9 digits) or SIRET (14 digits). Spaces and dots are accepted. |
| `query` | Full-text search in names, trade names, addresses and managers. |
| `nafCodes` | NAF/APE codes, e.g. `10.71C`, `62.01Z`, `4120A`. |
| `departments`, `postalCodes`, `communeCodes`, `regions` | Geography. These match companies that have **at least one establishment** in the area. |
| `headcountRanges` | INSEE bands: `00`, `01` (1-2), `02` (3-5), `03` (6-9), `11` (10-19), `12` (20-49), `21` (50-99), and so on. |
| `companyCategories` | `PME`, `ETI`, `GE`. |
| `legalFormCodes` | INSEE legal category, e.g. `5710` SAS, `5499` SARL, `5720` SASU, `9220` association. |
| `createdAfter`, `createdBefore`, `createdWithinDays` | Filter on the company's creation date. |
| `minRevenue`, `maxRevenue` | Filter on published revenue (EUR). |
| `status` | `active` (default), `ceased` or `all`. |
| `maxResults` | Cap on companies returned by the search (up to 10,000). |
| `onlyNew` | Skip companies already delivered by previous runs of the same search. |

### Output

One dataset item per company. Example (abridged):

```json
{
  "siren": "356000000",
  "siret": "35600000000048",
  "name": "LA POSTE",
  "legalName": "LA POSTE",
  "status": "active",
  "legalFormCode": "5510",
  "nafCode": "53.10Z",
  "nafSection": "H",
  "companyCategory": "GE",
  "headcountRangeCode": "53",
  "headcountRange": "10,000+ employees",
  "headcountYear": 2023,
  "isEmployer": true,
  "creationDate": "1991-01-01",
  "vatNumber": "FR39356000000",
  "address": "9 RUE DU COLONEL PIERRE AVIA 75015 PARIS",
  "postalCode": "75015",
  "city": "PARIS",
  "department": "75",
  "region": "11",
  "latitude": 48.83,
  "longitude": 2.27,
  "headquarters": { "siret": "35600000000048", "isHeadquarters": true, "status": "active", "address": "9 RUE DU COLONEL PIERRE AVIA 75015 PARIS" },
  "establishmentCount": 20000,
  "openEstablishmentCount": 12000,
  "matchingEstablishments": [{ "siret": "35600000000048", "postalCode": "75015", "city": "PARIS", "nafCode": "53.10Z" }],
  "requestedEstablishment": { "siret": "35600000000048", "isHeadquarters": true },
  "managers": [
    { "type": "person", "name": "Jane DOE", "role": "Président-directeur général", "birthYear": 1960, "birthMonth": "1960-05" },
    { "type": "company", "name": "AUDIT FIRM SA", "siren": "775726417", "role": "Commissaire aux comptes titulaire" }
  ],
  "finances": [{ "year": 2024, "revenue": 25000000000, "netIncome": 500000000 }],
  "latestFinancialYear": 2024,
  "latestRevenue": 25000000000,
  "latestNetIncome": 500000000,
  "collectiveAgreements": ["3255"],
  "flags": { "estEss": false, "estRge": false, "estQualiopi": false, "estAssociation": false },
  "annuaireUrl": "https://annuaire-entreprises.data.gouv.fr/entreprise/356000000",
  "matchedBy": "siret",
  "input": "356 000 000 00048",
  "scrapedAt": "2026-10-17T08:00:00+00:00",
  "summaryText": "LA POSTE (SIREN 356000000) is an active French company created on 1991-01-01. Main activity (NAF/APE): 53.10Z. Head office: ..."
}
```

The figures above are illustrative. Fields the register does not publish are `null`. Download the results as JSON, CSV, Excel or XML from the dataset, or use the **Overview** table view.

### Use cases

#### 1. Daily lead list of newly created businesses (sales and lead generation)

An accountant in Toulouse wants every new bakery, restaurant or construction business in their department each morning, to offer bookkeeping before a competitor does. They schedule the actor daily:

```json
{ "departments": ["31"], "nafCodes": ["10.71C", "56.10A", "43.22A"], "createdWithinDays": 7, "onlyNew": true, "maxResults": 500 }
```

```json
[{ "siren": "9xxxxxxxx", "name": "BOULANGERIE DU CANAL", "nafCode": "10.71C", "creationDate": "2026-10-14", "address": "12 RUE ... 31000 TOULOUSE", "managers": [{ "name": "...", "role": "Gérant" }] }]
```

About 20 to 60 new companies a week, so roughly $0.13 to $0.38. An n8n or Make flow appends them to Google Sheets or the CRM, and the sales assistant calls them the same day.

#### 2. CRM enrichment and KYC from a SIREN list (finance and compliance)

A B2B SaaS has 5,000 customers with only a SIREN in its billing tool. Finance needs the legal name, VAT number, status (active or ceased), head-office address and managers to fix invoices and flag closed companies:

```json
{ "identifiers": ["552032534", "542051180", "380129866"] }
```

```json
[{ "siren": "552032534", "name": "DANONE", "status": "active", "vatNumber": "FR...", "address": "...", "managers": ["..."] }]
```

5,000 companies cost $32. Rows with `status: "ceased"` are sent to the collections team, and the VAT numbers are written back into the invoicing tool.

#### 3. Market sizing by area (consultants and franchise developers)

A franchise developer compares how many bakeries with 3 to 49 employees exist in Haute-Garonne, Gironde and Rhône, and what revenue they publish:

```json
{ "nafCodes": ["10.71C"], "departments": ["31", "33", "69"], "headcountRanges": ["02", "03", "11", "12"], "maxResults": 3000 }
```

```json
[{ "siren": "...", "name": "...", "department": "33", "headcountRange": "6-9 employees", "latestRevenue": 812000, "latitude": 44.84, "longitude": -0.58 }]
```

Up to 3,000 companies cost at most $19.20. The analyst builds a pivot table of counts and median revenue by department and maps the GPS points to find under-served towns.

#### 4. Context for an AI agent

An AI sales agent receives a prospect's company name. It calls the actor through MCP with `{ "query": "Michelin", "maxResults": 1 }` and uses `summaryText` to write a personalised email. Each call costs less than one cent.

### Call it from the API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("<USERNAME>/french-companies").call(run_input={
    "query": "boulangerie",
    "communeCodes": ["31555"],
    "maxResults": 50,
})
for company in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(company["siren"], company["name"], company["address"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<APIFY_TOKEN>' });
const run = await client.actor('<USERNAME>/french-companies').call({
    identifiers: ['552032534', '35600000000048'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((c) => `${c.siren} ${c.name} ${c.vatNumber}`));
```

**One HTTP call (synchronous, returns the items):**

```bash
curl -X POST "https://api.apify.com/v2/acts/<USERNAME>~french-companies/run-sync-get-dataset-items?token=<APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"identifiers": ["552032534"]}'
```

### Automation (Make, n8n, Zapier, Google Sheets)

Example **n8n** workflow for monitoring new registrations:

1. **Schedule Trigger** every day at 7:00.
2. **Apify node**, operation *Run actor and get dataset*, actor `french-companies`, input `{ "departments": ["31"], "nafCodes": ["62.01Z"], "createdWithinDays": 3, "onlyNew": true }`.
3. **Google Sheets node**, *Append row*: map `siren`, `name`, `creationDate`, `address`, `annuaireUrl`.
4. Optional **Slack node**: "{{ $json.name }} was just created in {{ $json.city }}".

In **Make** or **Zapier**, use the Apify app: "Run an actor", then "Get dataset items", then Google Sheets or HubSpot. You can also attach an Apify **Schedule** and a **webhook** directly to the actor.

### Use with AI agents (MCP)

The actor is available through the Apify MCP server, so Claude, Cursor, ChatGPT and other agents can call it as a tool:

```json
{ "mcpServers": { "apify": { "url": "https://mcp.apify.com/?actors=<USERNAME>/french-companies" } } }
```

Ask, for example: "Find active software companies (NAF 62.01Z) created this year in Lyon and give me their managers." Each result includes `summaryText`, a plain-text paragraph you can pass directly to an LLM or store as a RAG chunk.

### FAQ

**Where does the data come from?** From the official French government API "Recherche d'entreprises" (DINUM), built on INSEE Sirene, the RNE (national business register) and other public datasets. It is open data, refreshed daily.

**Do I need an API key or an account on a French website?** No.

**What is the difference between SIREN and SIRET?** SIREN (9 digits) identifies the company. SIRET (14 digits) identifies one establishment: the SIREN plus 5 digits. Both work as input. With a SIRET, the matched establishment is returned in `requestedEstablishment`.

**Why does a company located in Paris show up when I filter on Toulouse?** Geographic filters match companies that have *at least one establishment* in the area. Check `matchingEstablishments` to see the local SIRETs.

**Are revenue figures always available?** No. Only companies that publish their accounts have them; many small companies opt for confidentiality. Missing values are `null`.

**How does `onlyNew` work?** The actor remembers the SIRENs it has delivered for a given search, in a named key-value store (`french-companies-state`). The next run of the same search returns only companies not delivered before. Use `stateKey` to name the memory yourself.

**Can I skip the list of matching establishments?** Yes: set `maxEstablishments` to `0` and `matchingEstablishments` is `null` (the head office is always in `headquarters`).

**Can I get emails or phone numbers?** No. The official register does not publish them.

**Is it GDPR compliant?** The data is public open data published by the French State. Some sole proprietors have opted out of publication ("non diffusible"), and the API returns them in redacted form. Managers' data is limited to what the register publishes (name, role, birth month and year).

### Limits

- The API serves at most **10,000 results per search**. For larger exports, split the search by department or NAF code.
- The creation-date filter is applied after the search, because the API has no date filter. A broad search with a narrow date range can take a minute or two, but you only pay for the companies delivered.
- The actor respects the API rate limit: up to 5 requests in parallel, capped at 5 requests per second in total (25 companies per search request, one request per SIREN/SIRET lookup), which is about 7,000 companies per minute for searches and 300 per minute for direct lookups. On a rate-limit answer (HTTP 429) every request pauses for the time the API asks for.
- If the official API is down and nothing can be delivered, the run ends as failed with a clear message (nothing charged). If only some requests fail, the rest is delivered and the status message says how many were skipped.
- A text search ranks results by relevance, so it is not an exhaustive filter. Use NAF codes and geography for complete lists.
- Activity codes are returned as codes (NAF rev. 2 and NAF 2025), not as labels.

# Actor input Schema

## `identifiers` (type: `array`):

Direct lookup by 9-digit SIREN or 14-digit SIRET (spaces and dots allowed). Each company found is one result. Unknown or invalid numbers are logged and never charged.

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

Full-text search in company names, trade names, addresses and managers, e.g. "boulangerie", "plombier", "Michelin". Optional when you use filters below.

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

Main activity of the company, e.g. 10.71C (bakery), 62.01Z (software development), 56.10A (restaurants). Format 10.71C or 1071C.

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

French department codes, e.g. 31 (Haute-Garonne), 75 (Paris), 2A (Corse-du-Sud), 971 (Guadeloupe). Matches companies having at least one establishment there.

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

5-digit postal codes, e.g. 31000. Matches companies having at least one establishment there.

## `communeCodes` (type: `array`):

5-character INSEE city codes (not postal codes), e.g. 31555 = Toulouse, 75056 = Paris, 69123 = Lyon. Covers all postal codes of the city.

## `regions` (type: `array`):

2-digit INSEE region codes, e.g. 76 = Occitanie, 11 = Île-de-France, 84 = Auvergne-Rhône-Alpes.

## `headcountRanges` (type: `array`):

Official INSEE headcount bands of the company.

## `companyCategories` (type: `array`):

INSEE category: PME (SME), ETI (mid-cap), GE (large company).

## `legalFormCodes` (type: `array`):

INSEE legal category codes, e.g. 5710 = SAS, 5499 = SARL, 5720 = SASU, 1000 = sole proprietor, 9220 = association.

## `nafSections` (type: `array`):

Broad activity section letters A to U, e.g. F = construction, I = hotels and restaurants, J = information and communication.

## `status` (type: `string`):

Applies to searches only (direct SIREN/SIRET lookups always return the company).

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

Keep only companies created on or after this date (YYYY-MM-DD). Applies to searches.

## `createdBefore` (type: `string`):

Keep only companies created on or before this date (YYYY-MM-DD). Applies to searches.

## `createdWithinDays` (type: `integer`):

Relative date filter for scheduled runs, e.g. 30 = companies created during the last 30 days.

## `minRevenue` (type: `integer`):

Only companies with published revenue (chiffre d'affaires) at least this amount.

## `maxRevenue` (type: `integer`):

Only companies with published revenue at most this amount.

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

Maximum number of companies returned by the search (the API serves at most 10,000 per search: split by department or NAF code for more). Does not limit SIREN/SIRET lookups.

## `maxEstablishments` (type: `integer`):

How many establishments (SIRET) matching your filters to include per company (0 to 100). For a SIRET lookup, the requested establishment is also returned in requestedEstablishment.

## `onlyNew` (type: `boolean`):

Skip companies already delivered by a previous run with the same search. Perfect to monitor new registrations every day or week. Memory is kept in the named key-value store "french-companies-state".

## `stateKey` (type: `string`):

Optional name of the onlyNew memory (letters, digits, - and \_). By default it is derived from the search criteria.

## Actor input object example

```json
{
  "identifiers": [
    "552032534",
    "356 000 000 00048"
  ],
  "query": "boulangerie",
  "nafCodes": [
    "10.71C"
  ],
  "departments": [
    "31"
  ],
  "postalCodes": [
    "31000",
    "31300"
  ],
  "communeCodes": [
    "31555"
  ],
  "status": "active",
  "maxResults": 8,
  "maxEstablishments": 10,
  "onlyNew": false
}
```

# Actor output Schema

## `companies` (type: `string`):

No description

## `overview` (type: `string`):

No description

# 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 = {
    "identifiers": [
        "552032534",
        "542051180"
    ],
    "query": "boulangerie",
    "communeCodes": [
        "31555"
    ],
    "maxResults": 8
};

// Run the Actor and wait for it to finish
const run = await client.actor("actose/french-companies").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 = {
    "identifiers": [
        "552032534",
        "542051180",
    ],
    "query": "boulangerie",
    "communeCodes": ["31555"],
    "maxResults": 8,
}

# Run the Actor and wait for it to finish
run = client.actor("actose/french-companies").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 '{
  "identifiers": [
    "552032534",
    "542051180"
  ],
  "query": "boulangerie",
  "communeCodes": [
    "31555"
  ],
  "maxResults": 8
}' |
apify call actose/french-companies --silent --output-dataset

```

## MCP server setup

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

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/5uotp9ErUAcFrWDjO/builds/PcJXGVNxPhh8Pfb4z/openapi.json