# BODACC France Company Notices Scraper (`automation-lab/bodacc-france-company-notices-scraper`) Actor

Extract official French BODACC company legal notices by SIREN, company, date range, department, and event type for KYB and risk workflows.

- **URL**: https://apify.com/automation-lab/bodacc-france-company-notices-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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

## BODACC France Company Notices Scraper

Extract official French BODACC company legal notices from the DILA/OpenDataSoft API.

Use this actor to search, monitor, and export company announcements by SIREN, company name, publication date, department, notice family, notice type, or legal-event keyword.

The actor is designed for compliance, KYB, credit-risk, legal operations, sales operations, and data teams that need repeatable BODACC data without maintaining their own API client.

### What does BODACC France Company Notices Scraper do?

BODACC France Company Notices Scraper collects announcement records from the official BODACC commercial notices dataset.

It saves normalized rows to an Apify dataset.

Each row includes identifiers, source URLs, dates, notice categories, company names, SIREN/RCS numbers, geography, tribunal data, event summaries, structured nested objects, and optional raw source JSON.

You can run it once for ad-hoc research.

You can also schedule it to build a daily or weekly monitoring feed.

### Who is it for?

Compliance analysts use it to watch suppliers, customers, or counterparties for legal events.

KYB teams use it to enrich onboarding checks with official French public notices.

Credit-risk teams use it to spot insolvency, liquidation, radiation, filing, and registration signals.

Legal teams use it to monitor restructuring or court-related notices.

B2B sales and RevOps teams use it to detect company changes that may trigger outreach.

Data vendors use it as an official public-data source for French company-event feeds.

### Why use this actor?

It uses the official DILA/OpenDataSoft API.

No login is required.

No browser automation is required.

No proxy is required for the normal workflow.

The output is immediately available in JSON, CSV, Excel, XML, RSS, and via the Apify API.

The actor preserves the raw record by default so French source fields remain available for audit and downstream parsing.

### BODACC data source

The source dataset is `annonces-commerciales` hosted by `bodacc-datadila.opendatasoft.com`.

BODACC announcements cover French commercial legal events.

The dataset includes notices for registrations, modifications, radiations, account filings, judgments, acts, transfers, and other commercial announcements.

OpenDataSoft field names are French.

This actor maps common fields into English names while keeping `rawRecord` available.

### Data fields you get

| Field | Description |
| --- | --- |
| `bodaccId` | BODACC announcement identifier |
| `sourceUrl` | Official BODACC detail URL when available |
| `publicationDate` | Publication date |
| `publicationCode` | BODACC publication code |
| `announcementNumber` | Announcement number inside the issue |
| `noticeTypeLabel` | Human-readable notice type |
| `noticeFamilyLabel` | Human-readable notice family |
| `companyName` | Company or commercial name |
| `siren` | Normalized 9-digit SIREN when present |
| `rcsNumbers` | RCS/registration values from the source |
| `departmentCode` | French department code |
| `departmentName` | Department name |
| `city` | City |
| `postalCode` | Postal code |
| `tribunal` | Registry court / tribunal |
| `legalForm` | Legal form when available |
| `eventSummary` | Best available short event summary |
| `persons` | Parsed person/company object |
| `establishments` | Parsed establishment object |
| `judgment` | Parsed judgment object |
| `filing` | Parsed filing/deposit object |
| `rawRecord` | Complete source record when enabled |

### How much does it cost to scrape BODACC company notices?

This actor uses pay-per-event pricing.

A small run fee is charged when the actor starts.

A per-result fee is charged for each BODACC notice saved to the dataset.

The exact live price is visible on the Apify Store pricing panel.

Because the actor uses an official HTTP API and does not need a browser or proxy, normal runs are designed to be inexpensive.

### How to use it

1. Open the actor on Apify.
2. Choose a maximum number of notices.
3. Add a date range.
4. Optionally add department codes.
5. Optionally add one or more SIREN numbers.
6. Optionally add a company-name search.
7. Optionally add a full-text legal-event query.
8. Run the actor.
9. Download the dataset or connect it to your workflow.

