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

🇫🇷 Extract French SIRENE company and establishment records by name, SIREN/SIRET, location, NAF code, and active status.

- **URL**: https://apify.com/automation-lab/france-sirene-company-registry-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **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 Registry Scraper

Extract French company and establishment records from the official SIRENE / Recherche Entreprises API.

Use this actor to build verified B2B lead lists, enrich SIREN or SIRET numbers, check company status, and export structured French registry data to JSON, CSV, Excel, or your own API workflow.

### What does France SIRENE Company Registry Scraper do?

France SIRENE Company Registry Scraper searches the public French company registry and saves clean records to an Apify dataset.

It can search by:

- 🔎 company name or keyword
- 🆔 SIREN number
- 🧾 SIRET number
- 📍 postal code
- 🗺️ department or region code
- 🏭 NAF / APE activity code
- ✅ active or inactive administrative status

The source is the official public French government search API, so the actor does not need a browser, login, or private token.

### Who is it for?

#### Sales and lead generation teams

Find French companies in a city, department, region, or activity category and export leads for outreach.

#### KYB and compliance teams

Check whether a French business is active, verify its SIREN/SIRET identifiers, and capture registry metadata for onboarding.

#### Market researchers

Measure company presence by industry, geography, establishment count, and administrative status.

#### Data enrichment teams

Append legal names, addresses, activity codes, and public registry URLs to an existing list of SIREN or SIRET numbers.

#### No-code automation users

Connect the actor to Google Sheets, Make, Zapier, Slack, or your CRM using Apify integrations.

### Why use this actor?

- ✅ Uses the official public SIRENE search API
- ✅ HTTP-only, fast, and cost-efficient
- ✅ Supports direct SIREN/SIRET lookup
- ✅ Supports geographic and activity filters
- ✅ Exports structured fields instead of raw API blobs
- ✅ Includes source URLs for verification
- ✅ Works well for recurring lead enrichment jobs

### Data you can extract

| Field | Description |
| --- | --- |
| `siren` | 9-digit company identifier |
| `siret` | 14-digit establishment identifier |
| `legalName` | Registered legal name |
| `fullName` | Full public registry name |
| `tradeName` | Commercial name when available |
| `companyStatus` | Company administrative status |
| `establishmentStatus` | Establishment administrative status |
| `isActive` | Boolean active/inactive flag |
| `activityCode` | NAF / APE code |
| `activityCodeNaf25` | NAF 2025 code when available |
| `legalFormCode` | French legal-form code |
| `companyCategory` | Company size category |
| `employeeRange` | Company employee band |
| `address` | Establishment address |
| `postalCode` | Postal code |
| `communeName` | Commune name |
| `department` | Department code |
| `region` | Region code |
| `latitude` / `longitude` | Geolocation when published |
| `sourceUrl` | Public Annuaire Entreprises URL |
| `sourceApiUrl` | API request URL used for the record |
| `scrapedAt` | Timestamp of extraction |

### How much does it cost to scrape France SIRENE company records?

The actor uses pay-per-event pricing.

- A small one-time start event is charged when the run starts.
- A record-pack event is charged once for each started pack of 4 companies or establishments saved.
- The BRONZE reference price is $0.0001 per 4-record pack, which is about $0.000025 per record (about $0.025 per 1,000 records) when records are returned in full packs, with tier discounts on larger Apify plans.
- The final price is visible before you run the actor on Apify.

Because the scraper uses an official JSON API and no browser, it is designed to stay inexpensive for lead-generation and enrichment workloads.

### Input options

#### `queries`

Search terms such as:

- `boulangerie Paris`
- `restaurant Lyon`
- `société conseil informatique`
- `plomberie Marseille`

#### `identifiers`

Direct SIREN or SIRET lookup values.

Examples:

- `830998175`
- `83099817500012`

#### `maxResults`

Maximum number of records to save.

Start with a small value such as 25 or 50 when testing.

#### `activeStatus`

Choose:

- `all`
- `active`
- `inactive`

#### `establishmentMode`

Choose:

- `headquarters` — one row per company head office
- `matchingEstablishments` — rows for matching establishments returned by the API

#### Geographic filters

Use one or more of:

- `postalCodes`
- `departments`
- `regions`

#### Activity filters

Use `activityCodes` for NAF / APE codes such as:

- `56.10A` restaurants
- `47.11D` supermarkets
- `62.01Z` software publishing

### Example input

