# Company Hiring Signals — Open Vacancies by Function & Board (`studio-amba/company-hiring-signals`) Actor Give it a company name and get its hiring heat: total open vacancies across our European job boards, broken down by function (engineering, sales, marketing, etc.) and by source board, plus a registry identity match. - **URL**: https://apify.com/studio-amba/company-hiring-signals.md - **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community) - **Categories:** Business, Jobs - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $40.00 / 1,000 company hiring profiles 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 ## Company Hiring Signals Give it a company name and get back its hiring heat: how many open vacancies it has right now across our European job boards, broken down by function (engineering, sales, marketing, and more) and by which board each posting came from — plus, optionally, a registry identity match so the profile is tied to a real legal entity. This actor does not scrape a website itself. It runs our own StepStone (Germany, Austria, Netherlands), Reed, HelloWork, Jobs.ch, JobUp.ch, Pracuj.pl, Jobindex, InfoJobs, Jobat, IrishJobs and EURES scrapers in parallel (the same roster as our EU Vacancy Feed actor), filters every posting down to ones that actually belong to the input company, and rolls the result into one hiring-heat profile. ### Why use this actor? A company's live vacancy count is one of the cleanest, hardest-to-fake signals of growth, funding, restructuring, or trouble. Sales teams use it to time outreach — a company suddenly hiring 10 engineers is a different conversation than one with a hiring freeze. Recruiters use it to see if a target company is actively competing for the same talent pool. Investors and market analysts use hiring breadth across functions as a proxy for what a company is actually investing in this quarter. Checking this by hand means visiting 13 different job boards, searching each one, and manually counting and classifying results — every board names its fields differently and none of them offer a "hiring by department" view out of the box. This actor does the fan-out, the company matching, and the function classification in one call, and returns exactly one row: the company's current hiring profile. ### What it returns One dataset row per run — a company profile, not a vacancy list. A company with zero matching postings right now is a valid result (`totalOpenVacancies: 0`), not a failure; it just means that company isn't hiring through these boards at the moment. Real example from a live run: ```json { "company": "Siemens", "country": "DE", "totalOpenVacancies": 14, "byFunction": { "engineering": 8, "operations": 3, "finance": 2, "sales": 1 }, "byBoard": { "StepStone Germany": 14 }, "registryId": "HRB 6684", "registryStatus": "active", "registryLegalName": "Siemens Aktiengesellschaft", "registryConfidence": "high", "boardsQueried": ["StepStone Germany"], "boardsFailed": [], "rawMatchedBeforeDedup": 14, "topVacancies": [ { "title": "Senior Software Engineer (m/w/d)", "location": "München", "boards": ["StepStone Germany"], "url": "https://www.stepstone.de/...", "postedAt": "2026-07-10" } ], "sampledAt": "2026-07-20T09:12:03.000Z" } ```` ### How to scrape company hiring signals in Europe 1. Enter a **Company name** exactly as it would appear on a job posting (e.g. `Siemens`, `ASML`, `Danone`). Matching strips common legal-entity suffixes (GmbH, SA, Ltd, BV, and a dozen others) so `Siemens` also matches postings listing `Siemens AG`. 2. Optionally set **Countries** to restrict which job boards to search. Leave empty to check all 13 boards. Narrowing to the country (or countries) where the company actually operates cuts down on false negatives from boards it doesn't post to and speeds up the run. 3. Set **Max postings scanned per board** high enough that the board's own keyword search surfaces the company's postings — a generic search can return many unrelated results before filtering down to a real match. 4. Leave **Enrich with registry identity** on to attach a legal-entity match (registration number, status, legal name) from our own company-registry scrapers. Turn it off for a faster, cheaper vacancy-only run. 5. Run the actor. All selected boards (and the registry check) run in parallel, so a full run typically finishes in 30-90 seconds. 6. Open the dataset. The single row is the company's hiring profile: total open vacancies, the function breakdown, the board breakdown, and (if enabled) the registry match. 7. Check `RUN_SUMMARY` in the key-value store for the same numbers in a quick-glance format. ### Input | Field | Type | Description | |-------|------|-------------| | `companyName` | string | Company to profile, as it appears on job postings. Defaults to `"Siemens"`. | | `countries` | array | Restrict which job-board countries to search: `DE`, `AT`, `NL`, `GB`, `FR`, `CH`, `PL`, `DK`, `ES`, `BE`, `IE`, `EU`. Empty means all 13 boards. | | `maxPerBoard` | integer | Raw postings fetched per board before filtering to this company (5-200, default 30). | | `enrichRegistry` | boolean | Attach a registry identity match via our EU Dealer Counterparty Check actor. Default `true`. | | `registryCountry` | string | Country whose registry to check: `auto` (first covered country from `countries`, falling back to Germany), an explicit code, or `none` to skip registry enrichment. | | `timeoutPerBoardSecs` | integer | Max seconds to wait per board/registry source before treating it as failed (30-600, default 120). | | `proxyConfiguration` | object | Proxy settings passed to the underlying scrapers. Leave default — each source falls back to its own known-good country-pinned residential proxy. | #### Example input ```json { "companyName": "ASML", "countries": ["NL"], "maxPerBoard": 30, "enrichRegistry": true } ``` ### Output | Field | Type | Description | |-------|------|-------------| | `company` | string | Company name that was searched | | `country` | string | Primary country for this profile (registry country if resolved, else first requested board country) | | `totalOpenVacancies` | integer | Deduplicated open-vacancy count across all queried boards. `0` is valid — it means no match, not a failed run | | `byFunction` | object | Vacancy count per function bucket: `engineering`, `sales`, `marketing`, `customer_support`, `operations`, `finance`, `hr`, `product`, `design`, `legal`, `healthcare`, `logistics`, `admin`, `other` | | `byBoard` | object | Raw matched vacancy count per source board (a vacancy cross-posted on 2 boards counts on both) | | `registryId` | string | Official registration number, when a registry match was found | | `registryStatus` | string | `active`, `dissolved`, `insolvent`, `unknown`, `not_found`, `not_covered`, or `error` | | `registryLegalName` | string | Legal entity name from the matched registry entry | | `registryConfidence` | string | `high`/`medium`/`low` confidence of the registry match | | `boardsQueried` | array | Boards successfully queried this run | | `boardsFailed` | array | Boards that errored, timed out, or returned zero raw items | | `rawMatchedBeforeDedup` | integer | Matched postings before cross-board dedup | | `topVacancies` | array | Up to 10 sample matched vacancies for spot-checking | | `sampledAt` | string | ISO timestamp of collection | ### How function classification works Each matched vacancy's title is checked against a keyword list, ordered from most specific to most general — a `Support Engineer` title lands in `customer_support`, not `engineering`, because the more specific department pattern is checked first. Keywords cover English plus common German, French, Dutch, Spanish, Polish and Danish job-title vocabulary. This is a heuristic keyword match, not a machine-learning classifier — see Limitations. ### How company matching works A job posting's employer field is compared against the input `companyName` after both are lowercased, stripped of diacritics, and stripped of ~30 common EU legal-entity suffixes (GmbH, SA, SARL, BV, NV, Ltd, PLC, Srl, Sp z o.o., S.r.o., Oy, AB, Kft, and more). An exact match after normalization counts, and so does a substring match either way (so `Siemens` matches `Siemens Energy AG` and `Siemens AG` both) — guarded so short 1-2 character names can't match everything. ### Registry enrichment When enabled, the actor calls our own [EU Dealer Counterparty Check](https://apify.com/studio-amba/eu-dealer-counterparty-check) actor, which covers 11 European registries: Germany, France, UK, Poland, Italy, Spain, Switzerland, Norway, Sweden, Czechia, Netherlands. If the resolved country isn't in that list (Austria, Denmark, Belgium, Ireland, or EU-wide EURES-only searches), `registryStatus` is `not_covered` rather than a guess. ### FAQ **Does this actor scrape the job boards or registries itself?** No. It calls our own StepStone, Reed, HelloWork, Jobs.ch, JobUp.ch, Pracuj, Jobindex, InfoJobs, Jobat, IrishJobs, EURES and EU Dealer Counterparty Check actors and merges their output. Each is also available separately on the Store. **Why is `totalOpenVacancies` 0 for a company I know is hiring?** Either the company isn't posting on any of the 13 boards this actor queries, the posted employer name doesn't match closely enough (check for a very different trading name vs. legal entity), or `maxPerBoard` wasn't high enough for the board's own search to surface the company's postings before the cutoff. Try raising `maxPerBoard` or widening `countries`. **Why does `byBoard` sometimes sum to more than `totalOpenVacancies`?** `byBoard` counts raw matched postings per board before cross-board dedup. If the same vacancy is cross-posted on 2 boards (e.g. EURES re-indexing a national board), it counts once on each board in `byBoard` but only once in `totalOpenVacancies`. **Can I profile a company with no presence in our registry fleet?** Yes — set `enrichRegistry` to `false`, or leave it on and just read `registryStatus: "not_covered"`. The vacancy breakdown works independently of registry coverage. **How accurate is the function breakdown?** It's a keyword heuristic, not a taxonomy the company itself assigned. A title like "Growth Marketing Engineer" or an unusually worded internal title can land in the wrong bucket. Treat `byFunction` as a directional signal, not an exact org chart. ### Limitations - Function classification is keyword-based and English/DE/FR/NL/ES/PL/DK-vocabulary aware, not a machine-learning classifier — unusual or highly localized job titles can be misclassified into `other` or the wrong bucket. - Company matching only catches postings where the employer field names the company (directly or via a common legal-suffix variant) — postings through a recruitment agency that doesn't list the hiring company by name won't match. - Coverage is limited to the 13 job boards in the roster (one per-market leader per country) — a company's postings on a board outside this set won't be counted. - Registry enrichment covers 11 countries; others return `not_covered`, not a guess. - Data is scraped from public job board and registry listings and may change without notice. ### Related actors - [EU Vacancy Feed](https://apify.com/studio-amba/eu-vacancy-feed) — the same 13-board roster, but keyword-driven and deduplicated across all companies, not filtered to one - [EU Dealer Counterparty Check](https://apify.com/studio-amba/eu-dealer-counterparty-check) — the registry identity check this actor uses for enrichment, also available standalone - [StepStone Germany](https://apify.com/studio-amba/stepstone-de) - [Reed](https://apify.com/studio-amba/reed-scraper) - [Pracuj.pl](https://apify.com/studio-amba/pracuj-scraper) We also run this as a managed service: scheduled runs against a fixed company watchlist, delivered to your inbox, Google Sheets, or API, maintenance included. See [studioamba.dev/services](https://studioamba.dev/services/) or email for a free data sample. # Actor input Schema ## `companyName` (type: `string`): Name of the company to profile, as it would appear on a job posting (e.g. 'Siemens', 'ASML', 'Danone'). Matching is fuzzy on legal-entity suffixes (GmbH, SA, Ltd, BV, ...) but requires the core name to match. ## `countries` (type: `array`): Restrict which job-board countries to search for this company's postings. Leave empty to search all 13 boards. Use ISO2 codes: DE, AT, NL, GB, FR, CH, PL, DK, ES, BE, IE, EU (EURES, pan-European). ## `maxPerBoard` (type: `integer`): How many raw postings to fetch from each board before filtering to this company. A generic keyword search on a board can return many unrelated postings, so this needs headroom above the number of vacancies you expect the company to actually have open. ## `enrichRegistry` (type: `boolean`): Run our EU Dealer Counterparty Check to attach a registry identity match (legal name, registration number, status) to the profile. Adds one extra child-actor call. On by default. ## `registryCountry` (type: `string`): Country whose company registry to check for identity enrichment. 'Auto' picks the first of your selected job-board countries that our registry fleet covers (DE, FR, GB, PL, IT, ES, CH, NO, SE, CZ, NL), falling back to Germany. Set 'None' to skip registry enrichment entirely. ## `timeoutPerBoardSecs` (type: `integer`): Maximum time to wait for each underlying board scraper (or the registry check) to finish. A slow source is skipped after this and reported as failed rather than blocking the whole run. ## `proxyConfiguration` (type: `object`): Proxy settings passed to the underlying board and registry scrapers. Leave default (Apify Residential) — each source otherwise uses its own known-good country-pinned residential proxy. ## Actor input object example ```json { "companyName": "Siemens", "countries": [ "DE" ], "maxPerBoard": 15, "enrichRegistry": true, "registryCountry": "auto", "timeoutPerBoardSecs": 120, "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } } ``` # 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 = { "companyName": "Siemens", "countries": [ "DE" ], "maxPerBoard": 15, "registryCountry": "auto", "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }; // Run the Actor and wait for it to finish const run = await client.actor("studio-amba/company-hiring-signals").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 = { "companyName": "Siemens", "countries": ["DE"], "maxPerBoard": 15, "registryCountry": "auto", "proxyConfiguration": { "useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"], }, } # Run the Actor and wait for it to finish run = client.actor("studio-amba/company-hiring-signals").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 '{ "companyName": "Siemens", "countries": [ "DE" ], "maxPerBoard": 15, "registryCountry": "auto", "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": [ "RESIDENTIAL" ] } }' | apify call studio-amba/company-hiring-signals --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=studio-amba/company-hiring-signals", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Company Hiring Signals — Open Vacancies by Function & Board", "description": "Give it a company name and get its hiring heat: total open vacancies across our European job boards, broken down by function (engineering, sales, marketing, etc.) and by source board, plus a registry identity match.", "version": "0.1", "x-build-id": "E2QuM23TFSwLuqCQN" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/studio-amba~company-hiring-signals/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-studio-amba-company-hiring-signals", "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~company-hiring-signals/runs": { "post": { "operationId": "runs-sync-studio-amba-company-hiring-signals", "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~company-hiring-signals/run-sync": { "post": { "operationId": "run-sync-studio-amba-company-hiring-signals", "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": { "companyName": { "title": "Company name", "type": "string", "description": "Name of the company to profile, as it would appear on a job posting (e.g. 'Siemens', 'ASML', 'Danone'). Matching is fuzzy on legal-entity suffixes (GmbH, SA, Ltd, BV, ...) but requires the core name to match.", "default": "Siemens" }, "countries": { "title": "Countries", "type": "array", "description": "Restrict which job-board countries to search for this company's postings. Leave empty to search all 13 boards. Use ISO2 codes: DE, AT, NL, GB, FR, CH, PL, DK, ES, BE, IE, EU (EURES, pan-European).", "items": { "type": "string", "enum": [ "DE", "AT", "NL", "GB", "FR", "CH", "PL", "DK", "ES", "BE", "IE", "EU" ], "enumTitles": [ "Germany (StepStone)", "Austria (StepStone)", "Netherlands (StepStone)", "United Kingdom (Reed)", "France (HelloWork)", "Switzerland (Jobs.ch + JobUp.ch)", "Poland (Pracuj.pl)", "Denmark (Jobindex)", "Spain (InfoJobs)", "Belgium (Jobat)", "Ireland (IrishJobs)", "EU-wide (EURES)" ] } }, "maxPerBoard": { "title": "Max postings scanned per board", "minimum": 5, "maximum": 200, "type": "integer", "description": "How many raw postings to fetch from each board before filtering to this company. A generic keyword search on a board can return many unrelated postings, so this needs headroom above the number of vacancies you expect the company to actually have open.", "default": 30 }, "enrichRegistry": { "title": "Enrich with registry identity", "type": "boolean", "description": "Run our EU Dealer Counterparty Check to attach a registry identity match (legal name, registration number, status) to the profile. Adds one extra child-actor call. On by default.", "default": true }, "registryCountry": { "title": "Registry country", "enum": [ "auto", "DE", "FR", "GB", "PL", "IT", "ES", "CH", "NO", "SE", "CZ", "NL", "none" ], "type": "string", "description": "Country whose company registry to check for identity enrichment. 'Auto' picks the first of your selected job-board countries that our registry fleet covers (DE, FR, GB, PL, IT, ES, CH, NO, SE, CZ, NL), falling back to Germany. Set 'None' to skip registry enrichment entirely.", "default": "auto" }, "timeoutPerBoardSecs": { "title": "Timeout per board (seconds)", "minimum": 30, "maximum": 600, "type": "integer", "description": "Maximum time to wait for each underlying board scraper (or the registry check) to finish. A slow source is skipped after this and reported as failed rather than blocking the whole run.", "default": 120 }, "proxyConfiguration": { "title": "Proxy configuration", "type": "object", "description": "Proxy settings passed to the underlying board and registry scrapers. Leave default (Apify Residential) — each source otherwise uses its own known-good country-pinned residential proxy." } } }, "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 } } } } } } } } } } ```