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

Export Naukri.com job listings to CSV-ready data: company, location, salary, skills, ratings, walk-in flags, and optional full descriptions. Filter by role, city, experience, freshness, and work type. For recruiters, staffing, and sales teams.

- **URL**: https://apify.com/vamsi-krishna/naukri-job-scraper.md
- **Developed by:** [Vamsi Krishna](https://apify.com/vamsi-krishna) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

## Naukri.com Job Scraper

**Turn Naukri job search into a recruiter-ready spreadsheet in minutes.**

Export fresh Naukri.com listings as a **flat dataset with a variable-length `skills` array** plus CSV-friendly columns—ready for Google Sheets, Airtable, your ATS, CRM, or BI stack. Built for recruiters, sales teams, and automation builders who need clean hiring data without writing a custom parser.

**[Run on Apify](https://console.apify.com/actors/YOUR_ACTOR_ID)** · [Try example input](#example-fresher-fullstack-tight-sourcing-list)

Actor name: `naukri-job-scraper`

---

### The problem — and the fix

| Pain | This Actor |
|---|---|
| Nested JSON breaks Sheets and CRM imports | Flat schema with `skills` array + export columns |
| Sourcing lists fill up with stale jobs | `freshnessDays` plus parsed-date post-filtering |
| Hours spent cleaning salary and skills text | Parsed `salaryMin`, `salaryMax`, and `skills` array (plus `skills/0`–`skills/7` for CSV) |
| Runs die on blocks with nothing saved | Sessions, retries, proxy support, and partial-result recovery |

---

### Who it's for

#### Recruiters and staffing

- Build **fresh sourcing lists** with experience bands, walk-in flags, and company ratings.
- Filter by **location, work type, and how recently jobs were posted**.
- Spot **walk-in drives** and employer reputation before you reach out.

**Typical workflow:** Search by role and city → export to Sheets or your ATS → start outreach the same day.

#### Sales and GTM

- Find **companies actively hiring** for roles you sell into.
- Target accounts with **company name, rating, review count, and job URL** in every row.
- Track **remote, hybrid, and office** demand by market.

**Typical workflow:** Run weekly searches by keyword → push dataset to your CRM → trigger outreach when hiring signals match your ICP.

#### Builders and ops

- Pipe jobs into **Apify datasets**, webhooks, or scheduled runs—no scraper maintenance.
- Choose **fast listing mode** or **full descriptions** depending on volume and cost.
- Rely on **deduplication, block detection, and incremental dataset push** for production pipelines.

**Typical workflow:** `apify call` or Console schedule → download CSV/JSON → feed Sheets, Airtable, or your data warehouse.

---

### Why teams switch from basic scrapers

| What you need | Basic Naukri scraper | This Actor |
|---|---|---|
| CRM or Sheets import | Manual JSON cleanup | Flat schema + `skills` JSON array |
| Fresher or band hiring | Single experience value | `experienceMin` + `experienceMax` range |
| Only recent openings | Sort-only or coarse filter | `freshnessDays` + parsed-date filtering |
| Salary benchmarking | Raw salary text only | Raw `salary` + `salaryMin` / `salaryMax` |
| Skills reporting | Nested arrays | `skills` array (any length) + first 8 in `skills/0`–`skills/7` |
| Walk-in campaigns | Often missing | `isWalkin` on every row |
| Cost vs depth | Fixed behavior | Fast listing mode or full-description mode |
| Clean account lists | Basic URL dedup | Job ID → URL → title/company/location fallback |
| Long or fragile runs | Basic retries | Sessions, block detection, proxy, recovery |

---

### Built for production runs

- **CSV-ready:** flat job fields plus `skills` array; first 8 skills also in `skills/0`–`skills/7`.
- **Incremental export:** jobs land in the dataset as they are scraped.
- **Smart dedup:** job ID, then URL, then title/company/location fallback.
- **Resilient sessions:** rotate when blocks or rate limits appear; retry failed requests.
- **Your pace:** optional fast listing scrape or full job descriptions from detail pages.
- **Proxy-ready:** Apify Proxy enabled by default; tune delays when sites get strict.

---

### Quick start

#### First run in 60 seconds

1. Set **keyword** (e.g. `software engineer`).
2. Set **location** (e.g. `Bangalore`).
3. Set **maxItems** (e.g. `50`).
4. Click **Start** on Apify Console—or run the CLI below.

#### Run on Apify

```bash
apify push
apify call naukri-job-scraper --input='{"keyword":"product manager","location":"Delhi","maxItems":50}'
````

Open **[Apify Console](https://console.apify.com/actors/YOUR_ACTOR_ID)** to configure inputs in the UI, view the **Output** table, and download CSV or JSON.

#### Run locally

```bash
npm install -g apify-cli && apify login
cd <your-repo-clone> && npm install && apify run
```

Dataset from the last run: `apify dataset get default` (files also under `storage/datasets/default/`).

***

### Example inputs

<a id="example-fresher-fullstack-tight-sourcing-list"></a>

#### Fresher fullstack — tight sourcing list

Use when you need **recent, junior fullstack roles** with full descriptions for screening.

```json
{
  "keyword": "fullstack developer",
  "location": "Bangalore",
  "experienceMin": 0,
  "experienceMax": 2,
  "freshnessDays": 5,
  "strictFreshness": true,
  "sortBy": "date",
  "maxItems": 100,
  "includeDescriptions": true
}
```

#### Fast listing — high volume, lower cost

Use when you want **large exports quickly** without opening every job detail page.

```json
{
  "keyword": "data analyst",
  "location": "Mumbai",
  "maxItems": 200,
  "includeDescriptions": false,
  "sortBy": "relevance",
  "minDelaySeconds": 2,
  "maxDelaySeconds": 4,
  "blockResources": true
}
```

#### Remote product manager — GTM or market scan

Use when you track **who is hiring remotely** and only want jobs from the last week.

```json
{
  "keyword": "product manager",
  "location": "India",
  "workType": "remote",
  "freshnessDays": 7,
  "sortBy": "date",
  "maxItems": 150,
  "includeDescriptions": false
}
```

***

### Technical reference

Everything below is for configuration, integration, and troubleshooting.

#### Input fields

| Field | Type | Required | Default | Description |
|---|---:|:---:|---|---|
| `keyword` | string | Yes | - | Job search keyword, e.g. `"software engineer"` |
| `location` | string | No | `""` | Location filter, e.g. `"Bangalore"`, `"Mumbai"`, `"India"` |
| `experience` | integer | No | - | Legacy minimum experience; prefer `experienceMin` / `experienceMax` |
| `experienceMin` | integer | No | - | Minimum years of experience (0–50) |
| `experienceMax` | integer | No | - | Maximum years of experience (0–50) |
| `sortBy` | string | No | `"relevance"` | `"relevance"` or `"date"` |
| `workType` | string | No | `""` | `""`, `"office"`, `"remote"`, or `"hybrid"` |
| `freshnessDays` | integer | No | - | Keep jobs posted within the last N days (1–30) |
| `strictFreshness` | boolean | No | `true` | Exclude jobs with unknown posted dates when `freshnessDays` is set |
| `maxItems` | integer | No | `50` | Maximum jobs to scrape (1–1000) |
| `includeDescriptions` | boolean | No | `true` | Visit detail pages and extract full descriptions |
| `proxyConfiguration` | object | No | `{ "useApifyProxy": true }` | Apify proxy settings |
| `minDelaySeconds` | integer | No | `2` | Minimum random delay between requests (0–30) |
| `maxDelaySeconds` | integer | No | `6` | Maximum random delay between requests (0–60) |
| `blockResources` | boolean | No | `true` | Block images, fonts, and media for faster runs |
| `debugSnapshots` | boolean | No | `false` | Save HTML snapshots on errors for debugging |

#### Output fields

One flat JSON object per job:

```text
title
companyLogo
companyName
companyRating
companyReviewCount
description
experience
isWalkin
jobId
jobUrl
location
postedDate
salary
salaryMax
salaryMin
scrapedAt
skills
skills/0
skills/1
skills/2
skills/3
skills/4
skills/5
skills/6
skills/7
```

##### Output example

```json
{
  "title": "Fullstack Developer",
  "companyLogo": "https://img.naukimg.com/companyimages/...",
  "companyName": "TechCorp",
  "companyRating": 4.2,
  "companyReviewCount": 801,
  "description": "We are looking for...",
  "experience": "0-2 Yrs",
  "isWalkin": false,
  "jobId": "12345678",
  "jobUrl": "https://www.naukri.com/job-listings-...",
  "location": "Bengaluru",
  "postedDate": "2024-01-10T08:00:00.000Z",
  "salary": "10-15 Lacs PA",
  "salaryMax": 15,
  "salaryMin": 10,
  "scrapedAt": "2024-01-15T10:30:00.000Z",
  "skills": ["Python", "React"],
  "skills/0": "Python",
  "skills/1": "React",
  "skills/2": null,
  "skills/3": null,
  "skills/4": null,
  "skills/5": null,
  "skills/6": null,
  "skills/7": null
}
```

**Skills fields:** `skills` holds every skill for the job (0 to many). `skills/0`–`skills/7` duplicate the first eight for spreadsheet imports; jobs with more than eight skills only show extras in `skills`.

On Apify Console, the run **Output** tab shows this schema in a table; **Storage** holds INPUT, scraper state, and optional debug snapshots.

#### How filtering works

**Experience:** When both `experienceMin` and `experienceMax` are set, the Actor uses the matching Naukri experience slug and validates parsed experience text from listings.

**Freshness:** With `freshnessDays`, the Actor applies the nearest Naukri job-age filter on the search URL, then post-filters by parsed posted date. `strictFreshness: true` drops jobs with unknown dates; `false` keeps unknown-date jobs but still removes known stale ones.

**Description mode:**

| Mode | Best for | Behavior |
|---|---|---|
| `includeDescriptions: false` | Fast exports, larger sets, lower cost | Data from listing cards only |
| `includeDescriptions: true` | ATS import, full-text search | Opens detail pages for full descriptions |

#### Reliability notes

- Jobs are pushed to the dataset as soon as they are extracted.
- Duplicates are skipped via job ID, normalized URL, then title/company/location.
- Sessions retire on block or rate-limit signals; failed requests retry.
- Enable `debugSnapshots` when selectors need investigation.
- `blockResources` reduces page weight while keeping useful Naukri assets.

#### Limitations

- Public Naukri job listings only—no login, CAPTCHA bypass, or paywall access.
- Some fields may be empty when Naukri does not show them.
- Selectors may need updates if Naukri changes page structure.
- Very strict filters can return fewer jobs than `maxItems`.

#### Troubleshooting

| Issue | Likely cause | What to try |
|---|---|---|
| No jobs found | Filters too narrow | Broaden keyword, location, experience, or freshness |
| Fewer jobs than expected | `strictFreshness` removing unknown dates | Set `strictFreshness` to `false` |
| Slow runs | Detail pages enabled | Set `includeDescriptions` to `false` |
| Missing descriptions | Detail page failed or changed | Enable `debugSnapshots` and inspect HTML |
| Missing salary min/max | Unparseable salary text | Use raw `salary` as fallback |
| HTTP 403 or blocks | Proxy or session flagged | Keep Apify Proxy on; increase delays |
| Duplicate-looking jobs | Naukri reposts similar listings | Match on `jobId` and title/company/location |

#### Compliance

This Actor collects only publicly visible job listing information. It does not access private user data, bypass login walls, solve CAPTCHAs, or evade access controls.

You are responsible for use that complies with Naukri.com terms, applicable laws, privacy rules, and your organization’s policies. Use reasonable crawl rates and cache results where possible.

# Actor input Schema

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

Job search keyword (e.g., 'software engineer')

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

Filter jobs by location (e.g., 'Bangalore', 'Mumbai')

## `experience` (type: `integer`):

Minimum years of experience required (legacy; prefer experienceMin/experienceMax)

## `experienceMin` (type: `integer`):

Minimum years for range filter (e.g. 0 with experienceMax 2 for fresher roles)

## `experienceMax` (type: `integer`):

Maximum years for range filter (e.g. 2 with experienceMin 0)

## `freshnessDays` (type: `integer`):

Only keep jobs posted within the last N days (also uses nearest Naukri jobAge filter)

## `strictFreshness` (type: `boolean`):

When true, exclude jobs with unknown posted date if freshnessDays is set. When false, keep jobs without a parseable posted date.

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

Sort search results by relevance or date

## `workType` (type: `string`):

Filter by work type

## `maxItems` (type: `integer`):

Maximum number of job listings to scrape

## `includeDescriptions` (type: `boolean`):

If true, fetch detailed job descriptions from individual job pages

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

Apify proxy configuration

## `minDelaySeconds` (type: `integer`):

Minimum random delay between requests

## `maxDelaySeconds` (type: `integer`):

Maximum random delay between requests (must be >= minDelaySeconds)

## `blockResources` (type: `boolean`):

Block images, fonts, and media to speed up scraping and reduce bandwidth

## `debugSnapshots` (type: `boolean`):

Save HTML snapshots when errors occur for debugging purposes

## `headless` (type: `boolean`):

Run Chromium headless. Defaults to true on Apify Cloud and false for local apify run (Naukri often returns 403 for headless without proxy).

## Actor input object example

```json
{
  "location": "",
  "strictFreshness": true,
  "sortBy": "relevance",
  "workType": "",
  "maxItems": 10,
  "includeDescriptions": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "minDelaySeconds": 2,
  "maxDelaySeconds": 6,
  "blockResources": true,
  "debugSnapshots": false
}
```

# Actor output Schema

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

All scraped jobs as dataset items matching the flat export columns.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("vamsi-krishna/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("vamsi-krishna/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 '{}' |
apify call vamsi-krishna/naukri-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naukri Job Scraper",
        "description": "Export Naukri.com job listings to CSV-ready data: company, location, salary, skills, ratings, walk-in flags, and optional full descriptions. Filter by role, city, experience, freshness, and work type. For recruiters, staffing, and sales teams.",
        "version": "0.2",
        "x-build-id": "ZDptzUn9hMlnhHzgx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vamsi-krishna~naukri-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vamsi-krishna-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/vamsi-krishna~naukri-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-vamsi-krishna-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/vamsi-krishna~naukri-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-vamsi-krishna-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": [
                    "keyword"
                ],
                "properties": {
                    "keyword": {
                        "title": "Search Keyword",
                        "minLength": 1,
                        "type": "string",
                        "description": "Job search keyword (e.g., 'software engineer')"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Filter jobs by location (e.g., 'Bangalore', 'Mumbai')",
                        "default": ""
                    },
                    "experience": {
                        "title": "Minimum Experience",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Minimum years of experience required (legacy; prefer experienceMin/experienceMax)"
                    },
                    "experienceMin": {
                        "title": "Experience Min (years)",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Minimum years for range filter (e.g. 0 with experienceMax 2 for fresher roles)"
                    },
                    "experienceMax": {
                        "title": "Experience Max (years)",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum years for range filter (e.g. 2 with experienceMin 0)"
                    },
                    "freshnessDays": {
                        "title": "Posted Within (days)",
                        "minimum": 1,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Only keep jobs posted within the last N days (also uses nearest Naukri jobAge filter)"
                    },
                    "strictFreshness": {
                        "title": "Strict Freshness Filter",
                        "type": "boolean",
                        "description": "When true, exclude jobs with unknown posted date if freshnessDays is set. When false, keep jobs without a parseable posted date.",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Sort search results by relevance or date",
                        "default": "relevance"
                    },
                    "workType": {
                        "title": "Work Type",
                        "enum": [
                            "",
                            "office",
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Filter by work type",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Maximum Items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape",
                        "default": 10
                    },
                    "includeDescriptions": {
                        "title": "Include Descriptions",
                        "type": "boolean",
                        "description": "If true, fetch detailed job descriptions from individual job pages",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Apify proxy configuration",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "minDelaySeconds": {
                        "title": "Minimum Delay (seconds)",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Minimum random delay between requests",
                        "default": 2
                    },
                    "maxDelaySeconds": {
                        "title": "Maximum Delay (seconds)",
                        "minimum": 0,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum random delay between requests (must be >= minDelaySeconds)",
                        "default": 6
                    },
                    "blockResources": {
                        "title": "Block Unnecessary Resources",
                        "type": "boolean",
                        "description": "Block images, fonts, and media to speed up scraping and reduce bandwidth",
                        "default": true
                    },
                    "debugSnapshots": {
                        "title": "Save Debug Snapshots",
                        "type": "boolean",
                        "description": "Save HTML snapshots when errors occur for debugging purposes",
                        "default": false
                    },
                    "headless": {
                        "title": "Headless Browser",
                        "type": "boolean",
                        "description": "Run Chromium headless. Defaults to true on Apify Cloud and false for local apify run (Naukri often returns 403 for headless without proxy)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
