# France BODACC Business Legal Gazette Scraper (`parseforge/france-bodacc-gazette-scraper`) Actor

Track French business activity through the official BODACC legal gazette. Pull commercial announcements with company name, RCS number, publication ID, parution date, notice category, and tribunal. Filter by company, event type, or date for due diligence and risk monitoring.

- **URL**: https://apify.com/parseforge/france-bodacc-gazette-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.06 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🇫🇷 France BODACC Business Legal Gazette Scraper

> 🚀 **Export French commercial announcements in seconds.** Pull BODACC legal-gazette notices with company name, RCS number, publication ID, parution date, announcement category, and tribunal, newest first.

> 🕒 **Last updated:** 2026-06-08 · **📊 Up to 30 fields** per record · search + filters · official open data

Turn the official French BODACC legal gazette into clean, structured records you can drop into a due-diligence workflow, a risk monitor, or a business-intelligence pipeline. Search across announcements, narrow by category, notice type, and date, and get one tidy record per commercial announcement.

Coverage is the public BODACC commercial-announcements dataset: company name, RCS number, publication and announcement IDs, parution date, notice category and type, tribunal, location, legal form, and detailed payloads for account filings, court rulings, and sales when present.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Due-diligence and KYC teams | Check a company's legal events |
| Risk and credit analysts | Monitor insolvencies and strike-offs |
| Sales and lead researchers | Find new company registrations |
| Legal and compliance monitors | Track modifications and sales |

### 📋 What the France BODACC Scraper does

This Actor queries the official BODACC commercial-announcements open dataset and returns one clean record per announcement:

- **Free-text search** — match company name, address, or descriptive text.
- **Category and notice filters** — narrow to creations, insolvencies, sales, and more, or to initial notices, corrections, or cancellations.
- **Date range** — bound results by publication date, newest first.

Each record carries the company and registration details, the gazette metadata, the court and location, and event-specific payloads when applicable. Every record carries a `scrapedAt` timestamp.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `query` | string | Free text across announcements (company name, address, text), for example `Carrefour`. Empty lists the most recent announcements. |
| `announcementCategory` | select | Restrict to one business-event category (BODACC "famille d'avis"): creations, registrations, modifications, strike-offs, sales, insolvency, and more. |
| `noticeType` | select | Restrict to a notice type: initial notice (`annonce`), correction (`rectificatif`), or cancellation (`annulation`). |
| `dateFrom` | string | Only announcements published on or after this date. Format `YYYY-MM-DD`. |
| `dateTo` | string | Only announcements published on or before this date. Format `YYYY-MM-DD`. |
| `maxItems` | integer | How many records to return. Free plan is capped at 10. |

