# France SIRENE Company Scraper (`automation-lab/france-sirene-company-scraper`) Actor

Extract French company registry leads from the official SIRENE API with SIREN, SIRET, addresses, activity codes, status, and establishment counts.

- **URL**: https://apify.com/automation-lab/france-sirene-company-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

## France SIRENE Company Scraper

Extract French company registry data from the official SIRENE search API. This Apify Actor turns company names, activities, SIREN numbers, SIRET numbers, departments, regions, postal codes, and NAF/APE activity codes into clean dataset records for lead generation, KYC, CRM enrichment, and market mapping.

It does **not** scrape Pappers web pages. It uses the public French government company search endpoint so runs stay fast, low-cost, and browser-free.

### What does France SIRENE Company Scraper do?

France SIRENE Company Scraper searches the official French company register and exports normalized company records.

You can use it to:

- 🇫🇷 Find active French businesses by keyword or activity.
- 🧾 Enrich known SIREN and SIRET identifiers.
- 📍 Build local lead lists by department, region, city, or postal code.
- 🏢 Collect headquarters addresses and establishment counts.
- 🧩 Prepare official registry data for CRM, KYC, vendor onboarding, or compliance workflows.

### Who is it for?

This actor is useful for teams that repeatedly need official French company data:

- Sales teams building French B2B prospect lists.
- RevOps teams cleaning CRM records with SIREN/SIRET identifiers.
- KYC and compliance teams validating vendor identity and status.
- Market researchers mapping French companies by activity code and region.
- Data teams that need API-friendly registry exports without writing custom pagination code.

### Why use this actor?

The official API is public, but production workflows still need pagination, retry handling, de-duplication, schema-stable output, and Apify integrations.

This actor adds:

- A simple Apify input form.
- Typed dataset records.
- Bounded pagination and max item controls.
- Optional nested executives and establishments.
- PPE pricing tied to records saved.
- API, schedule, webhook, and MCP compatibility through Apify.

### Data source

The actor queries:

`https://recherche-entreprises.api.gouv.fr/search`

This is the French government company search API. The output reflects fields returned by that source at run time.

### What data can you extract?

| Field | Description |
| --- | --- |
| `siren` | French company SIREN identifier |
| `siret` | Headquarters or matched establishment SIRET |
| `companyName` | Legal company name |
| `fullName` | Full display name returned by the API |
| `tradeName` | Commercial/trade name when available |
| `legalFormCode` | Legal form code |
| `companyCategory` | Company category such as PME when available |
| `employeeSizeCode` | Employee size band code |
| `activityCode` | NAF/APE activity code |
| `status` | Administrative status |
| `isActive` | Boolean active flag derived from status |
| `headquartersAddress` | Headquarters address |
| `headquartersCity` | Headquarters city |
| `headquartersDepartment` | Department code |
| `headquartersRegion` | Region code |
| `latitude`, `longitude` | Coordinates when returned by the source |
| `openEstablishments` | Number of open establishments |
| `totalEstablishments` | Total establishment count |
| `executives` | Optional executives/officers array |
| `matchingEstablishments` | Optional matched establishments array |

### How much does it cost to scrape French SIRENE company data?

The actor uses pay-per-event pricing:

- A $0.005 start fee is charged once per run.
- The BRONZE per-company price is $0.000032031.
- Volume tiers reduce the per-company price down to $0.00001 on DIAMOND.

You can control spend with `maxItems`. A 1,000-company BRONZE run is roughly $0.037 before any platform-side limits or tier differences.

### Input options

The most important inputs are:

- `query` — company name, activity, keyword, SIREN, or SIRET.
- `identifiers` — optional SIREN/SIRET list for enrichment.
- `maxItems` — maximum companies to save.
- `activeOnly` — request active records by default.
- `activityCode` — optional NAF/APE filter such as `56.10A`.
- `department` — optional department code such as `75`.
- `region` — optional region code such as `11`.
- `cityCode` — optional INSEE commune code.
- `postalCode` — optional postal code.
- `includeExecutives` — include directors/officers when available.
- `includeMatchingEstablishments` — include matched establishment details.

### Example input: Paris restaurant leads

