# France Company Registry Scraper — SIRENE API (`bovi/companies-france`) Actor

Search French companies via the official open SIRENE / Recherche-Entreprises API. Returns SIREN, legal name, NAF code, address, employee band, incorporation date, officers, and financial data. No API key required. Pay per result.

- **URL**: https://apify.com/bovi/companies-france.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Lead generation
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 companies

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Company Registry Scraper — SIRENE / Recherche-Entreprises API

Used by KYC teams verifying French counterparties before contract signing, B2B sales reps enriching French prospect lists, and M&A analysts mapping sector exposure via NAF codes.

Search and extract French company data from the official **SIRENE / Recherche-Entreprises** open government API. No API key required. Pay per result.

**$5.00/1K records** (Pay Per Event). Financial data add-on +$2.00/1K (charged only when revenue/net_income present). Officers add-on +$2.00/1K. First 10 results free. No API key required. Official French government data (INSEE SIRENE + RNE). SIREN/SIRET authoritative.

### What you get

| Field | Description |
|---|---|
| `siren` | 9-digit French company identifier |
| `siret` | 14-digit registered office (siege) identifier |
| `name` | Full company display name |
| `legal_name` | Raison sociale |
| `trade_name` | Commercial name of the registered office |
| `legal_form_code` | Nature juridique code (e.g. 5710 = SAS) |
| `status` | `active` or `closed` |
| `naf_code` | NAF/APE activity code (e.g. `30.30Z`) |
| `naf_label` | NAF section in English (e.g. Manufacturing) |
| `category` | Company size: GE / ETI / PME / TPE |
| `employee_band` | Employee count range (decoded) |
| `incorporation_date` | Date of creation (YYYY-MM-DD) |
| `closure_date` | Closure date if applicable |
| `address` | Full formatted address of the registered office |
| `city` | City |
| `postal_code` | Postal code |
| `department` | Department code (e.g. 75) |
| `region` | Region code |
| `latitude` / `longitude` | GPS coordinates of the registered office |
| `revenue` | Latest year turnover in EUR (when available) |
| `net_income` | Latest year net income in EUR (when available) |
| `finance_year` | Year of the financial data |
| `officers` | List of dirigeants (name, role, nationality, birth year) |
| `officers_count` | Total officer count |
| `establishments_count` | Total establishments |
| `open_establishments_count` | Open establishments |
| `query` | Search query that returned this record |
| `parse_confidence` | Data quality score 0–1 |
| `warnings` | Machine-readable quality flags |

### How to use

1. Set **Search queries** — company name, city, activity sector, or free text (e.g. `LVMH`, `boulangerie Paris`, `Airbus`)
2. Set **Max results per query** (default 100, 0 = unlimited)
3. Optionally filter: **Active companies only**, **Company size category**
4. Optionally disable **Include officers** if you only need the firmographic data

No API key is needed. The Recherche-Entreprises API is a free, open French government service.

### Use cases

- **KYC / due diligence** — verify a French counterparty's SIREN, legal status, registered address, and officers
- **B2B lead generation** — find companies by activity (NAF code), city, or size category
- **Market research** — map sectors, employee bands, incorporation trends
- **Compliance** — track company status, closure dates, officer changes
- **Financial data** — extract revenue and net income for companies that file public accounts

### Data source

**Recherche-Entreprises API** — official French government open data platform (`api.gouv.fr`). Data is sourced from INSEE SIRENE (company registry) and RNE (national company register), updated continuously.

Financial data (revenue, net income) is available for companies that file public annual accounts (approximately 30–40% of registered companies).

### Pricing

**Pay-per-result (PPE):**

| Event | Rate | Trigger |
|---|---|---|
| `company-record` (base) | **$5.00/1K** | Every company record returned |
| `financials-record` (add-on) | **$2.00/1K** | Records with `revenue` or `net_income` present (~35% of companies) |
| `officers-fetch` (add-on) | **$2.00/1K** | Records with officers when `includeOfficers: true` |

