# French Companies SIRENE Scraper (`automation-lab/french-companies-sirene-scraper`) Actor

Search and enrich French companies from official SIRENE data. Export SIREN, SIRET, names, addresses, activity codes, and source URLs.

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

## French Companies SIRENE Scraper

Search and enrich French companies from the public SIRENE / Annuaire des Entreprises API. Export clean company records with SIREN, SIRET, legal names, activity codes, addresses, establishment counts, and source URLs for B2B enrichment workflows.

### What does French Companies SIRENE Scraper do?

French Companies SIRENE Scraper turns French public company registry search into a repeatable Apify dataset.

It queries `recherche-entreprises.api.gouv.fr`, the public Annuaire des Entreprises search API backed by official French company data, and flattens the response into spreadsheet-ready records.

Use it to collect French business leads, enrich CRM rows, validate SIREN/SIRET identifiers, or map companies by keyword and location.

### Who is it for?

- 🧑‍💼 B2B sales teams building French prospect lists by activity or city
- 🧾 Compliance teams checking vendor identifiers and legal names
- 🧑‍💻 Data teams enriching CRM records with official registry fields
- 📍 Market researchers mapping companies by French department or postal-code prefix
- 🔎 Analysts who need a lighter government-API alternative to Pappers page scraping

### Why use this actor?

The actor is HTTP-only and uses a public JSON endpoint, so runs are fast, predictable, and inexpensive.

It also saves the API URL and public source URL for every row, which helps with audits and repeatable enrichment pipelines.

### Data source

The source is the French public Annuaire des Entreprises search endpoint:

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

The actor does not log in, bypass paywalls, or scrape private account data.

### Data you can extract

| Field group | Examples |
|---|---|
| Identifiers | SIREN, SIRET |
| Names | company name, full name, trade name |
| Legal/activity | legal category, activity code, activity label |
| Location | address, postal code, city, department, coordinates |
| Status | active company flag, active establishment flag, creation dates |
| Scale | establishment count, open establishment count, workforce range |
| People | directors when returned by the public API |
| Provenance | source URL, API URL, scrape timestamp |

### How much does it cost to scrape French SIRENE companies?

This actor uses pay-per-event pricing: a small run start event plus a per-company dataset item event.

Formula-derived pricing from the realistic cloud run:

- Start event: `$0.005` per run
- Company item event, BRONZE tier: `$0.000030384` per extracted company
- Higher-volume tiers decrease down to `$0.00001` per company at DIAMOND

The price was checked against Pappers/SIRENE competitor benchmarks and is below common company-enrichment pricing because the public API is lightweight.

### Input options

#### Company search queries

Use `queries` for names, brands, activities, cities, or free-text searches such as:

- `restaurant paris`
- `boulangerie lyon`
- `peugeot`

#### Exact SIREN enrichment

Use `sirens` for 9-digit French company identifiers.

Example: `552100554`

#### Exact SIRET enrichment

Use `sirets` for 14-digit French establishment identifiers.

The public API search endpoint accepts SIRET-like text searches and the actor stores the matching head-office SIRET returned by the source.

#### Location filters

Use `departments` for French department codes such as `75`, `13`, `69`, or `971`.

Use `postalCodes` for postal-code prefixes such as `750`, `130`, or `690`.

Filters are applied to the returned establishment postal code so the output remains predictable even if the upstream API changes its optional filter parameters.

### Example input: Paris restaurants

