# Naukri Scraper 🇮🇳 (job alerts, salaries, skills, ratings) (`tagadanar/naukri-scraper`) Actor

Scrape Naukri.com jobs and get Slack alerts for new postings only: titles, salaries, skills, company ratings and full descriptions from Naukri's own API. No residential proxy needed, monitor mode remembers what it already sent. $0.95 per 1,000 jobs.

- **URL**: https://apify.com/tagadanar/naukri-scraper.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Jobs, AI, Automation
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.53 / 1,000 job scrapeds

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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: Jobs, Salaries, Skills & Company Ratings

Pull structured job data from Naukri.com, India's largest job board. Give it a job title or a skill and you get back a clean list of postings: title, company, locations, experience band, salary when it is disclosed, the required skills, the full description and the company's AmbitionBox rating.

It reads Naukri's own search API, so it is fast and returns complete records, not half-loaded page fragments. There is no browser to time out, no login, and no proxy at all: it reads Naukri's JSON API directly, and platform usage is included in the price, so there is no proxy surcharge or separate Apify bill the way most Naukri scrapers hit you with. Turn on monitor mode and it remembers what it has already seen, so scheduled runs surface only the new postings and can post them straight to Slack.

### What you get per job

| Field | Description |
| --- | --- |
| `title`, `url` | Job title and the canonical Naukri listing URL |
| `company` | Name, id, and AmbitionBox `rating` / `reviewCount` when available |
| `locations` | Cities for the role, cleaned from Naukri's location text |
| `workMode` | On-site, Hybrid or Remote |
| `experience` | Minimum and maximum years, plus a readable label |
| `salary` | Disclosed amount, currency and label (many Indian postings hide it) |
| `skills` | The skills Naukri tags on the posting |
| `employmentType`, `role`, `vacancies` | Contract type, role family, number of openings |
| `description`, `summary` | Full description text and the short teaser |
| `postedDate`, `daysOld` | When it was posted, and its age in days |

### Who uses it

- **Recruiters and sourcers** building a live feed of new openings for a role or a city.
- **Job seekers and career tools** who want the whole market for a skill in one export, not one page at a time.
- **Market and salary research**: pull thousands of postings for a skill and analyze demand, experience bands and disclosed pay.
- **Agents and data pipelines** that need job data as clean JSON.

### Input examples

Scrape recent Python jobs in Bangalore:

