# France Company Registry Search (`vivid_astronaut/france-company-registry-search`) Actor

Search the official French company registry (SIRENE / Recherche d'Entreprises) by name, location or industry. Get SIREN/SIRET, executives, NAF codes and addresses as normalized JSON. Ideal for KYB, compliance and B2B prospecting in France.

- **URL**: https://apify.com/vivid\_astronaut/france-company-registry-search.md
- **Developed by:** [Fabio Suizu](https://apify.com/vivid_astronaut) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## France Company Registry Search (SIRENE)

France Company Registry Search (SIRENE) searches the official French government Recherche d'Entreprises API and returns normalized company records that are ready for KYB, compliance screening, sales prospecting, B2B enrichment, and market mapping workflows. The actor is built for teams that need reliable French company data without maintaining their own pagination, rate limiting, retry logic, and field mapping around the public API.

The source is the official French state company search service at `recherche-entreprises.api.gouv.fr`. It exposes SIRENE identifiers, legal names, headquarters details, administrative status, NAF activity codes, legal form codes, employee size bands, establishments, and executives when available. The actor keeps the output compact and stable so it can be consumed by lead generation tools, CRM enrichment jobs, data warehouses, and onboarding checks.

### What It Does

Provide a company name, SIREN, SIRET, brand, or free-text query and the actor searches the official registry endpoint. It paginates through results with `per_page=25`, respects a conservative 5 requests per second throttle, retries HTTP 429 responses with exponential backoff, and stops at your configured `maxResults`.

Each saved dataset item is normalized to a predictable shape:

```json
{
  "siren": "383474814",
  "siret": "38347481400100",
  "name": "AIRBUS",
  "legalName": "AIRBUS",
  "acronym": null,
  "naf": "30.30Z",
  "nafLabel": null,
  "legalFormCode": "5710",
  "status": "A",
  "createdAt": "1991-10-18",
  "employeesRange": "53",
  "address": {
    "street": "2 ROND-POINT DEWOITINE 31700 BLAGNAC",
    "postalCode": "31700",
    "city": "BLAGNAC"
  },
  "executives": [
    {
      "name": "GUILLAUME FAURY",
      "role": "Président de SAS",
      "birthYearMonth": "1968-02"
    }
  ],
  "establishmentsCount": 11,
  "isHeadOfficeMatch": true
}
````

Missing values are returned as `null`, not omitted, which makes downstream mapping simpler. Dates from the official API are preserved as ISO-style strings.

### Use Cases

KYB and compliance teams can use the actor to verify whether a French company exists, whether it is administratively active, where its head office is located, and which executives are listed by the official service. The `siren` and `siret` fields make it easy to join results with internal onboarding records or sanctions, VAT, and adverse media workflows.

Sales and growth teams can use the actor for prospecting in France and the EU. Search by keyword, department, postal code, NAF activity, employee range, or active-only status to build focused account lists. For example, a supplier selling aerospace services can search for companies matching a relevant activity section or keyword, then export normalized records into a CRM or enrichment pipeline.

Data enrichment teams can use the actor to add official identifiers and headquarters fields to existing company lists. When a record already has a company name but no SIREN or SIRET, the actor can search the registry and return candidate matches with address and legal form context for matching logic.

Market research teams can use the actor to sample companies by geography, activity code, and size band. The official API includes filters for departments, NAF sections, legal form, and employee ranges, which are useful for building snapshots of local business populations.

### Input

The default input searches for `airbus`, active companies only, and returns up to 100 results. This default is intentionally small and should complete in less than five minutes.

Available input fields:

- `query`: required search term. Use a company name, brand, SIREN, SIRET, or free-text expression.
- `postalCode`: maps to `code_postal`.
- `department`: maps to `departement`.
- `naf`: maps to `activite_principale`.
- `nafSection`: maps to `section_activite_principale`.
- `activeOnly`: when true, sends `etat_administratif=A`.
- `employeeRanges`: maps to `tranche_effectif_salarie`.
- `legalFormCode`: maps to `nature_juridique`.
- `maxResults`: maximum number of normalized records to save.

Example input:

```json
{
  "query": "airbus",
  "department": "31",
  "nafSection": "C",
  "activeOnly": true,
  "employeeRanges": ["52", "53"],
  "maxResults": 250
}
```

### Output Fields

The actor saves one item per company. The most important identifiers are `siren` for the legal unit and `siret` for the headquarters establishment. The `address` object is based on the `siege` record returned by the official API. `executives` contains both physical persons and legal entities where available: physical persons are mapped from `prenoms`, `nom`, `qualite`, and `date_de_naissance`; legal entities are mapped from `denomination` and `qualite`.

`isHeadOfficeMatch` indicates whether the headquarters establishment appears among the matching establishments for the search. This helps distinguish cases where the company matched because of another establishment rather than the head office.

### GDPR And Data Source Note

This actor uses public official company registry data made available by the French state through Recherche d'Entreprises. The data may include executive names and partial birth dates when the official API returns them. Users are responsible for using exported data lawfully, applying an appropriate legal basis, respecting retention limits, and honoring applicable GDPR obligations in their own systems.

### Pricing

This actor is designed for pay-per-event pricing. Suggested PPE tiers:

- Starter: approximately $1.50 per 1,000 saved company results.
- Growth: approximately $1.90 per 1,000 saved company results.
- Business: approximately $2.30 per 1,000 saved company results.
- Enterprise: approximately $2.70 per 1,000 saved company results with higher-volume support expectations.

Actual Apify Store pricing is configured in the Apify Console.

### FAQ

**Does this actor need an API key?**\
No. The official Recherche d'Entreprises endpoint is public and does not require an API key.

**What rate limit does it use?**\
The public service documents a higher limit, but the actor uses a conservative 5 requests per second throttle and handles HTTP 429 responses with backoff.

**Can I search only active companies?**\
Yes. Set `activeOnly` to true to apply `etat_administratif=A`.

**Can I filter by NAF activity?**\
Yes. Use `naf` for a specific activity code such as `30.30Z`, or `nafSection` for a broader section such as `C`.

**Are results guaranteed to be unique?**\
The actor saves one normalized item per company result returned by the official search API. If you run multiple searches, deduplicate downstream by `siren` or `siret`.

**Why are some fields null?**\
The official API does not provide every field for every record. The actor keeps the schema stable by returning `null` for absent values.

# Actor input Schema

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

Company name, brand, SIREN, SIRET, or free-text search term.

## `postalCode` (type: `string`):

Filter by French postal code, mapped to code\_postal.

## `department` (type: `string`):

Filter by French department code, mapped to departement.

## `naf` (type: `string`):

Filter by activite\_principale, for example 30.30Z.

## `nafSection` (type: `string`):

Filter by section\_activite\_principale, for example C.

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

When enabled, sends etat\_administratif=A.

## `employeeRanges` (type: `array`):

SIRENE tranche\_effectif\_salarie values to include. Multiple values are sent as a comma-separated filter.

## `legalFormCode` (type: `string`):

Filter by nature\_juridique.

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

Maximum number of normalized company records to save.

## Actor input object example

```json
{
  "query": "airbus",
  "activeOnly": true,
  "maxResults": 100
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("vivid_astronaut/france-company-registry-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("vivid_astronaut/france-company-registry-search").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call vivid_astronaut/france-company-registry-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France Company Registry Search",
        "description": "Search the official French company registry (SIRENE / Recherche d'Entreprises) by name, location or industry. Get SIREN/SIRET, executives, NAF codes and addresses as normalized JSON. Ideal for KYB, compliance and B2B prospecting in France.",
        "version": "0.1",
        "x-build-id": "I5zrPHUKvWqerYo6Q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vivid_astronaut~france-company-registry-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vivid_astronaut-france-company-registry-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/vivid_astronaut~france-company-registry-search/runs": {
            "post": {
                "operationId": "runs-sync-vivid_astronaut-france-company-registry-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/vivid_astronaut~france-company-registry-search/run-sync": {
            "post": {
                "operationId": "run-sync-vivid_astronaut-france-company-registry-search",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Company name, brand, SIREN, SIRET, or free-text search term.",
                        "default": "airbus"
                    },
                    "postalCode": {
                        "title": "Postal code",
                        "type": "string",
                        "description": "Filter by French postal code, mapped to code_postal."
                    },
                    "department": {
                        "title": "Department",
                        "type": "string",
                        "description": "Filter by French department code, mapped to departement."
                    },
                    "naf": {
                        "title": "NAF activity code",
                        "type": "string",
                        "description": "Filter by activite_principale, for example 30.30Z."
                    },
                    "nafSection": {
                        "title": "NAF section",
                        "type": "string",
                        "description": "Filter by section_activite_principale, for example C."
                    },
                    "activeOnly": {
                        "title": "Active companies only",
                        "type": "boolean",
                        "description": "When enabled, sends etat_administratif=A.",
                        "default": true
                    },
                    "employeeRanges": {
                        "title": "Employee ranges",
                        "type": "array",
                        "description": "SIRENE tranche_effectif_salarie values to include. Multiple values are sent as a comma-separated filter.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "legalFormCode": {
                        "title": "Legal form code",
                        "type": "string",
                        "description": "Filter by nature_juridique."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of normalized company records to save.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```