```json
{
  "query": "restaurant paris",
  "department": "75",
  "activeOnly": true,
  "maxItems": 100,
  "resultsPerPage": 25
}
````

### Example input: enrich SIREN identifiers

```json
{
  "query": "830998175",
  "identifiers": ["830998175", "552100554"],
  "activeOnly": true,
  "maxItems": 10,
  "includeMatchingEstablishments": true
}
```

### Example output

```json
{
  "siren": "830998175",
  "siret": "83099817500012",
  "companyName": "SARL RESTAURANT LES PEUPLIERS",
  "tradeName": "RESTAURANT LES PEUPLIERS",
  "activityCode": "56.10A",
  "status": "A",
  "isActive": true,
  "headquartersCity": "SELTZ",
  "headquartersPostalCode": "67470",
  "headquartersDepartment": "67",
  "openEstablishments": 1,
  "sourceUrl": "https://recherche-entreprises.api.gouv.fr/search?...",
  "scrapedAt": "2026-06-29T00:00:00.000Z"
}
```

### How to run it on Apify

1. Open the actor on Apify.
2. Enter a company/activity query or SIREN/SIRET identifiers.
3. Add optional location or activity filters.
4. Set `maxItems` to your desired export size.
5. Run the actor.
6. Download the dataset as JSON, CSV, Excel, XML, or RSS.

### Tips for better results

- Use French business terms for activity searches.
- Combine `query` with `department` or `region` for local lead lists.
- Use `identifiers` when enriching existing CRM records.
- Keep `includeExecutives` disabled unless you need officer data.
- Use `includeMatchingEstablishments` when you care about SIRET-level matching.

### Integrations

Common integration patterns include:

- CRM enrichment: send SIREN/SIRET lists from HubSpot, Salesforce, or Airtable and load the dataset back.
- Vendor onboarding: validate legal name, status, and headquarters before approval.
- Lead generation: schedule regional searches and export new official registry records.
- Data warehouse loading: run via API and ingest JSONL/CSV into BigQuery, Snowflake, or Postgres.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/france-sirene-company-scraper').call({
  query: 'restaurant paris',
  department: '75',
  maxItems: 100
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/france-sirene-company-scraper').call(run_input={
    'query': 'conseil informatique',
    'region': '11',
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[0])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~france-sirene-company-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"restaurant paris","department":"75","maxItems":100}'
```

### MCP usage

Use the actor from MCP-compatible tools through Apify MCP:

```bash
npx -y @apify/actors-mcp-server --actors automation-lab/france-sirene-company-scraper
```

MCP endpoint format:

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

JSON config block for Claude Desktop or compatible MCP clients:

```json
{
  "mcpServers": {
    "apify-france-sirene": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "automation-lab/france-sirene-company-scraper"],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Example prompts:

- "Find 100 active restaurant companies in Paris and return SIREN, SIRET, address, and activity code."
- "Enrich these French SIREN identifiers and flag inactive companies."
- "Build an Île-de-France list of IT consulting companies by NAF code."

### Legality

The actor uses a public official API and extracts business registry data returned by that API. You are responsible for using the data lawfully, respecting privacy and compliance rules, and following the source terms for your jurisdiction and use case.

### FAQ

#### Is it legal to scrape SIRENE company data?

The actor queries a public official API. You still need to make sure your storage, outreach, enrichment, and retention workflows comply with applicable laws and source terms.

#### Why did I get zero results?

Try a broader French-language query, remove strict location filters, or verify that your SIREN/SIRET identifiers are valid.

#### Why are fewer unique companies saved than `maxItems`?

The actor de-duplicates by SIREN, so duplicate identifiers or overlapping searches may produce fewer unique company rows than requested.

### Troubleshooting

If you get zero results, try a broader French-language query, remove strict location filters, or verify that your SIREN/SIRET identifiers are valid.

If a run stops early, check `maxItems` and the input filters. The actor de-duplicates by SIREN, so duplicate identifiers or overlapping searches may produce fewer unique rows than requested.

### Related Apify actors

You may also need:

- `https://apify.com/automation-lab/google-maps-lead-finder` for place/contact lead discovery.
- `https://apify.com/automation-lab/company-domain-to-twitter-x-url-resolver` for enrichment workflows.
- `https://apify.com/automation-lab/website-contact-finder` for website contact extraction.

### Limitations

- The actor returns fields provided by the official API, not paid Pappers-only data.
- Filter behavior depends on the source API parameters.
- Some optional nested arrays can be large, so keep them disabled unless needed.

### Changelog

- `0.1` — Initial implementation using the official French company search API.

### Support

Open an Apify issue if you need a missing field, a new filter, or help shaping a French company enrichment workflow.

# Actor input Schema

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

Free-text company name, brand, activity, SIREN, SIRET, or keyword to search in the official French company register.

## `identifiers` (type: `array`):

Optional list of specific SIREN or SIRET numbers to enrich. The actor searches each identifier and de-duplicates companies by SIREN.

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

Maximum number of company records to save across all searches.

## `resultsPerPage` (type: `integer`):

Official API page size. Keep the default unless you need smaller bursts.

## `activeOnly` (type: `boolean`):

When enabled, request active/open records from the official API.