```json
{
  "queries": ["restaurant paris"],
  "departments": ["75"],
  "maxItems": 50
}
````

### Example input: enrich exact companies

```json
{
  "sirens": ["552100554"],
  "queries": ["airbus"],
  "maxItems": 25
}
```

### Example output item

```json
{
  "query": "restaurant paris",
  "queryType": "search",
  "siren": "830998175",
  "siret": "83099817500010",
  "companyName": "SARL RESTAURANT LES PEUPLIERS",
  "mainActivityCode": "56.10A",
  "address": "CAMPING PLAGE LES PEUPLIERS 67470 SELTZ",
  "postalCode": "67470",
  "department": "67",
  "source": "recherche-entreprises.api.gouv.fr",
  "scrapedAt": "2026-06-26T00:00:00.000Z"
}
```

### How to run

1. Open the actor on Apify.
2. Add one or more `queries`, `sirens`, or `sirets`.
3. Set `maxItems` to your desired dataset size.
4. Optionally add `departments` or `postalCodes`.
5. Start the run and download the dataset as JSON, CSV, Excel, or via API.

### Tips for better results

- Use activity words plus a city for lead generation, for example `cabinet comptable lyon`.
- Use exact SIREN values for enrichment when you already have identifiers.
- Keep `maxItems` small for testing, then scale up once the output shape matches your workflow.
- Use department filters for regional campaigns.

### Integrations

Common workflows:

- 🧩 CRM enrichment: upload SIREN values, export records, join by SIREN.
- 📊 Market mapping: search an activity across departments and aggregate counts.
- 🧾 Vendor checks: validate names, addresses, and legal identifiers before onboarding.
- 🔁 Scheduled monitoring: run a saved task weekly for a keyword and compare new SIRENs.

### 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/french-companies-sirene-scraper').call({
  queries: ['restaurant paris'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/french-companies-sirene-scraper').call(run_input={
    'queries': ['boulangerie lyon'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~french-companies-sirene-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"queries":["restaurant paris"],"maxItems":100}'
```

### MCP: use from Claude Desktop or Claude Code

You can connect Apify actors to MCP clients through Apify MCP Server.

Use a URL scoped to this actor:

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

Claude Code setup:

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

Claude Desktop JSON configuration:

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

Example prompts:

- “Find 50 French restaurants in Paris and return their SIREN numbers.”
- “Enrich this SIREN list with official company names and addresses.”
- “Build a CSV of accounting firms in Lyon from the French company registry.”

### Scheduling and monitoring

Create an Apify task with a fixed input and schedule it daily, weekly, or monthly.

For monitoring, keep the same search query and compare SIREN values between datasets.

### Limits and reliability

The upstream API is public and may apply rate limits or temporary errors.

The actor retries 429 and 5xx responses with backoff.

If a broad query returns too many irrelevant records, narrow it with a city, activity phrase, department, or postal-code prefix.

### Legality

This actor uses a public government API and outputs business registry information.

You are responsible for using the data in compliance with applicable laws, platform terms, GDPR, and your own business policies.

Avoid using public registry data for spam or unlawful profiling.

### Troubleshooting

#### I got zero results

Check that at least one `queries`, `sirens`, or `sirets` value is present. Then try a broader term without location filters.

#### My department filter removed expected records

The actor derives departments from establishment postal codes. If the company head office is outside the target department, it may be filtered out even when the brand operates there.

#### The run was slower than expected

Reduce `maxItems`, use fewer broad queries, or provide exact SIREN values.

### Related scrapers

These Automation Labs actors may fit adjacent workflows:

- https://apify.com/automation-lab/google-maps-lead-finder
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/linkedin-company-url-finder

### FAQ

#### Does this actor scrape Pappers?

No. It targets the public French government company-search API to avoid Cloudflare-protected Pappers pages and provide stable official-source enrichment.

#### Can I search by SIREN?

Yes. Put 9-digit identifiers in `sirens` or include them as query text.

#### Can I export CSV?

Yes. Apify datasets can be downloaded as CSV, JSON, Excel, XML, RSS, or HTML.

#### Does it need proxies?

No proxy is required for the MVP because the source API returned public JSON without login or browser rendering.

### Changelog

- `0.1.0` Initial private build with keyword, SIREN, SIRET, department, postal-code, and max item controls.

### Field reference

The dataset schema includes all emitted fields. Keep joins on stable identifiers: `siren` for companies and `siret` for establishments.

### Support

