# France Supplier Verifier | SIREN & Name Match (`krabani/france-supplier-verifier`) Actor

Match French supplier lists by SIREN or legal name using official administrative data. Keep your row IDs, review ambiguous candidates, and export legal-entity facts. No source API key required. Strict privacy exclusions. Not a credit or solvency assessment.

- **URL**: https://apify.com/krabani/france-supplier-verifier.md
- **Developed by:** [Krabani](https://apify.com/krabani) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 supplier row checkeds

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

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

## What's an Apify Actor?

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

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

## How to integrate an Actor?

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

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

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

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

# README

## France Supplier Verifier | SIREN & Name Match

### Match your French supplier list to legal entities

Keep your supplier row IDs and check French legal entities against official administrative data. Use a SIREN for a direct identity check, or a legal name with a postal code or commune to find a match or candidates for review.

For procurement operations and supplier data cleanup, the Actor returns one result per input row in a completed run. Matched rows include the legal name, active/closed administrative status, creation date and age, company-size category, employee-size class and its reference year, NAF activity code, check time, and available source update time. Missing source values remain `null`.

The only runtime source is the official API Recherche d'entreprises, operated by DINUM/data.gouv.fr. The Actor uses its SIRENE administrative fields. No source API key or external AI service is required.

### Check a 3-row supplier sample

Paste this into the Actor input and run it:

```json
{
  "rows": [
    { "buyer_row_id": "supplier-001", "siren": "356000000" },
    { "buyer_row_id": "supplier-002", "company_name": "FSVZZZXNOEXIST20261107" },
    { "buyer_row_id": "supplier-003" }
  ]
}
```

This sample completed locally in 17.83 seconds in the recorded 8 November 2026 test (Asia/Jayapura). Startup time, source availability, and throttling vary; this is an observation, not a 60-second guarantee. At the listed price, its two eligible row events are USD 0.02. The invented name deliberately demonstrates a negative result; the last row demonstrates a missing identifier.

Input supports 1 to 1,000 rows. Each needs a unique, nonempty string `buyer_row_id`. Use an internal identifier without personal information. Optional fields are `siren`, `company_name`, `postal_code`, and `commune`.

- A SIREN must contain nine ASCII digits and pass Luhn. All-zero and invalid SIRENs return `needs_identifier` without a source request, even when a name is present.
- A valid SIREN takes priority over the name and location.
- For a name search, include a postal code or commune when available. Commune accepts a label or INSEE commune code. Postal codes need five digits and a prefix from 01 to 98. Unsupported postal formats reject the whole input before lookups or row events.
- Input is JSON. Export results as JSON or CSV from the default dataset. Up to three candidates for an ambiguous row are easiest to inspect in JSON.

### Example output

Actual output from the recorded 8 November 2026 local sample, abbreviated to selected fields. Timestamps are UTC. These dated examples do not replace a new check. Ordinary full output includes the remaining administrative fields, candidates, source URL, and attribution.

```json
[
  {
    "buyer_row_id": "supplier-001",
    "match_status": "matched",
    "match_reason": "exact_siren",
    "confidence": "high",
    "siren": "356000000",
    "company_name": "LA POSTE",
    "administrative_status": "active",
    "creation_date": "1991-01-01",
    "age_years": 35,
    "company_size_category": "GE",
    "company_size_reference_year": "2024",
    "employee_size_class": "53",
    "employee_reference_year": "2024",
    "naf_code": "53.10Z",
    "naf_version": null,
    "source_updated_at": "2026-07-10T10:25:02",
    "checked_at": "2026-11-07T15:49:19+00:00"
  },
  {
    "buyer_row_id": "supplier-002",
    "match_status": "not_found",
    "match_reason": "no_eligible_name_and_location_result_in_public_api",
    "confidence": "low",
    "siren": null,
    "company_name": null,
    "checked_at": "2026-11-07T15:49:20+00:00"
  },
  {
    "buyer_row_id": "supplier-003",
    "match_status": "needs_identifier",
    "match_reason": "missing_siren_and_searchable_name",
    "confidence": "low",
    "siren": null,
    "company_name": null,
    "checked_at": "2026-11-07T15:49:20+00:00"
  }
]
```

Check `SUMMARY` in the default key-value store before treating the dataset as a complete list. Join results to your original records using `buyer_row_id`. Review candidates or request a SIREN for unresolved rows; never accept the first candidate as a confirmed identity.

### Pricing and limitations

**USD 0.01 per checked row, or USD 10 per 1,000 checked rows.** The single event is `row-verified`. A checked row means one completed result with status `matched`, `ambiguous`, or `not_found`. A successful identity match is not required for this event.

| Result | Meaning | Row event |
| --- | --- | --- |
| `matched` | Direct SIREN match, or one exact normalized legal-name match in a complete bounded search, consistent with any supplied location | USD 0.01 |
| `ambiguous` | Identity needs manual review; up to three eligible candidates, sometimes none when safe evidence is insufficient | USD 0.01 |
| `not_found` | No eligible identity established in this public API | USD 0.01 |
| `needs_identifier` | Supply or correct the SIREN or name | No charge |
| `privacy_excluded` | Diffusion status is restricted, missing, or unknown | No charge |
| `out_of_scope` | Legal category is excluded or unsupported | No charge |

An ambiguous row with three candidates is one event. For example, four matched, four ambiguous, two not-found, two identifier-error, and one excluded row would create ten events: USD 0.10. There is no separate Actor startup or dataset-item event. Standard-run infrastructure is included in the event price. Subsequent dataset/storage interactions can incur Apify platform costs; see [Apify's Store usage documentation](https://docs.apify.com/actors/running/actors-in-store).

A new verification run may charge again for the same supplier. Set a maximum run charge in Apify before running a large batch. Source errors do not become paid negative results. Eligible completed rows in a partial run can still be charged. If charge and delivery status disagree after an interruption, stop and raise an issue with the run ID; do not repeatedly restart the run. The operator must review uncertain billing and delivery before recovery. Automatic replay or refunds are not promised.

#### What the check can establish

This is administrative reconciliation, not a credit rating, solvency or payment-capacity assessment, sanctions check, or guarantee of supplier quality. Active status does not establish that a company is trading, financially healthy, or approved for onboarding.

- Prefer SIRENs. Legal names, brands, and acronyms can refer to several legal entities. Registered acronyms, commercial names, establishment signs, shortened names, and supported one-character spelling variants produce candidates for manual review. They do not automatically establish identity. Short acronyms are not fuzzy-matched. A single-word typo that the source does not retrieve can remain unresolved.
- Name searches are bounded. Primary retrieval covers up to two pages of 25 companies; broader retrieval adds up to two pages, then refreshes up to three candidates. Broad or incomplete retrieval never establishes uniqueness. A name row can use up to seven requests before bounded retries.
- `confidence` is a rule label, not a probability or risk score. Exact SIREN is `high`; exact normalized legal-name evidence is `medium`; unresolved and negative rows are `low`. Candidate evidence does not resolve an ambiguous row.
- The public API can omit records or lag behind updates. `not_found` does not prove that a company does not exist. Source update time is reported only when supplied; it is not an index-refresh timestamp. `checked_at` is the Actor's UTC check time.
- The source does not provide an explicit primary NAF nomenclature version, so `naf_version` is `null`. Statistical company-size and employee-size fields include their available reference years and may differ from today's workforce.
- Corporate legal forms in a verified 151-code allowlist are supported. Individual entrepreneurs, associations, administrative bodies, and unknown or unsupported legal forms are out of scope. See the [official legal-category nomenclature](https://www.insee.fr/fr/information/2028129).
- Requests are sequential, capped at 30 per minute per run, including retries. HTTP 429 is handled with `Retry-After` and bounded backoff. A 1,000-row batch needs roughly 34 minutes for source request spacing alone at one request per row; difficult name searches can take substantially longer. Start with small batches and allow for the run timeout. A 1,000-row production workload has not been benchmarked.
- An upstream failure, budget limit, or interruption can leave a partial dataset. Inspect completion and remaining rows in `SUMMARY`. Uncertain charge/delivery needs operator review. Change monitoring and a spreadsheet upload interface are outside this MVP.

### Privacy policy

Submit company identifiers and names only. Do not submit officers, people, contact details, or street addresses. Use opaque `buyer_row_id` values.

The Actor excludes individual entrepreneurs in legal category 1000 and all units with diffusion P, missing status, or unknown status. It also requires safe diffusion status for headquarters and any included matching establishment. Unsupported legal categories are excluded. An excluded result contains exactly `buyer_row_id` and `match_status`; it does not repeat the submitted name, SIREN, location, or other fields.

Source responses are immediately reduced to approved administrative fields. Officers, elected people, personal fields, street addresses, coordinates, finances, tax identifiers, and unrecognized fields are discarded before business processing. Registered corporate aliases are used temporarily for matching and are not written to output or the recovery journal. Supplier data is not sent to AI services or another data provider.

Raw inputs and upstream responses are not written to Actor logs. Apify still stores the input submitted with a run. Results and a minimal recovery journal are stored in the run's dataset/key-value store; the journal contains safe outputs and a one-way input fingerprint. Apify access controls, retention, and deletion settings apply. Downloaded copies remain under your control. This product does not claim zero retention.

### Attribution

Source : API Recherche d'entreprises (DINUM/data.gouv.fr), données SIRENE (Insee); Licence Ouverte 2.0. Analyse dérivée indépendante.

This product is not affiliated with or endorsed by the French government, DINUM, data.gouv.fr, or Insee.

Official references: [API documentation](https://recherche-entreprises.api.gouv.fr/docs/), [SIRENE dataset](https://www.data.gouv.fr/datasets/base-sirene-des-entreprises-et-de-leurs-etablissements-siren-siret), and [Licence Ouverte 2.0](https://www.data.gouv.fr/pages/legal/licences/etalab-2-0).

# Actor input Schema

## `rows` (type: `array`):

1 to 1000 rows with unique opaque buyer_row_id, optional SIREN, legal name and postal code or commune. Invalid SIRENs receive needs_identifier.

## Actor input object example

```json
{
  "rows": [
    {
      "buyer_row_id": "supplier-001",
      "siren": "356000000"
    },
    {
      "buyer_row_id": "supplier-002",
      "company_name": "FSVZZZXNOEXIST20261107"
    },
    {
      "buyer_row_id": "supplier-003"
    }
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "rows": [
        {
            "buyer_row_id": "supplier-001",
            "siren": "356000000"
        },
        {
            "buyer_row_id": "supplier-002",
            "company_name": "FSVZZZXNOEXIST20261107"
        },
        {
            "buyer_row_id": "supplier-003"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("krabani/france-supplier-verifier").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 = { "rows": [
        {
            "buyer_row_id": "supplier-001",
            "siren": "356000000",
        },
        {
            "buyer_row_id": "supplier-002",
            "company_name": "FSVZZZXNOEXIST20261107",
        },
        { "buyer_row_id": "supplier-003" },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("krabani/france-supplier-verifier").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 '{
  "rows": [
    {
      "buyer_row_id": "supplier-001",
      "siren": "356000000"
    },
    {
      "buyer_row_id": "supplier-002",
      "company_name": "FSVZZZXNOEXIST20261107"
    },
    {
      "buyer_row_id": "supplier-003"
    }
  ]
}' |
apify call krabani/france-supplier-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,krabani/france-supplier-verifier"
        }
    }
}
```

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/LkPJdigjeK51gvUUP/builds/E6Af0qUVtUu4fuwoO/openapi.json