Premium events fire only when the data is actually present — you are never charged a premium for companies that don't file public accounts or have no officers on record. No monthly subscription.

**Worked examples:**

| Run | Records | Financials? | Officers? | Cost |
|---|---|---|---|---|
| 100 companies (name search) | 100 | No | No | **$0.50** |
| 1,000 companies | 1,000 | No | No | **$5.00** |
| 500 companies with financials (~35% hit rate) | 500 | ~175 | No | **$2.85** ($2.50 + $0.35 financials) |
| 200 companies with officers | 200 | No | Yes | **$1.40** ($1.00 base + $0.40 officers) |

### FAQ

**Do I need an API key or proxy?**
No. The Recherche-Entreprises API is a free, open French government service — no key, no proxy, no signup needed.

**How much financial data is available?**
Revenue and net income are available for companies that file public annual accounts — approximately 30–40% of French registered companies. Others return `null` on those fields and are not charged the financial add-on.

**Can I filter by region or sector?**
Filter by company size category (GE / ETI / PME / TPE) using the `categorieEntreprise` input. For sector filtering, include NAF code or sector keywords in your search query (e.g. `fintech Paris`).

**What if my search returns empty?**
Zero results are not charged. Try broader search terms — the API searches across company name, trade name, and city. Use `activeOnly: false` to include dissolved companies.

### Notes

- The API is open and free; no key is needed
- Financial data is available for companies that file public accounts; others return `null` on `revenue` / `net_income`
- Officer birth dates are partially masked (year only) in the API response — full dates are not available
- The `parse_confidence` field ranges from 0 to 1; records below 0.7 may have incomplete data

### vs. Competitors

| Feature | This Actor | silentflow/france-company-scraper | Pappers / Societe.com API |
|---|---|---|---|
| Data source | Official INSEE SIRENE + RNE | HTML scraping Pappers | Paid vendor API |
| No API key required | Yes — zero friction | No (proxy needed) | No (paid subscription) |
| Revenue & net income | Yes (public filers, ~35%) | Partial | Yes (paid tier) |
| GPS coordinates | Yes (lat/lon of siege) | No | No |
| Officers (dirigeants) | Yes (included by default) | Partial | Yes (paid) |
| parse_confidence | Yes | No | No |
| Cost | **$5/1K** | ~$3-7/1K + proxy | $20-50/1K+ |

### Use with AI agents (MCP)

An agent calls this tool to **look up a French company's legal identity, registered address, size, sector, and officers mid-conversation** — e.g. "Is Airbus active and where is it registered?" or "Find all fintech PMEs in Lyon" or "Verify the SIREN and officer list for counterparty X before signing a contract."

Point your MCP client at this single tool:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.apify.com/?tools=bovi/companies-france",
        "--header",
        "Authorization: Bearer <YOUR_APIFY_TOKEN>"
      ]
    }
  }
}
````

Minimal input an agent can pass (set `maxResultsPerQuery` low to control token cost; set `includeOfficers: false` when you only need firmographics):

```json
{ "queries": ["LVMH"], "maxResultsPerQuery": 5, "includeOfficers": false }
```

Returns flat, clean rows the agent can reason over directly:

```json
{
  "siren": "775670417",
  "name": "LVMH MOËT HENNESSY LOUIS VUITTON",
  "status": "active",
  "naf_code": "70.10Z",
  "naf_label": "Professional, Scientific and Technical",
  "category": "GE",
  "employee_band": "10 000+",
  "incorporation_date": "1987-06-20",
  "city": "PARIS 8",
  "postal_code": "75008",
  "parse_confidence": 1.0,
  "warnings": []
}
```

Reliability for agents: data comes from the **official French government SIRENE API** (INSEE + RNE), not HTML scraping — results don't break on website redesigns and every record carries a stable `siren` identifier for de-duplication across runs. `parse_confidence` (0–1) and `warnings` flag any incomplete records so agents can filter low-quality results. Stale or unmatched queries return an empty result set, never bad rows. No API key needed inside the tool — auth is your Apify token in the client config above.

