# Pappers Scraper — French Company Register (SIREN/SIRET) Data (`studio-amba/pappers-scraper`) Actor

Search and extract French company data from Pappers. Look up companies by name or activity and get SIREN, SIRET, legal form, NAF code, address, status, share capital, revenue, and headcount. No API key, no login required.

- **URL**: https://apify.com/studio-amba/pappers-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 result 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/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

## Pappers Scraper — French Company Register (SIREN/SIRET)

Search and extract French company data from Pappers, the popular public directory of French businesses built on the official SIRENE / RCS data. Look up companies by name or business activity and get the SIREN, SIRET, legal form, NAF activity code, registered address, status, share capital, revenue, and headcount for each match. No API key, no login, no cookies required.

France has more than 26 million registered business entities. This actor turns a plain keyword search into a clean, structured list of companies you can drop straight into a CRM, a lead list, or a market-research spreadsheet.

### How to scrape Pappers data

This actor searches the Pappers company directory and returns structured records for every matching French company. It reads Pappers' own public search endpoint, so the data matches what you see on the website, and it needs no paid Pappers API key.

#### Search by company name

Enter a company name to find that business and its related entities. Example: `Carrefour`, `Decathlon`, `Total`. The actor returns the top matches ranked the same way Pappers ranks them.

#### Search by business activity

Enter an activity keyword to build a list of companies in that line of work. Example: `boulangerie` (bakery), `restaurant`, `plombier` (plumber), `garage automobile`. This is the fastest way to build a prospecting list for a specific trade.

#### Filter by department

Set the **Department Filter** to a French department code to keep only companies whose head office is in that department. Use the 2-digit code (`75` Paris, `69` Rhône, `13` Bouches-du-Rhône, `33` Gironde) or the 3-digit code for overseas departments (`971` Guadeloupe, `974` Réunion). The filter is applied to the head-office postal code of every result.

#### Filter by SIREN

Set the **SIREN Filter** to a 9-digit SIREN to keep only the company with that identifier out of the search results. Combine it with a name query for an exact single-company lookup.

#### Active companies only

Turn on **Active Companies Only** to exclude ceased businesses and keep just the companies whose consolidated status is active.

### What data does Pappers Scraper extract?

