# LinkedIn Job Matcher: AI Fit Score & Cover Letters (`apexweb/linkedin-application-copilot`) Actor

Score LinkedIn jobs against your CV and get an AI application pack for every listing: a fit score, a tailored cover note draft, matched and missing skills, and a clear apply or skip call. Feed it the output of any LinkedIn jobs scraper and stop applying blind.

- **URL**: https://apify.com/apexweb/linkedin-application-copilot.md
- **Developed by:** [Adam Tokar](https://apify.com/apexweb) (community)
- **Categories:** AI, Jobs, Automation
- **Stats:** 21 total users, 3 monthly users, 97.4% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 application pack results

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

## LinkedIn Job Matcher: AI Fit Score & Cover Letters

Stop applying blind. This Actor finds LinkedIn jobs, scores every one against your actual profile, and hands you a review ready application pack for the ones worth your time.

You get a fit score, the skills you match, the skills you are missing, a tailored cover note draft, and a straight apply or skip call. For each job. Automatically.

### Why this exists

Most job search tools do one of two things: they scrape a pile of listings and leave you to read all of them, or they blast out generic applications on your behalf. Neither works.

This one does the part that actually takes your time: reading each posting, judging whether it genuinely fits you, and drafting the opening. You stay in control of what gets sent.

### What you get for every job

| Field | What it tells you |
|---|---|
| `fitScore` | 0 to 100, how well the role matches your profile |
| `recommendation` | Apply or skip, in plain language |
| `matchedSkills` | Your skills the posting actually asks for |
| `missingSkills` | Gaps worth knowing before you apply |
| `whyApply` / `whySkip` | The reasoning, so you can disagree with it |
| `scoreBreakdown` | How the score was built, not a black box |
| `evidenceLevel` | How much the posting actually told us |
| `applicationPack` | Cover note draft, resume emphasis, headline |
| `nextSteps` | What to do with this one |

Export as JSON, CSV, Excel, or Google Sheets, or pull it through the API.

### How to use it

**The simple way.** Turn on job discovery, give it what you are looking for, and describe yourself:

```json
{
    "discoverLinkedInJobs": true,
    "searches": [
        {
            "keywords": "Product Designer",
            "location": "United States",
            "postedWithin": "past-week",
            "workplaceType": "remote"
        }
    ],
    "candidateProfile": {
        "targetRoles": ["Product Designer"],
        "coreSkills": ["figma", "design systems", "user research"],
        "locationPreferences": ["United States", "Remote"],
        "avoidKeywords": ["internship", "unpaid"]
    },
    "minScore": 70,
    "maxDiscoveryJobs": 25
}
````

That is it. It searches, scores, and returns only jobs above your threshold.

**Bring your own jobs.** Already have listings from a scraper, a CSV, or an ATS export? Pass them in the `jobs` array and skip discovery entirely. This pairs directly with the **LinkedIn Jobs Scraper** and **Indeed Job Scraper** Actors, so you can scrape wide and score everything in one pipeline.

**Search several roles at once.** Put multiple entries in `searches` and each is searched separately, all scored against the same profile.

### Key settings

| Field | Description |
|---|---|
| `candidateProfile` | Your target roles, core skills, preferred locations, and keywords to avoid. This drives the whole score. |
| `minScore` | Only return jobs at or above this fit score. Default 70. |
| `searches` | One or more keyword and location searches. |
| `postedWithin` | `past-24-hours`, `past-week`, `past-month`. |
| `workplaceType` | `remote`, `hybrid`, `on-site`, or `any`. |
| `maxDiscoveryJobs` | Cap how many jobs are pulled per run. |
| `fetchJobDescriptions` | Read the full posting before scoring. Better scores, slower runs. |

### Good use cases

- **Daily job hunt.** Schedule it every morning and read only the jobs that scored above 75.
- **Career coaches and recruiters.** Score a batch of roles against a candidate and hand over reasoned shortlists instead of link dumps.
- **Job board and newsletter operators.** Add a relevance score and a summary to every listing you publish.
- **Skill gap analysis.** Run it across 100 roles and read the `missingSkills` column to see what your target market actually keeps asking for.

### What it deliberately does not do

It does not mass submit applications. Jobs are prepared for your review, not fired off automatically. That is a design decision, not a missing feature: automated bulk applying gets accounts flagged and produces worse outcomes than ten considered applications.

The cover note is a **draft**. It is a strong starting point, not something to send unread.

### Honest limitations

- Scores are only as good as the profile you give it. A vague `candidateProfile` produces vague scores. Spend two minutes filling it in properly.
- It reads LinkedIn's public job surface. Postings visible only to logged in users are out of scope.
- With `fetchJobDescriptions` off, scoring works from the listing summary only, so `evidenceLevel` will be lower. Leave it on unless you are optimising for speed.
- LinkedIn changes its public markup occasionally. If something stops populating, open an issue and it gets fixed.

### Pricing

Pay per result. You are charged for scored jobs returned, not for every job looked at, so a tighter `minScore` keeps runs cheap.

### Responsible use

This Actor reads publicly accessible job postings, the same pages any visitor can open without signing in. It does not log in, does not ask for your LinkedIn password, does not collect personal profiles, and does not submit applications. Requests are throttled. Please respect LinkedIn's terms and your local laws.

# Actor input Schema

## `discoverLinkedInJobs` (type: `boolean`):

When enabled, the Actor searches public LinkedIn job listings from the buyer-defined search fields below before preparing application packs.

## `searches` (type: `array`):

Buyer-defined LinkedIn searches. Add one or more target roles, locations, and filters. These replace the old one-person defaults.

## `searchKeywords` (type: `string`):

Optional single-search shortcut. Use this instead of Job searches if the buyer only wants one role query.

## `searchLocation` (type: `string`):

Optional single-search shortcut location, for example United States, London, Remote, or Berlin.

## `postedWithin` (type: `string`):

Optional LinkedIn date filter.

## `workplaceType` (type: `string`):

Optional LinkedIn workplace filter.

## `maxDiscoveryJobs` (type: `integer`):

Maximum number of public LinkedIn jobs to discover before scoring.

## `fetchJobDescriptions` (type: `boolean`):

Fetch each LinkedIn job detail page to improve scoring with description text. Disable for faster, cheaper runs.

## `jobs` (type: `array`):

Optional job records to score and prepare. Use this for API runs, CSV-derived jobs, ATS postings, or records from another Actor.

## `candidateProfile` (type: `object`):

Buyer profile used for scoring and apply-pack language. Set target roles, desired skills, optional preferred locations, and optional keywords to avoid.

## `minScore` (type: `integer`):

Minimum fit score required to prepare an application pack.

## `maxJobs` (type: `integer`):

Maximum number of jobs to process in one Actor run.

## `syncToNetlify` (type: `boolean`):

When enabled, prepared jobs are sent to your Netlify tracker intake endpoint as manual-source records.

## `netlifySiteUrl` (type: `string`):

Your own tracker site URL, for example https://your-tracker.netlify.app. Required only when syncToNetlify is enabled.

## Actor input object example

```json
{
  "discoverLinkedInJobs": true,
  "searches": [
    {
      "keywords": "Product Designer",
      "location": "United States",
      "postedWithin": "past-week",
      "workplaceType": "remote"
    },
    {
      "keywords": "Growth Marketer",
      "location": "London",
      "postedWithin": "past-month",
      "workplaceType": "hybrid"
    }
  ],
  "searchKeywords": "Product Designer",
  "searchLocation": "United States",
  "postedWithin": "past-week",
  "workplaceType": "any",
  "maxDiscoveryJobs": 25,
  "fetchJobDescriptions": true,
  "jobs": [],
  "candidateProfile": {
    "targetRoles": [
      "Product Designer"
    ],
    "coreSkills": [
      "figma",
      "design systems",
      "user research"
    ],
    "locationPreferences": [
      "United States",
      "Remote"
    ],
    "avoidKeywords": [
      "internship",
      "unpaid"
    ]
  },
  "minScore": 70,
  "maxJobs": 50,
  "syncToNetlify": false
}
```

# Actor output Schema

## `applicationPacks` (type: `string`):

Ranked job opportunities with fit score, recommendation, review status, and application-pack drafts.

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

Counts of total jobs, prepared application packs, skipped jobs, human-review requirements, and Netlify sync status.

# 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 = {
    "searches": [
        {
            "keywords": "Product Designer",
            "location": "United States",
            "postedWithin": "past-week",
            "workplaceType": "remote"
        },
        {
            "keywords": "Growth Marketer",
            "location": "London",
            "postedWithin": "past-month",
            "workplaceType": "hybrid"
        }
    ],
    "searchKeywords": "Product Designer",
    "searchLocation": "United States",
    "jobs": [],
    "candidateProfile": {
        "targetRoles": [
            "Product Designer"
        ],
        "coreSkills": [
            "figma",
            "design systems",
            "user research"
        ],
        "locationPreferences": [
            "United States",
            "Remote"
        ],
        "avoidKeywords": [
            "internship",
            "unpaid"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("apexweb/linkedin-application-copilot").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 = {
    "searches": [
        {
            "keywords": "Product Designer",
            "location": "United States",
            "postedWithin": "past-week",
            "workplaceType": "remote",
        },
        {
            "keywords": "Growth Marketer",
            "location": "London",
            "postedWithin": "past-month",
            "workplaceType": "hybrid",
        },
    ],
    "searchKeywords": "Product Designer",
    "searchLocation": "United States",
    "jobs": [],
    "candidateProfile": {
        "targetRoles": ["Product Designer"],
        "coreSkills": [
            "figma",
            "design systems",
            "user research",
        ],
        "locationPreferences": [
            "United States",
            "Remote",
        ],
        "avoidKeywords": [
            "internship",
            "unpaid",
        ],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("apexweb/linkedin-application-copilot").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 '{
  "searches": [
    {
      "keywords": "Product Designer",
      "location": "United States",
      "postedWithin": "past-week",
      "workplaceType": "remote"
    },
    {
      "keywords": "Growth Marketer",
      "location": "London",
      "postedWithin": "past-month",
      "workplaceType": "hybrid"
    }
  ],
  "searchKeywords": "Product Designer",
  "searchLocation": "United States",
  "jobs": [],
  "candidateProfile": {
    "targetRoles": [
      "Product Designer"
    ],
    "coreSkills": [
      "figma",
      "design systems",
      "user research"
    ],
    "locationPreferences": [
      "United States",
      "Remote"
    ],
    "avoidKeywords": [
      "internship",
      "unpaid"
    ]
  }
}' |
apify call apexweb/linkedin-application-copilot --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Job Matcher: AI Fit Score & Cover Letters",
        "description": "Score LinkedIn jobs against your CV and get an AI application pack for every listing: a fit score, a tailored cover note draft, matched and missing skills, and a clear apply or skip call. Feed it the output of any LinkedIn jobs scraper and stop applying blind.",
        "version": "0.1",
        "x-build-id": "AvVR3M3aZMGpVA0SP"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/apexweb~linkedin-application-copilot/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-apexweb-linkedin-application-copilot",
                "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/apexweb~linkedin-application-copilot/runs": {
            "post": {
                "operationId": "runs-sync-apexweb-linkedin-application-copilot",
                "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/apexweb~linkedin-application-copilot/run-sync": {
            "post": {
                "operationId": "run-sync-apexweb-linkedin-application-copilot",
                "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": {
                    "discoverLinkedInJobs": {
                        "title": "Discover LinkedIn jobs automatically",
                        "type": "boolean",
                        "description": "When enabled, the Actor searches public LinkedIn job listings from the buyer-defined search fields below before preparing application packs.",
                        "default": true
                    },
                    "searches": {
                        "title": "Job searches",
                        "type": "array",
                        "description": "Buyer-defined LinkedIn searches. Add one or more target roles, locations, and filters. These replace the old one-person defaults."
                    },
                    "searchKeywords": {
                        "title": "Single search keywords",
                        "type": "string",
                        "description": "Optional single-search shortcut. Use this instead of Job searches if the buyer only wants one role query."
                    },
                    "searchLocation": {
                        "title": "Single search location",
                        "type": "string",
                        "description": "Optional single-search shortcut location, for example United States, London, Remote, or Berlin."
                    },
                    "postedWithin": {
                        "title": "Posted within",
                        "enum": [
                            "any",
                            "past-24h",
                            "past-week",
                            "past-month"
                        ],
                        "type": "string",
                        "description": "Optional LinkedIn date filter.",
                        "default": "past-week"
                    },
                    "workplaceType": {
                        "title": "Workplace type",
                        "enum": [
                            "any",
                            "remote",
                            "hybrid",
                            "onsite"
                        ],
                        "type": "string",
                        "description": "Optional LinkedIn workplace filter.",
                        "default": "any"
                    },
                    "maxDiscoveryJobs": {
                        "title": "Max jobs to discover",
                        "minimum": 1,
                        "maximum": 250,
                        "type": "integer",
                        "description": "Maximum number of public LinkedIn jobs to discover before scoring.",
                        "default": 25
                    },
                    "fetchJobDescriptions": {
                        "title": "Fetch job descriptions",
                        "type": "boolean",
                        "description": "Fetch each LinkedIn job detail page to improve scoring with description text. Disable for faster, cheaper runs.",
                        "default": true
                    },
                    "jobs": {
                        "title": "Optional pasted jobs",
                        "type": "array",
                        "description": "Optional job records to score and prepare. Use this for API runs, CSV-derived jobs, ATS postings, or records from another Actor."
                    },
                    "candidateProfile": {
                        "title": "Candidate profile",
                        "type": "object",
                        "description": "Buyer profile used for scoring and apply-pack language. Set target roles, desired skills, optional preferred locations, and optional keywords to avoid."
                    },
                    "minScore": {
                        "title": "Minimum score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Minimum fit score required to prepare an application pack.",
                        "default": 70
                    },
                    "maxJobs": {
                        "title": "Max jobs",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of jobs to process in one Actor run.",
                        "default": 50
                    },
                    "syncToNetlify": {
                        "title": "Sync prepared jobs to Netlify tracker",
                        "type": "boolean",
                        "description": "When enabled, prepared jobs are sent to your Netlify tracker intake endpoint as manual-source records.",
                        "default": false
                    },
                    "netlifySiteUrl": {
                        "title": "Netlify site URL",
                        "type": "string",
                        "description": "Your own tracker site URL, for example https://your-tracker.netlify.app. Required only when syncToNetlify is enabled."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
