# France Company Registry Scraper (`nanodata/france-company-registry-scraper`) Actor

Search the French business register by keyword, activity code, department, postal code and more. One row per company with SIREN, SIRET, address, activity, legal form, size band, officers and finances. Pay per company.

- **URL**: https://apify.com/nanodata/france-company-registry-scraper.md
- **Developed by:** [nanodata](https://apify.com/nanodata) (community)
- **Categories:** Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 92.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 french company scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## France Company Registry Scraper

Search the French business register and get one row per company: SIREN, SIRET, head office town and address, activity code, legal form, size band, creation date, status, officers and published finances. Search by keyword and narrow it down by activity code, department, postal code, legal form, size or status. You pay per company returned. Companies that opted out of commercial use are excluded.

Source: Annuaire des Entreprises / base SIRENE (INSEE), Licence Ouverte / Etalab 2.0. The data comes from the public French business register and its open API at recherche-entreprises.api.gouv.fr.

### What you get

For each company (one row per SIREN, duplicates across queries are removed):

- Identity: `siren`, `siret` of the head office, `nom_complet`, `nom_raison_sociale`, `sigle`, `url` (public company page)
- Head office: `adresse`, `code_postal`, `commune`, `commune_code`, `departement`, `region`, `latitude`, `longitude`, plus the full `siege` object as published
- Activity and type: `activite_principale` (NAF), `section_activite_principale`, `nature_juridique`, `categorie_entreprise`, `tranche_effectif_salarie`
- Dates and status: `date_creation`, `date_fermeture`, `date_mise_a_jour`, `etat_administratif`
- Size: `nombre_etablissements`, `nombre_etablissements_ouverts`
- `dirigeants` (officers), `finances` (revenue and net result by year when published), `complements` (flags such as `est_ess`, `est_association`, `est_entrepreneur_individuel`, `est_qualiopi`, `est_rge`)
- `matching_etablissements` when you switch on `includeEstablishments`
- `query`, `page`, `scraped_at`

Fields without a value are `null`.

### Pricing

| Event | When it is charged | Price |
|---|---|---|
| `actor-start` | Once per run, together with the first delivered rows | $0.001 |
| `company-result` | For each company row delivered | $0.0025 ($2.50 per 1,000) |

Nothing is charged for a search with no results. The run stops cleanly when your max charge per run is reached.

### Input

| Field | Meaning |
|---|---|
| `queries` | List of words or names. A single text also works. Leave empty to search by filters only. |
| `activitePrincipale` | NAF activity code such as `10.71A` |
| `sectionActivitePrincipale` | Activity section letter such as `I` |
| `departement` | Department code such as `75`, `2A`, `971`. Matches companies with at least one establishment in that department, so the head office of some results can be elsewhere |
| `region` | Region code such as `11` |
| `codePostal` | Postal code such as `75001` |
| `natureJuridique` | Legal form code such as `5710` |
| `categorieEntreprise` | `PME`, `ETI` or `GE` |
| `etatAdministratif` | `A` (active) or `C` (closed) |
| `trancheEffectifSalarie` | Headcount band code such as `11` |
| `maxResults` | Total number of companies, default 100. Numbers given as text work too. |
| `includeEstablishments` | Add the matching establishments to each row (default off) |
| `splitByDepartment` | Run a search that matches more than 10,000 companies once per department (default off) |

Filters accept text or numbers, and several values can be separated by commas.

Example, bakeries and plumbers in Paris:

```json
{
  "queries": ["boulangerie", "plombier"],
  "departement": "75",
  "maxResults": 60
}
```

Example, active mid-size companies in the food industry, split by department:

```json
{
  "sectionActivitePrincipale": "C",
  "categorieEntreprise": "ETI",
  "etatAdministratif": "A",
  "maxResults": 2000,
  "splitByDepartment": true
}
```

An empty input runs a small demo (query `boulangerie`, 5 results).

### Output sample

```json
{
  "siren": "822276416",
  "url": "https://annuaire-entreprises.data.gouv.fr/entreprise/822276416",
  "nom_complet": "BOULANGERIE BEAUBOURG",
  "siret": "82227641600010",
  "adresse": "149 RUE SAINT-MARTIN 75003 PARIS",
  "code_postal": "75003",
  "commune": "PARIS",
  "departement": "75",
  "region": "11",
  "latitude": 48.861850568,
  "longitude": 2.351665508,
  "activite_principale": "10.71C",
  "nature_juridique": "5710",
  "categorie_entreprise": "PME",
  "tranche_effectif_salarie": "11",
  "date_creation": "2016-08-30",
  "etat_administratif": "A",
  "nombre_etablissements": 1,
  "dirigeants": [{"nom": "NASSIRI", "prenoms": "MUSTAPHA", "qualite": "Président de SAS", "type_dirigeant": "personne physique"}],
  "finances": {"2025": {"ca": 0, "resultat_net": 199280}},
  "query": "boulangerie"
}
```

### Limitations

- The register returns at most 10,000 companies per search. When a search matches more, the run log and the final status say so. Narrow the filters, or turn on `splitByDepartment` to run the search once per department.
- Units whose data is not fully public (partial or withheld publication) are skipped, not charged, and counted in the final status ("Skipped N non-public units").
- Personal data of individuals is limited. For officers who are people, only name, first names and role are returned, with no birth date, birth year, nationality or address. For sole traders (entrepreneurs individuels), no street address and no coordinates are returned, only the town and department.
- `maxResults` is a total across all queries. Queries run in order, so a high first query can use up the whole limit.
- Finances and officers are only present when the register publishes them.
- Companies that opted out of commercial use (opposition_diffusion_commerciale) are excluded.

### FAQ

**Where does the data come from?**
From the public French business register (base SIRENE and related sources), published as open data under the Licence Ouverte / Etalab 2.0. Please keep the source attribution when you republish it.

**How fresh is it?**
Each row has update dates (`date_mise_a_jour`, `date_mise_a_jour_insee`, `date_mise_a_jour_rne`) taken from the register.

**Can I search by SIREN or SIRET?**
Yes, put the number in `queries`.

**Why do I get fewer rows than `maxResults`?**
The search has fewer matches, duplicates were removed, or non-public units were skipped. The final status message explains which.

**Does it use an API key?**
No. The register is open and needs no key or account.

# Actor input Schema

## `queries` (type: `array`):

Company names or keywords, for example 'boulangerie' or 'Dupont'. Queries run in order and results are merged without duplicates. Leave empty to search by the filters only.

## `activitePrincipale` (type: `string`):

Main activity code, for example 10.71A. Several codes can be separated by commas.

## `sectionActivitePrincipale` (type: `string`):

Section letter of the activity classification, for example I (accommodation and food service).

## `departement` (type: `string`):

Department code, for example 75, 2A or 971. Several codes can be separated by commas.

## `region` (type: `string`):

Region code, for example 11 (Ile-de-France).

## `codePostal` (type: `string`):

Postal code of the head office, for example 75001. Several codes can be separated by commas.

## `natureJuridique` (type: `string`):

Legal form code, for example 5710 (simplified joint-stock company) or 5499 (limited company).

## `categorieEntreprise` (type: `string`):

PME (small and medium), ETI (mid-size) or GE (large).

## `etatAdministratif` (type: `string`):

A for active companies, C for closed companies. Empty for both.

## `trancheEffectifSalarie` (type: `string`):

Headcount band code, for example 11 (10 to 19 employees) or 12 (20 to 49 employees).

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

Total across all queries (not per query). The register returns at most 10,000 companies per search.

## `includeEstablishments` (type: `boolean`):

Add the establishments (sites) that matched the search to each company row.

## `splitByDepartment` (type: `boolean`):

When a search matches more than 10,000 companies, run it once per department to get past the 10,000 limit.

## `proxyConfiguration` (type: `object`):

Network settings for the run. The default works for most runs.

## Actor input object example

```json
{
  "queries": [
    "boulangerie",
    "plombier"
  ],
  "departement": "75",
  "maxResults": 100,
  "includeEstablishments": false,
  "splitByDepartment": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `defaultDataset` (type: `string`):

One row per company from the French business register

# 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 = {
    "queries": [
        "boulangerie",
        "plombier"
    ],
    "departement": "75",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nanodata/france-company-registry-scraper").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 = {
    "queries": [
        "boulangerie",
        "plombier",
    ],
    "departement": "75",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nanodata/france-company-registry-scraper").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 '{
  "queries": [
    "boulangerie",
    "plombier"
  ],
  "departement": "75",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nanodata/france-company-registry-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nanodata/france-company-registry-scraper"
        }
    }
}
```

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/rMkjxDd0H3u3phCgF/builds/VqxBG6ooIHD3aO2GE/openapi.json
