# BODACC API: Company Creations, Sales, Insolvencies (`actose/bodacc-announcements`) Actor

French BODACC announcements as JSON: company, SIREN, legal form, activity, judgment (liquidation, receivership), sale price, accounts. Filter by type, department, dates, keywords, SIREN. onlyNew for daily monitoring. No API key, no login. MCP-ready. Pay per result. $0.80 per 1,000 announcements

- **URL**: https://apify.com/actose/bodacc-announcements.md
- **Developed by:** [ABM](https://apify.com/actose) (community)
- **Categories:** Lead generation, Business, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.68 / 1,000 announcements

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## BODACC API: Company Creations, Sales, Insolvencies (France)

**$0.80 per 1,000 announcements ($0.0008 each). No API key, no login, no monthly rental. Errors, duplicates and empty results are free.**

This Actor returns the official **BODACC** announcements (*Bulletin officiel des annonces civiles et commerciales*, France) as clean, structured JSON: new companies, business sales and transfers, collective proceedings (safeguard, receivership, judicial liquidation), deregistrations, filing of annual accounts and other legal notices.

It reads the official open data published by the DILA (French legal information directorate), so results are stable and complete, and it decodes the nested BODACC data into flat camelCase fields: company name, SIREN, legal form, activity, share capital, head office address, court, judgment nature and date, sale price, previous owner, accounts closing date, plus a Markdown `text` field ready for LLMs.

### What can you filter on?

| Filter | Example |
|---|---|
| Announcement type | `creation`, `vente` (sale/transfer), `collective` (insolvency), `radiation`, `dpc` (accounts), `modification`, `immatriculation`, `conciliation`... |
| Department | `"31"`, `"75"`, `"2A"`, `"971"` |
| Publication dates | `dateFrom`, `dateTo` or `daysBack` |
| Keywords (full text) | `"boulangerie"`, `"liquidation judiciaire"` (any / all) |
| SIREN | `"453439465"`, `"453 439 465"` or a 14-digit SIRET |
| Only new | `onlyNew: true` returns only announcements not delivered by your previous runs |

### How much does it cost?

You pay one `announcement` event per announcement written to your dataset: **$0.0008**.

- 15 latest insolvencies in one department: **$0.012**
- 1,000 announcements: **$0.80**
- 30,000 new companies (a month of France-wide creations): **$24**
- Daily monitoring of one department with `onlyNew` (~20 new notices a day): **about $0.50 per month**

Nothing is charged for invalid SIRENs, filters that match nothing, duplicates or parsing errors. When your maximum charge per run is reached, the Actor stops cleanly; it never delivers unpaid "preview" items.

### Input example

The 15 latest collective proceedings (insolvencies) in Haute-Garonne:

```json
{
  "announcementTypes": ["collective"],
  "departments": ["31"],
  "maxResults": 15
}
```

### Output example

```json
{
  "id": "A202601952716",
  "url": "https://www.bodacc.fr/pages/annonces-commerciales-detail/?q.id=id:A202601952716",
  "publication": "A",
  "publicationName": "BODACC A (sales, creations, collective proceedings)",
  "issueNumber": "20260195",
  "announcementNumber": 2716,
  "publicationDate": "2026-10-10",
  "family": "collective",
  "familyLabel": "Procédures collectives",
  "noticeType": "annonce",
  "noticeTypeLabel": "Avis initial",
  "companyName": "CERES",
  "siren": "912345678",
  "sirens": ["912345678"],
  "registry": "Toulouse",
  "personType": "company",
  "legalForm": "Société par actions simplifiée",
  "activity": "Boulangerie, pâtisserie, viennoiserie",
  "shareCapital": 5000,
  "shareCapitalCurrency": "EUR",
  "headOfficeAddress": "12 rue des Blés, 31000 Toulouse",
  "city": "Toulouse",
  "postalCode": "31000",
  "departmentCode": "31",
  "departmentName": "Haute-Garonne",
  "regionCode": "76",
  "regionName": "Occitanie",
  "court": "Greffe du Tribunal de Commerce de Toulouse",
  "judgmentFamily": "Jugement d'ouverture",
  "judgmentNature": "Jugement d'ouverture d'une procédure de liquidation judiciaire",
  "judgmentDate": "2026-10-01",
  "judgmentDetails": "Jugement prononçant la liquidation judiciaire, date de cessation des paiements le 1 juillet 2026, désignant liquidateur ...",
  "persons": [{ "name": "CERES", "type": "company", "legalForm": "Société par actions simplifiée", "address": "12 rue des Blés, 31000 Toulouse" }],
  "establishments": [],
  "saleCategory": null,
  "saleOrigin": null,
  "previousOwners": [],
  "accountsClosingDate": null,
  "text": "## Procédures collectives: CERES\n- **Published:** 2026-10-10\n- **SIREN:** 912345678\n- **Judgment:** Jugement d'ouverture d'une procédure de liquidation judiciaire\n..."
}
```

(The values above are illustrative; field names are exact.) Other families fill their own fields: `saleCategory`, `saleEffectiveDate`, `saleOrigin` (price), `saleOpposition`, `previousOwners` for sales; `registrationDate`, `activityStartDate`, `establishments` for creations; `accountsClosingDate`, `accountsFilingType` for accounts; `deregistrationComment` for deregistrations; `modifications` for changes. Set `includeRawData: true` to get every original BODACC field in `raw`.

### Use cases

#### 1. Insolvency watch for a credit manager

A credit manager at a wholesale supplier in Occitanie checks every morning whether customers or prospects in Haute-Garonne and Tarn entered receivership or liquidation, to block credit lines before new orders ship.

Input (scheduled daily at 7:00):

```json
{ "announcementTypes": ["collective"], "departments": ["31", "81"], "onlyNew": true, "maxResults": 500 }
```

Output excerpt:

```json
[{ "companyName": "CERES", "siren": "912345678", "judgmentNature": "Jugement d'ouverture d'une procédure de liquidation judiciaire", "judgmentDate": "2026-10-01", "city": "Toulouse" }]
```

Next: a Make scenario matches `siren` against the customer list in Google Sheets and emails the account manager. About 15 to 30 notices a day, i.e. **less than $1 a month**.

#### 2. Business-for-sale leads for a franchise developer or business broker

A business broker looks for restaurants and bakeries that changed hands in Paris and Hauts-de-Seine, with sale price and previous owner, to contact the new owners (equipment, insurance, accounting offers).

```json
{ "announcementTypes": ["vente"], "departments": ["75", "92"], "keywords": ["restaurant", "boulangerie"], "daysBack": 30, "maxResults": 1000 }
```

```json
[{ "companyName": "GARAGE GANDOSSI", "saleCategory": "Achat d'un établissement principal par une personne morale lors de l'immatriculation", "saleOrigin": "Achat au prix stipulé de 300000,00 euros.", "previousOwners": ["GARAGE GANDOSSI"], "saleEffectiveDate": "2026-09-30" }]
```

Next: export to CSV, sort by price, load in the CRM. 1,000 sales cost **$0.80**.

#### 3. New company leads for accountants, banks and B2B SaaS

An accounting firm in Toulouse wants every new company created in its department each week, with activity and legal form, to offer bookkeeping before a competitor does.

```json
{ "announcementTypes": ["creation"], "departments": ["31"], "onlyNew": true, "maxResults": 2000 }
```

```json
[{ "companyName": "Labbe, Amandine", "siren": "131023491", "personType": "individual", "activity": "Achat, vente de cartes à collectionner (TCG)", "activityStartDate": "2026-10-05", "city": "Blagnac" }]
```

Next: n8n pushes each new company into HubSpot with the `text` field as a note. Around 400 creations a week in Haute-Garonne: **about $1.30 a month**.

#### 4. Company history for due diligence (KYC / M\&A)

A compliance analyst pulls every BODACC notice of a list of counterparties (accounts filings, capital changes, judgments) before onboarding.

```json
{ "sirens": ["542051180", "552032534", "453 439 465"], "maxResults": 500 }
```

Next: feed the Markdown `text` of each notice to an LLM to summarise red flags.

### Use with AI agents (MCP)

This Actor works as a tool for Claude, Cursor, ChatGPT and other AI agents through the Apify MCP server (`https://mcp.apify.com`). Add the Actor to your MCP client and ask, for example: *"List the judicial liquidations published this week in Gironde with their SIREN."* The agent fills the input (`announcementTypes`, `departments`, `daysBack`) and gets structured JSON plus a Markdown `text` field per notice, ready for RAG chunks.

### API examples

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("<USERNAME>/bodacc-announcements").call(run_input={
    "announcementTypes": ["collective"],
    "departments": ["31"],
    "maxResults": 15,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["publicationDate"], item["companyName"], item["siren"], item["judgmentNature"])
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('<USERNAME>/bodacc-announcements').call({
    announcementTypes: ['creation'],
    departments: ['75'],
    daysBack: 7,
    maxResults: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((i) => `${i.companyName} (${i.siren}) - ${i.activity}`));
```

### Integrations and automation

- **Schedules**: run daily with `onlyNew: true`; you only pay for announcements you have not received yet.
- **Make / Zapier / n8n**: use the "Run Actor" module, then "Get dataset items", then route to Gmail, Slack, a CRM or Google Sheets. Example n8n flow: *Schedule (daily) → Apify: Run Actor (onlyNew) → Apify: Get dataset items → IF judgmentNature contains "liquidation" → Slack message*.
- **Google Sheets**: export the dataset as CSV or connect the Apify Google Sheets integration.
- **API / webhooks**: get JSON, CSV, Excel or XML from the dataset endpoint, or a webhook when the run finishes.

### FAQ

**Where does the data come from?** From the official BODACC open data published by the DILA (data.gouv.fr / bodacc-datadila.opendatasoft.com). No website scraping, no login, no captcha.

**How fresh is it?** BODACC is published Tuesday to Saturday; new issues appear in the open data the same day or the next.

**How does `onlyNew` work?** The Actor remembers, per filter combination, the last publication date and the announcements already delivered, in a named key-value store `bodacc-announcements-state` in your account. Next runs return only what is new, oldest first, so an interrupted run never skips notices. Delete that store to start over.

**Which family codes exist?** `creation`, `immatriculation`, `vente`, `collective`, `radiation`, `dpc` (annual accounts), `modification`, `conciliation`, `retablissement_professionnel`, `divers`.

**Can I get more than 10,000 results?** Yes. Beyond 10,000, the Actor switches to the streaming export of the open data API.

**Why are some fields empty?** Each family carries different information (a deregistration has no judgment, an accounts filing has no sale). Empty fields are `null` or `[]`.

**Is it legal?** BODACC is a public, official bulletin released under the French open licence (Licence Ouverte / Etalab). Personal data of sole traders is published by law; use it in compliance with GDPR (legitimate interest, no unrelated profiling).

### Limits

- Only the commercial BODACC bulletin (A, B, C). Civil announcements are not covered.
- Data is returned as published: typos or missing SIRENs in the source stay as they are. The official PDF is not downloaded; use the `url` link to the official notice.
- Keyword search is the open data full-text search (word-based, accent-insensitive); it is not a fuzzy search.
- Some rare nested fields (accounts filing, general modifications) are rendered as readable text rather than split into sub-fields; use `includeRawData` to get the original structure.
- Older history depends on the open data (announcements from 2008 onwards).

# Actor input Schema

## `announcementTypes` (type: `array`):

BODACC announcement families to return. Leave empty for all types. Creations and collective proceedings (insolvency: safeguard, receivership, liquidation) are the most used for monitoring.

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

French department codes, e.g. "31" (Haute-Garonne), "75" (Paris), "2A" (Corse-du-Sud), "971" (Guadeloupe). Leave empty for all of France.

## `keywords` (type: `array`):

Full-text search in the announcement (company name, activity, judgment, city...). Example: "boulangerie", "liquidation judiciaire", "Toulouse".

## `keywordsMatch` (type: `string`):

"any": an announcement matches if it contains at least one keyword. "all": it must contain every keyword.

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

Return the announcements of these companies only (9-digit SIREN; a 14-digit SIRET is converted to its SIREN). Spaces are allowed.

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

Earliest publication date (YYYY-MM-DD), inclusive.

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

Latest publication date (YYYY-MM-DD), inclusive.

## `daysBack` (type: `integer`):

Shortcut used when "Published from" is empty: only announcements published in the last N days.

## `excludeCorrections` (type: `boolean`):

Keep only initial notices (drop "avis rectificatif" and "avis d'annulation").

## `onlyNew` (type: `boolean`):

Return only announcements not delivered by a previous run with the same filters. The memory is kept in the named key-value store "bodacc-announcements-state". Ideal for a daily schedule: you pay only for new announcements.

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

Maximum number of announcements to return (newest first). Each announcement is one charged event.

## `includeRawData` (type: `boolean`):

Add a "raw" object with every original BODACC field (embedded JSON decoded).

## Actor input object example

```json
{
  "announcementTypes": [
    "collective"
  ],
  "departments": [
    "31"
  ],
  "keywordsMatch": "any",
  "excludeCorrections": false,
  "onlyNew": false,
  "maxResults": 15,
  "includeRawData": false
}
```

# Actor output Schema

## `announcements` (type: `string`):

One item per BODACC announcement.

## `announcementsJson` (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 = {
    "announcementTypes": [
        "collective"
    ],
    "departments": [
        "31"
    ],
    "maxResults": 15
};

// Run the Actor and wait for it to finish
const run = await client.actor("actose/bodacc-announcements").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 = {
    "announcementTypes": ["collective"],
    "departments": ["31"],
    "maxResults": 15,
}

# Run the Actor and wait for it to finish
run = client.actor("actose/bodacc-announcements").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 '{
  "announcementTypes": [
    "collective"
  ],
  "departments": [
    "31"
  ],
  "maxResults": 15
}' |
apify call actose/bodacc-announcements --silent --output-dataset

```

## MCP server setup

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

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/wiNFFA09oK4ffn6hv/builds/DUV4F8jGeMyVOHAlp/openapi.json