# Naukri & NaukriGulf Jobs Scraper (`silentflow/naukri-scraper`) Actor

Scrape jobs from Naukri.com and NaukriGulf in a single run. Get title, company, salary, skills, experience, company rating, recruiter contact and the direct company apply link as flat, ready-to-use fields. Filter by keyword, location and experience. No login. India and Gulf hiring data fast.

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

## Pricing

from $0.50 / 1,000 jobs

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 & NaukriGulf Jobs Scraper

Pull live job listings from Naukri.com (India) and NaukriGulf (UAE and the Gulf) into one clean dataset, with salary, skills, experience, recruiter contact, company rating and the full description on every row.

### How it works

![How it works](https://api.apify.com/v2/key-value-stores/BvtJ1XkDaqq4emdYH/records/how-it-works-v3.png)

1. **Set your search.** Type one or more keywords (for example `data scientist`, `accountant`), or paste Naukri search URLs you already use. Pick the region (Naukri.com, NaukriGulf, or both), add optional location and experience filters, and set `Max results`. The scraper stops exactly at that number, so you never pay for more than you asked for.
2. **Get clean job data.** Each job comes back as a flat row with around 35 fields, including the full description, salary, skills, company rating and the direct apply link, ready for Google Sheets, Excel, your ATS or a database.

No login, no cookies, no account. Proxies are included.

### ✨ Why teams choose this over other Naukri scrapers

Tired of scrapers that charge you for 100 results when you asked for 20? Tired of a giant nested blob that takes an afternoon to flatten before you can use it? Tired of paying for "Naukri" and getting only the job title and company?

- 🎯 **You get exactly the number of jobs you ask for.** Set `Max results` to 20 and you get 20, not 100. Most Naukri scrapers ignore the limit and bill you for the overflow. This one stops on the dot, so your cost is predictable to the result.
- 🧾 **Flat, ready-to-use rows, not a raw dump.** Salary, skills, experience, company rating, recruiter contact and location come back as separate columns. Other scrapers hand you the raw API blob and you spend hours flattening it before the data is usable.
- 📊 **Around 35 fields per job, not 5.** You get the full job description, required education, role category, industry, employment type, the direct application link (the company's own careers or ATS page), company rating and review count, work mode, structured salary, experience band, skills, apply and view counts, and more. Most Naukri scrapers stop at title, company, salary and experience. The fields they skip are often the ones you need.
- 📝 **The complete job description, not a teaser.** You get the full posting text, not the short snippet most scrapers return. Turn it off with one switch when you want a faster, lighter run.
- 🔗 **The real apply link on direct postings.** When a listing points to the company's own site, you get that URL (for example a Workday or Oracle careers page), not just the Naukri page. That is a field competitors do not give you.
- 🌍 **India and the Gulf in one actor.** Scrape Naukri.com and NaukriGulf together. Most tools cover only one. If you hire across India and the UAE, you run a single job instead of stitching two datasets.
- 📞 **Company reputation on every row, recruiter email when published.** Company rating and review count come standard on Naukri.com listings, so a job row doubles as a company signal. Recruiter email is included whenever the listing publishes one.
- 💸 **Honest pricing, pay per result.** You pay for the jobs you keep. No subscription, no "from" price that turns into something higher at checkout.
- 🔓 **No login required.** You do not hand over an account, and there is nothing to get blocked. Just run it.
- ⚡ **Fast and dependable.** Hundreds of jobs per minute, with retries handled for you so runs finish clean.

### 🎯 What you can do with Naukri data

| Team | What they build |
|------|-----------------|
| Recruiters and staffing | Live feeds of open roles by title, city and experience, refreshed daily |
| Sourcing and lead gen | Lists of hiring companies with rating and review signals, plus recruiter email where published |
| Market and salary research | Salary benchmarks by role, city and experience band across thousands of postings |
| HR and talent strategy | Demand tracking: which skills, titles and locations are heating up month over month |
| Job boards and aggregators | A fresh supply of India and Gulf listings to fill and refresh your own board |
| Competitive intelligence | Who is hiring, for what, and how fast, mapped against your own roadmap |

### 📥 Input parameters

| Parameter | Type | Description |
|-----------|------|-------------|
| `keywords` | array | Job titles or keywords to search. One search runs per keyword. |
| `startUrls` | array | Naukri search URLs to scrape directly. Used as-is, including their filters. |
| `region` | select | `india` (Naukri.com), `gulf` (NaukriGulf), or `both`. |
| `location` | string | City or region filter, for example `Bangalore` or `Dubai`. |
| `experienceYears` | integer | Minimum years of experience. Naukri.com only. |
| `freshnessDays` | integer | Only jobs posted within the last N days. Naukri.com only. |
| `maxItems` | integer | Maximum number of jobs to return. The run stops exactly here. |
| `fullDescription` | boolean | Fetch the full job description plus role, industry, education and apply/view counts (Naukri.com). On by default; turn off for a faster, lighter run. |
| `debugMode` | boolean | Verbose logging for troubleshooting. |

You need at least one keyword or one start URL. Everything else is optional.

### 📊 Output data

Each job is one flat record. A Naukri.com result:

```json
{
  "jobId": "240626501837",
  "title": "Data Scientist",
  "companyName": "GE Aerospace",
  "companyUrl": "https://www.naukri.com/ge-aerospace-jobs-careers-124423690",
  "jobUrl": "https://www.naukri.com/job-listings-data-scientist-ge-aerospace-bengaluru-1-to-3-years-240626501837",
  "applyUrl": "https://geaerospace.wd5.myworkdayjobs.com/en-US/GE_ExternalSite/job/Bengaluru/Data-Scientist_R5036520-1",
  "city": "Bengaluru",
  "location": "Bengaluru",
  "workMode": "Hybrid",
  "salaryText": "",
  "salaryMin": 2000000,
  "salaryMax": 4000000,
  "salaryCurrency": "INR",
  "experienceMin": 1,
  "experienceMax": 3,
  "experienceText": "1-3 Yrs",
  "skills": ["Machine Learning", "Python", "Operations research", "Aviation"],
  "recruiterEmails": [],
  "companyLogo": "https://img.naukimg.com/logo_images/groups/v1/4656483.gif",
  "companyRating": 4.0,
  "companyReviewsCount": 252,
  "vacancies": 2,
  "postedDate": "2026-06-24T10:06:17Z",
  "source": "naukri",
  "scrapedAt": "2026-06-26T05:24:45Z"
}
````

A NaukriGulf result has the same shape, with `source` set to `naukrigulf`:

```json
{
  "jobId": "250626000309",
  "title": "Assistant Accounts Manager",
  "companyName": "Leminar Air Conditioning Company",
  "jobUrl": "https://www.naukrigulf.com/assistant-accounts-manager-jobs-...",
  "city": "Dubai",
  "country": "United Arab Emirates (UAE)",
  "experienceMin": 5,
  "experienceMax": 9,
  "experienceText": "5-9 Yrs",
  "skills": ["Financial Reporting", "Account Reconciliation", "Accounts Receivable"],
  "companyLogo": "https://static.naukimg.com/ni/nipjp/161939/161939.gif",
  "vacancies": 1,
  "postedDate": "2026-06-25T06:42:09Z",
  "source": "naukrigulf",
  "scrapedAt": "2026-06-26T05:25:13Z"
}
```

### 🗂️ Data fields

| Category | Fields |
|----------|--------|
| Identity | `jobId`, `title`, `jobUrl`, `applyUrl`, `source` |
| Company | `companyName`, `companyId`, `companyUrl`, `companyLogo`, `companyRating`, `companyReviewsCount` |
| Location | `city`, `state`, `country`, `location`, `workMode` |
| Compensation | `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryText` |
| Experience | `experienceMin`, `experienceMax`, `experienceText`, `education` |
| Role detail | `skills`, `jobDescription`, `jobRole`, `roleCategory`, `functionalArea`, `industry`, `employmentType`, `vacancies`, `isWalkin`, `jobMode`, `postedDate`, `postedLabel` |
| Engagement | `applyCount`, `viewCount` |
| Company profile | `companyDescription` |
| Contact | `recruiterEmails` |
| Run metadata | `scrapedAt` |

`jobDescription` (full text), `jobRole`, `roleCategory`, `functionalArea`, `industry`, `employmentType`, `education`, `companyDescription`, `applyCount` and `viewCount` come from the detail enrichment and are filled when `fullDescription` is on (Naukri.com). `applyUrl` is the company's direct application page when the listing links out (otherwise the Naukri apply page). `salaryMin`, `salaryMax` and `salaryCurrency` are filled when the employer discloses pay; many Indian listings mark pay as not disclosed. `workMode` is `Hybrid`, `Remote`, or empty for on-site. `location` keeps the full multi-city label while `city` holds the primary city. Recruiter email appears when it is published on the listing.

### 🚀 Examples

**Find data scientists in India**

```json
{ "keywords": ["data scientist"], "region": "india", "maxItems": 200 }
```

**Pull accounting roles across the Gulf**

```json
{ "keywords": ["accountant", "auditor"], "region": "gulf", "location": "uae", "maxItems": 300 }
```

**Hire across India and the Gulf at once**

```json
{ "keywords": ["sales manager"], "region": "both", "maxItems": 500 }
```

**Senior roles posted this week in Bangalore**

```json
{ "keywords": ["engineering manager"], "location": "Bangalore", "experienceYears": 8, "freshnessDays": 7, "maxItems": 150 }
```

**Scrape a search you already built on Naukri**

```json
{ "startUrls": [{ "url": "https://www.naukri.com/python-developer-jobs-in-bangalore" }], "maxItems": 100 }
```

### 🤖 Copy to your AI assistant

```
I am using the "Naukri & NaukriGulf Jobs Scraper" on Apify.
It takes input: keywords (array), startUrls (array of {url}), region ("india"|"gulf"|"both"),
location (string), experienceYears (int), freshnessDays (int), maxItems (int).
Each output row has: jobId, title, companyName, companyUrl, jobUrl, city, state, country,
salaryMin, salaryMax, salaryCurrency, salaryText, experienceMin, experienceMax, experienceText,
skills[], jobDescription, recruiterEmails[], companyLogo, companyRating, companyReviewsCount,
vacancies, postedDate, source, scrapedAt.
Help me write the input JSON for: <describe what jobs you want>.
```

### 💻 Integrations

Run the actor and pull results with the Apify API. Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("YOUR_USERNAME/naukri-scraper").call(run_input={
    "keywords": ["data scientist"],
    "region": "india",
    "maxItems": 200,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["companyName"], job["city"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('YOUR_USERNAME/naukri-scraper').call({
    keywords: ['accountant'],
    region: 'gulf',
    maxItems: 300,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(j => console.log(j.title, j.companyName, j.city));
```

Push straight to a Google Sheet, Airtable or your CRM using Apify integrations, or schedule a daily run so a fresh feed of openings lands in your inbox every morning.

### 📈 Performance

| Metric | Value |
|--------|-------|
| Speed | Hundreds of jobs per minute |
| Pagination | Automatic, across all result pages |
| Duplicate handling | Removed by job ID within a run |
| Result cap | Honored exactly, to the single result |
| Reliability | Retries handled for you, proxies included |
| Login | Not required |

### 💾 Data export

Export the dataset as JSON, CSV, Excel, HTML or RSS from the Apify console, or fetch it through the API. Every format carries the same flat fields, so the data drops straight into a spreadsheet or a database without reshaping.

### 💡 Tips for best results

- Use specific keywords. `senior data scientist` returns tighter results than `data`.
- Set `maxItems` to what you actually need. The run stops there, which keeps cost and runtime down.
- For India use `region: india`, for the Gulf use `region: gulf`, and use `both` only when you hire across regions, since it draws from your shared `maxItems` budget.
- Paste a Naukri search URL into `startUrls` to reuse filters you have already tuned on the site.
- Use `freshnessDays` to keep a daily run focused on jobs posted since your last pull.

### ❓ FAQ

**Do I need a Naukri account or login?**
No. The scraper works without any account or cookies.

**Does it cover NaukriGulf as well as Naukri.com?**
Yes. Set `region` to `gulf` for NaukriGulf, `india` for Naukri.com, or `both` to combine them in one run.

**Will it really stop at my Max results number?**
Yes. The run stops exactly at `maxItems`, so you never pay for extra jobs.

**Do results include salary?**
Salary is included whenever the employer discloses it. Many Indian listings mark pay as not disclosed, in which case the salary fields stay empty and `salaryText` reflects that.

**Do I get recruiter contact details?**
Recruiter email is included when it is published on the listing. Company rating and review count are always included.

**Can I scrape a specific search I built on Naukri?**
Yes. Paste the search URL into `startUrls` and the scraper uses it as-is, including its filters.

**How fresh is the data?**
It is pulled live at runtime, so you get current openings every run. Use `freshnessDays` to limit to recently posted jobs.

**What format is the output?**
Flat rows, exported as JSON, CSV, Excel, HTML or RSS. Each job is a single record ready for a spreadsheet or database.

**How do I scrape thousands of jobs?**
Raise `maxItems` and the scraper paginates automatically through the result set.

**Are proxies included?**
Yes. Proxies are included, so you do not configure anything.

### ⚖️ Legal

This scraper collects publicly available job listings for legitimate uses such as recruitment, market research and analytics. You are responsible for using the data in line with Naukri and NaukriGulf terms, applicable laws, and data protection rules such as GDPR where they apply. Do not use recruiter contact details for unsolicited bulk messaging that breaks local rules. Scrape only public data and respect personal data.

### 📬 Support

Have a use case in mind or need a field that is not here yet? Open the actor and start a run to see the data first. Feedback shapes the roadmap, and new fields and filters are added based on what users ask for.

# Actor input Schema

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

Job titles or keywords to search (e.g. 'data scientist', 'accountant'). One search per keyword.

## `startUrls` (type: `array`):

Naukri search URLs to scrape directly (e.g. https://www.naukri.com/data-scientist-jobs-in-bangalore). Used as-is, including their filters.

## `region` (type: `string`):

Which board(s) to scrape.

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

City or region to filter results (e.g. 'Bangalore', 'Dubai'). Leave empty for all locations.

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

Filter by minimum years of experience. Leave empty for all. (Naukri.com only.)

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

Only return jobs posted within the last N days. Leave empty for all. (Naukri.com only.)

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

Maximum number of jobs to return. The scraper stops exactly at this number, so you never pay for more than you asked for.

## `fullDescription` (type: `boolean`):

Fetch the complete job description plus role category, industry, employment type, required education and apply/view counts (Naukri.com). Turn off for a faster, lighter run that keeps the short description.

## `debugMode` (type: `boolean`):

Enable verbose logging for troubleshooting.

## Actor input object example

```json
{
  "keywords": [
    "data scientist"
  ],
  "region": "india",
  "location": "",
  "maxItems": 50,
  "fullDescription": true,
  "debugMode": false
}
```

# Actor output Schema

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

All jobs collected in this run. Export as JSON, CSV, or Excel from the 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": [
        "data scientist"
    ],
    "region": "india",
    "location": "",
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("silentflow/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": ["data scientist"],
    "region": "india",
    "location": "",
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/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": [
    "data scientist"
  ],
  "region": "india",
  "location": "",
  "maxItems": 50
}' |
apify call silentflow/naukri-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Naukri & NaukriGulf Jobs Scraper",
        "description": "Scrape jobs from Naukri.com and NaukriGulf in a single run. Get title, company, salary, skills, experience, company rating, recruiter contact and the direct company apply link as flat, ready-to-use fields. Filter by keyword, location and experience. No login. India and Gulf hiring data fast.",
        "version": "1.0",
        "x-build-id": "Ug0SvpECCJ81ojr4h"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~naukri-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-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/silentflow~naukri-scraper/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-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/silentflow~naukri-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-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": {
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Job titles or keywords to search (e.g. 'data scientist', 'accountant'). One search per keyword.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Naukri search URLs to scrape directly (e.g. https://www.naukri.com/data-scientist-jobs-in-bangalore). Used as-is, including their filters.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "region": {
                        "title": "Region",
                        "enum": [
                            "india",
                            "gulf",
                            "both"
                        ],
                        "type": "string",
                        "description": "Which board(s) to scrape.",
                        "default": "india"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to filter results (e.g. 'Bangalore', 'Dubai'). Leave empty for all locations.",
                        "default": ""
                    },
                    "experienceYears": {
                        "title": "Experience (years)",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "integer",
                        "description": "Filter by minimum years of experience. Leave empty for all. (Naukri.com only.)"
                    },
                    "freshnessDays": {
                        "title": "Posted within (days)",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only return jobs posted within the last N days. Leave empty for all. (Naukri.com only.)"
                    },
                    "maxItems": {
                        "title": "Max results",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of jobs to return. The scraper stops exactly at this number, so you never pay for more than you asked for.",
                        "default": 50
                    },
                    "fullDescription": {
                        "title": "Full job description",
                        "type": "boolean",
                        "description": "Fetch the complete job description plus role category, industry, employment type, required education and apply/view counts (Naukri.com). Turn off for a faster, lighter run that keeps the short description.",
                        "default": true
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable verbose logging for troubleshooting.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
