# Jobs Scraper — Indeed, LinkedIn & Glassdoor (`khadinakbar/jobs-scraper`) Actor

Extract job listings from Indeed, LinkedIn & Glassdoor simultaneously. Returns title, company, salary, location, remote flag, job type, seniority, full description & apply URL. Pay-per-result — $3 per 1,000 jobs.

- **URL**: https://apify.com/khadinakbar/jobs-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Automation
- **Stats:** 11 total users, 5 monthly users, 93.8% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 job 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 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

## 💼 Jobs Scraper — Indeed, LinkedIn & Glassdoor

Extract job listings from **Indeed, LinkedIn, and Glassdoor simultaneously** with a single keyword search. Get structured job data including salary, company details, remote status, apply links, and more — all in a unified schema. Export to JSON, CSV, Excel, or feed directly into your AI pipeline.

**$3 per 1,000 results.** Export scraped data, run the scraper via API, schedule and monitor runs, or integrate with other tools.

---

### Why Use This Scraper?

Most job scrapers on the Apify Store only cover one platform. To aggregate data across Indeed, LinkedIn, and Glassdoor, you'd need to run three separate actors, manage three different schemas, and manually reconcile duplicates. This actor does it all in one run:

- **Unified schema** — every job record has the same fields regardless of platform, so your spreadsheet or database just works
- **Salary normalization** — `$80K/yr`, `$80,000 a year`, and `{min: 80000}` all become `salary_min: 80000, salary_period: "yearly"` — no more messy string parsing
- **Cross-platform deduplication** — when the same job appears on two platforms, you get one clean record, not two
- **No cookies or login required** — scrapes LinkedIn's public job search without an account. Glassdoor and Indeed scraped via public search pages
- **PPE pricing** — you only pay for what you get. No $25/month flat fee for a scraper that might be down

---

### Features

- **3 platforms in one run** — Indeed, LinkedIn, and Glassdoor simultaneously
- **Keyword + location search** — just type `"data engineer"` and `"Austin, TX"` and go
- **Salary normalization** — all salary formats unified into `salary_min`, `salary_max`, `salary_currency`, `salary_period`
- **Cross-platform dedup** — optional flag to remove jobs that appear on multiple platforms
- **Job type filter** — fulltime, parttime, contract, internship, temporary
- **Remote filter** — toggle to show only remote/WFH jobs
- **Posted date filter** — only return jobs posted in the last X hours
- **Company details** — rating, review count, industry, size, website
- **Skills extraction** — automatically detects skills from job descriptions
- **Graceful Glassdoor fallback** — if Glassdoor blocks, the run continues with Indeed + LinkedIn rather than failing entirely
- **MCP-ready** — works directly with Claude and other AI agents via Apify's MCP server

---

### Use Cases

**Recruiters & HR Teams**
Build a live feed of who's hiring for specific roles, monitor competitor hiring activity, and benchmark salaries across regions — all from a single API call.

**Job Market Researchers**
Aggregate hundreds of job listings daily for trend analysis: which skills are in demand, which companies are scaling, where salaries are moving.

**Salary Benchmarking**
Pull salary data for any role + location combination across three major platforms and normalize it into a consistent format for analysis.

**ATS / Job Board Enrichment**
Feed fresh job listings from all three major platforms into your own job board, internal dashboard, or CRM with structured, clean data.

**AI Pipeline Integration**
Use this actor as a data source for AI-powered job matching, career guidance agents, or labor market analysis systems via the Apify MCP server.

---

### Input Parameters

#### Basic Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `"software engineer"` | Job title, skills, or keyword to search for |
| `location` | string | `"United States"` | City, state, country, or `"Remote"` |
| `platforms` | array | `["indeed","linkedin","glassdoor"]` | Which platforms to scrape |
| `maxResults` | integer | `50` | Max total jobs to return (distributed evenly across platforms) |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `jobType` | string | `"all"` | `all`, `fulltime`, `parttime`, `contract`, `internship`, `temporary` |
| `isRemote` | boolean | `false` | Only return remote/WFH jobs |
| `hoursOld` | integer | `0` | Only jobs posted in the last X hours (`0` = no filter) |
| `deduplicate` | boolean | `true` | Remove cross-platform duplicates |

#### Example Input

