# French Insolvency & Solvency Checker (BODACC) (`fit_melon/french-insolvency-checker-bodacc`) Actor

Bulk-check French companies for insolvency from a SIREN or SIRET. Reads official BODACC open data and returns one clear verdict per company: ongoing procedure (liquidation, redressement, sauvegarde), closed, or struck off. Free — great for CRM cleaning, lead screening and credit-risk checks.

- **URL**: https://apify.com/fit\_melon/french-insolvency-checker-bodacc.md
- **Developed by:** [D N](https://apify.com/fit_melon) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## French Insolvency & Solvency Checker (BODACC) — free

**Is this French company bankrupt?** Paste a list of SIREN or SIRET numbers and get one clear solvency verdict per company: is it under an insolvency proceeding (*procédure collective* — liquidation judiciaire, redressement judiciaire, sauvegarde), has that proceeding been closed, or has the company been struck off the register (*radiation*)? Data comes straight from the official **BODACC** open dataset published by DILA, so it never breaks and needs no API key.

This is a **verdict tool, not a raw announcement feed**: instead of dumping every legal notice, it reads a company's whole BODACC history and collapses it into a single, decision-ready row — perfect for cleaning a CRM, screening leads, or running a credit-risk pass before you sign a client.

This Actor is **free** — you only pay your own Apify platform usage.

### What it does

For each French company identifier you provide, the Actor:

1. Normalizes the input (SIREN 9 digits, or SIRET 14 → SIREN).
2. Pulls that company's announcements from the BODACC *annonces-commerciales* open data API.
3. Detects collective proceedings and strike-offs, orders them by date, and computes the **current** solvency state.
4. Returns one row with a plain-English verdict and a risk level.

Keywords: BODACC, procédure collective, liquidation judiciaire, redressement judiciaire, sauvegarde, radiation RCS, entreprise en faillite, solvabilité entreprise française, French company insolvency, bankruptcy check, credit risk, KYC, due diligence, SIREN, SIRET.

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `companyIds` | array of strings | yes | One SIREN (9 digits) or SIRET (14 digits) per line. |
| `maxAnnouncementsPerCompany` | integer | no | Announcements pulled per company before deciding (default 200). |

```json
{
  "companyIds": ["356000000", "443061841", "55203253400041"]
}
````

### Output

One dataset item per identifier. Example:

```json
{
  "status": "found",
  "input": "552032534",
  "siren": "552032534",
  "companyName": "ACME DISTRIBUTION",
  "solvencyVerdict": "procedure_ongoing",
  "hasActiveProcedure": true,
  "riskLevel": "high",
  "latestProcedureType": "liquidation_judiciaire",
  "latestProcedureLabel": "Jugement d'ouverture de liquidation judiciaire",
  "latestProcedureDate": "2024-03-10",
  "latestProcedureTribunal": "Tribunal de commerce de Lille",
  "procedureCount": 2,
  "struckOff": false,
  "struckOffDate": null,
  "announcementsAnalyzed": 7,
  "sourceUrl": "https://bodacc-datadila.opendatasoft.com/explore/dataset/annonces-commerciales/table/?q=552032534",
  "checkedAt": "2026-07-05T10:00:00.000Z"
}
```

**`solvencyVerdict`** is one of:

| Verdict | Meaning |
| --- | --- |
| `no_procedure` | No collective proceeding found in BODACC. |
| `procedure_ongoing` | An insolvency proceeding is open (see `latestProcedureType`). |
| `procedure_closed` | A past proceeding that has since been closed (*clôture*). |
| `struck_off` | Company struck off the RCS (*radiation*). |
| `no_bodacc_record` | No BODACC announcement at all for this SIREN (see limitations). |

**`riskLevel`**: `none` · `low` · `medium` · `high` · `unknown`. Every item also carries a `status` of `found`, `not_found`, or `error`, so a bad identifier never breaks the run.

### Use cases

- **Lead & CRM cleaning** — drop dead or bankrupt companies from a prospecting list in one pass.
- **Credit risk & AR** — screen new clients before granting payment terms.
- **KYC / due diligence** — a fast, official first check on a French counterparty.
- **Portfolio monitoring** — re-run on a schedule to catch a supplier or client entering a procedure.

### Limitations & fair use

- BODACC records **RCS-registered** entities. A `no_bodacc_record` verdict means "no announcement found" — it is **not** proof of good health (some healthy companies only ever have a creation notice, and micro-entrepreneurs may be absent).
- Announcements are the legal record; there is a normal publication delay of days to weeks after a court decision.
- Data source: official BODACC open data by **DILA**, under the [Licence Ouverte / Open Licence 2.0](https://www.etalab.gouv.fr/licence-ouverte-open-licence). This tool is not affiliated with DILA. Use the data responsibly and in line with the *loi Informatique et Libertés*.

### More free French-data Actors by this developer

Part of a free toolkit for French company data — **find → enrich → verify**:

- **French Company Data Enricher (SIREN, dirigeants)** — identity, legal form, directors, address from a SIREN.
- **EU VAT Number Validator (VIES)** — check a VAT number is live and valid.
- **French Legal Notice Generator (Mentions Légales, LCEN)** — LCEN-compliant legal notice from a SIREN.
- **New French Companies Finder (SIRENE)** — fresh company registrations by department / activity.

👉 See all Actors: **https://apify.com/fit\_melon**

# Actor input Schema

## `companyIds` (type: `array`):

List of French company identifiers to check — one 9-digit SIREN or 14-digit SIRET per line. Paste a column from your CRM or lead list. One result row is produced per identifier.

## `maxAnnouncementsPerCompany` (type: `integer`):

How many BODACC announcements to pull per company before deciding the verdict (newest first). 200 is plenty for the vast majority of companies.

## Actor input object example

```json
{
  "companyIds": [
    "356000000",
    "443061841",
    "552032534"
  ],
  "maxAnnouncementsPerCompany": 200
}
```

# 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 = {
    "companyIds": [
        "356000000",
        "443061841",
        "552032534"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fit_melon/french-insolvency-checker-bodacc").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 = { "companyIds": [
        "356000000",
        "443061841",
        "552032534",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fit_melon/french-insolvency-checker-bodacc").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 '{
  "companyIds": [
    "356000000",
    "443061841",
    "552032534"
  ]
}' |
apify call fit_melon/french-insolvency-checker-bodacc --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fit_melon/french-insolvency-checker-bodacc",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "French Insolvency & Solvency Checker (BODACC)",
        "description": "Bulk-check French companies for insolvency from a SIREN or SIRET. Reads official BODACC open data and returns one clear verdict per company: ongoing procedure (liquidation, redressement, sauvegarde), closed, or struck off. Free — great for CRM cleaning, lead screening and credit-risk checks.",
        "version": "0.0",
        "x-build-id": "Zx4OpimGbWWkQRqsr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fit_melon~french-insolvency-checker-bodacc/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fit_melon-french-insolvency-checker-bodacc",
                "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/fit_melon~french-insolvency-checker-bodacc/runs": {
            "post": {
                "operationId": "runs-sync-fit_melon-french-insolvency-checker-bodacc",
                "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/fit_melon~french-insolvency-checker-bodacc/run-sync": {
            "post": {
                "operationId": "run-sync-fit_melon-french-insolvency-checker-bodacc",
                "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": [
                    "companyIds"
                ],
                "properties": {
                    "companyIds": {
                        "title": "Company IDs (SIREN or SIRET)",
                        "type": "array",
                        "description": "List of French company identifiers to check — one 9-digit SIREN or 14-digit SIRET per line. Paste a column from your CRM or lead list. One result row is produced per identifier.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxAnnouncementsPerCompany": {
                        "title": "Max announcements analysed per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "How many BODACC announcements to pull per company before deciding the verdict (newest first). 200 is plenty for the vast majority of companies.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
