# LinkedIn Jobs Scraper (`pryzmlabs/linkedin-jobs-scraper`) Actor

Scrape LinkedIn public job listings by keyword and location. No login required. Optional AI job fit scoring. Pay per job delivered — not per page scraped.

- **URL**: https://apify.com/pryzmlabs/linkedin-jobs-scraper.md
- **Developed by:** [Pryzm Labs](https://apify.com/pryzmlabs) (community)
- **Categories:** AI, Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 Jobs Search + AI Job Fit Scoring

Search LinkedIn public job listings by keyword and location — get back structured job data with optional full details and AI-powered job fit scoring. No login required.

---

### Overview

Enter your keywords and location and walk away. This actor scrapes LinkedIn's public job listings, returns structured data for every result, and optionally fetches full job details and scores each listing against your preferences using AI.

**Key highlights:**

- No LinkedIn account or cookies required
- Three tiers: basic search, full details, or AI job fit scoring
- Filters by date posted, experience level, job type, and workplace type
- Deduplication built in — only pay for net-new jobs on repeat runs
- Returns clean, flat output — ready to export as CSV or JSON
- Only charged for jobs successfully returned — failed or skipped results are free

---

### Quick Start

1. Enter your keywords (e.g. `product manager`, `senior react developer`)
2. Set your location (e.g. `San Francisco`, `Remote`, `United Kingdom`)
3. Apply filters if needed — date posted, experience level, job type, remote
4. Optionally enable full details or AI scoring
5. Run — get back a clean scored list of matching jobs

---

### Input

| Field | Required | Description |
|---|---|---|
| `mode` | Yes | Scrape mode — controls what data is returned and what you're charged |
| `maxResults` | No | Max jobs to return (default: 50, max: 1,000) |
| `keywords` | Yes* | Job title or keywords to search for |
| `location` | No | City, state, or country |
| `prefRole` | No | Target role or title (e.g. Senior Product Manager) — required for AI scoring |
| `prefIndustry` | No | Industry or company type (e.g. B2B SaaS, Series B startup) |
| `prefSalary` | No | Salary target (e.g. $150K+) |
| `prefWorkplace` | No | `any`, `remote`, `hybrid`, or `on-site` |
| `prefAvoid` | No | Anything to filter out (e.g. crypto, finance, agencies) |
| `searchUrl` | No | Paste a LinkedIn jobs search URL instead of keywords (advanced) |
| `datePosted` | No | Filter by recency: `any`, `24h`, `week`, `month` |
| `experienceLevel` | No | Filter by level: `internship`, `entry`, `associate`, `mid-senior`, `director`, `executive` |
| `jobType` | No | Filter by type: `full-time`, `part-time`, `contract`, `temporary`, `internship` |
| `remote` | No | Filter by workplace: `on-site`, `remote`, `hybrid` |
| `sortBy` | No | `relevant` (default) or `recent` |
| `enableDedup` | No | Skip jobs seen in previous runs (default: true) |

*Either `keywords` or `searchUrl` is required.

**Modes:**
- `basic` — Short ($0.50 / 1k jobs) — title, company, location, salary, posted date, job URL
- `full` — Full ($1.00 / 1k jobs) — everything above + full description, applicants, poster, seniority, company details
- `scored` — Full + AI Scoring ($3.00 / 1k jobs) — everything above + AI fit score, tier, pros/cons, salary estimate

**Basic search example:**
```json
{
  "mode": "basic",
  "keywords": "product manager",
  "location": "San Francisco",
  "maxResults": 50,
  "datePosted": "week",
  "remote": ["hybrid", "remote"]
}
````

**With AI scoring:**

```json
{
  "mode": "scored",
  "keywords": "senior software engineer",
  "location": "New York",
  "maxResults": 25,
  "prefRole": "Senior Software Engineer",
  "prefIndustry": "B2B SaaS, Series B+",
  "prefSalary": "$150K+",
  "prefWorkplace": "remote",
  "prefAvoid": "finance, crypto, agencies"
}
```

***

### Output

Each job returns a flat row — clean columns, ready to export as CSV or JSON.

**Basic output example:**

```json
{
  "id": "3892041823",
  "title": "Product Manager",
  "company": "Airbnb",
  "companyUrl": "https://www.linkedin.com/company/airbnb/",
  "location": "San Francisco, CA",
  "postedAt": "2026-04-20",
  "salary": ["$140,000 - $180,000"],
  "jobUrl": "https://www.linkedin.com/jobs/view/3892041823",
  "searchKeywords": "product manager"
}
```

**With full details:**

```json
{
  "id": "3892041823",
  "title": "Product Manager",
  "company": "Airbnb",
  "location": "San Francisco, CA",
  "description": "We are looking for a Product Manager to join our Payments team...",
  "applicantsCount": "142 applicants",
  "seniorityLevel": "Mid-Senior level",
  "employmentType": "Full-time",
  "jobFunction": "Product Management",
  "industries": "Software Development",
  "jobPosterName": "Jane Recruiter",
  "jobPosterTitle": "Senior Recruiter at Airbnb",
  "companySize": "5,001-10,000 employees",
  "applyUrl": "https://careers.airbnb.com/positions/..."
}
```

**With AI scoring:**

```json
{
  "jobFitScore": 87,
  "jobFitTier": "A",
  "jobFitReason": "Strong match on seniority, tech stack, and remote flexibility — compensation range aligns with stated target",
  "keySkills": ["product strategy", "payments", "cross-functional leadership"],
  "salaryEstimate": "$150,000 - $175,000",
  "pros": ["Remote-friendly", "Strong brand", "Matches seniority target"],
  "cons": ["Travel-heavy role", "Large company structure"]
}
```

**Full output fields:**

| Column | Description |
|---|---|
| `id` | LinkedIn job ID |
| `title` | Job title |
| `company` | Company name |
| `companyUrl` | Company LinkedIn URL |
| `companyLogo` | Company logo image URL |
| `location` | Job location |
| `postedAt` | Date posted |
| `salary` | Salary range if listed |
| `jobUrl` | Direct link to the job listing |
| `searchKeywords` | Keywords used in this search |
| `description` | Full job description (full details only) |
| `applicantsCount` | Number of applicants (full details only) |
| `seniorityLevel` | Seniority level (full details only) |
| `employmentType` | Employment type (full details only) |
| `jobFunction` | Job function category (full details only) |
| `industries` | Industry (full details only) |
| `jobPosterName` | Name of the person who posted (full details only) |
| `jobPosterTitle` | Their title (full details only) |
| `jobPosterUrl` | Their LinkedIn URL (full details only) |
| `companySize` | Company headcount range (full details only) |
| `applyUrl` | Direct apply URL (full details only) |
| `jobFitScore` | 0–100 fit score (AI scoring only) |
| `jobFitTier` | A/B/C/D tier — A=80-100, B=60-79, C=40-59, D=0-39 (AI scoring only) |
| `jobFitReason` | One-sentence explanation (AI scoring only) |
| `keySkills` | Key skills extracted from the listing (AI scoring only) |
| `salaryEstimate` | AI salary estimate if not listed (AI scoring only) |
| `pros` | Why this job fits your preferences (AI scoring only) |
| `cons` | Where it falls short (AI scoring only) |

***

### Pricing

| Mode | Cost |
|---|---|
| Short | $0.50 per 1,000 jobs |
| Full | $1.00 per 1,000 jobs |
| Full + AI Scoring | $3.00 per 1,000 jobs |

**You only pay for jobs you actually get.** Unlike scrapers that charge per page regardless of results, we charge per job delivered.

***

### Performance Tips

- **Use `searchUrl`** for precise filtering — go to linkedin.com/jobs/search, apply all your filters, copy the URL, paste it in
- **Enable dedup** on repeat runs — you only pay for net-new jobs
- **Keep `maxResults` reasonable** — LinkedIn public listings cap out around 1,000 per search

***

### Error Handling

- Failed job fetches are skipped — the run continues for all other results
- Individual failures don't stop the entire run
- If a search returns 0 results, check your keywords and location spelling

***

### Security & Privacy

- No LinkedIn account or authentication cookies required
- No data is stored beyond Apify's standard dataset storage

# Actor input Schema

## `mode` (type: `string`):

Choose what data to return. Higher modes include more detail and AI scoring.

## `maxResults` (type: `integer`):

Maximum number of jobs to return (max 1,000)

## `keywords` (type: `string`):

Job title or keywords to search for (e.g. 'react developer', 'product manager', 'data scientist')

## `location` (type: `string`):

City, state, or country (e.g. 'San Diego', 'New York', 'United Kingdom')

## `prefRole` (type: `string`):

What role or title are you looking for? (e.g. Senior Product Manager, Staff Engineer, Head of Marketing)

## `prefIndustry` (type: `string`):

What kind of company? (e.g. B2B SaaS, Series B startup, enterprise, agency)

## `prefSalary` (type: `string`):

Minimum or target salary (e.g. $150K+, $120K-$160K)

## `prefWorkplace` (type: `string`):

Where do you want to work?

## `prefAvoid` (type: `string`):

Anything to filter out — industries, company types, roles, etc. (e.g. finance, crypto, agencies, startups under Series A)

## `searchUrl` (type: `string`):

Paste a LinkedIn jobs search URL to use instead of keywords. Go to linkedin.com/jobs/search, apply your filters, copy the URL.

## `datePosted` (type: `string`):

Filter by when the job was posted

## `experienceLevel` (type: `array`):

Filter by experience level

## `jobType` (type: `array`):

Filter by employment type

## `remote` (type: `array`):

Filter by workplace type

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

Sort order for results

## `enableDedup` (type: `boolean`):

Skip jobs returned in previous runs. You only pay for net-new results.

## Actor input object example

```json
{
  "mode": "basic",
  "maxResults": 50,
  "keywords": "product manager",
  "location": "San Francisco",
  "prefWorkplace": "any",
  "datePosted": "any",
  "experienceLevel": [],
  "jobType": [],
  "remote": [],
  "sortBy": "relevant",
  "enableDedup": true
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": "product manager",
    "location": "San Francisco"
};

// Run the Actor and wait for it to finish
const run = await client.actor("pryzmlabs/linkedin-jobs-scraper").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 = {
    "keywords": "product manager",
    "location": "San Francisco",
}

# Run the Actor and wait for it to finish
run = client.actor("pryzmlabs/linkedin-jobs-scraper").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 '{
  "keywords": "product manager",
  "location": "San Francisco"
}' |
apify call pryzmlabs/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "LinkedIn Jobs Scraper",
        "description": "Scrape LinkedIn public job listings by keyword and location. No login required. Optional AI job fit scoring. Pay per job delivered — not per page scraped.",
        "version": "0.1",
        "x-build-id": "E782izMkZXG4z7FW7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/pryzmlabs~linkedin-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-pryzmlabs-linkedin-jobs-scraper",
                "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/pryzmlabs~linkedin-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-pryzmlabs-linkedin-jobs-scraper",
                "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/pryzmlabs~linkedin-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-pryzmlabs-linkedin-jobs-scraper",
                "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": [
                    "keywords"
                ],
                "properties": {
                    "mode": {
                        "title": "Scrape Mode",
                        "enum": [
                            "basic",
                            "full",
                            "scored"
                        ],
                        "type": "string",
                        "description": "Choose what data to return. Higher modes include more detail and AI scoring.",
                        "default": "basic"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of jobs to return (max 1,000)",
                        "default": 50
                    },
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job title or keywords to search for (e.g. 'react developer', 'product manager', 'data scientist')"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, or country (e.g. 'San Diego', 'New York', 'United Kingdom')"
                    },
                    "prefRole": {
                        "title": "Target Role",
                        "type": "string",
                        "description": "What role or title are you looking for? (e.g. Senior Product Manager, Staff Engineer, Head of Marketing)"
                    },
                    "prefIndustry": {
                        "title": "Industry or Company Type",
                        "type": "string",
                        "description": "What kind of company? (e.g. B2B SaaS, Series B startup, enterprise, agency)"
                    },
                    "prefSalary": {
                        "title": "Salary Target",
                        "type": "string",
                        "description": "Minimum or target salary (e.g. $150K+, $120K-$160K)"
                    },
                    "prefWorkplace": {
                        "title": "Workplace Preference",
                        "enum": [
                            "any",
                            "remote",
                            "hybrid",
                            "on-site"
                        ],
                        "type": "string",
                        "description": "Where do you want to work?",
                        "default": "any"
                    },
                    "prefAvoid": {
                        "title": "Must Avoid (optional)",
                        "type": "string",
                        "description": "Anything to filter out — industries, company types, roles, etc. (e.g. finance, crypto, agencies, startups under Series A)"
                    },
                    "searchUrl": {
                        "title": "Search URL (advanced)",
                        "type": "string",
                        "description": "Paste a LinkedIn jobs search URL to use instead of keywords. Go to linkedin.com/jobs/search, apply your filters, copy the URL."
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "any",
                            "24h",
                            "week",
                            "month"
                        ],
                        "type": "string",
                        "description": "Filter by when the job was posted",
                        "default": "any"
                    },
                    "experienceLevel": {
                        "title": "Experience Level",
                        "type": "array",
                        "description": "Filter by experience level",
                        "items": {
                            "type": "string",
                            "enum": [
                                "internship",
                                "entry",
                                "associate",
                                "mid-senior",
                                "director",
                                "executive"
                            ]
                        },
                        "default": []
                    },
                    "jobType": {
                        "title": "Job Type",
                        "type": "array",
                        "description": "Filter by employment type",
                        "items": {
                            "type": "string",
                            "enum": [
                                "full-time",
                                "part-time",
                                "contract",
                                "temporary",
                                "internship"
                            ]
                        },
                        "default": []
                    },
                    "remote": {
                        "title": "Workplace Type",
                        "type": "array",
                        "description": "Filter by workplace type",
                        "items": {
                            "type": "string",
                            "enum": [
                                "on-site",
                                "remote",
                                "hybrid"
                            ]
                        },
                        "default": []
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevant",
                            "recent"
                        ],
                        "type": "string",
                        "description": "Sort order for results",
                        "default": "relevant"
                    },
                    "enableDedup": {
                        "title": "Skip Previously Seen Jobs",
                        "type": "boolean",
                        "description": "Skip jobs returned in previous runs. You only pay for net-new results.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