```json
{
    "searchQuery": "data engineer",
    "location": "New York, NY",
    "platforms": ["indeed", "linkedin"],
    "maxResults": 100,
    "jobType": "fulltime",
    "isRemote": false,
    "hoursOld": 48,
    "deduplicate": true
}
````

**Health check / minimal input:**

```json
{
    "searchQuery": "software engineer",
    "location": "United States",
    "maxResults": 5
}
```

***

### Output Schema

Each record in the dataset contains:

```json
{
    "job_title": "Senior Data Engineer",
    "company_name": "Airbnb",
    "location": "San Francisco, CA",
    "is_remote": false,
    "salary_min": 150000,
    "salary_max": 200000,
    "salary_currency": "USD",
    "salary_period": "yearly",
    "job_type": "fulltime",
    "seniority_level": "Mid-Senior level",
    "description": "We are looking for a Senior Data Engineer...",
    "skills": ["python", "sql", "aws", "spark"],
    "posted_date": "2026-03-28T09:00:00.000Z",
    "apply_url": "https://www.linkedin.com/jobs/view/3987654321",
    "easy_apply": true,
    "platform": "linkedin",
    "company_rating": 4.3,
    "company_reviews_count": 3241,
    "company_size": "1001-5000 employees",
    "company_industry": "Internet & Web Services",
    "company_website": "https://airbnb.com",
    "source_url": "https://www.linkedin.com/jobs/search/?keywords=data+engineer...",
    "scraped_at": "2026-03-31T10:30:00.000Z"
}
```

#### Field Reference

| Field | Type | Notes |
|-------|------|-------|
| `job_title` | string | Job title as listed |
| `company_name` | string | Hiring company name |
| `location` | string | City, state, or "Remote" |
| `is_remote` | boolean | Detected from location + metadata |
| `salary_min` | number|null | Normalized to salary\_period units |
| `salary_max` | number|null | Normalized to salary\_period units |
| `salary_currency` | string|null | ISO 4217 code, e.g. "USD" |
| `salary_period` | string|null | "yearly", "monthly", or "hourly" |
| `job_type` | string|null | fulltime / parttime / contract / internship |
| `seniority_level` | string|null | Primarily from LinkedIn |
| `description` | string | Full job description text |
| `skills` | array|null | Auto-detected from description |
| `posted_date` | string|null | ISO 8601 |
| `apply_url` | string | Direct link to job listing |
| `easy_apply` | boolean|null | LinkedIn Easy Apply / Indeed Quick Apply |
| `platform` | string | "indeed", "linkedin", or "glassdoor" |
| `company_rating` | number|null | 0–5 stars (Indeed, Glassdoor) |
| `company_reviews_count` | integer|null | Employee review count |
| `company_size` | string|null | E.g. "1001-5000 employees" |
| `company_industry` | string|null | Industry category |
| `company_website` | string|null | Company homepage URL |
| `source_url` | string | Search results page that was scraped |
| `scraped_at` | string | ISO 8601 scrape timestamp |

***

### Pricing

This actor uses **Pay-Per-Event** pricing — you only pay for jobs actually returned.

| Plan | Price per 1,000 jobs |
|------|---------------------|
| Free tier | $3.00 |
| Bronze+ | $3.00 |

**Example cost estimates:**

- 100 jobs = ~$0.30
- 500 jobs = ~$1.50
- 1,000 jobs = ~$3.00
- 5,000 jobs = ~$15.00

No monthly fee. No minimum spend. You stop paying when results stop.

***

### Platform Notes

#### Indeed

- Searches public job listings globally (60+ countries supported)
- Salary data available on ~40–60% of listings
- Company ratings and review counts included where available
- Pagination handled automatically

#### LinkedIn (No Login Required)

- Uses LinkedIn's public job search — no cookies or account needed
- Seniority level and employment type from job criteria section
- Easy Apply detection included
- Skills extracted from job detail pages

#### Glassdoor

- Glassdoor now requires an Indeed account for full browse access
- The actor attempts to extract as many jobs as possible before login walls trigger
- If blocked, the run continues with Indeed + LinkedIn and logs a warning
- Residential proxies are used to improve Glassdoor reliability

***

### Performance

| Platform | Avg jobs/minute | Notes |
|----------|----------------|-------|
| Indeed | ~20/min | Residential proxy, paginated |
| LinkedIn | ~25/min | Guest API, no auth needed |
| Glassdoor | ~10/min | Slower due to bot detection mitigation |

A run for 100 jobs typically completes in **3–6 minutes**. Large runs (1,000+ jobs) may take 30–60 minutes depending on proxy availability.

***

### Limitations

- **Glassdoor login wall** — Glassdoor increasingly requires login to see full results. The actor extracts visible listings before the wall but cannot bypass authentication.
- **LinkedIn result cap** — LinkedIn's public search returns up to ~1,000 results per query. For broader coverage, narrow your search parameters.
- **Salary availability** — Salary data is only available on ~40–60% of Indeed listings and varies by location. LinkedIn and Glassdoor show salary on fewer listings.
- **Selectors may break** — Job platforms frequently update their HTML. If you notice empty results, please open an issue — we aim to fix selector changes within 48 hours.
- **Rate limits** — Running with `maxResults` above 500 on a single platform may trigger temporary rate limiting. The actor backs off automatically using session rotation and residential proxies.

***

### Works Great With

- **[Contact Info Finder](https://apify.com/supreme_coder/contact-info-finder)** — Enrich job listings with recruiter emails from company websites
- **Apify Datasets** — Export results to Google Sheets, Airtable, or any webhook
- **Apify Schedules** — Run daily to monitor new job postings for specific roles

***

### Support

Found a bug? Selectors breaking? Open an issue in the Issues tab. We respond within 48 hours.

If this actor saved you time, please leave a ⭐ review — it helps us maintain and improve the scraper.

***

### Changelog

**v1.0.0** (2026-03-31)

- Initial release
- Indeed, LinkedIn, and Glassdoor support
- Salary normalization across all platforms
- Cross-platform deduplication
- PPE pricing at $0.003/result

# Actor input Schema

## `searchQuery` (type: `string`):

Use this when the user provides a job title, skill, or keyword to search for. E.g. 'software engineer', 'data analyst', 'remote python developer'. Do NOT leave empty if you have a search intent — use this as the primary search field.

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

City, state, country, or 'Remote' to filter by location. E.g. 'New York, NY', 'London', 'United States', 'Remote'. Leave empty for worldwide results.

## `platforms` (type: `array`):

Which platforms to scrape. Use all three for maximum coverage, or a subset if you only need specific platforms.

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

Maximum total job listings to return across all selected platforms. Distributed evenly per platform. Min: 1, Max: 1000. Use lower values for quick tests.

## `jobType` (type: `string`):

Filter by employment type. Use 'all' for no filter, or a specific type. Note: availability varies by platform.

## `isRemote` (type: `boolean`):

If true, only return remote/work-from-home jobs. If false, return all jobs regardless of remote status.

## `hoursOld` (type: `integer`):

Only return jobs posted within the last X hours. E.g. 24 = last 24 hours, 168 = last week. Set to 0 to disable this filter.

## `deduplicate` (type: `boolean`):

If true, removes duplicate job listings that appear on multiple platforms (matched by job title + company + location). The record with the richer description is kept.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "location": "United States",
  "platforms": [
    "indeed",
    "linkedin",
    "glassdoor"
  ],
  "maxResults": 50,
  "jobType": "all",
  "isRemote": false,
  "hoursOld": 0,
  "deduplicate": true
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset of job listings. Each item includes job\_title, company\_name, location, is\_remote, salary\_min, salary\_max, salary\_currency, job\_type, description, skills, posted\_date, apply\_url, platform, and more.

# 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 = {
    "searchQuery": "software engineer",
    "location": "United States",
    "platforms": [
        "indeed",
        "linkedin",
        "glassdoor"
    ],
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQuery": "software engineer",
    "location": "United States",
    "platforms": [
        "indeed",
        "linkedin",
        "glassdoor",
    ],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "searchQuery": "software engineer",
  "location": "United States",
  "platforms": [
    "indeed",
    "linkedin",
    "glassdoor"
  ],
  "maxResults": 50
}' |
apify call khadinakbar/jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobs Scraper — Indeed, LinkedIn & Glassdoor",
        "description": "Extract job listings from Indeed, LinkedIn & Glassdoor simultaneously. Returns title, company, salary, location, remote flag, job type, seniority, full description & apply URL. Pay-per-result — $3 per 1,000 jobs.",
        "version": "1.0",
        "x-build-id": "z6SBGF4NLLnKjTDba"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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",
                "properties": {
                    "searchQuery": {
                        "title": "Job Title / Keywords",
                        "type": "string",
                        "description": "Use this when the user provides a job title, skill, or keyword to search for. E.g. 'software engineer', 'data analyst', 'remote python developer'. Do NOT leave empty if you have a search intent — use this as the primary search field.",
                        "default": "software engineer"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, country, or 'Remote' to filter by location. E.g. 'New York, NY', 'London', 'United States', 'Remote'. Leave empty for worldwide results.",
                        "default": "United States"
                    },
                    "platforms": {
                        "title": "Job Platforms to Search",
                        "type": "array",
                        "description": "Which platforms to scrape. Use all three for maximum coverage, or a subset if you only need specific platforms.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "indeed",
                                "linkedin",
                                "glassdoor"
                            ]
                        },
                        "default": [
                            "indeed",
                            "linkedin",
                            "glassdoor"
                        ]
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum total job listings to return across all selected platforms. Distributed evenly per platform. Min: 1, Max: 1000. Use lower values for quick tests.",
                        "default": 50
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "all",
                            "fulltime",
                            "parttime",
                            "contract",
                            "internship",
                            "temporary"
                        ],
                        "type": "string",
                        "description": "Filter by employment type. Use 'all' for no filter, or a specific type. Note: availability varies by platform.",
                        "default": "all"
                    },
                    "isRemote": {
                        "title": "Remote Jobs Only",
                        "type": "boolean",
                        "description": "If true, only return remote/work-from-home jobs. If false, return all jobs regardless of remote status.",
                        "default": false
                    },
                    "hoursOld": {
                        "title": "Posted Within (Hours)",
                        "minimum": 0,
                        "maximum": 720,
                        "type": "integer",
                        "description": "Only return jobs posted within the last X hours. E.g. 24 = last 24 hours, 168 = last week. Set to 0 to disable this filter.",
                        "default": 0
                    },
                    "deduplicate": {
                        "title": "Remove Cross-Platform Duplicates",
                        "type": "boolean",
                        "description": "If true, removes duplicate job listings that appear on multiple platforms (matched by job title + company + location). The record with the richer description is kept.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
