# French Company Data & KYB: SIREN/SIRET + BODACC Alerts (`datacraft-studio/french-company-enrichment`) Actor

SIREN and SIRET lookup for French company data, KYB and KYC. Official INSEE SIRENE identity with Kbis-style registry fields, directors, and BODACC insolvency alerts. An open-data alternative to Pappers and Societe.com.

- **URL**: https://apify.com/datacraft-studio/french-company-enrichment.md
- **Developed by:** [Yahya Nouali](https://apify.com/datacraft-studio) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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.

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 & KYB: SIREN/SIRET Lookup + BODACC Insolvency Alerts

Official French company data for KYB, KYC, lead generation, and supplier risk. One run returns SIREN, SIRET, legal identity, headquarters, NAF, directors, published revenue, and BODACC insolvency signals. A second mode watches a SIREN list and reports only what changed.

The data comes from two public government APIs: INSEE SIRENE, through the Recherche d'entreprises API, and BODACC, the official gazette of commercial announcements. There is no scrape of Pappers, Societe.com, Infogreffe, or any other private site. This is an open-data alternative to paying a data vendor for the same public registers. It is not a certified Kbis PDF from the commercial court.

The first enrich run is prefilled with Danone, Capgemini, and Orange. A short name can rank a smaller homonym first: `MICHELIN` currently matches an SCI, while the tire manufacturer is SIREN `855200507`.

### Where it pays off

- **KYB and KYC onboarding.** Confirm the SIREN, legal form, active or ceased status, headquarters, and directors before you open an account.
- **Lead generation.** Build a list by NAF code, department, region, and headcount, then keep SIRET and the official activity label.
- **CRM enrichment.** Paste names or SIREN/SIRET numbers from a spreadsheet and write one row per company back to the CRM.
- **Supplier and credit risk.** Flag a new BODACC collective proceeding (redressement, liquidation, sauvegarde) or a move, a rename, or a ceased SIREN on a watchlist.

### Price compared with buying a dossier per company

| | This actor | A per-company data vendor |
| --- | --- | --- |
| Source | INSEE SIRENE and BODACC open data | Usually a reseller of the same public registers, sometimes with a certified Kbis |
| Found company | **$0.005**, plus **$0.002** when BODACC history is included | A per-file fee or a seat on a subscription |
| Miss, bad checksum, or API error | Row is stored. **Not charged.** | A credit is often spent anyway |
| Weekly watchlist | **$0.015 per detected change.** Unchanged SIRENs are free. The first run is a free baseline. | Another full pull of every company |
| Certified Kbis | Not included. You get the SIRENE fields a Kbis also shows. | Some vendors sell the court extract separately |

With BODACC left on, enrichment is about **$7 per 1,000 found companies**. Monitoring costs nothing until a watched field or a new announcement moves.

### Pricing

Pay per event. Rental pricing is discontinued. Amounts are saved in Apify Console, not in the source. The actor charges three events:

| Event | Price | Charged when |
| --- | --- | --- |
| `company-enriched` (primary) | **$0.005** | Enrich mode found a company. **$5 / 1,000.** |
| `bodacc-history` | **$0.002** | Enrich mode fetched BODACC for that company. **$2 / 1,000.** |
| `change-detected` | **$0.015** | Monitor mode found one change or one new BODACC announcement. |

Not charged:

- `not_found`, `invalid`, and `error` rows
- the first monitor observation of a SIREN (`baseline`)
- a monitored company that has not changed
- a failed BODACC call in enrich mode (the company row is still delivered if SIRENE succeeded, without the BODACC event)

Set the synthetic events `apify-default-dataset-item` and `apify-actor-start` to **$0**. Otherwise every dataset row, including misses, is billed again. Steps are in [PUBLISHING.md](PUBLISHING.md).

### Input

`mode` is `enrich` (default) or `monitor`.

**Enrich** uses one of three search modes:

- **Names.** One best match per name. `activeOnly` drops ceased companies.
- **SIREN / SIRET.** Exact lookup. Spaces are ignored. A failed Luhn checksum is `invalid` and is not sent to the API. `activeOnly` does not apply.
- **Filters.** At least one of NAF code, NAF section, department, region, or headcount. Department and region match any establishment, so the headquarters on the row can sit in another department.

`maxResults` defaults to 25 and caps a run at 1,000. A name or identifier list longer than `maxResults` stops the run instead of silently dropping the tail.

Enrich example:

```json
{
  "mode": "enrich",
  "searchMode": "identifiers",
  "sirens": ["552032534", "330703844", "380129866"],
  "includeBodacc": true,
  "bodaccHistoryLimit": 5,
  "includeDirigeants": true,
  "includeFinances": true,
  "activeOnly": true,
  "maxResults": 25,
  "maxConcurrency": 4
}
```

The same three numbers are Danone, Capgemini, and Orange.

### Output

Enrich mode writes one dataset item per company. The Output tab has **Overview**, **Legal and BODACC**, and **Headquarters**. A shortened item, from the public Danone record:

```json
{
  "status": "found",
  "input": "DANONE",
  "matchType": "name",
  "siren": "552032534",
  "siretSiege": "55203253400703",
  "nom": "DANONE",
  "formeJuridique": "5599",
  "formeJuridiqueLibelle": "SA à conseil d'administration (s.a.i.)",
  "dateCreation": "1955-01-01",
  "etatAdministratif": "A",
  "etatAdministratifLibelle": "Active",
  "adresseLigne": "17 BOULEVARD HAUSSMANN",
  "codePostal": "75009",
  "ville": "PARIS",
  "departement": "75",
  "codeNaf": "70.10Z",
  "libelleNaf": "Activités des sièges sociaux",
  "trancheEffectif": "42",
  "trancheEffectifLibelle": "1 000 à 1 999 salariés",
  "dirigeants": [
    { "nom": "BERNARD DE SAINT AFFRIQUE", "prenoms": "ANTOINE", "qualite": "Directeur Général", "type": "personne physique" }
  ],
  "chiffreAffaires": 27376000000,
  "resultatNet": 2100000000,
  "anneeFinances": "2025",
  "bodaccCount": 107,
  "bodaccLastDate": "2026-09-02",
  "bodaccLastType": "Modifications diverses",
  "procedureCollectiveEnCours": false,
  "procedureCollectiveType": null,
  "sourceUrls": [
    "https://recherche-entreprises.api.gouv.fr/search?q=552032534",
    "https://annuaire-entreprises.data.gouv.fr/entreprise/552032534",
    "https://bodacc-datadila.opendatasoft.com/explore/dataset/annonces-commerciales/?q=552032534"
  ],
  "licence": "Licence Ouverte 2.0 / Etalab",
  "scrapedAt": "2026-10-24T22:05:20.108Z"
}
```

The live item also includes the parsed street fields, coordinates, the TVA number when SIRENE publishes it, and `bodaccAnnonces`. `procedureCollectiveEnCours` is `null` when BODACC was not requested. `scrapedAt` is the time the official APIs were called.

A miss looks like this and is not billed:

```json
{
  "status": "not_found",
  "input": "990003105",
  "siren": null,
  "message": "No company is published for SIREN 990003105.",
  "licence": "Licence Ouverte 2.0 / Etalab"
}
```

### Monitor a watchlist

Set `mode` to `monitor` and pass SIRENs or SIRETs. Each run reads the current SIRENE record and BODACC notices, then compares them with the snapshot in a named key-value store (`monitorStoreName`, default `fce-monitor-state`). Use the same store name on every run. A new name starts the baseline over.

Watched fields: administrative status (active or ceased), headquarters address, legal form, name, NAF code, directors when `includeDirigeants` is on, any new BODACC announcement, and a change in the collective-proceeding flag.

The first time a SIREN is seen, the actor stores the snapshot and writes one row with `status: "baseline"`. That row is not charged. Later runs write **one row per change**:

```json
{
  "status": "change",
  "input": "552032534",
  "siren": "552032534",
  "nom": "DANONE",
  "changeType": "procedure_collective",
  "field": "procedureCollective",
  "before": null,
  "after": "2026-10-20 — Procédures collectives",
  "eventDate": "2026-10-20",
  "detectedAt": "2026-10-27T07:00:12.000Z",
  "sourceUrl": "https://www.bodacc.fr/annonce/example",
  "licence": "Licence Ouverte 2.0 / Etalab",
  "scrapedAt": "2026-10-27T07:00:12.000Z"
}
```

`changeType` is one of `etat_administratif`, `adresse_siege`, `forme_juridique`, `nom`, `code_naf`, `dirigeants`, `bodacc_annonce`, `procedure_collective`. A new collective announcement is a single `procedure_collective` row, not a second BODACC row. Open the dataset view **Monitor changes**.

Unchanged SIRENs produce no row and no charge. `not_found`, `invalid`, and `error` are stored and not charged, and a miss does not erase the previous snapshot. If the run hits the user's charge limit, already-billed changes stay saved and the rest are retried next time.

Monitor input:

```json
{
  "mode": "monitor",
  "sirens": ["552032534", "330703844", "380129866"],
  "monitorStoreName": "fce-monitor-state",
  "includeBodacc": true,
  "includeDirigeants": true,
  "bodaccHistoryLimit": 20,
  "maxResults": 1000,
  "maxConcurrency": 4
}
```

`maxResults` must be at least the length of `sirens` (the cap is 1,000).

#### Run it every week

In Apify Console, open **Schedules** and create a schedule for this actor. Paste the monitor input above. Keep `monitorStoreName` identical to the store used on the first baseline run.

Cron for Monday at 07:00 UTC:

```text
0 7 * * 1
```

Save the schedule. The next run compares against `fce-monitor-state` and charges `change-detected` only when something moved. The schedule documentation is at [docs.apify.com/platform/schedules](https://docs.apify.com/platform/schedules).

### Integrations: Make, Zapier, n8n

You can call this Actor from no-code tools through Apify's official integrations. Use its Actor ID `SjJHbBzPhqXisaz6e`, and connect each tool with OAuth or your Apify API token. Never put the token in the Actor input.

- **Make**: in the Apify app, add **Run an Actor** and set *Run synchronously* to Yes. Then add **Get Dataset Items** with the run's default dataset ID, and map the rows to Google Sheets, a CRM or Slack. For long runs, use the **Watch Actor Runs** trigger instead.
- **Zapier**: the Apify app has the **Run Actor** action. A synchronous run has a 30-second hard timeout, so for larger lists start the run and use the **Finished Actor Run** trigger with **Fetch Dataset Items**.
- **n8n**: install the official node `@apify/n8n-nodes-apify`. It is a verified community node on n8n Cloud; on self-hosted n8n, add it under Settings > Community Nodes. Use **Run an Actor and Get Dataset**, or the Apify trigger for finished runs.

Example input:

```json
{"mode": "enrich", "searchMode": "identifiers", "sirens": ["552032534"], "includeBodacc": true, "includeDirigeants": true}
```

#### Scheduled monitor to Slack or Sheets

1. Save a monitor input as an Actor task and keep the same store name on every run:

```json
{
  "mode": "monitor",
  "sirens": [
    "552032534",
    "330703844"
  ],
  "monitorStoreName": "fce-monitor-state",
  "includeBodacc": true
}
```

2. In Apify Console > **Schedules**, run the task on a cron such as `0 7 * * 1` (every Monday at 07:00), with your timezone selected.
3. On the task's **Integrations** tab, add Slack or an HTTP webhook on *Run succeeded*. You can also use Make **Watch Actor Runs**, Zapier **Finished Actor Run** or the n8n Apify trigger.
4. Fetch the dataset items and keep only the change rows: `status` is `"change"`. The first run only stores the baseline and is free.

#### HTTP API

This call runs the Actor and returns the dataset rows in one request. Synchronous runs time out after 300 seconds, so use `/runs` for big lists.

```bash
curl -X POST "https://api.apify.com/v2/acts/SjJHbBzPhqXisaz6e/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode": "enrich", "searchMode": "identifiers", "sirens": ["552032534"], "includeBodacc": true, "includeDirigeants": true}'
```

### FAQ

**Where does the data come from?** The Recherche d'entreprises API (`https://recherche-entreprises.api.gouv.fr`) for SIRENE identity, and the DILA BODACC dataset `annonces-commerciales` on `bodacc-datadila.opendatasoft.com`. No API key is required. NAF and legal-form labels are bundled from INSEE. See [src/data/SOURCES.md](src/data/SOURCES.md).

**What licence applies?** **Licence Ouverte 2.0 / Etalab.** Every row repeats `licence` and `sourceUrls`. Keep both if you republish the dataset. [etalab.gouv.fr/licence-ouverte-open-licence](https://www.etalab.gouv.fr/licence-ouverte-open-licence).

**How fresh is it?** SIRENE lookup follows the government search API, which is the live register rather than a monthly file. BODACC appears when the gazette publishes the announcement, which can be days after the court decision. Revenue and net income are the latest year the API exposes, often the last filed accounts, and many companies have none.

**What are the rate limits?** SIRENE documents about **7 requests/second per IP**. This actor stays at 6 and retries HTTP 429 and 5xx with backoff. BODACC has no published quota; the actor stays at 4 requests/second. Several runs sharing one IP can still trip the SIRENE ceiling.

**Is this personal data?** The actor returns public company data only: legal entities and the directors the register already publishes. It does not look up private individuals, consumers, or hidden persons. Partial diffusion (`statutDiffusion` = `P`) omits many sole traders' details. Directors are still personal data under the GDPR once you store them in your own system. You are the controller for that copy. Do not use the output to profile people beyond the public company role.

**Is the insolvency flag a legal opinion?** No. `procedureCollectiveEnCours` reads the latest collective announcement. An opening or conversion counts as ongoing. A clôture or an adopted plan does not. Confirm anything material on the gazette text linked from the row.

**Why is a large group coded as a non-employer?** The headcount bracket is the legal unit's own INSEE code. A parent SIREN can be `NN` while the group employs thousands of people in subsidiaries.

### Region codes

| Code | Region | Code | Region |
| --- | --- | --- | --- |
| 11 | Île-de-France | 75 | Nouvelle-Aquitaine |
| 24 | Centre-Val de Loire | 76 | Occitanie |
| 27 | Bourgogne-Franche-Comté | 84 | Auvergne-Rhône-Alpes |
| 28 | Normandie | 93 | Provence-Alpes-Côte d'Azur |
| 32 | Hauts-de-France | 94 | Corse |
| 44 | Grand Est | 01 | Guadeloupe |
| 52 | Pays de la Loire | 02 | Martinique |
| 53 | Bretagne | 03 | Guyane |
| 04 | La Réunion | 06 | Mayotte |

Department codes use the INSEE list, including `2A`, `2B`, and `971`–`976`.

### Run it locally

Node.js 22 or newer.

```bash
npm install
npm start
```

With no input file, the actor enriches Danone, Capgemini, and Orange. To run the monitor example locally (the state store is created under `storage/key_value_stores/`):

```bash
mkdir -p storage/key_value_stores/default
cp examples/INPUT.monitor.json storage/key_value_stores/default/INPUT.json
npm start
```

```bash
npm test
npm run lint
npm run build
npm run smoke
```

The Docker image uses `apify/actor-node:22`. `apify push` builds it. See [PUBLISHING.md](PUBLISHING.md).

Author: **Yahya Nouali**.

### Données d'entreprises françaises : SIREN, SIRET, KYB et alertes BODACC

Acteur de données officielles pour le KYB, le KYC, la prospection et le risque fournisseur. Il interroge uniquement des API publiques de l'État : l'API Recherche d'entreprises (SIRENE / INSEE) et le BODACC (DILA). Aucun moissonnage de Pappers, Societe.com ou Infogreffe. Ce n'est pas un extrait Kbis certifié du greffe ; ce sont les informations d'identité que le répertoire SIRENE publie déjà (SIREN, SIRET, forme juridique, siège, activité, dirigeants lorsqu'ils sont diffusés).

Deux modes :

- **enrich** (par défaut) : une ligne par société, à partir d'un nom, d'un SIREN/SIRET, ou de filtres (code NAF, département, région, tranche d'effectif).
- **monitor** : une liste de SIREN. Le premier passage enregistre une référence (`baseline`), non facturée. Les passages suivants écrivent une ligne par changement (statut actif ou cessé, adresse du siège, forme juridique, dénomination, code NAF, dirigeants, nouvelle annonce BODACC, procédure collective). Les sociétés inchangées ne coûtent rien.

Sources, sans clé d'API :

- **API Recherche d'entreprises** ([recherche-entreprises.api.gouv.fr](https://recherche-entreprises.api.gouv.fr)). Plafond documenté : environ 7 requêtes par seconde. L'acteur se limite à 6 et réessaie en cas de 429 ou d'erreur serveur.
- **BODACC**, jeu `annonces-commerciales` ([bodacc-datadila.opendatasoft.com](https://bodacc-datadila.opendatasoft.com/explore/dataset/annonces-commerciales/)) : créations, modifications, ventes, radiations, procédures collectives (redressement, liquidation, sauvegarde). Au plus 4 requêtes par seconde.

Les données sont réutilisables sous **Licence Ouverte 2.0 / Etalab**. Chaque ligne porte la licence et les URL sources. Les libellés NAF et les catégories juridiques viennent de l'INSEE, sous la même licence. La fraîcheur suit l'API SIRENE pour l'identité, et la date de parution au BODACC pour les annonces (souvent quelques jours après la décision). Les comptes sont ceux de la dernière année publiée, parfois absents.

Facturation au résultat : **0,005 USD** par société trouvée, **0,002 USD** pour l'historique BODACC, **0,015 USD** par changement détecté en surveillance. Une recherche sans résultat, un SIREN invalide (clé de Luhn) ou une erreur d'API n'est pas facturé. La première observation d'un SIREN surveillé non plus.

Pour une alerte hebdomadaire : dans la console Apify, créer une planification (Schedules) sur cet acteur, avec le même `monitorStoreName` à chaque fois (par défaut `fce-monitor-state`). Expression cron du lundi à 07:00 UTC : `0 7 * * 1`.

**Intégrations** : l'acteur se branche sur Make (*Run an Actor* + *Get Dataset Items*), Zapier (*Run Actor*, déclencheur *Finished Actor Run*) et n8n (nœud officiel `@apify/n8n-nodes-apify`), ou par l'API `run-sync-get-dataset-items`. Les exemples sont dans la section *Integrations* ci-dessus.

RGPD : seules des données publiques de sociétés sont lues. Les dirigeants diffusés par le registre restent des données personnelles dès que vous les conservez dans votre propre base : vous en êtes responsable. Les personnes en diffusion partielle ne sont pas exposées.

Le drapeau `procedureCollectiveEnCours` résume la dernière annonce de procédure collective. Une ouverture ou une conversion est traitée comme une procédure en cours ; une clôture ou un plan arrêté ne l'est pas. C'est une aide au criblage, pas une analyse juridique.

Le détail de publication et le JSON de tarification sont dans [PUBLISHING.md](PUBLISHING.md).

# Actor input Schema

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

Enrich returns one company per input. Monitor compares a SIREN or SIRET list with the previous run in the named key-value store and returns one row per change. The first monitor run stores a baseline and is not charged. Unchanged companies are free. Set Max results to at least the size of the watchlist.

## `monitorStoreName` (type: `string`):

Named key-value store that keeps the last snapshot per SIREN. Used only in monitor mode. Schedule every run with the same name, or each run looks like a first baseline. Letters, numbers, and hyphens only.

## `searchMode` (type: `string`):

Names: best match for each company name. Identifiers: exact SIREN (9 digits) or SIRET (14 digits). Filters: list companies by NAF, area, and headcount. Only the selected mode is used.

## `companyNames` (type: `array`):

Used when search mode is Company names. Each name returns the single best match from the official search API. The prefilled example is Danone, Capgemini, and Orange. A short name can rank a smaller homonym first: MICHELIN currently matches an SCI, while the tire manufacturer is SIREN 855200507.

## `sirens` (type: `array`):

Used when search mode is SIREN / SIRET. Spaces and separators are ignored. A SIRET resolves the legal unit (SIREN); siretSiege in the output is always the headquarters. Example SIRENs: 552032534 (Danone), 330703844 (Capgemini), 380129866 (Orange).

## `activitePrincipale` (type: `array`):

Used when search mode is Filters. NAF rév. 2 subclass codes, for example 62.01Z (computer programming) or 70.10Z. Dots are optional.

## `sections` (type: `array`):

One-letter NAF sections. J is information and communication, M is professional services, G is trade, F is construction. The full list is in the README.

## `departements` (type: `array`):

INSEE department codes, including overseas departments. Examples: 75 Paris, 69 Rhône, 13 Bouches-du-Rhône, 2A Corse-du-Sud, 974 La Réunion. Use a leading zero (01, not 1). The official API matches any establishment in the department, so the headquarters in the result can sit in another department.

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

INSEE region codes. Examples: 11 Île-de-France, 84 Auvergne-Rhône-Alpes, 93 Provence-Alpes-Côte d'Azur, 75 Nouvelle-Aquitaine, 76 Occitanie. Matched on establishments, same as departments.

## `tranchesEffectif` (type: `array`):

INSEE workforce brackets: NN non-employer, 00 zero employees, 01 is 1–2, 02 is 3–5, 03 is 6–9, 11 is 10–19, 12 is 20–49, 21 is 50–99, 22 is 100–199, 31 is 200–249, 32 is 250–499, 41 is 500–999, 42 is 1,000–1,999, 51 is 2,000–4,999, 52 is 5,000–9,999, 53 is 10,000+.

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

Applies to name search and filters. Identifier lookups always return the company, including ceased ones.

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

Maximum companies to return. In name and identifier modes this must be at least the size of your list, so a long paste is not silently cut. Filter search stops at this number. Each found company is one billable result.

## `includeBodacc` (type: `boolean`):

Fetch commercial announcements and flag an ongoing collective proceeding (redressement, liquidation, sauvegarde) from the latest judgment. This is an optional extra charge. Not-found inputs are never sent to BODACC.

## `bodaccHistoryLimit` (type: `integer`):

How many recent announcements to keep on each company, newest first. The summary count still reflects the full number of matching announcements. 1–100.

## `includeDirigeants` (type: `boolean`):

Names, roles, and birth year when the company register publishes them. Some individuals are hidden under partial diffusion.

## `includeFinances` (type: `boolean`):

Latest published revenue (chiffre d'affaires) and net income (résultat net), with the year. Many companies have no public accounts; those fields stay empty.

## `maxConcurrency` (type: `integer`):

How many companies to enrich at once. Requests are still throttled under the SIRENE limit of 7 per second (this actor stays at 6) and at 4 per second for BODACC.

## Actor input object example

```json
{
  "mode": "enrich",
  "monitorStoreName": "fce-monitor-state",
  "searchMode": "names",
  "companyNames": [
    "DANONE",
    "CAPGEMINI",
    "ORANGE"
  ],
  "sirens": [
    "552032534",
    "330703844",
    "380129866"
  ],
  "activitePrincipale": [
    "62.01Z"
  ],
  "departements": [
    "75"
  ],
  "tranchesEffectif": [
    "11",
    "12"
  ],
  "activeOnly": true,
  "maxResults": 25,
  "includeBodacc": true,
  "bodaccHistoryLimit": 20,
  "includeDirigeants": true,
  "includeFinances": true,
  "maxConcurrency": 4
}
```

# Actor output Schema

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

Enriched company records from SIRENE and, when requested, BODACC.

## `changes` (type: `string`):

Baseline and change rows from monitor mode.

# 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 = {
    "companyNames": [
        "DANONE",
        "CAPGEMINI",
        "ORANGE"
    ],
    "sirens": [
        "552032534",
        "330703844",
        "380129866"
    ],
    "activitePrincipale": [
        "62.01Z"
    ],
    "departements": [
        "75"
    ],
    "tranchesEffectif": [
        "11",
        "12"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("datacraft-studio/french-company-enrichment").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 = {
    "companyNames": [
        "DANONE",
        "CAPGEMINI",
        "ORANGE",
    ],
    "sirens": [
        "552032534",
        "330703844",
        "380129866",
    ],
    "activitePrincipale": ["62.01Z"],
    "departements": ["75"],
    "tranchesEffectif": [
        "11",
        "12",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("datacraft-studio/french-company-enrichment").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 '{
  "companyNames": [
    "DANONE",
    "CAPGEMINI",
    "ORANGE"
  ],
  "sirens": [
    "552032534",
    "330703844",
    "380129866"
  ],
  "activitePrincipale": [
    "62.01Z"
  ],
  "departements": [
    "75"
  ],
  "tranchesEffectif": [
    "11",
    "12"
  ]
}' |
apify call datacraft-studio/french-company-enrichment --silent --output-dataset

```

## MCP server setup

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

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/SjJHbBzPhqXisaz6e/builds/YX94ayMCLagKE1t8L/openapi.json