# 4 (`shadowextractor/naukri-job-scraper`) Actor

- **URL**: https://apify.com/shadowextractor/naukri-job-scraper.md
- **Developed by:** [Shadow Extractor](https://apify.com/shadowextractor) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 standard jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 📇 Naukri Jobs & Recruiter Contacts Scraper

Collect fresh Naukri job listings for India recruiting, salary research, skills analysis, and lead generation. Search by role and city, reuse a Naukri results URL, or fetch exact job IDs. Detailed runs can add full descriptions, company context, AmbitionBox signals, and recruiter contact details when they are publicly posted in the listing.

> **Contact availability:** the Actor does not invent or guess personal data. Email addresses and phone numbers are returned only when they are publicly present in the Naukri job content.

### ✨ What you can collect

- Job title, company, location, experience, and posting date
- Salary label plus normalized minimum, maximum, and currency when available
- Skills, keywords, and full job descriptions
- Public recruiter email addresses and phone numbers
- Contact company, company address, and public website when exposed
- Company IDs, logos, profile links, and Naukri company jobs URLs
- AmbitionBox rating, review count, title, and profile URL when supplied by Naukri
- Clean job, contact, company, recruiting-intelligence, and error views

### 🚀 Quick start

1. Open the Actor **Input** tab.
2. Enter a role in **Job keyword**, for example `data engineer`.
3. Add one or more locations, for example `Bengaluru` and `Hyderabad`.
4. Set **Number of jobs**.
5. Keep **Fetch full job details** off for a faster search, or enable it for descriptions, richer salary data, contacts, and company context.
6. Click **Start** and open the **Jobs** or **Contacts / Leads** output view.

#### Recommended first run

```json
{
  "keyword": "data engineer",
  "cities": ["Bengaluru"],
  "maxJobs": 50,
  "fetchDetails": false,
  "extractContacts": true,
  "freshness": "7",
  "sortBy": "date"
}
````

### 🧭 Three input workflows

The Actor chooses one workflow from your input in this order:

```text
jobIds
  ↓ when empty
searchUrl
  ↓ when empty
keyword + cities
```

| Workflow | Best for | What to provide |
|---|---|---|
| **Keyword + cities** | Discovering jobs by role and market | `keyword`, `cities`, and optional filters |
| **Naukri search URL** | Reusing a search already configured on Naukri | `searchUrl` |
| **Direct job IDs** | Fetching exact known listings | `jobIds` |

When `jobIds` are supplied, search filters are ignored and full details are fetched automatically.

If no usable search input is supplied, the Actor uses a safe sample search for `data engineer` in `Bengaluru`, so a new user does not start with an empty configuration.

### 📬 Standard vs detailed results

| Capability | Standard search | Full details |
|---|:---:|:---:|
| Job cards | ✅ | ✅ |
| Title, company, location, experience | ✅ | ✅ |
| Posted date and visible salary | ✅ | ✅ |
| Skills visible in search | ✅ | ✅ |
| Full job description | Limited | ✅ |
| Public recruiter contacts | Best effort | Best coverage |
| Detailed company fields | Limited | ✅ when published |
| AmbitionBox context | When available | Best coverage |
| Speed | Faster | Slower |

Use `fetchDetails: false` for discovery and dashboards. Use `fetchDetails: true` when you need the complete listing or contact extraction.

The Actor uses separate result events for standard and detailed job items. The current prices are always shown in the Apify Store before a run.

### 📇 Public recruiter contacts

Enable `extractContacts` to extract contact information from recruiter-written listing content, including patterns such as:

```text
Send your CV to hiring@example.com
Call or WhatsApp +91 98765 43210
```

Possible output fields include:

- `contactEmails`
- `contactPhones`
- `contactCompany`
- `contactAddress`
- `companyWebsite`

Contact coverage varies by role and employer. Staffing, recruiter, sales, BPO, field, and walk-in listings often publish more direct contact information. Many large employers intentionally accept applications only through Naukri and therefore expose no email or phone number.

Set `extractContacts` to `false` when you only need job-market data.

### 🎛️ Filters

#### Posted within

Use `freshness` with one of these values:

| Value | Meaning |
|---|---|
| `all` | Any time |
| `30` | Last 30 days |
| `15` | Last 15 days |
| `7` | Last 7 days |
| `3` | Last 3 days |
| `1` | Last 24 hours |

#### Experience

Use the same style accepted by Naukri:

```json
{
  "experience": "2-5"
}
```

#### Salary range

Salary buckets use annual lakh ranges. Examples:

```json
{
  "salaryRange": ["10to15"]
}
```

```json
{
  "salaryRange": ["15to25", "25to50"]
}
```

Multiple buckets are combined into one wider range. Common styles include `10to15`, `15to25`, and `75plus`.

#### Sort order

- `relevance`: Naukri relevance order
- `date`: newest jobs first

#### Industry

Use `industry` when you already know Naukri industry IDs:

```json
{
  "industry": ["25", "34"]
}
```

### 📥 Input examples

#### Detailed recruiter leads

```json
{
  "keyword": "HR recruiter",
  "cities": ["Delhi / NCR", "Gurugram"],
  "maxJobs": 50,
  "fetchDetails": true,
  "extractContacts": true,
  "freshness": "7",
  "sortBy": "date"
}
```

#### Salary and skills research

```json
{
  "keyword": "python developer",
  "cities": ["Bengaluru", "Pune", "Hyderabad"],
  "maxJobs": 100,
  "fetchDetails": true,
  "extractContacts": false,
  "experience": "3-6",
  "salaryRange": ["10to15", "15to25"],
  "freshness": "30"
}
```

#### Use a ready Naukri search URL

```json
{
  "searchUrl": "https://www.naukri.com/data-analyst-jobs-in-mumbai",
  "maxJobs": 50,
  "fetchDetails": true,
  "extractContacts": true
}
```

#### Fetch exact job IDs

```json
{
  "jobIds": [
    "010726501234",
    "020726009876"
  ],
  "maxJobs": 50,
  "extractContacts": true
}
```

Direct job IDs always use detailed collection. Expired, removed, or private IDs may return no job row.

### 📤 Output views

#### 📇 Contacts / Leads

Designed for recruiting and outreach workflows:

- role and company
- recruiter email and phone
- contact company
- location and salary
- posting date and job URL

#### 💼 Jobs

The clean job-discovery table:

- job ID
- title and company
- location and experience
- salary and salary source
- skills, posting date, and URL

#### 📊 Recruiting intelligence

Adds normalized salary fields and AmbitionBox context for analysis:

- `minSal`, `maxSal`, and `currency`
- `salarySource`
- `tagsAndSkills`
- `ambitionBoxData`

#### 🏢 Companies & AmbitionBox

Focuses on company-level fields, profiles, logos, and AmbitionBox signals.

#### ⚠️ Errors

Shows actionable diagnostics for invalid direct IDs or a temporary source issue. Diagnostic rows are clearly labeled with `type: "error"` and are not disguised as jobs.

### 🧾 Example detailed job

The exact fields depend on what Naukri publishes for a listing. A detailed row can look like this:

```json
{
  "jobId": "010726501234",
  "title": "Senior Data Engineer",
  "companyName": "Example Technologies",
  "location": "Bengaluru",
  "experience": "4-8 years",
  "salary": "₹18-28 Lacs P.A.",
  "salarySource": "source",
  "minSal": 1800000,
  "maxSal": 2800000,
  "currency": "INR",
  "tagsAndSkills": ["Python", "SQL", "AWS", "Spark"],
  "jobDescription": "Build and operate reliable data pipelines...",
  "contactEmails": ["hiring@example.com"],
  "contactPhones": ["+91 98765 43210"],
  "ambitionBoxData": {
    "rating": 4.1,
    "reviewCount": 1250,
    "url": "https://www.ambitionbox.com/..."
  },
  "createdDate": "2026-07-01",
  "jdURL": "https://www.naukri.com/job-listings-..."
}
```

### 🔗 Build a simple recruiting pipeline

```text
Naukri search
     ↓
Job rows + salary + skills
     ↓
Optional full details
     ↓
Public contacts + company context
     ↓
CSV / Excel / API / automation
```

Use `jobId` as the primary job identifier and `jdURL` as the source link. For company analysis, group rows by `companyId` when present, otherwise by `companyName`.

### ✅ Data-quality notes

- Missing public contacts are omitted rather than replaced with placeholders.
- Salary fields appear only when the source publishes salary information or a clear salary value can be recovered from the listing text.
- AmbitionBox fields appear only when Naukri supplies the corresponding company metadata.
- A detail request that cannot be completed during a search can fall back to the standard job card, so useful results are not discarded.
- The Actor can return fewer rows than `maxJobs` when the search has fewer matching public listings.
- The minimum supported `maxJobs` value is `50` because Naukri search results are collected in batches.

### ❓ FAQ

#### Why did I get no recruiter email or phone?

The employer did not publish contact information in that job listing. Enable full details for the best available coverage, but no scraper can return data that is not public.

#### Does `fetchDetails` matter for direct job IDs?

No. Direct job IDs are detailed automatically.

#### Can I search for Remote as a city?

Naukri's supported search fields vary. Use a real city or a ready Naukri search URL for the most predictable results. A standalone `Remote`, `WFH`, or `Hybrid` pseudo-location may not produce a valid search.

#### Why did I receive fewer than 50 jobs?

`maxJobs` is an upper limit, not a promise. Filters, listing availability, expired jobs, and the source result count can all reduce the final number.

#### Why is a detailed run slower?

It opens each selected job individually to collect the complete description and additional fields.

#### Can I export the data?

Yes. Apify datasets can be downloaded as JSON, CSV, Excel, XML, RSS, or accessed through the API.

### ⚖️ Responsible use

Collect and use only publicly available information. Follow applicable privacy, employment, anti-spam, and data-protection laws. Review your outreach workflow before contacting candidates, recruiters, or employers.

### 🏷️ Good for

`Naukri jobs` · `India jobs` · `recruiter contacts` · `salary data` · `skills intelligence` · `AmbitionBox` · `lead generation` · `recruiting automation`

# Actor input Schema

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

Role, skill, or job title to search for. Examples: data engineer, python developer, product manager.

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

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

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

Upper limit on how many job listings to collect. Naukri pages are fetched in batches, so the minimum safe value is 50.

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

Adds full description, company profile, detailed skills, education fields, and AmbitionBox data when available. Richer but slower than standard mode.

## `extractContacts` (type: `boolean`):

Pull recruiter email and phone from the public job description when the recruiter posted them (e.g. "share CV to hr@acme.com / call 98xxxxxxxx"), plus the contact company. Best coverage with Detailed mode on recruiter, sales, BPO, and field roles. Turn off for a leaner dataset.

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

Full Naukri search-results URL to scrape. Use this when you already built exact filters on Naukri.

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

Specific Naukri job IDs to fetch directly. Search filters are ignored when job IDs are provided.

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

How recently the job was posted.

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

Sort order of the results.

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

Required years of experience. Use the same style Naukri accepts, for example 2 or 2-5.

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

Annual salary buckets in lakhs, for example 10to15 or 15to25. Multiple buckets are merged into one wider range.

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

Industry-type IDs to filter by.

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

Maximum number of concurrent requests. The default is balanced for most runs.

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

Retry budget per request for temporary errors.

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

Optional network settings for outbound requests. Leave disabled unless your workflow requires a custom setup.

## Actor input object example

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

# Actor output Schema

## `contacts` (type: `string`):

No description

## `jobs` (type: `string`):

No description

## `recruiting_intelligence` (type: `string`):

No description

## `companies` (type: `string`):

No description

## `errors` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keyword": "data engineer",
    "cities": [
        "Bengaluru"
    ],
    "maxJobs": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("shadowextractor/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",
    "cities": ["Bengaluru"],
    "maxJobs": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "4",
        "description": null,
        "version": "0.1",
        "x-build-id": "fVvzRcW5jb38wZ6Z7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/shadowextractor~naukri-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-shadowextractor-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/shadowextractor~naukri-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-shadowextractor-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/shadowextractor~naukri-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-shadowextractor-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": "🔎 Job keyword",
                        "type": "string",
                        "description": "Role, skill, or job title to search for. Examples: data engineer, python developer, product manager.",
                        "default": "data engineer"
                    },
                    "cities": {
                        "title": "📍 City / location(s)",
                        "type": "array",
                        "description": "Cities to filter jobs by. Accepts city names or numeric Naukri IDs.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "Bengaluru"
                        ]
                    },
                    "maxJobs": {
                        "title": "💯 Number of jobs",
                        "minimum": 50,
                        "type": "integer",
                        "description": "Upper limit on how many job listings to collect. Naukri pages are fetched in batches, so the minimum safe value is 50.",
                        "default": 100
                    },
                    "fetchDetails": {
                        "title": "📄 Fetch full job details",
                        "type": "boolean",
                        "description": "Adds full description, company profile, detailed skills, education fields, and AmbitionBox data when available. Richer but slower than standard mode.",
                        "default": false
                    },
                    "extractContacts": {
                        "title": "📇 Extract recruiter contacts",
                        "type": "boolean",
                        "description": "Pull recruiter email and phone from the public job description when the recruiter posted them (e.g. \"share CV to hr@acme.com / call 98xxxxxxxx\"), plus the contact company. Best coverage with Detailed mode on recruiter, sales, BPO, and field roles. Turn off for a leaner dataset.",
                        "default": true
                    },
                    "searchUrl": {
                        "title": "🔗 Naukri search URL",
                        "type": "string",
                        "description": "Full Naukri search-results URL to scrape. Use this when you already built exact filters on Naukri."
                    },
                    "jobIds": {
                        "title": "🆔 Job IDs",
                        "type": "array",
                        "description": "Specific Naukri job IDs to fetch directly. Search filters are ignored when job IDs are provided.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "freshness": {
                        "title": "🕒 Posted within",
                        "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",
                        "type": "string",
                        "description": "Required years of experience. Use the same style Naukri accepts, for example 2 or 2-5."
                    },
                    "salaryRange": {
                        "title": "Salary range",
                        "type": "array",
                        "description": "Annual salary buckets in lakhs, for example 10to15 or 15to25. Multiple buckets are merged into one wider range.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "industry": {
                        "title": "Industry IDs",
                        "type": "array",
                        "description": "Industry-type IDs to filter by.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "maxConcurrency": {
                        "title": "⚙️ Max concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of concurrent requests. The default is balanced for most runs.",
                        "default": 5
                    },
                    "maxRetries": {
                        "title": "Max retries",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Retry budget per request for temporary errors.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Network settings",
                        "type": "object",
                        "description": "Optional network settings for outbound requests. Leave disabled unless your workflow requires a custom setup.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
