# LinkedIn Company Jobs Monitor (`apixyz/linkedin-company-jobs-monitor`) Actor

Monitor new, updated, and confirmed-removed job postings for up to 20 companies on LinkedIn's public job search. Faceted enumeration covers large employers; confirmed removals require a complete scan. No login or cookies.

- **URL**: https://apify.com/apixyz/linkedin-company-jobs-monitor.md
- **Developed by:** [Tarek Etman](https://apify.com/apixyz) (community)
- **Categories:** Jobs, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

Track hiring changes for up to 20 companies through LinkedIn's public guest job search. Every scan reports new and updated postings from the newest-first window, for companies of any size. A removal is emitted only after the same job is absent from two complete consecutive scans, which protects saved history when source access is incomplete.

The current Store configuration charges $0.005 at run start, $0.003 per posting checked, and $0.015 per non-baseline change. Apify platform usage is billed separately to the user. No LinkedIn account or cookies are required.

### Built for recurring company research

Use the monitor for account research that needs fresh hiring signals or for competitor intelligence that must keep its history through an interrupted source scan. The first run creates a baseline. Later runs emit `NEW_POSTING`, `UPDATED_POSTING`, and — from complete scans — `REMOVED_POSTING` rows.

A numeric LinkedIn company ID gives the cleanest scope. Company-name search remains available as a filtered fallback when the ID is unavailable.

### Coverage: how large employers are enumerated

LinkedIn's public guest search returns only about 30 to 50 results for a single company query, regardless of how large the company is. To see past that ceiling, the monitor runs the company query once per location in `facetLocations` and unions the de-duplicated postings. On a large employer this recovers many times more postings than a single query. Each scan reads newest-first (`sortBy=DD`), paces its requests, and retries a repeated page once before treating it as the end, because a repeat on the guest surface is usually a transient throttle rather than the true end of results.

Set `facetLocations` to the markets a company hires in for the best coverage-to-cost ratio, keep the broad default list, or set it to an empty list to run a single query for a small employer that fits under the ceiling.

### The two guarantees

The monitor makes two promises with different evidence requirements, and it keeps them separate so each is honest:

- **New and updated postings** need only a recent view of the newest jobs. They are reported from the observed window on **every** scan, complete or not. Adding an observed posting to saved state can never fabricate a removal, so this is safe even when a scan cannot be finished.
- **Confirmed removals** need full enumeration, so that an absent job is known to be gone rather than merely beyond the scanned window. A removal is therefore restricted to **complete** scans (the base query and every location facet each reached an empty final page) and still requires two consecutive complete absences. Very large employers may not reach a complete scan on the public guest surface; for those, the monitor reports new and updated postings and holds removals rather than guessing.

### Sample change

```json
{
  "changeType": "NEW_POSTING",
  "companyLabel": "Acme",
  "companyId": "1035",
  "companyName": null,
  "jobId": "4440655897",
  "title": "Applied AI Engineer",
  "location": "Paris, France",
  "salary": null,
  "postedAt": "2026-07-21",
  "postedText": "1 day ago",
  "url": "https://www.linkedin.com/jobs/view/4440655897/",
  "scanComplete": false,
  "scanTruncated": true,
  "scanDiagnostic": "FACETED_INCOMPLETE",
  "checkedAt": "2026-07-22T09:15:00.000Z"
}
````

`scanComplete` tells you whether the scan that produced a row was exhaustive. Removed rows keep the fields from the last complete snapshot. Relative posting text is excluded from change identity, so a label such as "2 days ago" becoming "3 days ago" does not create an update.

### Input

`companies` accepts one to 20 entries. Add `companyId` when possible, or use `companyName` as the fallback. The optional `label` is copied to each output row.

```json
{
  "companies": [
    { "companyId": "1035", "label": "Microsoft" },
    { "companyName": "Acme Corp", "label": "Acme" }
  ],
  "monitorId": "target-accounts-eu",
  "maxItemsPerCompany": 100,
  "facetLocations": ["United States", "United Kingdom", "Germany", "India"],
  "sortBy": "DD",
  "pacingMs": 1500,
  "fullReport": true,
  "webhookUrl": "https://example.com/linkedin-job-changes"
}
```

Reuse the same `monitorId` on scheduled runs to compare with the same saved history. `maxItemsPerCompany` defaults to 50, is capped at 500, and bounds the union across all facets — reaching it marks the scan incomplete, so choose a value above a company's expected public posting count when you need complete scans and confirmed removals. `facetLocations` controls coverage and cost: more locations means more requests and more postings checked. `pacingMs` spaces requests to reduce throttling. `fullReport` adds diagnostic rows for quiet or incomplete company scans. `webhookUrl` receives one HTTPS POST when a scan finds changes.

### State and removal safety

Only a genuinely empty final page completes a facet, and a scan is complete only when the base query and every facet complete without truncation. A block, fetch failure, malformed response, duplicate page, per-company cap, per-facet page guard, or billing limit leaves the scan incomplete. Incomplete scans still report new and updated postings, but they never drop a stored job and never increment a removal count, so no sequence of incomplete scans can confirm a removal or erase history.

The two-scan removal rule applies to complete scans. If a job is absent from one complete scan, the monitor records that absence internally. A second complete absence emits `REMOVED_POSTING`. A job that reappears clears its pending absence.

Review `OUTPUT_SUMMARY` before acting on a quiet run. It records, per company, how many postings were observed, whether the scan was complete, and the billing outcome.

#### Where the history is kept

On its first run each `monitorId` creates a named key-value store, `linkedin-company-jobs-<monitorId>`, in your account and reuses it on every later run. Keep the `monitorId` stable to keep the history; change it to start a fresh baseline.

This Actor runs with limited permissions, so it can only use a store it created itself. If a store of that name already exists in your account from something else, the run stops immediately and tells you to pick a different `monitorId` or remove that store. It never falls back to a new store, because a silent fallback would erase the history and re-report every posting as a baseline.

### Billing

The Actor event charge is `$0.005 + ($0.003 × postings checked) + ($0.015 × non-baseline changes)`.

Postings checked and non-baseline changes are billed on every scan that observes postings, complete or incomplete, because each such scan delivers new-and-updated detection. A scan that observes nothing — blocked, failed, or empty and incomplete — charges only the start event. Baseline postings on a first run are checked but not counted as changes.

A scan that checks 50 postings and finds two changes creates $0.185 in Actor event charges, including the start event. Larger coverage across more location facets checks more postings and costs proportionally more; `maxItemsPerCompany` and `facetLocations` are the controls. Apify platform usage, including compute and data transfer, is charged separately under the user's Apify plan.

If the platform cannot accept all required events for a company, the Actor emits `BUDGET_EXHAUSTED` and preserves that company's prior state — it never bills for a partial result it cannot deliver.

### Output and delivery

The dataset view puts the change type and company label first, followed by the job fields and check time. Results can be exported as JSON, CSV, Excel, or XML. The optional webhook carries a scan's changes to an HTTPS endpoint.

Coverage is limited to postings returned by LinkedIn's public guest search. Local tests verify state transitions, faceted enumeration, and failure handling against structural fixtures. A bounded cloud run is required before this version becomes the public default.

### Support

For a reproducible issue report, include the Apify run ID, `monitorId`, affected company input, and `OUTPUT_SUMMARY`. Remove webhook secrets and downstream customer data before sharing it.

# Actor input Schema

## `companies` (type: `array`):

Add one to 20 companies. A numeric LinkedIn company ID gives the most precise scope. Company name is available as a filtered search fallback. The optional label is copied to output rows.

## `monitorId` (type: `string`):

Use the same name on later runs to compare against the same saved posting history.

## `maxItemsPerCompany` (type: `integer`):

Maximum recent postings to collect across all location facets for each company. Reaching this cap marks the scan incomplete: new and updated postings are still reported, but a removal cannot be confirmed until a complete scan.

## `facetLocations` (type: `array`):

The public guest search caps a single company query at roughly 30-50 results. To cover large employers, the monitor runs the company query once per location below and unions the de-duplicated postings. Leave the default list for broad coverage, tailor it to the markets a company hires in, or set it to an empty list to run a single query (best for small employers). More locations means more requests and more postings checked.

## `sortBy` (type: `string`):

DD reads the newest postings first, which is what a new-postings monitor wants from every scan. R sorts by LinkedIn relevance.

## `pacingMs` (type: `integer`):

Spacing between requests to the public guest surface. Higher values reduce transient throttling; lower values run faster.

## `retryOnDuplicate` (type: `boolean`):

When a page repeats already-seen postings, retry the same offset once after a short backoff before treating it as the end. A repeat on the guest surface is usually a transient throttle rather than the true end of results.

## `fullReport` (type: `boolean`):

Add diagnostic rows for quiet or incomplete company scans. Budget exhaustion is always reported.

## `webhookUrl` (type: `string`):

Receives one POST when a scan finds new, updated, or confirmed-removed postings.

## Actor input object example

```json
{
  "companies": [
    {
      "companyName": "Acme Corp",
      "label": "Acme"
    }
  ],
  "monitorId": "default",
  "maxItemsPerCompany": 50,
  "facetLocations": [
    "United States",
    "United Kingdom",
    "India",
    "Germany",
    "France",
    "Canada",
    "Ireland",
    "Netherlands",
    "Australia",
    "Brazil",
    "Poland",
    "Singapore"
  ],
  "sortBy": "DD",
  "pacingMs": 1500,
  "retryOnDuplicate": true,
  "fullReport": false
}
```

# 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 = {
    "companies": [
        {
            "companyName": "Acme Corp",
            "label": "Acme"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("apixyz/linkedin-company-jobs-monitor").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 = { "companies": [{
            "companyName": "Acme Corp",
            "label": "Acme",
        }] }

# Run the Actor and wait for it to finish
run = client.actor("apixyz/linkedin-company-jobs-monitor").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 '{
  "companies": [
    {
      "companyName": "Acme Corp",
      "label": "Acme"
    }
  ]
}' |
apify call apixyz/linkedin-company-jobs-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=apixyz/linkedin-company-jobs-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Company Jobs Monitor",
        "description": "Monitor new, updated, and confirmed-removed job postings for up to 20 companies on LinkedIn's public job search. Faceted enumeration covers large employers; confirmed removals require a complete scan. No login or cookies.",
        "version": "0.2",
        "x-build-id": "i9tsUPJ0Uvvm58ssl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apixyz~linkedin-company-jobs-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apixyz-linkedin-company-jobs-monitor",
                "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/apixyz~linkedin-company-jobs-monitor/runs": {
            "post": {
                "operationId": "runs-sync-apixyz-linkedin-company-jobs-monitor",
                "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/apixyz~linkedin-company-jobs-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-apixyz-linkedin-company-jobs-monitor",
                "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": [
                    "companies"
                ],
                "properties": {
                    "companies": {
                        "title": "Companies to watch",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Add one to 20 companies. A numeric LinkedIn company ID gives the most precise scope. Company name is available as a filtered search fallback. The optional label is copied to output rows.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "companyId": {
                                    "title": "LinkedIn company ID (recommended)",
                                    "type": "string",
                                    "description": "Numeric ID from the company's LinkedIn URL, for example linkedin.com/company/1035 gives 1035."
                                },
                                "companyName": {
                                    "title": "Company name",
                                    "type": "string",
                                    "description": "Filtered search fallback when the numeric company ID is unavailable."
                                },
                                "label": {
                                    "title": "Label",
                                    "type": "string",
                                    "description": "Optional reference copied to every row for this company."
                                }
                            }
                        }
                    },
                    "monitorId": {
                        "title": "Monitor name",
                        "type": "string",
                        "description": "Use the same name on later runs to compare against the same saved posting history.",
                        "default": "default"
                    },
                    "maxItemsPerCompany": {
                        "title": "Max postings checked per company",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum recent postings to collect across all location facets for each company. Reaching this cap marks the scan incomplete: new and updated postings are still reported, but a removal cannot be confirmed until a complete scan.",
                        "default": 50
                    },
                    "facetLocations": {
                        "title": "Location facets (coverage)",
                        "type": "array",
                        "description": "The public guest search caps a single company query at roughly 30-50 results. To cover large employers, the monitor runs the company query once per location below and unions the de-duplicated postings. Leave the default list for broad coverage, tailor it to the markets a company hires in, or set it to an empty list to run a single query (best for small employers). More locations means more requests and more postings checked.",
                        "default": [
                            "United States",
                            "United Kingdom",
                            "India",
                            "Germany",
                            "France",
                            "Canada",
                            "Ireland",
                            "Netherlands",
                            "Australia",
                            "Brazil",
                            "Poland",
                            "Singapore"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "DD",
                            "R"
                        ],
                        "type": "string",
                        "description": "DD reads the newest postings first, which is what a new-postings monitor wants from every scan. R sorts by LinkedIn relevance.",
                        "default": "DD"
                    },
                    "pacingMs": {
                        "title": "Delay between page requests (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Spacing between requests to the public guest surface. Higher values reduce transient throttling; lower values run faster.",
                        "default": 1500
                    },
                    "retryOnDuplicate": {
                        "title": "Retry a repeated page once",
                        "type": "boolean",
                        "description": "When a page repeats already-seen postings, retry the same offset once after a short backoff before treating it as the end. A repeat on the guest surface is usually a transient throttle rather than the true end of results.",
                        "default": true
                    },
                    "fullReport": {
                        "title": "Full report",
                        "type": "boolean",
                        "description": "Add diagnostic rows for quiet or incomplete company scans. Budget exhaustion is always reported.",
                        "default": false
                    },
                    "webhookUrl": {
                        "title": "Posting changes webhook (https)",
                        "pattern": "^https://.*",
                        "type": "string",
                        "description": "Receives one POST when a scan finds new, updated, or confirmed-removed postings."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
