# Naukri Jobs Scraper - India Job Postings (`benthepythondev/naukri-jobs-scraper`) Actor

Scrape Naukri.com (India's #1 job board): title, company, location, experience, salary, skills, posted date and direct job URL. Search by keyword, role or skill. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/benthepythondev/naukri-jobs-scraper.md
- **Developed by:** [ben](https://apify.com/benthepythondev) (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 $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Jobs Scraper - India Job Postings & Hiring Data

Scrape job postings from **Naukri.com**, India's #1 job board, at scale. Search by role, skill, company or keyword and get clean, structured records for every listing: job title, hiring company, location, required experience, salary, key skills, a short job-description snippet, posted date and the direct job URL. Perfect for recruitment intelligence, lead generation, salary benchmarking and job-market research. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### 🔎 What is the Naukri Jobs Scraper?

The Naukri Jobs Scraper is an automated tool that turns Naukri's search results into a structured dataset. Instead of copy-pasting from page after page, you give it one or more keywords (and an optional city or experience filter) and it returns every matching job posting as a tidy row you can sort, filter and analyze.

It talks directly to Naukri's own job-search backend, so the data is fast, accurate and matches what you see on the live site — including the hiring company name on every record, which makes it a powerful source for B2B and recruiting lead generation.

#### What data does it extract?

For each job posting the scraper returns:

- **Job title** — the role as advertised
- **Company** — the hiring company name (great for lead-gen)
- **Location** — city / region of the role
- **Experience** — required years of experience
- **Salary** — the advertised salary range (when shown)
- **Skills** — the key skills / tags attached to the listing
- **Job description snippet** — a short summary of the role
- **Posted date** — how recently the job was posted
- **Company rating & reviews** — employer rating when available
- **Job URL** — a direct link to the full posting on Naukri
- **Job ID** — Naukri's unique identifier for the listing

### ⬇️ Input

| Field | Type | Description |
|-------|------|-------------|
| `keywords` | array | Job titles, roles, skills or company names to search (each searched separately). |
| `location` | string | Optional city or region to narrow results, e.g. `Bangalore`. |
| `experience` | string | Optional minimum years of experience, e.g. `2`. |
| `maxResults` | integer | Max job postings to return per keyword (default 10). |
| `useResidentialProxy` | boolean | Route via Apify residential (IN) proxies — keep ON (default true). |

#### Example input

```json
{
  "keywords": ["python developer", "data scientist"],
  "location": "Bangalore",
  "experience": "3",
  "maxResults": 50,
  "useResidentialProxy": true
}
````

### ⬆️ Output

Each item in the dataset looks like this:

```json
{
  "jobId": "010101011234567",
  "title": "Python Developer",
  "company": "Acme Technologies Pvt Ltd",
  "location": "Bangalore",
  "experience": "3-6 Yrs",
  "salary": "Not disclosed",
  "job_description_snippet": "We are looking for a Python developer with strong experience in Django, REST APIs and AWS to join our backend team...",
  "skills": ["Python", "Django", "AWS", "REST", "PostgreSQL"],
  "posted_date": "3 Days Ago",
  "created_date_ms": 1719500000000,
  "company_rating": "4.1",
  "company_reviews": "1200",
  "logo": "https://img.naukimg.com/logo/acme.gif",
  "job_url": "https://www.naukri.com/job-listings-python-developer-acme-bangalore",
  "is_premium": false,
  "keyword": "python developer"
}
```

Export the dataset as JSON, CSV, Excel, XML or HTML from the Apify console or via the API.

### 💡 Use cases

- 🧲 **Recruitment lead generation** — build lists of companies actively hiring for a role, with a direct link to every opening.
- 📊 **Salary & skills benchmarking** — aggregate advertised salaries and in-demand skills across thousands of listings.
- 🏢 **Competitor & market intelligence** — track which firms are scaling which teams, and where.
- 🤖 **Job-board automation** — feed fresh Naukri listings into your own job aggregator, CRM, Google Sheet or Slack on a schedule.

### ❓ FAQ

**Which jobs can I scrape?**
Any role searchable on Naukri — by job title, skill, technology, function or company name. Combine keywords with an optional location and experience filter.

**How many results can I get?**
Set `maxResults` per keyword (up to 2000). Naukri paginates results; the scraper walks through pages automatically until your limit is reached or results run out.

**Why does it need a residential proxy?**
Naukri's search API blocks datacenter IP addresses (it returns HTTP 406, "recaptcha required"). Routing through Apify residential proxies in India makes requests look like a real visitor from India, which is where the jobs are. Keep `useResidentialProxy` ON.

**Do I need an Apify paid plan?**
Residential proxy usage requires a plan that includes it. The free tier has a small monthly usage allowance you can test with, but for steady scraping a paid plan is recommended.

**Does the scraper return the hiring company?**
Yes — every record includes the company name, and many include the employer rating and review count, which makes the output ideal for B2B and recruiting lead generation.

**How fresh is the data?**
The scraper reads Naukri's live search backend, so results reflect what is on the site at the moment you run it, including the "posted X days ago" recency label.

**Can I schedule it?**
Yes. Use Apify Schedules to run the scraper hourly, daily or weekly and automatically collect new postings over time.

**Is it legal?**
The scraper collects only publicly available job-posting information. You are responsible for using the data in line with Naukri's terms, applicable laws and data-protection rules such as the GDPR and India's DPDP Act. Do not use the data to send unsolicited communications where that is prohibited, and respect candidates' and companies' privacy.

### 🔗 You might also like

- 💼 **Lever Jobs Scraper** — pull openings from Lever-powered career pages.
- 💼 **Greenhouse Jobs Scraper** — tech hiring data from Greenhouse boards.
- 💻 **Dice.com Jobs Scraper** — US tech jobs with salary data.
- 🌍 **Remote Jobs Aggregator** — remote roles across multiple platforms.

***

**Keywords:** naukri scraper, naukri.com scraper, naukri jobs api, india jobs scraper, job postings scraper, recruitment data, hiring data, job board scraper, job listings api, salary data india, tech jobs india, naukri data extraction, recruiter leads, india hiring intelligence, job market data, scrape naukri, naukri crawler, jobs dataset, candidate sourcing, talent intelligence

# Actor input Schema

## `keywords` (type: `array`):

Job titles, roles, skills or company names to search on Naukri, e.g. 'python developer', 'data scientist', 'sales manager'. Each keyword is searched separately.

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

Optional city or region to narrow results, e.g. 'Bangalore', 'Mumbai', 'Delhi / NCR'. Leave empty to search across all of India.

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

Optional minimum years of experience to filter by, e.g. '0', '2', '5'. Leave empty to include all experience levels.

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

Maximum number of job postings to return for each keyword.

## `useResidentialProxy` (type: `boolean`):

Route requests through Apify residential proxies in India. Naukri's search API blocks datacenter IPs (HTTP 406), so this should stay ON. Requires a proxy-enabled Apify plan.

## Actor input object example

```json
{
  "keywords": [
    "python developer"
  ],
  "maxResults": 10,
  "useResidentialProxy": true
}
```

# 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 = {
    "keywords": [
        "python developer"
    ],
    "location": "",
    "experience": "",
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/naukri-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["python developer"],
    "location": "",
    "experience": "",
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/naukri-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "python developer"
  ],
  "location": "",
  "experience": "",
  "maxResults": 10
}' |
apify call benthepythondev/naukri-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naukri Jobs Scraper - India Job Postings",
        "description": "Scrape Naukri.com (India's #1 job board): title, company, location, experience, salary, skills, posted date and direct job URL. Search by keyword, role or skill. Export to JSON, CSV or Excel.",
        "version": "1.0",
        "x-build-id": "M4oGsnxwScind3wpp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~naukri-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-naukri-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/benthepythondev~naukri-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-naukri-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/benthepythondev~naukri-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-naukri-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Job titles, roles, skills or company names to search on Naukri, e.g. 'python developer', 'data scientist', 'sales manager'. Each keyword is searched separately.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location (optional)",
                        "type": "string",
                        "description": "Optional city or region to narrow results, e.g. 'Bangalore', 'Mumbai', 'Delhi / NCR'. Leave empty to search across all of India."
                    },
                    "experience": {
                        "title": "Experience in years (optional)",
                        "type": "string",
                        "description": "Optional minimum years of experience to filter by, e.g. '0', '2', '5'. Leave empty to include all experience levels."
                    },
                    "maxResults": {
                        "title": "Max results per keyword",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Maximum number of job postings to return for each keyword.",
                        "default": 10
                    },
                    "useResidentialProxy": {
                        "title": "Use residential (IN) proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify residential proxies in India. Naukri's search API blocks datacenter IPs (HTTP 406), so this should stay ON. Requires a proxy-enabled Apify plan.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```