# Naukri Scraper (`crawlerbros/naukri-scraper`) Actor

Scrape job listings from Naukri.com, India's largest job board. Extract title, company, location, experience, salary, skills, and description from search results.

- **URL**: https://apify.com/crawlerbros/naukri-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Jobs, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.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.
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 Scraper

Extract job listings from [Naukri.com](https://www.naukri.com) — India's largest job board. Scrape job titles, companies, locations, experience, salary, skills, descriptions, and more from any Naukri search. Perfect for **recruitment analytics**, **market research**, **salary benchmarking**, and **competitor hiring intelligence**.

### What it does

- Scrapes Naukri search results from a URL or from structured filter fields
- Returns 23 fields per job: title, company, rating, location, experience, salary, skills, description, industry, role, posted date, logo, vacancies
- **RESIDENTIAL/IN proxy hardcoded** — Naukri's Akamai bot protection blocks Apify datacenter IPs, so the scraper applies an India residential proxy automatically. No configuration needed from you.
- Patchright stealth Chromium with up to 5 retries on session-level blocks
- Clean, non-null output — empty fields are omitted from records
- Supports Naukri filters: keyword, location, experience, salary, job age, job type, work mode (remote/hybrid)

### Input

#### Option A — Paste a Naukri URL (easiest)

Set **Naukri Search URL** to any Naukri search page URL, for example:

````

https://www.naukri.com/python-developer-jobs
https://www.naukri.com/data-scientist-jobs-in-bangalore
https://www.naukri.com/java-developer-jobs-in-delhi-ncr

````

The scraper parses the URL slug and filters automatically.

#### Option B — Use structured filters

Leave **Naukri Search URL** empty and configure:

| Field | Description |
|---|---|
| **Keyword** | Job title or keyword (e.g., "python developer") |
| **Location** | City name (e.g., "bangalore", "delhi-ncr", "mumbai") |
| **Experience (years)** | Years of experience (0–30) |
| **Salary Range (Lakhs)** | 0-3, 3-6, 6-10, 10-15, 15-25, 25+ lakhs per year |
| **Job Age (days)** | 1, 3, 7, 15, 30 days |
| **Job Type** | Full-time, Part-time, Internship, Contractual |
| **Work Mode** | Remote (work from home) or Hybrid. Naukri does not have an explicit "office" filter — office is the default state of every listing, so leave this empty for office jobs. |
| **Sort By** | Relevance, Date, Salary |
| **Max Items** | Maximum number of jobs to return (default 50) |

### Output

Each job is a JSON record with the following fields (empty fields are omitted to keep the dataset clean):

| Field | Description |
|---|---|
| `id` | Naukri job ID |
| `title` | Job title |
| `url` | Full Naukri job listing URL |
| `companyName` | Company name |
| `companyId` | Naukri company ID |
| `companyRating` | AmbitionBox rating (out of 5) |
| `companyReviewCount` | Number of reviews |
| `location` | Job location (may list multiple cities) |
| `experience` | Required experience range |
| `salary` | Salary range as displayed |
| `description` | Job description snippet |
| `skills` | Array of skill tags |
| `industry` | Industry |
| `role` | Job role category |
| `jobTypeFlags` | Flags such as `premium`, `easy_apply`, `walk_in` |
| `postedDate` | When the job was posted |
| `logoUrl` | Company logo URL |
| `vacancies` | Number of vacancies |
| `applyCount` | How many people applied |
| `recruiterName` | Recruiter name |
| `scrapedAt` | UTC timestamp when scraped |

#### Sample output

```json
{
  "id": "110924500001",
  "title": "Python Developer - Django / FastAPI",
  "url": "https://www.naukri.com/job-listings-python-developer-django-fastapi-110924500001",
  "companyName": "Infosys",
  "companyRating": 3.6,
  "companyReviewCount": 42850,
  "location": "Bangalore, Hyderabad",
  "experience": "3 - 7 Yrs",
  "salary": "8-15 Lacs PA",
  "skills": ["Python", "Django", "FastAPI", "REST API", "PostgreSQL"],
  "industry": "IT Services & Consulting",
  "role": "Software Development - Back End",
  "postedDate": "2 days ago",
  "logoUrl": "https://img.naukimg.com/logo_images/groups/v1/infosys.gif",
  "vacancies": 5,
  "applyCount": 147,
  "scrapedAt": "2026-04-13T12:00:00Z"
}
````

### FAQ

**Do I need a Naukri account?**
No. The scraper works against Naukri's public search — no login, cookies, or authentication.

**Do I need to configure a proxy?**
No configuration needed — an India RESIDENTIAL proxy is hardcoded and applied automatically. Naukri uses Akamai bot protection that blocks Apify datacenter IPs and most non-Indian residential pools, so the scraper combines patchright stealth Chromium with `RESIDENTIAL/IN` traffic. Sessions are rotated automatically (up to 5 attempts) on transient blocks.

**How many jobs can I get per run?**
Up to 800 jobs per run (40 pages × 20 jobs). For more, split your search by location, keyword, or salary range.

**How fresh is the data?**
Every run pulls live data directly from Naukri, so the data is as current as Naukri's search results.

**Can I filter by experience or salary?**
Yes — use the structured filter fields or paste a Naukri URL that already has the filters applied.

**What cities are supported?**
All Naukri-supported cities — bangalore, delhi-ncr, mumbai, hyderabad, chennai, pune, kolkata, ahmedabad, and many more.

**What happens if a job has missing data?**
Missing fields are omitted entirely — no null or empty values pollute the dataset.

### Use cases

- **Recruitment agencies**: build talent pipelines and track competitor openings
- **Job seekers**: automate job discovery matching your skills
- **HR analytics**: salary benchmarking and market demand analysis
- **Data science projects**: train ML models on India's hiring trends
- **Market researchers**: monitor hiring activity across industries and cities

### Notes

- Pricing is configured in the Apify UI (pay-per-event or pay-per-result).
- The scraper visits the Naukri homepage as a warmup before each search to seed Akamai cookies, then navigates to the search URL and intercepts the `jobapi/v3/search` response. If the homepage warmup is blocked or the API call fails to fire, the session is rotated to a fresh residential IP automatically.
- The Apify daily test run uses `maxItems=5` against the default python-developer-in-bangalore search.

# Actor input Schema

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

A Naukri.com search URL to scrape. Paste any URL from https://www.naukri.com — the scraper parses the slug and filters automatically. If empty, the structured filter fields below are used instead.

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

Maximum number of job listings to return. Each Naukri API page returns up to 20 jobs.

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

Job title or keyword (e.g., "python developer", "data scientist"). Used only when Search URL is empty.

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

City name (e.g., "bangalore", "delhi-ncr", "mumbai", "hyderabad"). Used only when Search URL is empty.

## `experienceYears` (type: `integer`):

Years of experience required.

## `salaryLakhs` (type: `string`):

Annual salary range in lakhs.

## `jobAge` (type: `string`):

Only include jobs posted within the last N days.

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

Employment type filter.

## `workMode` (type: `string`):

Filter by remote or hybrid work. Naukri does not have an explicit 'office' filter — office is the default state of every listing, so leave this empty for office jobs.

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

How results are ordered.

## Actor input object example

```json
{
  "searchUrl": "https://www.naukri.com/python-developer-jobs-in-bangalore",
  "maxItems": 5,
  "sortBy": "relevance"
}
```

# Actor output Schema

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

Dataset of scraped Naukri job listings

# 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 = {
    "searchUrl": "https://www.naukri.com/python-developer-jobs-in-bangalore",
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/naukri-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 = {
    "searchUrl": "https://www.naukri.com/python-developer-jobs-in-bangalore",
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/naukri-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 '{
  "searchUrl": "https://www.naukri.com/python-developer-jobs-in-bangalore",
  "maxItems": 5
}' |
apify call crawlerbros/naukri-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naukri Scraper",
        "description": "Scrape job listings from Naukri.com, India's largest job board. Extract title, company, location, experience, salary, skills, and description from search results.",
        "version": "1.0",
        "x-build-id": "L31PH3eWd4TekL50n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~naukri-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-naukri-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/crawlerbros~naukri-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-naukri-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/crawlerbros~naukri-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-naukri-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchUrl": {
                        "title": "Naukri Search URL",
                        "type": "string",
                        "description": "A Naukri.com search URL to scrape. Paste any URL from https://www.naukri.com — the scraper parses the slug and filters automatically. If empty, the structured filter fields below are used instead."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 800,
                        "type": "integer",
                        "description": "Maximum number of job listings to return. Each Naukri API page returns up to 20 jobs.",
                        "default": 50
                    },
                    "keyword": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Job title or keyword (e.g., \"python developer\", \"data scientist\"). Used only when Search URL is empty."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City name (e.g., \"bangalore\", \"delhi-ncr\", \"mumbai\", \"hyderabad\"). Used only when Search URL is empty."
                    },
                    "experienceYears": {
                        "title": "Experience (years)",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Years of experience required."
                    },
                    "salaryLakhs": {
                        "title": "Salary Range (Lakhs INR/yr)",
                        "enum": [
                            "0-3",
                            "3-6",
                            "6-10",
                            "10-15",
                            "15-25",
                            "25+"
                        ],
                        "type": "string",
                        "description": "Annual salary range in lakhs."
                    },
                    "jobAge": {
                        "title": "Job Age (days)",
                        "enum": [
                            "1",
                            "3",
                            "7",
                            "15",
                            "30"
                        ],
                        "type": "string",
                        "description": "Only include jobs posted within the last N days."
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "full-time",
                            "part-time",
                            "internship",
                            "contractual"
                        ],
                        "type": "string",
                        "description": "Employment type filter."
                    },
                    "workMode": {
                        "title": "Work Mode",
                        "enum": [
                            "remote",
                            "hybrid"
                        ],
                        "type": "string",
                        "description": "Filter by remote or hybrid work. Naukri does not have an explicit 'office' filter — office is the default state of every listing, so leave this empty for office jobs."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "relevance",
                            "date",
                            "salary"
                        ],
                        "type": "string",
                        "description": "How results are ordered.",
                        "default": "relevance"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```