# France BODACC Watch: Insolvency and Company Events by SIREN (`atesen-software/bodacc-siren-watch`) Actor

Watch the French BODACC gazette by SIREN or across France. Insolvency, liquidation, receivership, conciliation, sales, deregistrations and filings from DILA open data, classified by event and risk level. Only-new mode for daily alerts. Natural persons are never returned.

- **URL**: https://apify.com/atesen-software/bodacc-siren-watch.md
- **Developed by:** [Atesen Software](https://apify.com/atesen-software) (community)
- **Categories:** Business, Automation, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 bodacc notices

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 BODACC Watch: Insolvency and Company Events by SIREN

Watch the French **BODACC** (Bulletin officiel des annonces civiles et commerciales) for the companies you care about, or scan the whole gazette. The Actor reads the official DILA open data and returns one clean row per notice: **liquidation, receivership (redressement judiciaire), safeguard procedure (sauvegarde), conciliation agreements, closures, business sales and mergers, deregistrations, dissolutions, new registrations and filed accounts**. Every row has the SIREN, the event type, a plain-English label, a rule-based risk level and a link to the original notice.

Typical uses: **supplier and customer insolvency monitoring**, B2B credit-risk alerts, KYB and onboarding checks, accounts-receivable collections, M\&A and distressed-asset deal sourcing, restructuring and insolvency-practitioner lead lists, and sector or region trend reports.

### What you get

- **SIREN watchlist**: paste SIREN (9 digits) or SIRET (14 digits) numbers, one per line. Check digits are validated.
- **Whole-gazette scan**: filter by event type, French department and minimum risk level instead.
- **Only new notices**: switch on `onlyNewSinceLastRun`, schedule the Actor daily, and every run returns only notices that were not delivered before. Corrections and cancellations published by BODACC arrive as new rows (`noticeType` = `correction` or `cancellation`, with `correctsNoticeId`).
- **Event classification**: `eventCode` (for example `liquidation_opened`, `receivership_opened`, `safeguard_opened`, `closed_insufficient_assets`, `conciliation_agreement_homologated`, `merger_project`, `dissolution_or_cessation`), `eventLabel`, the official French `eventNature`, and `riskLevel` (`info`, `medium`, `high`, `critical`).
- **Dates that matter**: publication date, judgment date and, for openings of insolvency procedures, the date of cessation of payments when the notice states it.
- **Source and attribution on every row**: `source`, `attribution`, `noticeUrl` (the notice on bodacc.fr).

### Input

| Field | What it does |
|---|---|
| `eventTypes` | `insolvency`, `conciliation`, `sales`, `deregistrations`, `registrations`, `modifications`, `accounts`. Default: insolvency and conciliation. |
| `sirens` | Watchlist of SIREN or SIRET numbers. Empty = all companies. |
| `lookbackDays` / `dateFrom` / `dateTo` | Publication window. Up to 366 days, or 1830 days with a watchlist. |
| `departments` | Keep only these departments (75, 13, 2A, 971...). |
| `minRiskLevel` | Return only notices at or above `info`, `medium`, `high` or `critical`. |
| `onlyNewSinceLastRun` / `stateKey` / `stateStore` | Alert-feed mode, the name of its memory and the key-value store that holds it. |
| `maxResults` | Stop after this many notices. Set a low number for a test. |

Example input, a supplier watchlist checked every day:

```json
{
  "sirens": ["503309007", "328 770 854"],
  "eventTypes": ["insolvency", "conciliation", "modifications"],
  "lookbackDays": 30,
  "onlyNewSinceLastRun": true,
  "maxResults": 500
}
```

### Output

One row per notice (illustrative values):

```json
{
  "siren": "123456782",
  "companyName": "EXEMPLE INDUSTRIE SAS",
  "companyNameWithheld": false,
  "legalForm": "Societe par actions simplifiee",
  "eventCategory": "collective",
  "eventCode": "liquidation_opened",
  "eventLabel": "Compulsory liquidation (liquidation judiciaire) opened",
  "eventNature": "Jugement d'ouverture de liquidation judiciaire",
  "riskLevel": "critical",
  "noticeType": "initial",
  "publishedDate": "2026-11-04",
  "judgmentDate": "2026-11-03",
  "cessationOfPaymentsDate": "2026-04-30",
  "court": "Greffe du Tribunal de Commerce de Lyon",
  "department": "69",
  "city": "Lyon",
  "noticeId": "A202602152001",
  "noticeUrl": "https://www.bodacc.fr/pages/annonces-commerciales-detail/?q.id=id:A202602152001",
  "source": "BODACC - Bulletin officiel des annonces civiles et commerciales (DILA)",
  "attribution": "Source: DILA ... BODACC ... Licence Ouverte 2.0 (Etalab); notice publication date in publishedDate. Reformatted and classified by Atesen Software; not an official DILA product and not endorsed by DILA."
}
```

The dataset has a **Notices** table view. A `RUN_SUMMARY` record in the key-value store lists counts per event code, skipped notices, and whether the run was complete.

### Risk levels

`riskLevel` is a fixed mapping from the event, not a credit score and not a prediction. `critical`: liquidation opened, procedure converted into liquidation. `high`: receivership or safeguard opened, plan terminated, liquidation closed for insufficient assets, liquidation resumed. `medium`: plans adopted or modified, other judgments, conciliation agreements, deregistration, dissolution or cessation of activity. `info`: routine filings, registrations, sales, mergers, accounts.

### Privacy

The notices name liquidators, administrators, managers and private individuals. This Actor does **not** copy the notice texts. They are read only to choose the event code and the risk level, and the link `noticeUrl` leads to the full notice on bodacc.fr.

- Notices about **natural persons** (sole traders, EI/EIRL, micro-entrepreneurs, private individuals) are **never returned**, and there is no option to include them. A notice is kept only when BODACC types the registrant as a legal entity and the legal form or name does not point to a natural person.
- If the name of a legal entity looks like a person's name (two or three plain words, for example a company named after its owner), `companyName`, `activity`, `city` and `postalCode` are withheld and `companyNameWithheld` is `true`; the SIREN, the event and the link to the notice remain. The rule is a conservative heuristic, so some ordinary company names are withheld too.
- Single-member companies (EURL, SASU) are legal entities and are returned with their registered office city and postal code (no street). That office can be the owner's home; handle those rows with the same care.
- Notices of **personal sanctions** (personal bankruptcy, management bans) are never returned.
- No e-mail addresses, phone numbers, liquidator or manager names are output.

### Source and licence

Data: BODACC open data published by DILA (Direction de l'information legale et administrative) through the Opendatasoft portal `bodacc-datadila.opendatasoft.com`, under the Licence Ouverte 2.0 (Etalab), which allows reuse including commercial use with attribution. The licence asks you to credit the source and the date of the information: the `attribution` field carries the credit and `publishedDate` the date; keep both when you republish, and do not suggest that DILA endorses your product. DILA reminds reusers that the data protection law still applies to personal data.

### Limits (read before you rely on it)

- BODACC is not real time. A court decision appears in the gazette some days after it is taken, and not every procedure is published.
- Not a legal or credit opinion. Check the original notice (`noticeUrl`) before acting on a row.
- Only BODACC. Company status, accounts figures and beneficial owners are not in this data.
- The notice texts are not returned (see Privacy). Some generic judgments therefore appear as `other_judgment` with a few neutral tags in `mentions`.
- `accounts` is a very large stream (thousands of notices per day). Use it with a watchlist or a low `maxResults`.
- A publication day with more than 10,000 matching notices is cut at that number and the run says so; narrow the filters.
- Only-new mode keeps notice ids in a key-value store. Pick or create one in **Memory store (pick one)** and use it for every run of that watchlist; this also works with limited Actor permissions. If you change the filters, use a new `stateKey`, because reading restarts a few days before the last fully covered day.
- Without a picked store the Actor tries the named store `bodacc-watch-state` in your account. If that store cannot be opened, the run still succeeds, but there is no history: every notice counts as new, nothing is remembered for the next run, and the run notes say so.

### Use via API

One request runs the Actor, waits for it and returns the dataset items as JSON. Send your token in the `Authorization` header, not in the URL:

```bash
curl -X POST "https://api.apify.com/v2/acts/atesen-software~bodacc-siren-watch/run-sync-get-dataset-items?timeout=120" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"eventTypes":["insolvency"],"lookbackDays":7,"maxResults":10}'
```

The synchronous endpoint waits up to 300 seconds. For longer jobs start a run with `POST https://api.apify.com/v2/acts/atesen-software~bodacc-siren-watch/runs` and read the dataset when it finishes.

**JavaScript** (`npm install apify-client`):

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('atesen-software/bodacc-siren-watch').call({ eventTypes: ["insolvency"], lookbackDays: 7, maxResults: 10 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with AI agents (MCP)

Claude Desktop, Cursor, VS Code and other MCP clients can call this Actor as a tool through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). Load only this Actor with:

```text
https://mcp.apify.com?tools=atesen-software/bodacc-siren-watch
```

Client config (sign in with Apify OAuth when the browser opens, or add an `Authorization: Bearer <APIFY_TOKEN>` header instead):

```json
{
  "mcpServers": {
    "apify": { "url": "https://mcp.apify.com?tools=atesen-software/bodacc-siren-watch" }
  }
}
```

Then ask in plain words, for example: "List French companies with an insolvency notice in BODACC in the last 7 days." The agent fills the same input fields you see on the Input tab, and runs are billed to your Apify account at the prices on the Pricing tab.

### Pricing

**Maximum items is a hard cap on charged rows.** Set `maxItems` in the run options (or `?maxItems=` in the API) and the run stops after that many notices: it never writes or charges more rows than that number. Leave it empty for no cap. Free status rows are not counted.

### FAQ

**How do I get an alert when a supplier enters insolvency?** Put the supplier SIREN numbers in `sirens`, choose `insolvency`, switch on `onlyNewSinceLastRun`, and schedule the Actor daily. Use an Apify webhook, Make, Zapier or the API to forward new rows.

**Can I monitor all insolvencies in a region?** Yes: leave `sirens` empty, choose `insolvency` and set `departments`.

**Where does the SIREN come from for associations or foreign entities?** From the register number in the notice. Some entities have none, then `siren` is `null`.

**What happens when the source is unreachable?** The run ends with a message. Rows already delivered stay in the dataset, an empty or failed run charges nothing, and with only-new mode the missing notices follow in the next run.

**Does the Actor stop at my budget?** Yes. Set a maximum charge for the run on the Apify run options; the Actor stops cleanly before it would exceed it.

Made by Atesen Software.

### Related actors

- [SIRENE API & SIRET Lookup: French Company Data in Bulk](https://apify.com/atesen-software/french-company-enrichment-sirene)
- [France New Companies Feed: SIRENE Leads, Opt-Outs Removed](https://apify.com/atesen-software/france-new-companies-feed)
- [French Company Financials API: Revenue, EBITDA & Ratios](https://apify.com/atesen-software/french-company-financials-ratios)

# Actor input Schema

## `eventTypes` (type: `array`):

Which kinds of BODACC notices to return. insolvency = procedures collectives (safeguard, receivership, liquidation, plans, closures); conciliation = court-approved conciliation agreements; sales = sales and transfers of businesses, mergers; deregistrations = removals from the commercial register; registrations = new companies and establishments; modifications = changes such as dissolution, cessation of activity, capital or management; accounts = annual accounts filed (a very large stream).

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

SIREN (9 digits) or SIRET (14 digits) numbers of the companies to watch, one per line, for example your suppliers or customers. Spaces are allowed. Numbers with a wrong check digit are ignored with a warning. Leave empty to scan the whole gazette. With a watchlist the date window can reach back up to 1830 days.

## `lookbackDays` (type: `integer`):

How many days of publications to read, counted back from today (or from dateTo). Ignored when dateFrom is set. At most 366 days without a SIREN watchlist, 1830 days with one.

## `dateFrom` (type: `string`):

First publication day, format YYYY-MM-DD. Overrides the look-back days.

## `dateTo` (type: `string`):

Last publication day, format YYYY-MM-DD. Default: today.

## `departments` (type: `array`):

Keep only notices of these French departments, for example 75 (Paris), 13, 69, 2A, 971. Empty = all of France.

## `minRiskLevel` (type: `string`):

Every notice gets a risk level from its event: info (routine filings), medium (plans, other judgments, deregistration, dissolution), high (receivership, safeguard, closed for insufficient assets, plan terminated), critical (liquidation). Notices below this level are not returned and not charged.

## `onlyNewSinceLastRun` (type: `boolean`):

Return only notices not delivered by an earlier run with the same filters (corrections and cancellations count as new notices). The first run returns everything in the window. Schedule the Actor daily with this switch on to get an alert feed. Delivered ids are kept in a named key-value store (no names, no texts). After a complete run, reading restarts a few days before the last covered day, so an older window needs a different memory name.

## `stateKey` (type: `string`):

Name of the 'already delivered' memory used by the only-new mode. Default: derived from your filters, so different watchlists never share a memory. Set the same name in several schedules to share one.

## `stateStore` (type: `string`):

Key-value store that keeps the 'already delivered' memory between runs. Pick or create a store here to use the only-new mode. This works with the Actor's limited permissions. Leave it empty to use the named store 'bodacc-watch-state' in your account, or to run without memory.

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

Stop after this many returned notices. Each returned notice is one billed event; set a low number for a test. Hard cap: the run never writes or charges more rows than this.

## `maxRuntimeSeconds` (type: `integer`):

0 = use the platform timeout. When the limit is reached the run stops cleanly and reports a partial result.

## Actor input object example

```json
{
  "eventTypes": [
    "insolvency",
    "conciliation"
  ],
  "sirens": [
    "503309007",
    "328 770 854"
  ],
  "lookbackDays": 7,
  "dateFrom": "2026-10-01",
  "dateTo": "2026-10-31",
  "departments": [
    "75",
    "92"
  ],
  "minRiskLevel": "info",
  "onlyNewSinceLastRun": false,
  "maxResults": 10,
  "maxRuntimeSeconds": 0
}
```

# Actor output Schema

## `notices` (type: `string`):

No description

## `runSummary` (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 = {
    "eventTypes": [
        "insolvency",
        "conciliation"
    ],
    "lookbackDays": 7,
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("atesen-software/bodacc-siren-watch").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 = {
    "eventTypes": [
        "insolvency",
        "conciliation",
    ],
    "lookbackDays": 7,
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("atesen-software/bodacc-siren-watch").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 '{
  "eventTypes": [
    "insolvency",
    "conciliation"
  ],
  "lookbackDays": 7,
  "maxResults": 10
}' |
apify call atesen-software/bodacc-siren-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,atesen-software/bodacc-siren-watch"
        }
    }
}
```

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/e98zQW9eqEW0yhhVX/builds/uL6cVtFgp9fesdhcm/openapi.json