If a run fails, open the Apify run log and copy the failing query, status code, and run ID when asking for help.

### Implementation notes

The actor is implemented as an HTTP-only TypeScript actor using the Apify SDK and built-in Node.js `fetch`.

### Quality checklist

The actor keeps defaults small for affordable first runs, but supports larger `maxItems` values for production enrichment.

# Actor input Schema

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

Company names, brands, activities, cities, SIREN/SIRET values, or keywords to search in the French public company registry.

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

Optional 9-digit French company identifiers for direct enrichment.

## `sirets` (type: `array`):

Optional 14-digit French establishment identifiers for direct enrichment.

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

Maximum number of company or establishment records to save across all searches.

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

Keep only head-office establishments whose postal code starts with one of these prefixes, e.g. 75 for Paris or 130 for Marseille area.

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

Keep only companies in these French departments, e.g. 75, 13, 69, 971.

## `includeClosed` (type: `boolean`):

By default the actor skips records that appear administratively closed. Enable this for historical enrichment.

## `perPage` (type: `integer`):

Number of source API results to request per page. The public endpoint works reliably up to 25.

## Actor input object example

```json
{
  "queries": [
    "restaurant paris",
    "boulangerie lyon"
  ],
  "sirens": [
    "552100554"
  ],
  "maxItems": 20,
  "includeClosed": false,
  "perPage": 25
}
```

# 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": [
        "restaurant paris",
        "boulangerie lyon"
    ],
    "sirens": [
        "552100554"
    ],
    "maxItems": 20,
    "includeClosed": false,
    "perPage": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/french-companies-sirene-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": [
        "restaurant paris",
        "boulangerie lyon",
    ],
    "sirens": ["552100554"],
    "maxItems": 20,
    "includeClosed": False,
    "perPage": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/french-companies-sirene-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": [
    "restaurant paris",
    "boulangerie lyon"
  ],
  "sirens": [
    "552100554"
  ],
  "maxItems": 20,
  "includeClosed": false,
  "perPage": 25
}' |
apify call automation-lab/french-companies-sirene-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "French Companies SIRENE Scraper",
        "description": "Search and enrich French companies from official SIRENE data. Export SIREN, SIRET, names, addresses, activity codes, and source URLs.",
        "version": "0.1",
        "x-build-id": "qKRt9AFYiqKr9xgDJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~french-companies-sirene-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-french-companies-sirene-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~french-companies-sirene-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-french-companies-sirene-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~french-companies-sirene-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-french-companies-sirene-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 search queries",
                        "type": "array",
                        "description": "Company names, brands, activities, cities, SIREN/SIRET values, or keywords to search in the French public company registry.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sirens": {
                        "title": "Exact SIREN numbers",
                        "type": "array",
                        "description": "Optional 9-digit French company identifiers for direct enrichment.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\d{9}$"
                        }
                    },
                    "sirets": {
                        "title": "Exact SIRET numbers",
                        "type": "array",
                        "description": "Optional 14-digit French establishment identifiers for direct enrichment.",
                        "items": {
                            "type": "string",
                            "pattern": "^\\d{14}$"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum companies",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of company or establishment records to save across all searches.",
                        "default": 20
                    },
                    "postalCodes": {
                        "title": "Postal code prefixes",
                        "type": "array",
                        "description": "Keep only head-office establishments whose postal code starts with one of these prefixes, e.g. 75 for Paris or 130 for Marseille area.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "departments": {
                        "title": "Department codes",
                        "type": "array",
                        "description": "Keep only companies in these French departments, e.g. 75, 13, 69, 971.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeClosed": {
                        "title": "Include closed companies",
                        "type": "boolean",
                        "description": "By default the actor skips records that appear administratively closed. Enable this for historical enrichment.",
                        "default": false
                    },
                    "perPage": {
                        "title": "API page size",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Number of source API results to request per page. The public endpoint works reliably up to 25.",
                        "default": 25
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```