```json
{
  "queries": ["boulangerie Paris"],
  "maxResults": 50,
  "activeStatus": "active",
  "establishmentMode": "headquarters",
  "departments": ["75"],
  "resultsPerPage": 25,
  "requestDelayMs": 200
}
````

### Example output

```json
{
  "query": "boulangerie Paris",
  "siren": "123456789",
  "siret": "12345678900012",
  "legalName": "EXAMPLE BOULANGERIE",
  "tradeName": "BOULANGERIE EXAMPLE",
  "companyStatus": "A",
  "isActive": true,
  "activityCode": "10.71C",
  "address": "1 RUE EXEMPLE 75001 PARIS",
  "postalCode": "75001",
  "communeName": "PARIS",
  "department": "75",
  "sourceUrl": "https://annuaire-entreprises.data.gouv.fr/entreprise/123456789",
  "scrapedAt": "2026-06-10T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Enter one or more search terms or SIREN/SIRET numbers.
3. Add optional location or activity filters.
4. Set `maxResults`.
5. Click **Start**.
6. Export the dataset as CSV, Excel, JSON, XML, or RSS.

### Search tips

- Use French business terms for better coverage.
- Combine keywords with location filters for cleaner leads.
- Use SIREN/SIRET lookup when enriching a known list.
- Use `activeStatus: active` for prospecting.
- Use `matchingEstablishments` when you need branch-level locations.
- Keep `resultsPerPage` at 25 for efficient pagination.

### Common use cases

- Build a list of restaurants in a department.
- Find active construction companies by NAF code.
- Enrich CRM rows with SIREN and SIRET identifiers.
- Verify whether a French supplier is still active.
- Create a local-business database for market analysis.
- Monitor changes in public company availability.

### Integrations

You can connect results to:

- Google Sheets for lead lists
- Make for no-code automations
- Zapier for CRM workflows
- Slack for status notifications
- Webhooks for enrichment pipelines
- Apify API for scheduled data jobs

### API usage

#### 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-registry-scraper').call({
  queries: ['restaurant Lyon'],
  maxResults: 25,
  activeStatus: 'active'
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/france-sirene-company-registry-scraper').call(run_input={
    'queries': ['restaurant Lyon'],
    'maxResults': 25,
    'activeStatus': 'active',
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~france-sirene-company-registry-scraper/runs?token=YOUR_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["restaurant Lyon"],"maxResults":25,"activeStatus":"active"}'
```

### MCP usage

Use this actor from Claude Desktop, Claude Code, or any MCP-compatible client through Apify MCP Server.

MCP server URL:

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

Claude Code setup:

```bash
claude mcp add apify-france-sirene "https://mcp.apify.com/?tools=automation-lab/france-sirene-company-registry-scraper"
```

Claude Desktop JSON config:

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

Example prompts:

- "Find 25 active bakeries in Paris from the SIRENE registry."
- "Enrich these SIREN numbers with legal names and addresses."
- "Export active restaurants in department 69 with SIRET and address fields."

### Scheduling

Schedule the actor to refresh a French company lead list weekly or monthly.

Recommended recurring setup:

- Keep a stable query and filters.
- Export the dataset to your warehouse.
- Deduplicate by SIRET.
- Track changes in `companyStatus`, `address`, or `activityCode`.

### Data quality notes

The actor returns fields published by the public registry API.

Some companies may not publish every optional field. For example, geolocation, employee range, or trade name may be missing for some records.

Use `siren` for company-level deduplication and `siret` for establishment-level deduplication.

### Legality

This actor uses public French government registry data. You are responsible for using exported data lawfully, including respecting GDPR, ePrivacy, anti-spam rules, and contractual obligations that apply to your use case.

Do not use the data for unlawful profiling, harassment, or unsolicited communications that violate applicable law.

### FAQ

#### Is this an official French government actor?

No. The actor is built by Automation Lab and uses the public official Recherche Entreprises / SIRENE API as its data source.

#### Can I search only active companies?

Yes. Set `activeStatus` to `active` to request active registry records.

#### Can I deduplicate results?

Yes. Use `siret` for establishment-level deduplication or `siren` for company-level deduplication.

### Troubleshooting

#### Why did I get fewer records than requested?

The source may have fewer matching records for your query and filters, or duplicates may be removed by SIRET.

#### Why are some fields empty?

The public API does not publish every optional attribute for every company or establishment.

#### Why did a SIREN lookup return one company but no branch rows?

Use `establishmentMode: matchingEstablishments` to return matching establishment rows when the API exposes them.

### Related scrapers

Explore other Automation Lab actors for company, lead-generation, and public registry workflows:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/companies-house-scraper
- https://apify.com/automation-lab/npi-registry-scraper
- https://apify.com/automation-lab/zefix-scraper

### Support

If you need a field that exists in the public SIRENE API but is not exported yet, open an issue with an example SIREN/SIRET and the field name.

### Changelog

Initial version:

- Search by keyword or identifier
- Location and NAF filters
- Active/inactive status filter
- Headquarters or matching-establishments mode
- Structured output dataset

# Actor input Schema

## `queries` (type: `array`):

Free-text searches such as company names, brands, activities, or local-business keywords. If no query or identifier is provided, the actor uses a small restaurant sample.

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

Optional direct lookups. Enter 9-digit SIREN or 14-digit SIRET numbers.

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

Maximum number of company/establishment records to save.

## `activeStatus` (type: `string`):

Filter by active or inactive companies and establishments.

## `establishmentMode` (type: `string`):

Choose whether each company returns only its head office or every matching establishment returned by the SIRENE search API.

## `postalCodes` (type: `array`):

Optional French postal-code filters, for example 75001 or 69002.

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

Optional INSEE department filters, for example 75, 13, 2A, or 971.

## `regions` (type: `array`):

Optional INSEE region filters, for example 11 for Île-de-France or 84 for Auvergne-Rhône-Alpes.

## `activityCodes` (type: `array`):

Optional primary activity filters such as 56.10A for traditional restaurants or 47.11D for supermarkets.

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

Number of records requested from the API per page. The official API currently accepts up to 25.

## `requestDelayMs` (type: `integer`):

Polite delay between paginated API requests.

## Actor input object example

```json
{
  "queries": [
    "boulangerie Paris"
  ],
  "identifiers": [],
  "maxResults": 20,
  "activeStatus": "active",
  "establishmentMode": "headquarters",
  "postalCodes": [],
  "departments": [],
  "regions": [],
  "activityCodes": [],
  "resultsPerPage": 25,
  "requestDelayMs": 200
}
```

# 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 = {
    "queries": [
        "boulangerie Paris"
    ],
    "identifiers": [],
    "postalCodes": [],
    "departments": [],
    "regions": [],
    "activityCodes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/france-sirene-company-registry-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 = {
    "queries": ["boulangerie Paris"],
    "identifiers": [],
    "postalCodes": [],
    "departments": [],
    "regions": [],
    "activityCodes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/france-sirene-company-registry-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 '{
  "queries": [
    "boulangerie Paris"
  ],
  "identifiers": [],
  "postalCodes": [],
  "departments": [],
  "regions": [],
  "activityCodes": []
}' |
apify call automation-lab/france-sirene-company-registry-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-registry-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France SIRENE Company Registry Scraper",
        "description": "🇫🇷 Extract French SIRENE company and establishment records by name, SIREN/SIRET, location, NAF code, and active status.",
        "version": "0.1",
        "x-build-id": "z7wMuy7u2Lxp4ImnJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~france-sirene-company-registry-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-france-sirene-company-registry-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-registry-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-france-sirene-company-registry-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-registry-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-france-sirene-company-registry-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": {
                    "queries": {
                        "title": "Company names or keywords",
                        "type": "array",
                        "description": "Free-text searches such as company names, brands, activities, or local-business keywords. If no query or identifier is provided, the actor uses a small restaurant sample.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "identifiers": {
                        "title": "SIREN or SIRET numbers",
                        "type": "array",
                        "description": "Optional direct lookups. Enter 9-digit SIREN or 14-digit SIRET numbers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of company/establishment records to save.",
                        "default": 20
                    },
                    "activeStatus": {
                        "title": "Administrative status",
                        "enum": [
                            "all",
                            "active",
                            "inactive"
                        ],
                        "type": "string",
                        "description": "Filter by active or inactive companies and establishments.",
                        "default": "active"
                    },
                    "establishmentMode": {
                        "title": "Establishment output mode",
                        "enum": [
                            "headquarters",
                            "matchingEstablishments"
                        ],
                        "type": "string",
                        "description": "Choose whether each company returns only its head office or every matching establishment returned by the SIRENE search API.",
                        "default": "headquarters"
                    },
                    "postalCodes": {
                        "title": "Postal codes",
                        "type": "array",
                        "description": "Optional French postal-code filters, for example 75001 or 69002.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "departments": {
                        "title": "Department codes",
                        "type": "array",
                        "description": "Optional INSEE department filters, for example 75, 13, 2A, or 971.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regions": {
                        "title": "Region codes",
                        "type": "array",
                        "description": "Optional INSEE region filters, for example 11 for Île-de-France or 84 for Auvergne-Rhône-Alpes.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "activityCodes": {
                        "title": "NAF/APE activity codes",
                        "type": "array",
                        "description": "Optional primary activity filters such as 56.10A for traditional restaurants or 47.11D for supermarkets.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "resultsPerPage": {
                        "title": "Results per API page",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Number of records requested from the API per page. The official API currently accepts up to 25.",
                        "default": 25
                    },
                    "requestDelayMs": {
                        "title": "Delay between API pages (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Polite delay between paginated API requests.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```