```json
{
  "keywords": ["python developer"],
  "location": "bangalore",
  "sortByDate": true,
  "maxResults": 200
}
````

Several searches at once, senior only:

```json
{
  "keywords": ["data scientist", "machine learning engineer"],
  "minExperience": 5,
  "maxResults": 500
}
```

A new-jobs alert feed (schedule this and point it at Slack):

```json
{
  "keywords": ["devops engineer"],
  "location": "pune",
  "postedWithinDays": 3,
  "sortByDate": true,
  "monitorMode": true,
  "webhookUrl": "https://hooks.slack.com/services/XXX/YYY/ZZZ"
}
```

### Pricing

You pay per job returned, platform usage included. No separate Apify bill, no subscription, no minimum.

| Event | Price |
| --- | --- |
| Job scraped | $0.00075 per job ($0.75 per 1,000) |
| Digest sent (monitor mode) | $0.03 per digest |

### FAQ

**Does it need a proxy?** No. It reads Naukri's JSON API directly with browser-like requests, so it needs no proxy and there is no proxy option to configure.

**Can I get the recruiter's email or phone?** No. Naukri does not expose recruiter contact details on the public search, so this actor does not promise them. It gives you the job, the company and the AmbitionBox rating.

**Why is the salary often empty?** Many Indian employers hide the salary on Naukri. When it is disclosed the `salary` object is filled; otherwise `disclosed` is false.

**How do I only get new jobs?** Turn on `monitorMode` and schedule the actor. It remembers jobs from previous runs (per `monitorName`) and returns only new ones, and it can post them to a webhook or Slack.

**How many jobs can I pull?** As many as the search has. Raise `maxResults`; the actor paginates through Naukri for you.

***

### Something missing?

If you need an extra field, another source, or a different output, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More monitors and data Actors are on [my profile](https://apify.com/tagadanar).

*Naukri scraper, Naukri jobs API, India job board scraper, scrape Naukri.com, job postings India, recruitment data India, Naukri salary data, new jobs alert, hiring feed India.*

# Actor input Schema

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

One search per entry. Use a job title or skill, e.g. <code>python developer</code>, <code>data scientist</code>, <code>digital marketing</code>.

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

Optional city or region to filter on, e.g. <code>bangalore</code>, <code>mumbai</code>, <code>delhi ncr</code>. Leave empty to search all of India.

## `minExperience` (type: `integer`):

Optional. Only return jobs asking for at least this many years of experience.

## `sortByDate` (type: `boolean`):

Sort results by posting date instead of Naukri's relevance ranking. Useful with monitor mode.

## `postedWithinDays` (type: `integer`):

Optional. Drop jobs older than this many days.

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

Total jobs to return across all searches.

## `monitorMode` (type: `boolean`):

Remember jobs seen on previous runs and return only new postings. Combine with a schedule and a webhook for a new-jobs alert feed.

## `monitorName` (type: `string`):

Label for the remembered-jobs set. Use different names to track different searches independently.

## `webhookUrl` (type: `string`):

Optional. In monitor mode, new jobs are posted here as a digest (Slack incoming webhook or any endpoint accepting JSON).

## Actor input object example

```json
{
  "keywords": [
    "python developer"
  ],
  "sortByDate": false,
  "maxResults": 100,
  "monitorMode": false,
  "monitorName": "default"
}
```

# Actor output Schema

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

One item per job posting in the default dataset.

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/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 = { "keywords": ["python developer"] }

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/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 '{
  "keywords": [
    "python developer"
  ]
}' |
apify call tagadanar/naukri-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naukri Scraper 🇮🇳 (job alerts, salaries, skills, ratings)",
        "description": "Scrape Naukri.com jobs and get Slack alerts for new postings only: titles, salaries, skills, company ratings and full descriptions from Naukri's own API. No residential proxy needed, monitor mode remembers what it already sent. $0.95 per 1,000 jobs.",
        "version": "0.1",
        "x-build-id": "ImBgDFNlXGcuHP07m"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~naukri-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-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/tagadanar~naukri-scraper/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-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/tagadanar~naukri-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-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",
                "required": [
                    "keywords"
                ],
                "properties": {
                    "keywords": {
                        "title": "Job titles or skills",
                        "minItems": 1,
                        "type": "array",
                        "description": "One search per entry. Use a job title or skill, e.g. <code>python developer</code>, <code>data scientist</code>, <code>digital marketing</code>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional city or region to filter on, e.g. <code>bangalore</code>, <code>mumbai</code>, <code>delhi ncr</code>. Leave empty to search all of India."
                    },
                    "minExperience": {
                        "title": "Minimum years of experience",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Optional. Only return jobs asking for at least this many years of experience."
                    },
                    "sortByDate": {
                        "title": "Sort by newest first",
                        "type": "boolean",
                        "description": "Sort results by posting date instead of Naukri's relevance ranking. Useful with monitor mode.",
                        "default": false
                    },
                    "postedWithinDays": {
                        "title": "Posted within N days",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Optional. Drop jobs older than this many days."
                    },
                    "maxResults": {
                        "title": "Max jobs",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Total jobs to return across all searches.",
                        "default": 100
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new jobs)",
                        "type": "boolean",
                        "description": "Remember jobs seen on previous runs and return only new postings. Combine with a schedule and a webhook for a new-jobs alert feed.",
                        "default": false
                    },
                    "monitorName": {
                        "title": "Monitor name",
                        "type": "string",
                        "description": "Label for the remembered-jobs set. Use different names to track different searches independently.",
                        "default": "default"
                    },
                    "webhookUrl": {
                        "title": "Webhook / Slack URL",
                        "type": "string",
                        "description": "Optional. In monitor mode, new jobs are posted here as a digest (Slack incoming webhook or any endpoint accepting JSON)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
