# Naukri Jobs History (`hyperbach/naukri-jobs-history`) Actor

- **URL**: https://apify.com/hyperbach/naukri-jobs-history.md
- **Developed by:** [Hyperbach](https://apify.com/hyperbach) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 job records

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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, with applicant counts

**Naukri demand signals without a detailed-record surcharge.** Full postings — salary, description, key skills and employment type — include `apply_count`, `view_count` and `vacancy` on the base record. The archive also retains when a posting disappears, so you can distinguish what is merely listed from what was filled or expired.

### Why this feed, not another Naukri scraper

- **Demand signals on the base record.** `apply_count`, `view_count` and `vacancy` come straight from Naukri and are included at the standard result price rather than gated behind a higher-priced detailed mode.
- **An exact posting timestamp on every record.** `posted_at` is 100% populated and carries a real time of day, normalised to UTC from Naukri's IST. Sort by it, filter by it, or poll on it — no other feed here gives you a reliable clock.
- **Database speed, and unblockable.** You read our archive, not naukri.com. Naukri fronts Akamai and answers `recaptcha required` on its own API — none of that is your problem here, and a run can never be rate-limited or blocked.
- **Incremental by design.** Leave `postedSince` empty and each run returns only what appeared since the last one — the Actor tracks its own cursor, so you poll without re-pulling.
- **Refreshed every four hours.** Postings are re-checked six times a day, so what you read is hours old, not days. `status` marks anything Naukri has since removed.
- **Full postings, not just listings.** Salary band where the employer discloses one, the complete description, key skills, employment type, vacancy count, industry and role category — fetched from Naukri's own job API, not parsed off a page.

### Who it's for

- **Labor-market researchers** — demand per role, company and city — applicants and views per posting, with an exact posting timestamp to trend against.
- **Recruitment analytics & HR-tech** — competition benchmarks per role and city: applicants per posting, vacancy counts, and which employers repost the same role.
- **Competitive & hiring intelligence** — which companies are hiring in India, at what volume, in which cities, and how much candidate interest each opening attracts.
- **Job-board & aggregator builders** — a typed, deduplicated Naukri mirror with a cursor for incremental pulls, so you never re-fetch or re-dedupe.

### Quick start

**Basic — newest postings**

```json
{
  "maxItems": 10
}
```

**Filtered**

```json
{
  "keyword": "engineer",
  "salaryMin": 120000,
  "remoteOnly": true,
  "maxItems": 50
}
```

**Notification mode — only what appeared since the last run**

```json
{
  "postedSince": ""
}
```

### Output

One record per posting, live or dead:

| field | meaning |
|---|---|
| `job_id` | Stable unique key for the posting, `<source>:<id>`. Deduplicate across runs and join to your own data on this. |
| `url` | Canonical posting URL. |
| `title` | Job title. |
| `company` | Employer name as the board lists it. |
| `company_domain` | The employer's own web domain, resolved from the posting. |
| `company_slug` | The board's identifier for the employer. |
| `company_logo_url` | Employer logo, when the board provides one. |
| `location_restriction` | Where the posting says the role may be based. |
| `employment_type` | Full time, contract, and so on, as declared by the employer. |
| `categories` | Category tags the board assigned to the posting. |
| `role_keys` | Naukri's own search groups that surfaced this posting; one job may belong to several roles. |
| `job_role` | Naukri's specific role label. |
| `role_category` | Naukri's role-category facet, such as Engineering & Manufacturing. |
| `functional_area` | Naukri's functional-area facet. |
| `industry` | Naukri's employer-industry facet. |
| `work_mode` | Normalized board-declared work mode: Office, Remote, Hybrid, or Temporary WFH. |
| `wfh_type` | Naukri's underlying work-mode code (0 office, 1 temporary WFH, 2 remote, 3 hybrid). |
| `wfh_label` | Naukri's display label for non-office work modes. |
| `locations` | Structured Naukri locations with labels, URLs, and any localities. |
| `education` | Structured undergraduate, postgraduate, and doctorate requirements. |
| `key_skills` | Structured preferred and other skills, preserving Naukri labels and links. |
| `minimum_experience` | Minimum required experience in years. |
| `maximum_experience` | Maximum required experience in years. |
| `company_detail` | Structured employer details including address, description, and website when supplied. |
| `short_description` | Naukri's compact summary of the role and requirements. |
| `company_id` | Naukri's stable company identifier. |
| `company_page_url` | Employer page on Naukri, when supplied. |
| `static_company_name` | Naukri's static employer display name. |
| `job_type` | Naukri's job-type value, such as fulltime. |
| `walk_in` | Whether Naukri marks this as a walk-in role. |
| `consultant` | Whether the posting is handled by a recruitment consultant. |
| `description` | Full posting description. |
| `salary_min` | Lower bound of the advertised band. |
| `salary_max` | Upper bound of the advertised band. |
| `salary_currency` | ISO currency of the advertised band. |
| `salary_unit` | Period the band refers to (e.g. `YEAR`, `HOUR`). |
| `apply_count` | How many candidates applied to this posting, as the board reports it. |
| `view_count` | How many times the posting was viewed on the board. |
| `vacancy` | Openings on this posting (not the number of postings). |
| `posted_at` | When the posting first appeared. |
| `first_posted_at` | The date the posting FIRST existed, decoded from the job id. Naukri rewrites the posting date when an employer refreshes a listing, so this is the one date that cannot move — use it for true listing age. |
| `first_seen_at` | When our archive first captured it. |
| `status` | `live` while listed, `gone` once removed. |
| `gone_reason` | `filled` if removed before its expiry date, `expired` if it ran to term. |
| `gone_at` | The date the posting was first observed gone. Null while it is live. Naukri overwrites its expired list nightly, so this is only knowable to whoever was watching that day. |
| `apply_url` | Where to apply for the role. |
| `enriched` | Whether salary, employment type and employer domain have been resolved yet — a posting is returned as soon as it is found, enriched or not. |

Example record:

```json
{
  "job_id": "naukri_jobs:030826016870",
  "url": "https://www.naukri.com/job-listings-it-executive-hayat-placement-services-kanpur-4-to-6-years-030826016870",
  "title": "It Executive",
  "company": "Hayat Placement Services",
  "company_domain": "hayatplacement.in",
  "company_slug": null,
  "company_logo_url": "https://img.naukimg.com/logo_images/groups/v1/11753383.gif",
  "location_restriction": "Kanpur",
  "employment_type": "Full Time, Permanent",
  "categories": [
    "Desktop Support",
    "IT Support",
    "System Support",
    "IT Executive"
  ],
  "role_keys": [
    "operating-system-jobs"
  ],
  "job_role": "Desktop Engineer",
  "role_category": "IT Support",
  "functional_area": "IT & Information Security",
  "industry": "Textile & Apparel (Fashion)",
  "work_mode": "Office",
  "wfh_type": "0",
  "wfh_label": null,
  "locations": [
    {
      "url": "https://www.naukri.com/jobs-in-kanpur",
      "label": "Kanpur",
      "localities": []
    }
  ],
  "education": {
    "pg": [],
    "ug": [
      "Any Graduate"
    ],
    "ppg": [],
    "label": "",
    "isSchool": null,
    "premiumProcessed": false,
    "degreeCombination": "",
    "eduPlaceholderText": ""
  },
  "key_skills": {
    "other": [
      {
        "label": "IT Support",
        "clickable": "it support"
      },
      {
        "label": "System Support",
        "clickable": "system support"
      },
      {
        "label": "IT Executive",
        "clickable": ""
      }
    ],
    "preferred": [
      {
        "label": "Desktop Support",
        "clickable": "desktop support"
      }
    ]
  },
  "minimum_experience": 4,
  "maximum_experience": 6,
  "company_detail": {
    "name": "Hayat Placement Services",
    "media": {
      "ppt": [],
      "video": [],
      "photos": []
    },
    "address": "24/147 Kalpana Plaza, Birhana Road Kanpur, Near Kashi Jewellers, KANPUR, Uttar Pradesh - 208001,India Contact Number:9565352026/8090971123 Email-hayatplacementservices@gmail.com,,,",
    "details": "Hayat Placement Services is supported by a dynamic rung of consultants. We introduce ourselves as an organization committed to establish and maintain new standards in Human Resource Consulting . In keeping with the current industry requirements....",
    "hiringFor": "Hayat Placement Services",
    "clientType": "",
    "websiteUrl": "https://www.hayatplacement.in",
    "hideClientName": false,
    "isKycSuccessful": true
  },
  "short_description": "Experience managing LANs, WANs, VPNs and installing operating systems|Provide hardware and network support, configure and maintain IT systems, troubleshoot issues, suggest workflow improvements",
  "company_id": "5107678",
  "company_page_url": null,
  "static_company_name": "hayat-placement-services-jobs-careers-5107678",
  "job_type": "fulltime",
  "walk_in": false,
  "consultant": true,
  "description": "Provide support to all departments in hardware and network related issues. Configure, install and maintain IT systems. Ensure confidential information.. Experience in managing LANs …(truncated for display)",
  "salary_min": 250000.0,
  "salary_max": 350000.0,
  "salary_currency": "INR",
  "salary_unit": "YEAR",
  "apply_count": 0,
  "view_count": 4,
  "vacancy": 1,
  "posted_at": "2026-08-03 11:22:49+00",
  "first_posted_at": "2026-08-03",
  "first_seen_at": "2026-08-03 11:42:41.138283+00",
  "status": "live",
  "gone_reason": null,
  "gone_at": null,
  "apply_url": null,
  "enriched": true
}
```

### Pricing

Pay per result, with **no start fee** — poll as often as you like, and a run that returns nothing costs nothing. Platform usage is included on every plan.

| per 1,000 results | Free | Starter | Scale | Business |
|---|---|---|---|---|
| **Job record** | $5.00 | $4.00 | $3.00 | $2.00 |
| **Expired job record** (surcharge) | $50.00 | $25.00 | $15.00 | $8.00 |
| Platform usage | Free | Free | Free | Free |

**Job record** covers every posting a run returns: the full posting — salary where the employer discloses a band, description, key skills, employment type — together with `apply_count`, `view_count` and `vacancy`. There is no separate detailed-record tier to pay for.

**Expired job record** is charged *in addition* to the job record, and only for a posting we watched go from live to removed. It carries `gone_at` and the complete record captured while the posting was still up. Naukri returns no body for an expired posting, so that detail cannot be fetched after the fact — it exists only if someone was already watching. A run that returns only live postings is never charged this.

You are reading our continuously tailed archive, not scraping naukri.com, so a run answers as a database query.

### Usage patterns

- **Which roles are actually contested** — Sort by `apply_count` to see what Indian candidates are chasing, or filter it low to find roles employers are struggling to fill. Combined with `view_count` you get an apply-through rate per posting — a signal no live scrape of the page can give you.
- **The live board, fully typed** — Run with no filters (or just a `keyword`) and get current Naukri postings with salary, description, key skills, employment type and applicant counts as structured fields.
- **Competition per role** — Sort by `apply_count` to see what Indian candidates are actually chasing, or filter it low to find roles employers are struggling to fill — a signal a live scrape cannot give you.
- **Incremental polling** — Leave `postedSince` empty; each run returns only what appeared since your last one. The cursor is stored per-source, so a schedule never re-delivers the same page.

### Input configuration

| field | type | default | what it does |
|---|---|---|---|
| `keyword` | `string` |  | Matches Naukri's own role group when that role is tracked (for example, data scientist also includes related ML and analytics titles); otherwise falls back to title, skills and description text. |
| `company` | `string` |  | Employer name as the board lists it. Partial matches work. |
| `companyDomain` | `string` |  | Exact normalized employer domain, for example acme.com. |
| `postedSince` | `string` |  | ISO timestamp. Leave empty and the Actor remembers where it stopped, returning only new postings each run. |
| `goneSince` | `string` |  | Only postings observed dead at or after this ISO timestamp (e.g. 2026-07-01). This is the query no other Naukri actor can answer: Naukri overwrites its expired list daily, so a death is only knowable to whoever was watching that day. |
| `status` | `live` / `gone` / `any` |  | Defaults to 'Gone' when Died since is set; otherwise defaults to currently listed. An explicit choice always wins. |
| `location` | `string` |  | Substring match on the posting's location. |
| `remoteOnly` | `boolean` | `false` | Only postings the employer marks as remote. |
| `roleCategory` | `string` |  | Exact Naukri role-category label, for example Data Science & Analytics. |
| `functionalArea` | `string` |  | Exact Naukri functional-area label. |
| `industry` | `string` |  | Exact Naukri industry label. |
| `workMode` | `Office` / `Remote` / `Hybrid` / `Temporary WFH` |  | Naukri's declared work mode, not a guess from the description. |
| `descriptionSearch` | `string` |  | Substring match inside the job description. |
| `excludeTitle` | `string` |  | Drop postings whose title contains this. |
| `maxItems` | `integer` | `500` | Upper bound on results returned in a single run. The Actor paginates through the archive up to this value. |
| `fullRefresh` | `boolean` | `false` | By default each run returns only what appeared since your last one, so a schedule never re-delivers the same page. Tick this to ignore that bookmark and re-pull the full result set for your filters — and it clears the stored cursor, so your next ordinary run starts clean. |
| `salaryMin` | `integer` |  | Matches any posting whose advertised band reaches this figure. A $10-35/hr band matches a request for 35. |
| `enrichedOnly` | `boolean` | `false` | Return only postings whose salary, employment type and description have been parsed. Off by default: an unenriched record still carries title, company, location and dates, and withholding it trades a real answer for a slower better one. |

### FAQ

**How is this different from the other Naukri scrapers on Apify?**

Other actors also return applicant, view and vacancy counts. This one includes them on the base record and answers from a continuously tailed archive rather than scraping on demand, so a run is a database query that cannot be rate-limited, blocked or defeated by Naukri's recaptcha wall. The archive also retains `gone_at`, which an on-demand scrape cannot reconstruct after Naukri overwrites its expired feed.

**Does it include salary and the full job description?**

Yes — description, key skills, employment type, vacancy count and role category on every enriched posting. Salary is present where the employer discloses a band; Naukri hides it on a large share of listings, and we return null there rather than a fabricated zero.

**What are apply\_count and view\_count?**

Naukri publishes, per posting, how many people applied and how many viewed it. They are included directly on this Actor's base record. Paired with the exact posting timestamp they give you applicants-per-day and an apply-through rate — a direct read on which roles are contested and which are struggling to attract anyone.

**How current is it?**

The archive ingests every four hours, including Naukri's overwritten expired file and freshness-sorted searches across 100 board-defined role keys.

**Where do title and location come from?**

On enriched rows they come directly from Naukri's detail API, including structured per-city locations. A newly discovered row may briefly use the posting URL as a fallback until its detail payload arrives.

**Does this return every job on Naukri?**

No, and no Naukri actor honestly can. Discovery combines Naukri's own sitemaps, which lag about a day, with freshness searches across 100 board-defined role keys selected by marginal unique-job yield inside the same eight-hour window production ingests. It is a broad, continuously refreshed sample, not a census.

### Integration

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('hyperbach/naukri-jobs-history').call({"maxItems": 10});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')
run = client.actor('hyperbach/naukri-jobs-history').call(run_input={'maxItems': 10})
items = client.dataset(run['defaultDatasetId']).list_items().items
```

#### CLI

```bash
apify call hyperbach/naukri-jobs-history --input '{"maxItems": 10}'
```

#### REST

```bash
curl -X POST "https://api.apify.com/v2/acts/hyperbach~naukri-jobs-history/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' -d '{"maxItems": 10}'
```

### Support

support@hyperbach.com

*This page is generated from the Actor's schemas and a live sample — it cannot describe a field the Actor does not have.*

# Actor input Schema

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

Matches Naukri's own role group when that role is tracked (for example, data scientist also includes related ML and analytics titles); otherwise falls back to title, skills and description text.

## `company` (type: `string`):

Employer name as the board lists it. Partial matches work.

## `companyDomain` (type: `string`):

Exact normalized employer domain, for example acme.com.

## `postedSince` (type: `string`):

ISO timestamp. Leave empty and the Actor remembers where it stopped, returning only new postings each run.

## `goneSince` (type: `string`):

Only postings observed dead at or after this ISO timestamp (e.g. 2026-07-01). This is the query no other Naukri actor can answer: Naukri overwrites its expired list daily, so a death is only knowable to whoever was watching that day.

## `status` (type: `string`):

Defaults to 'Gone' when Died since is set; otherwise defaults to currently listed. An explicit choice always wins.

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

Substring match on the posting's location.

## `remoteOnly` (type: `boolean`):

Only postings the employer marks as remote.

## `roleCategory` (type: `string`):

Exact Naukri role-category label, for example Data Science & Analytics.

## `functionalArea` (type: `string`):

Exact Naukri functional-area label.

## `industry` (type: `string`):

Exact Naukri industry label.

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

Naukri's declared work mode, not a guess from the description.

## `descriptionSearch` (type: `string`):

Substring match inside the job description.

## `excludeTitle` (type: `string`):

Drop postings whose title contains this.

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

Upper bound on results returned in a single run. The Actor paginates through the archive up to this value.

## `fullRefresh` (type: `boolean`):

By default each run returns only what appeared since your last one, so a schedule never re-delivers the same page. Tick this to ignore that bookmark and re-pull the full result set for your filters — and it clears the stored cursor, so your next ordinary run starts clean.

## `salaryMin` (type: `integer`):

Matches any posting whose advertised band reaches this figure. A $10-35/hr band matches a request for 35.

## `enrichedOnly` (type: `boolean`):

Return only postings whose salary, employment type and description have been parsed. Off by default: an unenriched record still carries title, company, location and dates, and withholding it trades a real answer for a slower better one.

## Actor input object example

```json
{
  "goneSince": "2026-08-01",
  "remoteOnly": false,
  "maxItems": 500,
  "fullRefresh": false,
  "enrichedOnly": false
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped records in the default dataset. One record per posting, live or dead:

# 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 = {
    "goneSince": "2026-08-01"
};

// Run the Actor and wait for it to finish
const run = await client.actor("hyperbach/naukri-jobs-history").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 = { "goneSince": "2026-08-01" }

# Run the Actor and wait for it to finish
run = client.actor("hyperbach/naukri-jobs-history").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 '{
  "goneSince": "2026-08-01"
}' |
apify call hyperbach/naukri-jobs-history --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/DZtM9hrLCBPPARwgu/builds/b8qIzul0gH9oM7P9M/openapi.json