### Example input: Paris keyword search

```json
{
  "maxItems": 100,
  "dateFrom": "2025-01-01",
  "dateTo": "2025-01-31",
  "departments": ["75"],
  "companyQuery": "boulangerie",
  "sortOrder": "newest",
  "includeRawRecord": true
}
````

### Example input: SIREN monitoring

```json
{
  "maxItems": 50,
  "sirens": ["752461681"],
  "dateFrom": "2024-01-01",
  "dateTo": "2025-12-31",
  "sortOrder": "newest",
  "includeRawRecord": true
}
```

### Example input: insolvency and risk feed

```json
{
  "maxItems": 250,
  "dateFrom": "2025-01-01",
  "dateTo": "2025-01-31",
  "departments": ["75", "92", "93"],
  "fullTextQuery": "liquidation redressement radiation",
  "sortOrder": "newest",
  "includeRawRecord": true
}
```

### Input options

`maxItems` controls how many notices are saved.

`dateFrom` and `dateTo` filter by BODACC publication date.

`departments` filters by French department code.

`sirens` filters by registration number.

`companyQuery` searches company and person fields.

`fullTextQuery` performs a global OpenDataSoft search.

`noticeFamilies` filters BODACC family codes or labels.

`noticeTypes` filters notice type codes or labels.

`sortOrder` returns newest or oldest records first.

`includeRawRecord` keeps the complete source JSON.

### Output example

```json
{
  "bodaccId": "C202500182618",
  "source": "BODACC OpenDataSoft",
  "sourceUrl": "https://www.bodacc.fr/pages/annonces-commerciales-detail/?q.id=id:C202500182618",
  "publicationDate": "2025-01-26",
  "noticeTypeLabel": "Avis initial",
  "noticeFamilyLabel": "Dépôts des comptes",
  "companyName": "Le Fournil des Bocages",
  "siren": "752461681",
  "departmentCode": "60",
  "departmentName": "Oise",
  "city": "Thiescourt",
  "tribunal": "Greffe du Tribunal de Commerce de compiègne"
}
```

### Tips for better results

Use a date range for scheduled monitoring.

Use SIREN numbers when you need exact company matches.

Use department codes to keep searches focused.

Use `fullTextQuery` for legal-event keywords such as `liquidation`, `redressement`, or `radiation`.

Keep `includeRawRecord` enabled when you need legal auditability.

Lower `maxItems` for test runs.

Increase `maxItems` for production exports.

### Common workflows

Daily supplier-risk monitoring.

Weekly insolvency alert feed.

Portfolio company legal-event enrichment.

French company onboarding checks.

CRM enrichment for newly registered or modified companies.

Legal research by department and tribunal.

Data warehouse ingestion of official BODACC records.

### Integrations

Export the dataset to Google Sheets for analyst review.

Send results to Make or Zapier for alerting.

Load JSON into a warehouse using the Apify API.

Connect the actor to webhooks for scheduled monitoring.

Combine BODACC data with other automation-lab French company actors for richer KYB workflows.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/bodacc-france-company-notices-scraper').call({
  maxItems: 100,
  dateFrom: '2025-01-01',
  dateTo: '2025-01-31',
  departments: ['75'],
  companyQuery: 'boulangerie'
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/bodacc-france-company-notices-scraper').call(run_input={
    'maxItems': 100,
    'dateFrom': '2025-01-01',
    'dateTo': '2025-01-31',
    'departments': ['75'],
    'companyQuery': 'boulangerie'
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~bodacc-france-company-notices-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"dateFrom":"2025-01-01","dateTo":"2025-01-31","departments":["75"],"companyQuery":"boulangerie"}'
```

### MCP: use BODACC data from AI tools

You can call this actor through the Apify MCP server from Claude Code, Claude Desktop, Cursor, or VS Code.

Use the MCP URL with this actor tool enabled:

`https://mcp.apify.com/?tools=automation-lab/bodacc-france-company-notices-scraper`

Claude Code setup with HTTP transport:

```bash
claude mcp add apify-bodacc --transport http "https://mcp.apify.com/?tools=automation-lab/bodacc-france-company-notices-scraper"
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify-bodacc": {
      "url": "https://mcp.apify.com/?tools=automation-lab/bodacc-france-company-notices-scraper"
    }
  }
}
```

Cursor JSON setup:

```json
{
  "mcpServers": {
    "apify-bodacc": {
      "url": "https://mcp.apify.com/?tools=automation-lab/bodacc-france-company-notices-scraper"
    }
  }
}
```

VS Code JSON setup:

```json
{
  "servers": {
    "apify-bodacc": {
      "type": "http",
      "url": "https://mcp.apify.com/?tools=automation-lab/bodacc-france-company-notices-scraper"
    }
  }
}
```

Example prompt for Claude Code MCP usage:

"Use the BODACC France Company Notices Scraper tool for Paris notices in January 2025 matching boulangerie and summarize insolvency or radiation signals."

Example prompt for Claude Desktop, Cursor, or VS Code MCP usage:

"Run the Apify BODACC tool for these SIRENs and return a table with publication date, family, tribunal, and source URL."

Example workflow prompt:

"Create a weekly BODACC monitoring feed for departments 75 and 92 and highlight redressement, liquidation, or radiation notices."

### Scheduling

Create an Apify task with your preferred filters.

Schedule it daily, weekly, or monthly.

Use the Apify dataset API to fetch only the latest run results.

For delta workflows, set a date range matching the schedule window.

### Legality

This actor uses official public-data endpoints.

You are responsible for using the data in compliance with applicable law, privacy rules, and your internal policies.

The actor does not bypass authentication or private systems.

### FAQ

#### Is this official BODACC data?

Yes. The actor reads the official DILA/OpenDataSoft BODACC commercial announcements dataset.

#### Do I need a BODACC login or API key?

No. The implemented source is public and does not require a user account.

#### Can I monitor a list of SIRENs?

Yes. Add your SIREN or RCS values to the `sirens` input and schedule the actor.

#### Why do some nested fields vary by row?

BODACC notice families have different French source structures, so the actor keeps parsed nested objects and optional `rawRecord` data.

### Troubleshooting

If you get zero results, widen the date range or remove restrictive filters.

If SIREN matching returns unexpected records, check whether the source record contains multiple formatted RCS values.

If a keyword query is too broad, add departments or dates.

If nested French fields are important, keep `includeRawRecord` enabled.

### Related scrapers

Use other automation-lab French company or registry actors for profile-level data.

Use this actor when you need event-level BODACC legal announcements.

Use procurement-specific actors for BOAMP or tender workflows.

### Limitations

OpenDataSoft pagination has practical offset limits.

For very large exports, narrow the run by date, department, family, or company.

Some event-specific details are nested and vary by notice family.

The actor preserves raw data so you can inspect fields not yet normalized.

### Support

Open an Apify issue if a run fails or if a BODACC field should be normalized into a top-level column.

Include your input, run ID, and a short description of the expected result.

### Version notes

Initial version focuses on official commercial notices from the BODACC OpenDataSoft API.

Future versions can add more opinionated event classification if users request it.

# Actor input Schema

## `maxItems` (type: `integer`):

Maximum number of BODACC announcement records to save.

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

Inclusive publication date lower bound in YYYY-MM-DD format.

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

Inclusive publication date upper bound in YYYY-MM-DD format.

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

Optional department filters such as 75 for Paris, 69 for Rhône, or 13 for Bouches-du-Rhône.

## `companyQuery` (type: `string`):

Search the company/commercial name fields. Example: boulangerie, orange, totalenergies.

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

Optional company registration numbers. Spaces are ignored.

## `fullTextQuery` (type: `string`):

Optional global text search across the BODACC record, useful for insolvency terms, cities, or keywords.

## `noticeFamilies` (type: `array`):

Optional BODACC family filters. Use codes such as dpc or labels such as Dépôts des comptes.

## `noticeTypes` (type: `array`):

Optional notice type filters such as annonce or Avis initial.

## `sortOrder` (type: `string`):

Return the newest or oldest matching notices first.