| Field | Type | Description |
|-------|------|-------------|
| **companyName** | String | Registered company name (dénomination) |
| **siren** | String | 9-digit SIREN identifier |
| **siret** | String | 14-digit SIRET of the head office (siège) |
| **legalForm** | String | Legal form label (SA, SARL, SAS, EURL, etc.) |
| **legalCategoryCode** | String | INSEE legal category code (catégorie juridique) |
| **nafCode** | String | NAF/APE activity code (e.g. `10.71A`) |
| **nafLabel** | String | Description of the NAF activity |
| **activitySector** | String | Broader activity domain (domaine d'activité) |
| **address** | String | Head-office street address |
| **postalCode** | String | 5-digit French postal code |
| **city** | String | Head-office city |
| **department** | String | French department code derived from the postal code |
| **latitude** | Number | Head-office latitude |
| **longitude** | Number | Head-office longitude |
| **status** | String | Consolidated status (`actif`, ceased, etc.) |
| **rcsStatus** | String | RCS registration status (statut RCS) |
| **ceased** | Boolean | Whether the company has ceased activity |
| **creationDate** | String | Company creation date (ISO) |
| **employeeRange** | String | Headcount bracket (tranche d'effectif) |
| **employeeCountYear** | Number | Reference year of the headcount |
| **shareCapital** | Number | Share capital amount in euros |
| **revenue** | Number | Latest reported revenue (chiffre d'affaires) |
| **financialsYear** | Number | Reference year of the financials |
| **isEmployer** | Boolean | Whether the company is an employer |
| **isNonProfit** | Boolean | Whether it belongs to the social/solidarity economy |
| **url** | String | Link to the company page on Pappers |
| **scrapedAt** | String | ISO timestamp of extraction |

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| **Company Name / Activity Keywords** | String | `boulangerie` | Search by company name or activity (in French) |
| **SIREN Filter** | String | — | Keep only the company with this 9-digit SIREN |
| **Department Filter** | String | — | Keep only companies in this department (`75`, `69`, `971`, …) |
| **Active Companies Only** | Boolean | `false` | Exclude ceased companies |
| **Max Results** | Integer | `100` | Maximum companies to return (endpoint returns up to 100 per query) |
| **Proxy Configuration** | Object | FR proxy | Proxy settings (French proxy recommended) |

### Example output

```json
{
    "companyName": "CARREFOUR",
    "siren": "652014051",
    "siret": "65201405100732",
    "legalForm": "SA à conseil d'administration (s.a.i.)",
    "legalCategoryCode": "5599",
    "nafCode": "64.20Z",
    "nafLabel": "Activités des sociétés holding",
    "activitySector": "Activités des services financiers, hors assurance et caisses de retraite",
    "address": "93 AVENUE DE PARIS",
    "postalCode": "91300",
    "city": "MASSY",
    "department": "91",
    "latitude": 48.7234959998,
    "longitude": 2.2652320000,
    "status": "actif",
    "rcsStatus": "Inscrit",
    "ceased": false,
    "creationDate": "1963-01-01",
    "employeeRange": "Entre 3 et 5 salariés",
    "employeeCountYear": 2022,
    "shareCapital": 1840786972.5,
    "revenue": 0,
    "financialsYear": 2024,
    "isEmployer": false,
    "isNonProfit": false,
    "url": "https://www.pappers.fr/entreprise/652014051",
    "scrapedAt": "2026-07-09T21:09:31.558Z"
}
````

### Common use cases

- Build B2B prospecting lists for a specific trade and department.
- Enrich a CRM with SIREN, SIRET, legal form, and NAF codes.
- Verify a supplier's legal identity and activity before signing.
- Map competitors in a region by activity code.
- Feed French company data into market-research and scoring pipelines.

### Cost estimate

Pricing is pay-per-result. Each run returns up to 100 companies per search query, so a full search costs roughly the per-item price times the number of companies returned. Because the actor reads a single lightweight JSON endpoint, compute cost per run is negligible.

### Limitations

- The public search endpoint returns up to 100 matches per query. For broader coverage, run several targeted queries (by activity, by region, by name fragment).
- SIREN and department filters are applied to the results of the keyword search — pair them with a name or activity keyword for best results.
- Financial fields (revenue, share capital) reflect the latest figures Pappers has on file and may be missing for some smaller entities.
- This actor reads head-office (siège) data. It does not enumerate every secondary establishment (établissement) of a company.

### Related scrapers

- **Italian Company Register Scraper (Registro Imprese)** — company data for Italy.
- **KVK Scraper** — company data from the Dutch Chamber of Commerce.
- **Handelsregister Scraper** — company data from the German commercial register.

### Data source and legality

This actor reads publicly available company data that Pappers republishes from the official French SIRENE and RCS registers. It does not access any login-protected or paid area. Use the data in line with Pappers' terms and applicable data-protection rules.

# Actor input Schema

## `searchQuery` (type: `string`):

Search for French companies by name or business activity. Example: 'boulangerie', 'Carrefour', 'restaurant', 'plombier'.

## `siren` (type: `string`):

Optional. Keep only the company whose 9-digit SIREN matches this value. Applied to the search results (combine with a name query).

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

Optional. Keep only companies whose head office is in this French department. Use the 2-digit code. Example: '75' (Paris), '69' (Rhône), '13' (Bouches-du-Rhône), '971' (Guadeloupe).

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

Only return companies whose consolidated status is active. Excludes ceased companies.

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

Maximum number of companies to return. The Pappers search endpoint returns up to 100 matches per query.

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

Select proxies to use. French residential proxies recommended for geo-consistent results.

## Actor input object example

```json
{
  "searchQuery": "boulangerie",
  "activeOnly": false,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}
```

# 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 = {
    "searchQuery": "boulangerie",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "FR"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/pappers-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 = {
    "searchQuery": "boulangerie",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "FR",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/pappers-scraper").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 '{
  "searchQuery": "boulangerie",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "FR"
  }
}' |
apify call studio-amba/pappers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=studio-amba/pappers-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Pappers Scraper — French Company Register (SIREN/SIRET) Data",
        "description": "Search and extract French company data from Pappers. Look up companies by name or activity and get SIREN, SIRET, legal form, NAF code, address, status, share capital, revenue, and headcount. No API key, no login required.",
        "version": "0.0",
        "x-build-id": "OlJXVvLsqKKfgETOj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~pappers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-pappers-scraper",
                "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/studio-amba~pappers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-pappers-scraper",
                "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/studio-amba~pappers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-pappers-scraper",
                "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",
                "properties": {
                    "searchQuery": {
                        "title": "Company Name / Activity Keywords",
                        "type": "string",
                        "description": "Search for French companies by name or business activity. Example: 'boulangerie', 'Carrefour', 'restaurant', 'plombier'."
                    },
                    "siren": {
                        "title": "SIREN Filter",
                        "type": "string",
                        "description": "Optional. Keep only the company whose 9-digit SIREN matches this value. Applied to the search results (combine with a name query)."
                    },
                    "departement": {
                        "title": "Department Filter",
                        "type": "string",
                        "description": "Optional. Keep only companies whose head office is in this French department. Use the 2-digit code. Example: '75' (Paris), '69' (Rhône), '13' (Bouches-du-Rhône), '971' (Guadeloupe)."
                    },
                    "activeOnly": {
                        "title": "Active Companies Only",
                        "type": "boolean",
                        "description": "Only return companies whose consolidated status is active. Excludes ceased companies.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of companies to return. The Pappers search endpoint returns up to 100 matches per query.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to use. French residential proxies recommended for geo-consistent results.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "FR"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
