# Naukri Job Scraper (`trakk/naukri-job-scraper`) Actor

Scrape Naukri job listings by keyword, search URL, or job IDs. Standard mode returns search-card data; Detailed mode adds full description, company profile and AmbitionBox reviews. Auto-resolves city names to internal IDs. HTTP-only with TLS impersonation, no browser.

- **URL**: https://apify.com/trakk/naukri-job-scraper.md
- **Developed by:** [Blynx](https://apify.com/trakk) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 66.7% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 standard job items

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Naukri Job Scraper

A pay-per-event Apify actor that pulls structured job listings from Naukri
through its internal JSON endpoints. No browser, no Chromium, no Selenium -
plain HTTP with TLS impersonation, so it stays cheap and fast even at tens
of thousands of listings.

### What it does

- Takes one of three inputs as a starting point: a free-text keyword, a
  full Naukri search URL, or an explicit list of job IDs.
- Optionally narrows the search by city, experience, posting age, salary,
  industry and sort order.
- Paginates through the search results, deduplicates by job ID, stops at
  the user-supplied `maxJobs` cap.
- In Standard mode pushes the trimmed search-card object for each job
  (title, company, salary, experience, location, skills, URL, AmbitionBox
  rating, ...).
- In Detailed mode additionally fetches the per-job endpoint and merges
  the full HTML description, key skills, role category, education
  requirements, AmbitionBox reviews/salaries/benefits onto the card.
- Writes everything to the default Apify dataset and bills one
  pay-per-event charge per pushed item (`job_item` or `job_item_detailed`).

### Modes

| Mode | Trigger | Output | Billed event |
|---|---|---|---|
| Standard | `keyword` or `searchUrl`, `fetchDetails=false` | Job summary card from search results | `job_item` |
| Detailed | `fetchDetails=true` (with keyword/URL) | Summary plus full description, company profile, AmbitionBox reviews/salaries/benefits | `job_item_detailed` |
| Direct | non-empty `jobIds` | Full detail object for each given ID | `job_item_detailed` |

Precedence: `jobIds > searchUrl > keyword`. When `searchUrl` is set, manual
filters are ignored, but `sortBy` is still applied on top.

### Input fields

#### Anchors (one of these is required)

| Field | What it does |
|---|---|
| `keyword` | Free-text search term (e.g. `"python developer"`). |
| `searchUrl` | A full Naukri search-results URL. Just paste whatever is in your browser's address bar after you've set the filters you want on the Naukri site itself. Supports all three URL shapes - `/<keyword>-jobs`, `/jobs-in-<city>`, `/<keyword>-jobs-in-<city>` - and carries every URL-style filter parameter through to the API (`?experience=5&jobAge=7&minSalary=...`). When this is set, the structured filter fields below are ignored, but `sortBy` is still layered on top. |
| `jobIds` | Direct list of Naukri job IDs to fetch detail-pages for. Skips search entirely. |

#### Filters (all optional, all verified to actually work)

| Field | Format | What it does |
|---|---|---|
| `cities` | `["Mumbai", "Bengaluru"]` or `["17", "97"]` or mixed | City filter. Names are auto-resolved through a built-in lookup; unknown names are forwarded to Naukri's server-side resolver. Numeric IDs pass through. |
| `experience` | `"5"` | Required years of experience. Vacancies whose declared range covers this value match (so `"5"` matches `3-7 Yrs`, `5-10 Yrs`, etc.). |
| `freshness` | `"1"` / `"3"` / `"7"` / `"15"` / `"30"` / `"all"` | How recently the job was posted (in days). |
| `salaryRange` | `["10to15", "15to25"]` | Annual salary buckets in lakhs (LPA). Multiple buckets are merged into one wider range. `"75plus"` drops the upper bound. |
| `industry` | `["25", "14"]` | Numeric Naukri industry IDs. |
| `sortBy` | `"date"` or `"relevance"` | Sort order. Defaults to relevance. |

#### Run controls

| Field | Default | What it does |
|---|---|---|
| `maxJobs` | `100` | Upper limit on jobs collected (minimum `50`). |
| `fetchDetails` | `false` | Toggle between Standard and Detailed mode. |
| `proxyConfiguration` | residential | Apify proxy settings; residential is strongly recommended. |
| `maxConcurrency` | `5` | Concurrent HTTP requests cap. |
| `maxRetries` | `5` | Retry budget per request for transient errors (separate from proxy and block-detection retries, which have their own caps). |

### Quick examples

**Plain keyword search**

```json
{
  "keyword": "data engineer",
  "experience": "5",
  "freshness": "7",
  "sortBy": "date",
  "maxJobs": 100
}
````

**Keyword + city filter (auto-resolved by name)**

```json
{
  "keyword": "frontend developer",
  "cities": ["Singapore"],
  "freshness": "30",
  "maxJobs": 100,
  "fetchDetails": true
}
```

**From a full search URL** - paste any Naukri search-results URL (the one in your address bar after picking filters on the site)

```json
{
  "searchUrl": "https://www.naukri.com/python-jobs?experience=3",
  "maxJobs": 100,
  "sortBy": "date"
}
```

**Direct fetch by job IDs**

```json
{
  "jobIds": ["220126040161", "170424007054"],
  "maxJobs": 50,
  "fetchDetails": true
}
```

**Salary band + industry**

```json
{
  "keyword": "devops",
  "salaryRange": ["15to25", "25to50"],
  "industry": ["25"],
  "maxJobs": 200
}
```

### How it stays unblocked

Naukri sits behind an Akamai-class bot manager. Generic Python HTTP clients
are dead on arrival because they fail at the TLS handshake before a single
request body goes out. This actor uses a different toolchain:

- **`curl_cffi` with `impersonate="chrome"`** - TLS handshake, HTTP/2
  SETTINGS frame, ALPN, cipher order and JA3/JA4 fingerprint all match a
  real Chrome.
- **Residential proxies** - datacenter exits get challenged constantly.
- **Per-request session rotation** - every retry spins up a fresh
  `AsyncSession` with a new `session_id`, which means a new exit IP and an
  empty cookie jar. No state carries over between attempts.
- **Three-budget retry policy** - proxy failures, bot-management blocks
  (HTTP 401/403 with bot-wall markers, or 406 with `recaptcha required`),
  and ordinary 429/5xx/parse errors each have their own counter. A flaky
  proxy cannot eat the retry budget reserved for transient errors.
- **Browser-shaped headers** - Accept, Accept-Language, Sec-Fetch-\*,
  Priority, Upgrade-Insecure-Requests, etc.; the Chrome user agent and
  `sec-ch-ua-*` are set automatically by curl\_cffi based on the impersonate
  profile.
- **Internal `/jobapi/v1/*` endpoint family** - chosen specifically because
  v3+ now requires an invisible reCAPTCHA token only the real frontend can
  mint. The actor will detect a `406 recaptcha required` if Naukri ever
  closes v1 too, and rotate sessions.

No Playwright, no Chromium, no Selenium. Default memory is 512 MB.

### Output shape

Standard-mode items are trimmed to ~40 useful fields. Legacy v1 keys that
are always null, internal flags, recruiter-contact junk and duplicates of
derived fields (`post`, `urlStr`, `addDate`, `compLogo`, `keywords`,
`jobDesc`, `tupleDesc`, `currencySal`, `isSavedJob`, internship-only fields
on non-internship jobs) are stripped before writing to the dataset. The
useful surface is:

- `jobId`, `title`, `companyName`, `companyId`, `groupId`, `staticCompanyName`
- `experience` (`"5-10 Yrs"` derived from numeric `minExp` + `maxExp`)
- `salary` (`"Not disclosed"` if the company hid the figure, otherwise the
  formatted range; raw `minSal`/`maxSal`/`showSal` are also kept)
- `location` (best-effort canonical city), `cityfield`, `locality`
- `jdURL` (with the trailing tracking query stripped)
- `tagsAndSkills`, `logoPath`, `currency` (always normalised to `INR`)
- `companyJobsUrl` (synthesised from `staticCompanyName`)
- `companyProfile`, `employmentType`, `noOfVacancy`
- `ambitionBoxData` (object with rating, reviewCount, title, url - when
  Naukri provides it; expect `undefined` for smaller employers in Standard
  mode)
- `createdDate`, `isSaved`, `isExpiredJob`, `isWalkIn`, `isTopGroup`,
  `multipleApply`
- `jobtype`, `jobType1`-`jobType5` (Naukri's internal listing categorisation)

Detailed-mode items merge the search-card on top of the full detail-API
response, which adds:

- the entire `job` object - HTML description, key skills (preferred +
  other), industry, employment type, role category, education requirements
- AmbitionBox details (reviews, salaries, benefits) when present

### Local development

```bash
pip install -r requirements.txt
python -m src
```

Place an `INPUT.json` under `storage/key_value_stores/default/` and run
`apify run --purge` (Apify CLI required). Output lands in
`storage/datasets/default/`.

### Notes & limits

- `maxJobs` is clamped to a minimum of 50.
- Page size is 20 (the v1 endpoint default); pagination stops on the first
  short page.
- If a detail-API call fails despite retries, the job is still pushed using
  only the search summary and billed as `job_item` rather than dropped.
- The built-in city table covers ~30 high-volume cities; smaller cities
  take the free-text fallback path automatically.
- "Remote" / "Hybrid" inside `cities` is rejected with a helpful error
  message because Naukri's workMode filter is broken on v1 and would
  silently return the full database.

# Actor input Schema

## `keyword` (type: `string`):

Search term to look up jobs by.

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

Full Naukri search-results URL to scrape.

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

Upper limit on how many job listings to collect.

## `jobIds` (type: `array`):

Specific Naukri job IDs to fetch directly.

## `fetchDetails` (type: `boolean`):

Enable detailed mode: pull the full description, company profile and AmbitionBox data for each job.

## `freshness` (type: `string`):

How recently the job was posted.

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

Sort order of the results.

## `experience` (type: `string`):

Required years of experience.

## `salaryRange` (type: `array`):

Annual salary buckets in lakhs (e.g. "10to15", "15to25"). Multiple buckets are merged into one wider range.

## `cities` (type: `array`):

Cities to filter jobs by. Accepts city names or numeric Naukri IDs.

## `industry` (type: `array`):

Industry-type IDs to filter by.

## `proxyConfiguration` (type: `object`):

Proxy settings used for outbound requests.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent HTTP requests.

## `maxRetries` (type: `integer`):

Retry budget per request for transient errors.

## Actor input object example

```json
{
  "keyword": "data engineer",
  "maxJobs": 50,
  "jobIds": [],
  "fetchDetails": false,
  "freshness": "all",
  "sortBy": "relevance",
  "salaryRange": [],
  "cities": [
    "Bengaluru"
  ],
  "industry": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  },
  "maxConcurrency": 5,
  "maxRetries": 5
}
```

# 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 = {
    "keyword": "data engineer",
    "maxJobs": 50,
    "cities": [
        "Bengaluru"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("trakk/naukri-job-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 = {
    "keyword": "data engineer",
    "maxJobs": 50,
    "cities": ["Bengaluru"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("trakk/naukri-job-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 '{
  "keyword": "data engineer",
  "maxJobs": 50,
  "cities": [
    "Bengaluru"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  }
}' |
apify call trakk/naukri-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naukri Job Scraper",
        "description": "Scrape Naukri job listings by keyword, search URL, or job IDs. Standard mode returns search-card data; Detailed mode adds full description, company profile and AmbitionBox reviews. Auto-resolves city names to internal IDs. HTTP-only with TLS impersonation, no browser.",
        "version": "0.1",
        "x-build-id": "9N5u7vV4hdeGQ6WZH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/trakk~naukri-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-trakk-naukri-job-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/trakk~naukri-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-trakk-naukri-job-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/trakk~naukri-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-trakk-naukri-job-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": [
                    "maxJobs"
                ],
                "properties": {
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Search term to look up jobs by."
                    },
                    "searchUrl": {
                        "title": "Search URL",
                        "type": "string",
                        "description": "Full Naukri search-results URL to scrape."
                    },
                    "maxJobs": {
                        "title": "Max jobs",
                        "minimum": 50,
                        "type": "integer",
                        "description": "Upper limit on how many job listings to collect.",
                        "default": 100
                    },
                    "jobIds": {
                        "title": "Job IDs",
                        "type": "array",
                        "description": "Specific Naukri job IDs to fetch directly.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch detailed data",
                        "type": "boolean",
                        "description": "Enable detailed mode: pull the full description, company profile and AmbitionBox data for each job.",
                        "default": false
                    },
                    "freshness": {
                        "title": "Freshness (days)",
                        "enum": [
                            "all",
                            "30",
                            "15",
                            "7",
                            "3",
                            "1"
                        ],
                        "type": "string",
                        "description": "How recently the job was posted.",
                        "default": "all"
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Sort order of the results.",
                        "default": "relevance"
                    },
                    "experience": {
                        "title": "Experience (years)",
                        "type": "string",
                        "description": "Required years of experience."
                    },
                    "salaryRange": {
                        "title": "Salary range",
                        "type": "array",
                        "description": "Annual salary buckets in lakhs (e.g. \"10to15\", \"15to25\"). Multiple buckets are merged into one wider range.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Cities to filter jobs by. Accepts city names or numeric Naukri IDs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "industry": {
                        "title": "Industry IDs",
                        "type": "array",
                        "description": "Industry-type IDs to filter by.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings used for outbound requests.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of concurrent HTTP requests.",
                        "default": 5
                    },
                    "maxRetries": {
                        "title": "Max retries",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Retry budget per request for transient errors.",
                        "default": 5
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