## `includeRawRecord` (type: `boolean`):

Keep the complete source JSON in rawRecord for auditability and unmapped French fields.

## Actor input object example

```json
{
  "maxItems": 20,
  "dateFrom": "2025-01-01",
  "dateTo": "2025-01-31",
  "departments": [
    "75"
  ],
  "companyQuery": "boulangerie",
  "sirens": [],
  "noticeFamilies": [],
  "noticeTypes": [],
  "sortOrder": "newest",
  "includeRawRecord": true
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 20,
    "dateFrom": "2025-01-01",
    "dateTo": "2025-01-31",
    "departments": [
        "75"
    ],
    "companyQuery": "boulangerie",
    "sirens": [],
    "noticeFamilies": [],
    "noticeTypes": [],
    "sortOrder": "newest",
    "includeRawRecord": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/bodacc-france-company-notices-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 = {
    "maxItems": 20,
    "dateFrom": "2025-01-01",
    "dateTo": "2025-01-31",
    "departments": ["75"],
    "companyQuery": "boulangerie",
    "sirens": [],
    "noticeFamilies": [],
    "noticeTypes": [],
    "sortOrder": "newest",
    "includeRawRecord": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/bodacc-france-company-notices-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 '{
  "maxItems": 20,
  "dateFrom": "2025-01-01",
  "dateTo": "2025-01-31",
  "departments": [
    "75"
  ],
  "companyQuery": "boulangerie",
  "sirens": [],
  "noticeFamilies": [],
  "noticeTypes": [],
  "sortOrder": "newest",
  "includeRawRecord": true
}' |
apify call automation-lab/bodacc-france-company-notices-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/bodacc-france-company-notices-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "BODACC France Company Notices Scraper",
        "description": "Extract official French BODACC company legal notices by SIREN, company, date range, department, and event type for KYB and risk workflows.",
        "version": "0.1",
        "x-build-id": "oeqx30PIRdSUtqGiR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~bodacc-france-company-notices-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-bodacc-france-company-notices-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/automation-lab~bodacc-france-company-notices-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-bodacc-france-company-notices-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/automation-lab~bodacc-france-company-notices-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-bodacc-france-company-notices-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": {
                    "maxItems": {
                        "title": "Maximum notices",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of BODACC announcement records to save.",
                        "default": 20
                    },
                    "dateFrom": {
                        "title": "Published from",
                        "type": "string",
                        "description": "Inclusive publication date lower bound in YYYY-MM-DD format."
                    },
                    "dateTo": {
                        "title": "Published to",
                        "type": "string",
                        "description": "Inclusive publication date upper bound in YYYY-MM-DD format."
                    },
                    "departments": {
                        "title": "French department codes",
                        "type": "array",
                        "description": "Optional department filters such as 75 for Paris, 69 for Rhône, or 13 for Bouches-du-Rhône.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyQuery": {
                        "title": "Company name search",
                        "type": "string",
                        "description": "Search the company/commercial name fields. Example: boulangerie, orange, totalenergies."
                    },
                    "sirens": {
                        "title": "SIREN / RCS numbers",
                        "type": "array",
                        "description": "Optional company registration numbers. Spaces are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fullTextQuery": {
                        "title": "Full-text query",
                        "type": "string",
                        "description": "Optional global text search across the BODACC record, useful for insolvency terms, cities, or keywords."
                    },
                    "noticeFamilies": {
                        "title": "Notice family codes or labels",
                        "type": "array",
                        "description": "Optional BODACC family filters. Use codes such as dpc or labels such as Dépôts des comptes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "noticeTypes": {
                        "title": "Notice type codes or labels",
                        "type": "array",
                        "description": "Optional notice type filters such as annonce or Avis initial.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "newest",
                            "oldest"
                        ],
                        "type": "string",
                        "description": "Return the newest or oldest matching notices first.",
                        "default": "newest"
                    },
                    "includeRawRecord": {
                        "title": "Include raw OpenDataSoft record",
                        "type": "boolean",
                        "description": "Keep the complete source JSON in rawRecord for auditability and unmapped French fields.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
