# LinkedIn Job Apply Link Verifier & Ghost Job Checker (`kamerozkan/linkedin-job-apply-link-verifier`) Actor

Validate LinkedIn job rows, recover exact official apply URLs, flag expired or mismatched listings, and block unverified links before they reach your job board or recruiting pipeline.

- **URL**: https://apify.com/kamerozkan/linkedin-job-apply-link-verifier.md
- **Developed by:** [Kamer Ozkan](https://apify.com/kamerozkan) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 verified job decisions

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 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

## LinkedIn Job Apply Link Verifier and Ghost Job Checker

Recover exact company application links and stop unsafe job rows before they
reach your users.

LinkedIn job feeds often return an empty external apply URL, a copy of the
LinkedIn job URL, or a generic company careers page. This Actor takes the job
rows you already have, reconciles each one against public employer and ATS
evidence, and returns a safe action for your workflow.

It is built for job boards, recruiting products, staffing automations, and job
data pipelines. It is not another job scraper.

### What it fixes

| Feed problem | Actor decision |
|---|---|
| External apply URL is missing | Finds and proves the exact employer or ATS route |
| Apply URL opens a generic careers board | Resolves the board to the exact job |
| LinkedIn row remains visible after the official job closes | Returns `EXPIRED` with no publishable URL |
| Company, title, location, or job content conflicts | Returns `SOURCE_MISMATCH` or `STATUS_CONFLICT` |
| The job only supports LinkedIn Easy Apply | Returns `LINKEDIN_EASY_APPLY` and the LinkedIn route |
| Evidence is not strong enough | Returns `AMBIGUOUS`, publishes no URL, and does not charge |

The safety rule is simple: **no proof, no link**.

### Try it in 60 seconds

1. Keep the two prefilled example jobs.
2. Click **Start**.
3. Open the **Verified apply routes** dataset view.
4. Use `actionUrl` only when `safeToPublish` is `true`.

The prefill demonstrates both supported outcomes: an exact company-owned
application page and a LinkedIn Easy Apply route. No LinkedIn account, cookies,
or browser profile are required.

### Input

Use either an existing Apify dataset or paste rows directly. Common LinkedIn
scraper field names are detected automatically.

Each row needs:

- LinkedIn job URL or job ID
- job title
- company
- location

An existing `applyUrl`, `companyApplyUrl`, or company website is optional. It
is treated as a hint and must pass the same verification policy.

```json
{
  "rows": [
    {
      "jobId": "4441060956",
      "jobUrl": "https://www.linkedin.com/jobs/view/4441060956",
      "jobTitle": "Account Executive - Travel",
      "companyName": "Nike Communications, Inc.",
      "location": "New York, NY"
    }
  ],
  "maxItems": 25
}
````

For an existing dataset, provide its ID instead:

```json
{
  "datasetId": "YOUR_DATASET_ID",
  "maxItems": 500
}
```

### Output

Every input row produces an auditable decision. A verified result looks like:

```json
{
  "status": "ACTIVE",
  "actionUrl": "https://nikecommunicationsinc.applytojob.com/apply/eDPh7BCIhx/Account-Executive-Travel",
  "safeToPublish": true,
  "reviewRequired": false,
  "usefulClassification": true,
  "confidence": 1,
  "sourceProvider": "jazzhr",
  "evidence": [
    "linkedin_apply_method:OFFSITE",
    "official_site_to_career_source_verified",
    "generic_board_resolved_to_exact_job",
    "conservative_official_inventory_match"
  ]
}
```

Important output fields:

| Field | Use |
|---|---|
| `actionUrl` | Route your product may open or publish |
| `safeToPublish` | Machine-readable release gate |
| `status` | Final decision for the job row |
| `reviewRequired` | Whether the row should enter a manual queue |
| `confidence` | Strength of the match |
| `sourceProvider` | Verified ATS or official source |
| `evidence` | Checks supporting the decision |
| `requestAccounting` | Requests used by each verification layer |
| `original` | Original input row, unchanged |

### Decision statuses

| Status | Meaning |
|---|---|
| `ACTIVE` | Exact live official job route verified |
| `AUTHORIZED_APPLY_ROUTE` | Valid source-owned application route verified |
| `LINKEDIN_EASY_APPLY` | No external route is expected; use the LinkedIn URL |
| `EXPIRED` | The exact official job is no longer available |
| `SOURCE_MISMATCH` | The row appears to belong to a different hiring organization |
| `STATUS_CONFLICT` | Trusted sources disagree about the current state |
| `AMBIGUOUS` | Evidence is insufficient; no URL is published and the row is not charged |

### Why this is different

Most LinkedIn job Actors collect listings. Official career-site APIs sell
their own job inventory. This Actor works between those products and your
publishing system:

1. It preserves your existing job row.
2. It checks customer-supplied links instead of trusting them.
3. It resolves generic ATS boards to the exact job.
4. It compares LinkedIn, employer, ATS, and live detail-page evidence.
5. It blocks expired, mismatched, conflicting, and unproven routes.

Search results and job mirrors may help discover a candidate, but they can
never become a publishable answer on their own.

### Quality evidence

The latest clean regression used 100 previously unseen LinkedIn job rows with
static resolution memory disabled:

- 98 useful classifications
- 97 safe action routes
- 2 rows safely held as `AMBIGUOUS`
- 0 unsafe guessed URLs
- 697 total HTTP requests
- 468.6 seconds on the local reference run

The production build also passed private Apify cloud tests:

- 2 normal rows: 2 useful, 2 publishable, 0 held
- 1 unresolved row: 0 publishable, correctly held for review
- 42 automated regression tests passed

These are measured tests, not a promise that every future source will resolve
automatically. The product promise is that an unproven route is never marked
safe.

### Pricing

The Actor charges **$4.00 per 1,000 verified job decisions**.

- $0.004 per useful decision
- `AMBIGUOUS` rows are delivered without charge
- failed runs do not create useful-decision charges
- Apify platform usage is included
- no subscription or per-seat fee

Example: verifying 25,000 useful job rows costs $100.

### Production workflow

For a recurring feed:

1. Run your existing LinkedIn or job scraper.
2. Pass its dataset ID to this Actor.
3. Publish rows where `safeToPublish` is `true`.
4. Send `reviewRequired` rows to a review queue.
5. Schedule the workflow or connect it through webhooks, Make, Zapier, n8n,
   or the Apify API.

The default batch is 25 jobs for easy inspection. A run accepts up to 500
jobs. Cold companies take longer because their public website, ATS, and job
evidence must be discovered live.

### Responsible use and limits

- The Actor checks public web evidence and does not require LinkedIn login
  credentials.
- Source websites can throttle, remove, or change public pages.
- An active official listing proves that an application route exists. It
  cannot prove a hiring manager's private intent or guarantee that a role will
  be filled.
- Review the terms and laws that apply to your data source and use case.

# Actor input Schema

## `datasetId` (type: `string`):

Choose the dataset produced by your LinkedIn or job scraper. Leave empty when pasting rows below.

## `rows` (type: `array`):

Each row needs a LinkedIn job URL or ID, title, company, and location. Existing apply URLs are revalidated, never trusted blindly.

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

Start with 25 to inspect the evidence. Increase up to 500 when the output fits your workflow.

## `autoDiscoverCompanyWebsite` (type: `boolean`):

Recommended. Finds public employer evidence when the row does not include an official website.

## `useReaderFallback` (type: `boolean`):

Recommended. Uses a second public read path when the direct LinkedIn page is unavailable.

## `maxSearchQueries` (type: `integer`):

Higher values improve recall but increase run time.

## `maxCandidates` (type: `integer`):

Every candidate is fetched and checked before it can become an output route.

## `maxBridgePages` (type: `integer`):

Job mirrors can reveal an official outbound URL but can never become the final route.

## Actor input object example

```json
{
  "rows": [
    {
      "jobId": "4441060956",
      "jobUrl": "https://www.linkedin.com/jobs/view/account-executive-travel-at-nike-communications-inc-4441060956",
      "jobTitle": "Account Executive - Travel",
      "companyName": "Nike Communications, Inc.",
      "companyUrl": "https://www.linkedin.com/company/nike-communications",
      "location": "New York, NY"
    },
    {
      "jobId": "4440198123",
      "jobUrl": "https://www.linkedin.com/jobs/view/national-account-manager-at-sprout-living-4440198123",
      "jobTitle": "National Account Manager",
      "companyName": "Sprout Living",
      "companyUrl": "https://www.linkedin.com/company/sprout-living",
      "location": "United States"
    }
  ],
  "maxItems": 25,
  "autoDiscoverCompanyWebsite": true,
  "useReaderFallback": true,
  "maxSearchQueries": 3,
  "maxCandidates": 6,
  "maxBridgePages": 3
}
```

# Actor output Schema

## `jobResults` (type: `string`):

No description

## `summary` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "rows": [
        {
            "jobId": "4441060956",
            "jobUrl": "https://www.linkedin.com/jobs/view/account-executive-travel-at-nike-communications-inc-4441060956",
            "jobTitle": "Account Executive - Travel",
            "companyName": "Nike Communications, Inc.",
            "companyUrl": "https://www.linkedin.com/company/nike-communications",
            "location": "New York, NY"
        },
        {
            "jobId": "4440198123",
            "jobUrl": "https://www.linkedin.com/jobs/view/national-account-manager-at-sprout-living-4440198123",
            "jobTitle": "National Account Manager",
            "companyName": "Sprout Living",
            "companyUrl": "https://www.linkedin.com/company/sprout-living",
            "location": "United States"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kamerozkan/linkedin-job-apply-link-verifier").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 = { "rows": [
        {
            "jobId": "4441060956",
            "jobUrl": "https://www.linkedin.com/jobs/view/account-executive-travel-at-nike-communications-inc-4441060956",
            "jobTitle": "Account Executive - Travel",
            "companyName": "Nike Communications, Inc.",
            "companyUrl": "https://www.linkedin.com/company/nike-communications",
            "location": "New York, NY",
        },
        {
            "jobId": "4440198123",
            "jobUrl": "https://www.linkedin.com/jobs/view/national-account-manager-at-sprout-living-4440198123",
            "jobTitle": "National Account Manager",
            "companyName": "Sprout Living",
            "companyUrl": "https://www.linkedin.com/company/sprout-living",
            "location": "United States",
        },
    ] }

# Run the Actor and wait for it to finish
run = client.actor("kamerozkan/linkedin-job-apply-link-verifier").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 '{
  "rows": [
    {
      "jobId": "4441060956",
      "jobUrl": "https://www.linkedin.com/jobs/view/account-executive-travel-at-nike-communications-inc-4441060956",
      "jobTitle": "Account Executive - Travel",
      "companyName": "Nike Communications, Inc.",
      "companyUrl": "https://www.linkedin.com/company/nike-communications",
      "location": "New York, NY"
    },
    {
      "jobId": "4440198123",
      "jobUrl": "https://www.linkedin.com/jobs/view/national-account-manager-at-sprout-living-4440198123",
      "jobTitle": "National Account Manager",
      "companyName": "Sprout Living",
      "companyUrl": "https://www.linkedin.com/company/sprout-living",
      "location": "United States"
    }
  ]
}' |
apify call kamerozkan/linkedin-job-apply-link-verifier --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=kamerozkan/linkedin-job-apply-link-verifier",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Job Apply Link Verifier & Ghost Job Checker",
        "description": "Validate LinkedIn job rows, recover exact official apply URLs, flag expired or mismatched listings, and block unverified links before they reach your job board or recruiting pipeline.",
        "version": "0.0",
        "x-build-id": "exkVH9HZdfuPPF7WA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kamerozkan~linkedin-job-apply-link-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kamerozkan-linkedin-job-apply-link-verifier",
                "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/kamerozkan~linkedin-job-apply-link-verifier/runs": {
            "post": {
                "operationId": "runs-sync-kamerozkan-linkedin-job-apply-link-verifier",
                "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/kamerozkan~linkedin-job-apply-link-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-kamerozkan-linkedin-job-apply-link-verifier",
                "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": {
                    "datasetId": {
                        "title": "Source job dataset",
                        "type": "string",
                        "description": "Choose the dataset produced by your LinkedIn or job scraper. Leave empty when pasting rows below."
                    },
                    "rows": {
                        "title": "Paste job rows instead",
                        "maxItems": 500,
                        "type": "array",
                        "description": "Each row needs a LinkedIn job URL or ID, title, company, and location. Existing apply URLs are revalidated, never trusted blindly.",
                        "items": {
                            "type": "object",
                            "additionalProperties": true
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs to verify",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Start with 25 to inspect the evidence. Increase up to 500 when the output fits your workflow.",
                        "default": 25
                    },
                    "autoDiscoverCompanyWebsite": {
                        "title": "Discover official company websites",
                        "type": "boolean",
                        "description": "Recommended. Finds public employer evidence when the row does not include an official website.",
                        "default": true
                    },
                    "useReaderFallback": {
                        "title": "Use public page reader fallback",
                        "type": "boolean",
                        "description": "Recommended. Uses a second public read path when the direct LinkedIn page is unavailable.",
                        "default": true
                    },
                    "maxSearchQueries": {
                        "title": "Maximum search queries per unresolved job",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Higher values improve recall but increase run time.",
                        "default": 3
                    },
                    "maxCandidates": {
                        "title": "Maximum candidate pages to prove",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "Every candidate is fetched and checked before it can become an output route.",
                        "default": 6
                    },
                    "maxBridgePages": {
                        "title": "Maximum job mirrors to inspect",
                        "minimum": 0,
                        "maximum": 6,
                        "type": "integer",
                        "description": "Job mirrors can reveal an official outbound URL but can never become the final route.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```