### Integrations

Built for KYC analysts and B2B sales teams verifying and enriching French company data via official SIRENE records — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

# Actor input Schema

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

One or more search terms — company name, city, activity, or free text. Each query is searched separately and results merged. Examples: 'LVMH', 'boulangerie Paris', 'Airbus', 'SAS fintech Lyon'.

## `maxResultsPerQuery` (type: `integer`):

Maximum company records to return per query. Set low (10–50) for agent calls to control cost. 0 = no limit (up to API maximum ~10 000). The API paginates automatically.

## `includeOfficers` (type: `boolean`):

Include the list of company officers (dirigeants — name, role, birth year, nationality) in each record. Set false to reduce output size when you only need firmographic data. Officers are returned inline by the API at no extra cost.

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

When true, only companies with etat\_administratif=A (active, not dissolved) are included. Set false to also retrieve closed/dissolved entities.

## `categorieEntreprise` (type: `string`):

Filter by INSEE company size category. GE = large enterprise (>5 000 employees), ETI = mid-size (500–5 000), PME = SME (10–499), TPE = micro (<10). Leave blank to return all sizes.

## Actor input object example

```json
{
  "queries": [
    "LVMH"
  ],
  "maxResultsPerQuery": 25,
  "includeOfficers": true,
  "activeOnly": true,
  "categorieEntreprise": ""
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing French company records (siren, siret, name, trade\_name, legal\_form\_code, status, naf\_code, naf\_label, category, employee\_band, incorporation\_date, address, city, postal\_code, revenue, net\_income, officers\_count, etc.)

# 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": [
        "LVMH"
    ],
    "maxResultsPerQuery": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/companies-france").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": ["LVMH"],
    "maxResultsPerQuery": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/companies-france").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": [
    "LVMH"
  ],
  "maxResultsPerQuery": 25
}' |
apify call bovi/companies-france --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "France Company Registry Scraper — SIRENE API",
        "description": "Search French companies via the official open SIRENE / Recherche-Entreprises API. Returns SIREN, legal name, NAF code, address, employee band, incorporation date, officers, and financial data. No API key required. Pay per result.",
        "version": "0.1",
        "x-build-id": "6hDeigLW3iJzzm7sX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~companies-france/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-companies-france",
                "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/bovi~companies-france/runs": {
            "post": {
                "operationId": "runs-sync-bovi-companies-france",
                "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/bovi~companies-france/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-companies-france",
                "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": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "One or more search terms — company name, city, activity, or free text. Each query is searched separately and results merged. Examples: 'LVMH', 'boulangerie Paris', 'Airbus', 'SAS fintech Lyon'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerQuery": {
                        "title": "Max results per query",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum company records to return per query. Set low (10–50) for agent calls to control cost. 0 = no limit (up to API maximum ~10 000). The API paginates automatically.",
                        "default": 25
                    },
                    "includeOfficers": {
                        "title": "Include officers (dirigeants)",
                        "type": "boolean",
                        "description": "Include the list of company officers (dirigeants — name, role, birth year, nationality) in each record. Set false to reduce output size when you only need firmographic data. Officers are returned inline by the API at no extra cost.",
                        "default": true
                    },
                    "activeOnly": {
                        "title": "Active companies only",
                        "type": "boolean",
                        "description": "When true, only companies with etat_administratif=A (active, not dissolved) are included. Set false to also retrieve closed/dissolved entities.",
                        "default": true
                    },
                    "categorieEntreprise": {
                        "title": "Company size category",
                        "enum": [
                            "",
                            "GE",
                            "ETI",
                            "PME",
                            "TPE"
                        ],
                        "type": "string",
                        "description": "Filter by INSEE company size category. GE = large enterprise (>5 000 employees), ETI = mid-size (500–5 000), PME = SME (10–499), TPE = micro (<10). Leave blank to return all sizes.",
                        "default": ""
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```