## `activityCode` (type: `string`):

Optional NAF/APE activity code such as 56.10A for traditional restaurants.

## `department` (type: `string`):

Optional French department code such as 75, 13, 69, or 971.

## `region` (type: `string`):

Optional French region code, for example 11 for Île-de-France.

## `cityCode` (type: `string`):

Optional INSEE commune code when you need a precise municipality filter.

## `postalCode` (type: `string`):

Optional postal code such as 75008. Use this for local lead lists.

## `includeExecutives` (type: `boolean`):

Include directors/officers returned by the official API when available.

## `includeMatchingEstablishments` (type: `boolean`):

Include the API's matching establishments array with SIRET, address, city, geocoding, and status details.

## Actor input object example

```json
{
  "query": "restaurant paris",
  "identifiers": [
    "830998175"
  ],
  "maxItems": 20,
  "resultsPerPage": 20,
  "activeOnly": true,
  "department": "75",
  "includeExecutives": false,
  "includeMatchingEstablishments": false
}
```

# 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 = {
    "query": "restaurant paris",
    "identifiers": [
        "830998175"
    ],
    "maxItems": 20,
    "resultsPerPage": 20,
    "activeOnly": true,
    "activityCode": "",
    "department": "75",
    "region": "",
    "cityCode": "",
    "postalCode": "",
    "includeExecutives": false,
    "includeMatchingEstablishments": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/france-sirene-company-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 = {
    "query": "restaurant paris",
    "identifiers": ["830998175"],
    "maxItems": 20,
    "resultsPerPage": 20,
    "activeOnly": True,
    "activityCode": "",
    "department": "75",
    "region": "",
    "cityCode": "",
    "postalCode": "",
    "includeExecutives": False,
    "includeMatchingEstablishments": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/france-sirene-company-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 '{
  "query": "restaurant paris",
  "identifiers": [
    "830998175"
  ],
  "maxItems": 20,
  "resultsPerPage": 20,
  "activeOnly": true,
  "activityCode": "",
  "department": "75",
  "region": "",
  "cityCode": "",
  "postalCode": "",
  "includeExecutives": false,
  "includeMatchingEstablishments": false
}' |
apify call automation-lab/france-sirene-company-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France SIRENE Company Scraper",
        "description": "Extract French company registry leads from the official SIRENE API with SIREN, SIRET, addresses, activity codes, status, and establishment counts.",
        "version": "0.1",
        "x-build-id": "5dAQ7g1fMcGg1jP8n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~france-sirene-company-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-france-sirene-company-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~france-sirene-company-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-france-sirene-company-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~france-sirene-company-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-france-sirene-company-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",
                "required": [
                    "query"
                ],
                "properties": {
                    "query": {
                        "title": "Company or activity query",
                        "type": "string",
                        "description": "Free-text company name, brand, activity, SIREN, SIRET, or keyword to search in the official French company register."
                    },
                    "identifiers": {
                        "title": "SIREN/SIRET identifiers",
                        "type": "array",
                        "description": "Optional list of specific SIREN or SIRET numbers to enrich. The actor searches each identifier and de-duplicates companies by SIREN.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of company records to save across all searches.",
                        "default": 100
                    },
                    "resultsPerPage": {
                        "title": "Results per API page",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Official API page size. Keep the default unless you need smaller bursts.",
                        "default": 25
                    },
                    "activeOnly": {
                        "title": "Active companies only",
                        "type": "boolean",
                        "description": "When enabled, request active/open records from the official API.",
                        "default": true
                    },
                    "activityCode": {
                        "title": "NAF/APE activity code",
                        "type": "string",
                        "description": "Optional NAF/APE activity code such as 56.10A for traditional restaurants."
                    },
                    "department": {
                        "title": "Department code",
                        "type": "string",
                        "description": "Optional French department code such as 75, 13, 69, or 971."
                    },
                    "region": {
                        "title": "Region code",
                        "type": "string",
                        "description": "Optional French region code, for example 11 for Île-de-France."
                    },
                    "cityCode": {
                        "title": "INSEE commune code",
                        "type": "string",
                        "description": "Optional INSEE commune code when you need a precise municipality filter."
                    },
                    "postalCode": {
                        "title": "Postal code",
                        "type": "string",
                        "description": "Optional postal code such as 75008. Use this for local lead lists."
                    },
                    "includeExecutives": {
                        "title": "Include executives",
                        "type": "boolean",
                        "description": "Include directors/officers returned by the official API when available.",
                        "default": false
                    },
                    "includeMatchingEstablishments": {
                        "title": "Include matching establishments",
                        "type": "boolean",
                        "description": "Include the API's matching establishments array with SIRET, address, city, geocoding, and status details.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```