**Example 1 — search a company by name**
```json
{
    "query": "Carrefour",
    "maxItems": 50
}
````

**Example 2 — insolvency proceedings in a date range**

```json
{
    "announcementCategory": "collective",
    "noticeType": "annonce",
    "dateFrom": "2025-01-01",
    "dateTo": "2025-12-31",
    "maxItems": 200
}
```

> ⚠️ **Good to Know:** The underlying open dataset caps deep paging (offset plus limit) at 10,000 records per query, so to reach older announcements, narrow the date range or add a search term rather than paging through everything. The `accountFiling`, `courtRuling`, and `saleDetails` payloads are only populated for the relevant announcement categories and are otherwise null.

### 📊 Output

Each record represents one commercial announcement:

| Field | Description |
|---|---|
| 🏢 `companyName` | Company or merchant name |
| 🔢 `rcsNumber` | RCS registration number (human-spaced form) |
| `publicationId` | BODACC publication ID |
| 🔗 `url` | Link to the full announcement |
| 📑 `noticeType` | Notice type code |
| `noticeTypeLabel` | Notice type label |
| 🗂 `announcementCategory` | Category code (famille d'avis) |
| `announcementCategoryLabel` | Category label |
| 📅 `publicationDate` | Parution (publication) date |
| `publicationNumber` | Gazette parution number |
| `announcementNumber` | Announcement number within the parution |
| `gazette` | Gazette name |
| ⚖️ `tribunal` | Issuing tribunal |
| 📍 `city` | City |
| `postalCode` | Postal code |
| `departmentCode` | Department code |
| `departmentName` | Department name |
| `regionName` | Region name |
| `legalForm` | Legal form of the company |
| `registrationNumber` | Identification number |
| `registryCourt` | Registry court (greffe) |
| `accountFiling` | Account-filing payload (null when not applicable) |
| `courtRuling` | Court-ruling payload (null when not applicable) |
| `saleDetails` | Sale/disposal payload (null when not applicable) |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Null on success |

**Real sample — a creation announcement**

```json
{
    "companyName": "BOULANGERIE DU CENTRE SARL",
    "rcsNumber": "752 461 681",
    "publicationId": "A202600123456",
    "url": "https://www.bodacc.fr/annonce/detail-annonce/A/20260012/3456",
    "noticeType": "annonce",
    "noticeTypeLabel": "Annonce",
    "announcementCategory": "creation",
    "announcementCategoryLabel": "Créations",
    "publicationDate": "2026-06-05",
    "publicationNumber": "20260012",
    "announcementNumber": 3456,
    "gazette": "BODACC A",
    "tribunal": "GREFFE DU TRIBUNAL DE COMMERCE DE LYON",
    "city": "LYON",
    "postalCode": "69002",
    "departmentCode": "69",
    "departmentName": "Rhône",
    "regionName": "Auvergne-Rhône-Alpes",
    "legalForm": "Société à responsabilité limitée",
    "registrationNumber": "752461681",
    "registryCourt": "Lyon",
    "accountFiling": null,
    "courtRuling": null,
    "saleDetails": null,
    "scrapedAt": "2026-06-08T17:09:21.000Z",
    "error": null
}
```

### ✨ Why choose this Actor

- One clean record per announcement, with company and registration details resolved.
- Search plus category, notice-type, and date filters in a single run.
- RCS number returned in the readable spaced form.
- Event-specific payloads (filings, rulings, sales) included when relevant.
- Built on official open data: no account, no key, and no login required.

### 📈 How it compares to alternatives

| Approach | Effort | Structured fields | Filtering | Maintenance |
|---|---|---|---|---|
| This Actor | One run | Yes | Search + filters | None on your side |
| Searching the portal by hand | Hours | Manual | Limited | Constant |
| Writing your own API client | Days | Depends | You own it | You own the upkeep |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the France BODACC Business Legal Gazette Scraper.
3. Enter a `query` or set `announcementCategory`, `noticeType`, and a date range.
4. Set `maxItems` to the number of records you want.
5. Click **Start** and grab your results when the run finishes.

### 💼 Business use cases

#### Due diligence and KYC

| Goal | How this helps |
|---|---|
| Check a company's events | Search by name across announcements |
| Verify registration | Read RCS number, legal form, and registry court |

#### Risk and credit

| Goal | How this helps |
|---|---|
| Monitor insolvencies | Filter to insolvency proceedings |
| Watch strike-offs | Filter to radiations by date |

#### Sales and lead research

| Goal | How this helps |
|---|---|
| Find new companies | Filter to creations and registrations |
| Target by region | Use city, department, and region fields |

#### Legal and compliance

| Goal | How this helps |
|---|---|
| Track modifications | Filter to the modifications category |
| Follow sales and disposals | Use the sale-details payload |

### 🔌 Automating France BODACC Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger runs and route announcements into sheets or databases.
- **Slack** to post new announcements when a run finishes.
- **Airbyte** to load results into a warehouse.
- **GitHub** Actions to schedule periodic snapshots.
- **Google Drive** to archive each run's output.

### 🌟 Beyond business use cases

- **Research:** study French business formation and insolvency trends.
- **Personal:** check announcements for a company you deal with.
- **Non-profit:** power an economic-transparency project.
- **Experimentation:** prototype a company-intelligence app without writing a scraper.

### 🤖 Ask an AI assistant

Paste your results into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Microsoft Copilot](https://copilot.microsoft.com) and ask it to summarize a company's legal events, group announcements by category, or flag insolvencies.

### ❓ Frequently Asked Questions

**Do I need a BODACC account or API key?**
No. The Actor reads the official BODACC open dataset, which needs no login.

**What is an RCS number?**
It is the French commercial registry number identifying a company. The Actor returns the readable spaced form, for example `752 461 681`.

**How do I filter by event type?**
Use `announcementCategory` (creations, insolvencies, sales, and more) and `noticeType` (initial notice, correction, cancellation).

**What date format should I use?**
`YYYY-MM-DD` for both `dateFrom` and `dateTo`.

**Why can I only page so deep?**
The open dataset caps offset plus limit at 10,000 records per query. Narrow the date range or add a search term to reach older announcements.

**What are the account filing, court ruling, and sale payloads?**
They are event-specific detail objects, populated only for the relevant categories and null otherwise.

**In what order are announcements returned?**
By publication date, newest first.

**Can I get a link to the full notice?**
Yes. Each record includes a `url` to the complete announcement.

**How fresh is the data?**
Each run pulls live from the BODACC dataset, so it reflects the latest published announcements at run time.

**Can I schedule this?**
Yes. Use Apify Schedules to snapshot the gazette on any cadence.

### 🔌 Integrate with any app

Results are available through the Apify API, so you can pull them into any app, database, or workflow you already run.

### 🔗 Recommended Actors

- More business-intelligence and public-records Actors in the [ParseForge collection](https://apify.com/parseforge)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with BODACC, DILA, or the French government. Only publicly available data is collected.

# Actor input Schema

## `query` (type: `string`):

Free text to search across announcements (company name, address, descriptive text). For example 'Carrefour' or 'boulangerie Lyon'. Leave empty to list the most recent announcements.

## `announcementCategory` (type: `string`):

Restrict results to one business event category (the BODACC 'famille d'avis').

## `noticeType` (type: `string`):

Restrict results to a notice type (the BODACC 'type d'avis').

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

Only return announcements published on or after this date. Format YYYY-MM-DD, for example 2025-01-01.

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

Only return announcements published on or before this date. Format YYYY-MM-DD, for example 2025-12-31.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "announcementCategory": "",
  "noticeType": "",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/france-bodacc-gazette-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": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/france-bodacc-gazette-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": 10
}' |
apify call parseforge/france-bodacc-gazette-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France BODACC Business Legal Gazette Scraper",
        "description": "Track French business activity through the official BODACC legal gazette. Pull commercial announcements with company name, RCS number, publication ID, parution date, notice category, and tribunal. Filter by company, event type, or date for due diligence and risk monitoring.",
        "version": "0.1",
        "x-build-id": "pqrWtgX7JzKrJUZAt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~france-bodacc-gazette-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-france-bodacc-gazette-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/parseforge~france-bodacc-gazette-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-france-bodacc-gazette-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/parseforge~france-bodacc-gazette-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-france-bodacc-gazette-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": {
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free text to search across announcements (company name, address, descriptive text). For example 'Carrefour' or 'boulangerie Lyon'. Leave empty to list the most recent announcements."
                    },
                    "announcementCategory": {
                        "title": "Announcement category",
                        "enum": [
                            "",
                            "creation",
                            "immatriculation",
                            "modification",
                            "radiation",
                            "vente",
                            "collective",
                            "conciliation",
                            "retablissement_professionnel",
                            "dpc",
                            "divers"
                        ],
                        "type": "string",
                        "description": "Restrict results to one business event category (the BODACC 'famille d'avis').",
                        "default": ""
                    },
                    "noticeType": {
                        "title": "Notice type",
                        "enum": [
                            "",
                            "annonce",
                            "rectificatif",
                            "annulation"
                        ],
                        "type": "string",
                        "description": "Restrict results to a notice type (the BODACC 'type d'avis').",
                        "default": ""
                    },
                    "dateFrom": {
                        "title": "Published from",
                        "type": "string",
                        "description": "Only return announcements published on or after this date. Format YYYY-MM-DD, for example 2025-01-01."
                    },
                    "dateTo": {
                        "title": "Published to",
                        "type": "string",
                        "description": "Only return announcements published on or before this date. Format YYYY-MM-DD, for example 2025-12-31."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```