# EU Fresh Company Radar — New Company Registrations Feed (`studio-amba/eu-fresh-company-radar`) Actor Nightly meta-scraper that fans out to our UK, French, German, Norwegian, Swedish, Dutch, Polish and Italian company-registry scrapers and emits only company registrations not seen in a prior run — a deduped delta feed, not a full re-export. - **URL**: https://apify.com/studio-amba/eu-fresh-company-radar.md - **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community) - **Categories:** Business, Lead generation - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $10.00 / 1,000 new company records 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/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 ## EU Fresh Company Radar Nightly feed of new company registrations across five European registries — UK, France, Germany, Norway and Sweden — in one unified schema, deduplicated run over run so you only ever get what's new. ### Why use this actor? Sales teams, compliance/KYC desks and lead-gen shops all want the same thing: know the moment a new company shows up on a register, in a country they care about, without re-downloading the whole registry every night to spot the difference themselves. This actor does that diffing for you. Run it on a schedule (nightly is the intended cadence) and every run only returns companies it hasn't returned before — a persistent, named key-value store remembers what it has already seen, across separate scheduled runs, not just within one run. It is a meta-actor: under the hood it fans out to our own Companies House, Recherche Entreprises (French official registry), North Data, BRREG (Norwegian official registry) and Allabolag.se scrapers, normalizes every country's fields into one shape, and only pushes rows that are new to this actor's memory. ### How to scrape new company registrations in Europe 1. Pick your countries (or leave the field empty for all five). 2. Run it once — the first run has nothing to compare against, so it seeds its memory and every company found counts as "new." Expect a few hundred rows on a UK-only first run, since UK is the one country with a genuine incorporation-date filter. 3. Schedule it (see below). Every subsequent run only returns companies it hasn't seen before — a UK company incorporated last week that a prior run already reported won't come back. 4. For the four non-UK countries, "new" means "new to our search net," not strictly "newly incorporated" — see Limitations below for why, and how to read the `incorporationDate` field to judge true freshness yourself. ### Scheduling This actor's whole point is running on a schedule, not as a one-off. In the Apify Console: 1. Open the actor, go to **Schedules → Create new schedule**. 2. Nightly (e.g. `0 3 * * *`, 3am UTC) is the intended cadence — company registries update on business days, so a daily run is plenty granular. There is no benefit to running it more than once a day: the delta only grows by what registries actually published since the last run. 3. Leave the input as your default country/keyword selection. Do not turn on `resetState` on a scheduled run — that flag wipes the actor's memory and would make every run look like a "first run," defeating the whole point. 4. Optional: point the schedule's output at an integration (Zapier, Make, a webhook) that fires per new dataset item, so new registrations land in your CRM or Slack the same morning they're published. ### Input | Field | Type | Required | Description | |-------|------|----------|-------------| | `countries` | Array | No | Which registries to scan: `GB`, `FR`, `DE`, `NO`, `SE`. Empty = all 5. | | `keywordsPerCountryPerRun` | Integer | No | For the 4 non-UK countries: how many native-language search keywords to run per country per run (default 2). The keyword pool rotates forward each run. | | `maxResultsPerQuery` | Integer | No | Cap per keyword search / per UK date-window call (default 25). | | `recentWindowDays` | Integer | No | UK only — trailing window in days for the incorporation date-range filter (default 3). | | `timeoutPerSourceSecs` | Integer | No | Max wait per underlying registry call before it's marked failed and skipped (default 180). | | `proxyConfiguration` | Object | No | Passed through to North Data (Germany) only — every other source reads an open government API directly, no proxy needed. | | `resetState` | Boolean | No | Testing only — wipes the seen-set and keyword rotation before the run. Never use on a real schedule. | ### Output One row per newly-seen company, plus a single status row on a legitimate zero-delta run (sources healthy, nothing new since last run). | Field | Type | Example | |-------|------|---------| | `country` | String | `"GB"` | | `legalName` | String | `"BAMARI PROFESSIONAL CLEANING SERVICES LTD"` | | `regNumber` | String | `"17337314"` | | `incorporationDate` | String | `"2026-07-13"` | | `address` | String | `"Flat 3, ... Edinburgh EH2 4AN"` | | `source` | String | `"studio-amba/companies-house-scraper"` | | `firstSeenAt` | String | `"2026-07-18T07:10:51.272Z"` | | `recordType` | String | `"new_company"` or `"run_status"` | ### Example output ```json { "country": "GB", "legalName": "GOLD VAULT NEXUS INVESTMENTS LP", "regNumber": "SL038113", "incorporationDate": "2026-07-13", "address": "5 South Charlotte Street Edinburgh EH2 4AN", "source": "studio-amba/companies-house-scraper", "firstSeenAt": "2026-07-18T07:10:51.272Z", "recordType": "new_company" } ```` On a run where nothing new was found (sources healthy, just no fresh registrations since the last run), you get one status row instead of an empty dataset: ```json { "country": "ALL", "legalName": "STATUS: zero-delta run", "regNumber": "", "incorporationDate": "", "address": "", "source": "eu-fresh-company-radar", "firstSeenAt": "2026-07-18T08:00:00.000Z", "recordType": "run_status" } ``` ### How the delta works Every company's `country:regNumber` pair is checked against a named, persistent key-value store (`eu-fresh-company-radar-state`) that survives across separate scheduled runs — not `Actor.useState`, which only checkpoints a single run for migration-safe resume. First run: nothing is in the store yet, so every company found is "new" and gets added. Every later run: only companies whose `regNumber` isn't already in the store get emitted; everything else is silently skipped (it was already reported). Each country also has its own rotating offset into its keyword pool (see Limitations), so consecutive runs use different search terms and broaden coverage over time instead of hammering the same query every night. Proven live (2026-07-18): a first GB run with `resetState: true` returned 500 new companies incorporated in the trailing window; re-running the identical input immediately after with `resetState: false` returned 0 new companies (all 500 candidates already known) and correctly pushed a single zero-delta status row instead of an empty dataset or a failure. ### Country coverage and source choice | Country | Registry actor | Discovery mode | Has incorporation date? | |---------|----------------|----------------|--------------------------| | UK (GB) | `companies-house-scraper` | True date-range filter | Yes | | France (FR) | `recherche-entreprises-scraper` | Keyword search net | Yes | | Germany (DE) | `northdata-scraper` | Keyword search net (requires `fetchDetails: true`) | Yes | | Norway (NO) | `brreg-scraper` | Keyword search net | Yes | | Sweden (SE) | `allabolag-se-scraper` | Keyword search net | No (base output) | Five additional candidate sources were wired, cloud-tested and dropped — logged here rather than silently omitted, per the fleet's "skip and note broken children" rule: - **firmy-cz-scraper (Czech Republic)** — it's a business directory, not an official registry. It returns no registration number and no date field on any result, so there is no reliable identity to dedup on. Without that, a "new registrations" product can't work — every run would look "new" because nothing can be recognized as already-seen. - **pappers-scraper (FR) and proff-no-scraper (NO)** — both work and both cover the same countries as the sources above, but recherche-entreprises.api.gouv.fr and data.brreg.no are free official government APIs with no anti-bot and no proxy cost, while pappers and proff.no are commercial mirrors that need residential proxies for the same data. Kept the cheaper, more direct source; dropped the redundant one. - **kvk-scraper (Netherlands)** — live-tested 2026-07-18 with two different keywords ("bouw", "advies"); both returned 0 companies. The kvk.nl search flow or its selectors appear to have changed upstream. Needs separate healing before NL can be added back. - **krs-scraper (Poland)** — its `searchQuery` mode brute-force scans the entire Monitor Sądowy i Gospodarczy bulletin (18,000+ entries, checked sequentially) instead of querying an indexed search endpoint. A single keyword didn't finish within a 150-second timeout in testing. This isn't a timeout-tuning problem — the mechanism itself is too slow for a keyword-rotation product. `krsNumber` direct lookup is fast but doesn't fit a discovery product (you'd need the number already). - **registro-imprese-scraper (Italy)** — its `searchQuery` mode only hits an autocomplete suggester that returns company names, nothing else — no `numeroRea`, no `partitaIva`, no address, no date, by design (verified in source). No registration number means no dedup key, so it fails for the same reason firmy.cz does. ### Limitations - **Only UK has a true "new registrations" filter.** Companies House exposes an `incorporatedFrom`/`incorporatedTo` bulk filter — a genuine "everything incorporated in this window" feed, no keyword needed. None of the other four registries' actors expose an equivalent date-range parameter (verified against source, not assumed); every one of them requires a search keyword. For those countries, this actor rotates through a pool of common native-language business-type keywords each run and treats "not seen before" as the delta signal. That means a company surfacing for the first time is either genuinely newly registered, or an older company the keyword net finally reached. The `incorporationDate` field is still returned wherever the source exposes one, so you can judge true freshness yourself rather than trust the delta alone. - **Sweden has no incorporation date in the base output.** `allabolag-se-scraper` only returns founding date when detail enrichment is switched on, which multiplies requests per company. To keep this actor's per-run cost and runtime sane, Sweden runs with detail enrichment off — you get the company and its registration number, not a date. - **Search-net coverage is a sample, not a full census.** Non-UK countries are not exhaustively scanned every run; the keyword rotation trades completeness for a bounded, predictable runtime (target: comfortably under 15 minutes per run at default settings). - **A company that changes its registered address or name is not re-flagged.** The dedup key is the registration number only. This actor reports new registrations, not ongoing change monitoring. - **Only 5 of 8 originally scoped countries are live.** Netherlands, Poland and Italy were wired and cloud-tested but dropped for the reasons above — see "Country coverage and source choice." They can be added back once the underlying child actor is healed (NL) or a faster/richer discovery mode is added (PL, IT). ### Cost estimate Priced per new company record found, plus a flat per-run start fee. A typical nightly run at default settings (2 keywords per non-UK country, UK's 3-day incorporation window) returns anywhere from a handful to a few hundred new companies depending on how quiet or busy the last 24 hours were across all five registries — cost scales with genuine output, not with how much data was scanned underneath. # Actor input Schema ## `countries` (type: `array`): Which country registries to scan. Leave empty for all 5: United Kingdom (GB), France (FR), Germany (DE), Norway (NO), Sweden (SE). Netherlands, Poland and Italy were evaluated and are not currently included — see the README for why. ## `keywordsPerCountryPerRun` (type: `integer`): For countries without a true date-range filter (all except UK), how many native-language business-type keywords to search per run. The keyword pool rotates forward each run so coverage broadens over time instead of hammering the same term nightly. ## `maxResultsPerQuery` (type: `integer`): Maximum companies to fetch per keyword search (or per date-window call for UK, scaled up internally). Higher values find more per run but take longer. ## `recentWindowDays` (type: `integer`): For UK Companies House, the trailing window (in days from today) used for the incorporatedFrom/incorporatedTo bulk filter. Overlap with the previous run is fine — dedup against the seen-set drops repeats. ## `timeoutPerSourceSecs` (type: `integer`): Maximum time to wait for each underlying registry scraper call. A slow or failing source is skipped after this rather than blocking the whole run. ## `proxyConfiguration` (type: `object`): Proxy passed through to child scrapers that need one (currently only North Data / Germany — the other registries read open government APIs directly with no proxy). ## `resetState` (type: `boolean`): Clears the persistent seen-set and keyword rotation for every country before this run, so every candidate found counts as 'new'. Use for QA/testing so a run always produces items regardless of prior runs. Never enable this on a real scheduled run — it defeats the delta/dedup purpose of the actor. ## Actor input object example ```json { "countries": [ "GB" ], "keywordsPerCountryPerRun": 2, "maxResultsPerQuery": 10, "recentWindowDays": 3, "timeoutPerSourceSecs": 120, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "DE" }, "resetState": true } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "countries": [ "GB" ], "keywordsPerCountryPerRun": 2, "maxResultsPerQuery": 10, "recentWindowDays": 3, "timeoutPerSourceSecs": 120, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "DE" }, "resetState": true }; // Run the Actor and wait for it to finish const run = await client.actor("studio-amba/eu-fresh-company-radar").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "countries": ["GB"], "keywordsPerCountryPerRun": 2, "maxResultsPerQuery": 10, "recentWindowDays": 3, "timeoutPerSourceSecs": 120, "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "DE", }, "resetState": True, } # Run the Actor and wait for it to finish run = client.actor("studio-amba/eu-fresh-company-radar").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 '{ "countries": [ "GB" ], "keywordsPerCountryPerRun": 2, "maxResultsPerQuery": 10, "recentWindowDays": 3, "timeoutPerSourceSecs": 120, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ], "apifyProxyCountry": "DE" }, "resetState": true }' | apify call studio-amba/eu-fresh-company-radar --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=studio-amba/eu-fresh-company-radar", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "EU Fresh Company Radar — New Company Registrations Feed", "description": "Nightly meta-scraper that fans out to our UK, French, German, Norwegian, Swedish, Dutch, Polish and Italian company-registry scrapers and emits only company registrations not seen in a prior run — a deduped delta feed, not a full re-export.", "version": "0.1", "x-build-id": "nJ2w3NoaamzRezDwa" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/studio-amba~eu-fresh-company-radar/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-studio-amba-eu-fresh-company-radar", "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/studio-amba~eu-fresh-company-radar/runs": { "post": { "operationId": "runs-sync-studio-amba-eu-fresh-company-radar", "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/studio-amba~eu-fresh-company-radar/run-sync": { "post": { "operationId": "run-sync-studio-amba-eu-fresh-company-radar", "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": { "countries": { "title": "Countries", "type": "array", "description": "Which country registries to scan. Leave empty for all 5: United Kingdom (GB), France (FR), Germany (DE), Norway (NO), Sweden (SE). Netherlands, Poland and Italy were evaluated and are not currently included — see the README for why.", "items": { "type": "string", "enum": [ "GB", "FR", "DE", "NO", "SE" ], "enumTitles": [ "United Kingdom", "France", "Germany", "Norway", "Sweden" ] } }, "keywordsPerCountryPerRun": { "title": "Keywords Per Country Per Run", "minimum": 1, "maximum": 8, "type": "integer", "description": "For countries without a true date-range filter (all except UK), how many native-language business-type keywords to search per run. The keyword pool rotates forward each run so coverage broadens over time instead of hammering the same term nightly.", "default": 2 }, "maxResultsPerQuery": { "title": "Max Results Per Query", "minimum": 5, "maximum": 200, "type": "integer", "description": "Maximum companies to fetch per keyword search (or per date-window call for UK, scaled up internally). Higher values find more per run but take longer.", "default": 25 }, "recentWindowDays": { "title": "Recent Window Days (UK only)", "minimum": 1, "maximum": 30, "type": "integer", "description": "For UK Companies House, the trailing window (in days from today) used for the incorporatedFrom/incorporatedTo bulk filter. Overlap with the previous run is fine — dedup against the seen-set drops repeats.", "default": 3 }, "timeoutPerSourceSecs": { "title": "Timeout Per Source (seconds)", "minimum": 30, "maximum": 600, "type": "integer", "description": "Maximum time to wait for each underlying registry scraper call. A slow or failing source is skipped after this rather than blocking the whole run.", "default": 180 }, "proxyConfiguration": { "title": "Proxy Configuration", "type": "object", "description": "Proxy passed through to child scrapers that need one (currently only North Data / Germany — the other registries read open government APIs directly with no proxy)." }, "resetState": { "title": "Reset Seen-State (testing only)", "type": "boolean", "description": "Clears the persistent seen-set and keyword rotation for every country before this run, so every candidate found counts as 'new'. Use for QA/testing so a run always produces items regardless of prior runs. Never enable this on a real scheduled run — it defeats the delta/dedup purpose of the actor.", "default": false } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```