# Naukri Jobs Scraper - Clean India Job Data (`chronometrica/naukri-jobs-scraper`) Actor

Search Naukri India by keyword, location, date, and experience. Export clean unique jobs with salary, skills, descriptions, a firm row cap, and clear pricing.

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

## Pricing

$1.25 / 1,000 naukri job results

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

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

## What's an Apify Actor?

Actors are 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

### 🔎 What does Naukri Jobs Scraper do?

Naukri Jobs Scraper collects public job listings from the main
[Naukri India](https://www.naukri.com/) site. Enter job titles, skills, company
names, and optional Indian locations. The Actor returns clean job rows with
descriptions, skills, salary, experience, company data, posting data, and
canonical Naukri job URLs.

The default dataset grain is **one row per unique Naukri job listing observed
in one Actor run**. The Actor uses the Naukri `jobId` to remove overlap between
keywords, locations, and pages.

The Actor uses logged-out public data. It does not need a Naukri account,
cookies, or an API key. It does not access candidate profiles, submit job
applications, or solve CAPTCHAs.

### ✅ Clean data with clear controls

The Actor focuses on clean rows, easy input, useful fields, and less manual
search work.

- **Clear India scope:** The Actor covers the main Naukri India site. It does
  not cover NaukriGulf.
- **Direct search input:** Enter keywords, locations, posting age, experience,
  and sort order. The Actor has no start URL input or hidden location IDs.
- **Useful filters:** Search by job title, skill, company, location, posting
  age, and experience. You can also exclude company names.
- **Firm result cap:** When you set `maxItems`, the Actor never saves more than
  this number. It can save fewer rows. `OUTPUT` states why. Omit `maxItems`
  from API input when you do not want a saved-row limit.
- **Clean structured rows:** Each saved job uses 30 named public fields. The
  row includes a company rating and review count when Naukri makes them public.
  It does not include large company-review records that add cleanup work.
- **Clear price:** The price is exactly **$0.00125 per saved unique job**.
  Duplicate candidates, filtered candidates, and empty searches do not cause a
  result charge.
- **Easy first run:** Use the Apify form or API. You do not need a Naukri login,
  cookies, or a Naukri API key.

With Naukri Jobs Scraper, you can:

- 🔎 Search jobs by title, skill, company, and Indian location.
- 📝 Collect public job descriptions and skills in the base row.
- 💰 Extract source salary text and conservative numeric salary ranges.
- 🪜 Extract source experience text and numeric experience ranges.
- ♻️ Save one row per Naukri job ID.
- ⚖️ Spread coverage across keyword and location search pairs.
- 📊 Check candidates, duplicates, filters, source states, and stop reasons.
- 📦 Export rows as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### 📦 What Naukri job data can I extract?

Each default dataset row represents one unique public Naukri job listing
observed in the run.

| Data group        | Example fields                                                          |
| ----------------- | ----------------------------------------------------------------------- |
| 🆔 Job identity   | `jobId`, `jobUrl`, `schemaVersion`                                      |
| 💼 Job details    | `title`, `descriptionText`, `skills`                                    |
| 🏢 Company        | `companyName`, `companyLogoUrl`, `companyRating`, `companyReviewCount`  |
| 📍 Location       | `location`                                                              |
| 🪜 Experience     | `experienceRaw`, `experienceMinYears`, `experienceMaxYears`             |
| 💰 Salary         | `salaryRaw`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` |
| 📅 Time           | `postedAt`, `postedAtRaw`, `observedAt`                                 |
| 🔍 Search context | `searchTerm`, `searchLocation`, `sourceUrl`, `pageNumber`, `rankOnPage` |
| 🚦 Row state      | `status`, `statusReason`, `source`                                      |

Missing public values stay `null`. The Actor does not replace missing salary,
experience, rating, description, or posting data with zero.

### 🧱 Data model and row grain

The Actor keeps two output shapes separate.

| Output          | Model shape          | One record means                   | Identity or scope      |
| --------------- | -------------------- | ---------------------------------- | ---------------------- |
| Default dataset | Job observation fact | One Naukri job observed in one run | `jobId` within the run |
| `OUTPUT` record | Run state            | One completed Actor run            | Current Actor run      |

`observedAt` records when the run observed the job. The same `jobId` can appear
again in a later run. This behavior lets you build job snapshots over time.

The public row is flat for CSV, spreadsheets, APIs, and warehouse loads.
`skills` is the only multi-value field. If you load the data into a relational
warehouse, you can place skills in a job-to-skill bridge table. A bridge table
stores a many-to-many relationship without copying the job measures.

The internal sequence is:

```text
buyer input
-> keyword and location search pairs
-> public search candidates
-> normalized job observation
-> company filter
-> jobId duplicate check
-> optional saved-row limit and charge limit
-> dataset row and result charge
-> OUTPUT run state
```

### 🔄 Input to output seam

The input to output seam is the point where buyer settings and source evidence
become stable public fields. It keeps selection settings separate from observed
job facts.

| Public input       | Internal meaning                                             | Public output or run effect                                                                            |
| ------------------ | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------ |
| `searchTerm`       | One keyword per line                                         | The saved row keeps the matching value in `searchTerm`.                                                |
| `location`         | One Indian place per line                                    | Each keyword is paired with each location. Empty means India-wide.                                     |
| `postedWithinDays` | Source posting-age filter                                    | It selects candidates. `postedAt` and `postedAtRaw` still come from the job.                           |
| `sortBy`           | Source result order                                          | It changes result order and `rankOnPage`. It does not change job facts.                                |
| `experienceYears`  | Source experience filter                                     | It selects candidates. The three experience fields still come from the job.                            |
| `excludeCompanies` | One company filter per line                                  | Excluded jobs are not saved. `OUTPUT.rowsExcludedByCompany` counts them.                               |
| `searchDepth`      | Coverage level for each keyword and location pair            | `searchDepthSearches` and `stopReason` show when a search reaches the selected level.                  |
| `maxItems`         | Optional saved-row limit after filters and duplicate removal | `requestedMaxItems`, `rowsSaved`, and `stopReason` show the effect. An omitted API value gives `null`. |

Dataset rows and `OUTPUT` contain only the documented public fields.

#### Ordered public row contract

Every saved row uses these 30 fields in this order:

```text
schemaVersion
jobId
title
companyName
location
experienceRaw
experienceMinYears
experienceMaxYears
salaryRaw
salaryMin
salaryMax
salaryCurrency
salaryPeriod
skills
descriptionText
postedAt
postedAtRaw
jobUrl
companyLogoUrl
companyRating
companyReviewCount
searchTerm
searchLocation
sourceUrl
pageNumber
rankOnPage
status
statusReason
source
observedAt
```

### ⚙️ Can I use this Actor through an API?

Yes. You can run Naukri Jobs Scraper in Apify Console or through:

- 🔌 Apify API
- 🐍 Python SDK
- 🟩 Node.js SDK
- 🪝 Webhooks
- ⏰ Scheduled runs
- 🧩 Apify integrations

This makes the Actor useful for job alerts, recruiting pipelines, job boards,
dashboards, warehouse loads, and labor-market research.

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('chronometrica/naukri-jobs-scraper').call({
    searchTerm: 'data engineer',
    location: 'Bengaluru',
    maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

The input form starts with `maxItems: 500`. To remove the saved-row limit in
an API run, omit `maxItems` from the JSON input. Search coverage, source
inventory, run timeout, and the Apify charge limit can still stop the run.

### 🎯 Why scrape Naukri jobs?

Naukri is a main source of job listings in India. Its public listings can help
you measure hiring demand and find active roles across Indian markets.

| Use case                   | How the data helps                                           |
| -------------------------- | ------------------------------------------------------------ |
| 📈 Track hiring demand     | Compare job volume by role, skill, city, or company.         |
| 🔔 Build job alerts        | Schedule recent searches and route new rows to another tool. |
| 💰 Study salary signals    | Compare the salary ranges that employers publish.            |
| 🪜 Study experience demand | Measure requested experience by role and location.           |
| 🏢 Watch company hiring    | Track public hiring activity by company search terms.        |
| 🧱 Build job data products | Load stable job IDs and clean rows into apps and databases.  |

### 💵 Pricing event

Naukri Jobs Scraper uses Pay per Event pricing. The price is **$0.00125 per
saved job**, or **$1.25 per 1,000 saved jobs**. Platform usage is included.

One result charge occurs when the Actor saves one row to the default dataset.
Failed requests, duplicate candidates, filtered candidates, and zero-row
searches do not cause result charges.

| Saved rows | Actor charge |
| ---------: | -----------: |
|        100 |       $0.125 |
|      1,000 |        $1.25 |
|     10,000 |       $12.50 |

Use `maxItems` to set one shared saved-row limit. The input form starts at 500.
An API run has no saved-row limit when its JSON input omits `maxItems`. Start
with 10 to 100 rows when you test a new search. Check the **Pricing** tab for
the active rate before a large run.

If the Apify result charge limit is near, the Actor stops before it writes a
row that cannot be charged. `OUTPUT.stopReason` then becomes
`budget_cap_reached`.

### 🚀 How do I use Naukri Jobs Scraper?

1. Create or log in to your Apify account.
2. Open **Naukri Jobs Scraper**.
3. Enter one or more job titles, skills, or company names.
4. Add Indian cities or regions, or leave locations empty for India-wide
   results.
5. Keep the 500-row limit or set another positive number.
6. Keep the default settings for your first run.
7. Click **Start**.
8. Open the **Output** tab to inspect the dataset and run summary.
9. Download the rows as JSON, JSONL, CSV, Excel, XML, RSS, or HTML.

### ⬇️ Input

This small example searches two role terms in Bengaluru. It uses one shared
25-row limit after filters and duplicate removal.

```json
{
    "searchTerm": "data engineer\nanalytics engineer",
    "location": "Bengaluru",
    "postedWithinDays": "7",
    "maxItems": 25
}
```

#### 🔎 Search matrix

Enter one keyword or location per line. The Actor creates one search pair for
each keyword and location combination. Two keywords and three locations create
six search pairs. A run can contain up to 200 pairs. If `location` is empty,
each keyword creates one India-wide pair.

The Actor shares coverage across active search pairs. When set, `maxItems` is
one shared saved-row limit for the whole run.

#### 🎛️ Settings

| Input              | Allowed value                       | Default or blank behavior                     | Row, time, or cost effect                                                |
| ------------------ | ----------------------------------- | --------------------------------------------- | ------------------------------------------------------------------------ |
| `searchTerm`       | 1 to 50 non-empty lines             | Required                                      | More terms can increase search coverage and run time.                    |
| `location`         | 0 to 20 Indian places, one per line | Empty means India-wide                        | More locations increase the search-pair count and run time.              |
| `maxItems`         | Positive integer                    | Form: `500`; API omission: no saved-row limit | Sets an optional shared saved-row limit. It is a maximum, not a promise. |
| `postedWithinDays` | `0`, `1`, `3`, `7`, `15`, or `30`   | `7`; `0` means any time                       | A shorter window can return fewer jobs.                                  |
| `experienceYears`  | Integer from 0 to 30                | Not set                                       | Narrows source results. `0` includes fresher jobs.                       |
| `sortBy`           | `relevance` or `date`               | `relevance`                                   | Changes result order, not row fields.                                    |
| `excludeCompanies` | Company names, one per line         | Empty                                         | Matching jobs are filtered and not charged.                              |
| `searchDepth`      | `standard`, `extended`, or `deep`   | `standard`                                    | A higher level can increase coverage and run time.                       |

The JSON API also accepts the earlier `searchTerms` and `locations` arrays.
Set `failOnNoResults` to `true` in JSON API input when an empty dataset must
fail the run.

The Actor always saves one row per `jobId` in each run. This rule keeps the row
grain stable and prevents duplicate result charges.

### ⬆️ Output sample

This sample shows all public fields in contract order. Live values depend on
the job and observation time.

```json
{
    "schemaVersion": "2026-08-15",
    "jobId": "150826123456",
    "title": "Senior Data Engineer",
    "companyName": "Example India",
    "location": "Bengaluru",
    "experienceRaw": "3-7 Yrs",
    "experienceMinYears": 3,
    "experienceMaxYears": 7,
    "salaryRaw": "12-18 Lacs PA",
    "salaryMin": 1200000,
    "salaryMax": 1800000,
    "salaryCurrency": "INR",
    "salaryPeriod": "year",
    "skills": ["Python", "SQL", "Airflow"],
    "descriptionText": "Build trusted data systems.",
    "postedAt": "2026-08-13T12:00:00.000Z",
    "postedAtRaw": "2 Days Ago",
    "jobUrl": "https://www.naukri.com/job-listings-senior-data-engineer-150826123456",
    "companyLogoUrl": null,
    "companyRating": 4.2,
    "companyReviewCount": 321,
    "searchTerm": "data engineer",
    "searchLocation": "Bengaluru",
    "sourceUrl": "https://www.naukri.com/data-engineer-jobs-in-bengaluru?k=data%20engineer&l=Bengaluru",
    "pageNumber": 1,
    "rankOnPage": 1,
    "status": "ok",
    "statusReason": null,
    "source": "naukri.com",
    "observedAt": "2026-08-15T12:00:00.000Z"
}
```

#### 📌 Run summary

The `OUTPUT` record has one run-level state. It is not a dataset row and does
not cause a result charge. It includes:

- Actor name, schema version, status, and run times.
- Requested saved-row limit, or `null` when omitted.
- Searches queued and finished.
- Pages requested and candidates seen.
- Rows saved, duplicate candidates skipped, and companies filtered.
- Blocked and failed request counts.
- Source-state counts and unique warning messages.
- Per-search page, candidate, row, duplicate, filter, and end-reason counts.
- Final `stopReason`.

Possible stop reasons are:

- `max_items_reached`
- `source_exhausted`
- `search_depth_reached`
- `filtered_out`
- `blocked`
- `failed`
- `budget_cap_reached`

### 🎯 Status, quality, and time fields

Saved job rows use `status: "ok"`. Candidate failures, duplicate candidates,
filtered candidates, and empty searches stay out of the paid dataset. The
`OUTPUT` run state counts these outcomes.

- `salaryRaw` keeps the source salary text. Numeric salary fields are `null`
  when the text does not support a clear value.
- `experienceRaw` keeps the source experience text. Numeric experience fields
  are `null` when the text cannot be parsed safely.
- `postedAtRaw` keeps the source posting label. `postedAt` is a normalized time
  when the source value can support it.
- `observedAt` is the time when the run started observing its job rows.
- `pageNumber` and `rankOnPage` describe the search appearance that supplied
  the saved row.

#### ✅ Release evidence

The private release gate on 2026-08-15 recorded:

- 250 saved rows with 250 descriptions and 250 result charges.
- 69 duplicate candidates skipped in that scale run.
- Zero blocked requests and zero failed requests in the final gates.
- Two 100-row repeat panels with the same 100 job IDs.
- Stable title, company name, and canonical job URL for all 100 repeated jobs.
- A duplicate test with 40 skipped duplicates.
- A filtered test with 20 excluded jobs and zero result charges.
- An empty-source test with zero rows and zero result charges.

This is dated release evidence. Live Naukri inventory and source behavior can
change after this test.

### 🔒 Source boundary

The Actor collects logged-out public job listing data from the main Naukri
India site. It does not collect:

- NaukriGulf jobs.
- Candidate profiles or private account data.
- Job applications or account actions.
- Login sessions, user cookies, or user credentials.
- Data hidden behind a CAPTCHA or another access control.

### ⚠️ Limits and interpretation

- When set, `maxItems` is a maximum. Filters, duplicate removal, search coverage,
  source inventory, a block, or a charge limit can return fewer rows.
- When an API input omits `maxItems`, the Actor has no saved-row limit. Search
  coverage, source inventory, run timeout, and the Apify charge limit still
  apply.
- Naukri can hide salary, rating, description, or posting values. These values
  stay `null` when they are not public or cannot be parsed safely.
- Live result order and job inventory can change between runs.
- The Actor keeps the first observed search appearance for each `jobId`. It
  does not save every rank for the same job.
- A public request can be blocked or challenged. The run state reports the
  final source result without solving the challenge.
- The Actor returns fields that are available in public Naukri listings.

### ❓ FAQ

#### Is Naukri the main India site?

Yes. This Actor covers the main Naukri India site. It does not cover
NaukriGulf.

#### Does this Actor need login, cookies, or an API key?

No. It uses logged-out public job listing data.

#### Why did I get fewer jobs than `maxItems`?

`maxItems` is a shared maximum after filters and duplicate removal. Check
`OUTPUT` for candidate, duplicate, filter, page-limit, source-state, and stop
reason counts.

#### How do I remove the saved-row limit?

Use the JSON API and omit `maxItems` from the input. `OUTPUT.requestedMaxItems`
will be `null`. Other stop conditions still apply.

#### Why can salary or posting time be `null`?

Naukri does not publish every value for every job. The Actor keeps uncertain
values as `null` instead of making a value.

#### How do I avoid duplicate jobs?

The Actor saves each `jobId` once per run.

#### Why can some job fields be missing?

Naukri does not publish every field for every listing. Missing public values
stay `null`.

#### What happens when no jobs are saved?

The Actor writes `OUTPUT` with the stop reason. It completes with a zero-row
dataset by default. Set `failOnNoResults` to `true` if your automation must
fail on this state.

### ⚖️ Responsible use

Use the Actor only for lawful purposes. Follow applicable laws, Naukri terms,
and data protection rules. Do not use the output for spam or unfair automated
decisions.

Naukri is a trademark of its owner. This Actor is independent. Naukri does not
endorse or sponsor it.

### 🛟 Support

For support, include the Actor run ID, the input, the expected result, and one
sample row when possible. State whether the issue affects one row or the full
run. Do not send cookies or credentials.

### 🔗 Related job scrapers

Compare public job and freelance demand across these sources.

#### Compare jobs across sources

- [LinkedIn Jobs Scraper](https://apify.com/chronometrica/linkedin-jobs-scraper)
  — find public job listings, employers, locations, and company details.
- [Indeed Jobs Scraper](https://apify.com/chronometrica/indeed-jobs-scraper)
  — find public Indeed jobs, salaries, skills, and apply links.
- [Google Jobs Scraper](https://apify.com/chronometrica/google-jobs-scraper)
  — find public job listings, employers, locations, and apply links.
- [Upwork Job Scraper](https://apify.com/chronometrica/upwork-job-scraper)
  — find fresh freelance jobs, skills, budgets, and client signals.

# Actor input Schema

## `searchTerm` (type: `string`):

Enter one job title, skill, or company per line.

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

Optional. Enter one Indian city or region per line. Leave blank for India-wide results.

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

Maximum saved jobs across all keywords and locations, after filters and duplicate removal. The form starts at 500. Omit this field from JSON API input for no saved-row limit.

## `postedWithinDays` (type: `string`):

Only collect jobs posted in this time window.

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

Optional. Enter the requested years of experience. Use 0 to include fresher jobs.

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

Choose relevance or newest jobs first.

## `excludeCompanies` (type: `string`):

Optional. Enter one company per line. Matching jobs are skipped and counted in the run summary.

## `searchDepth` (type: `string`):

Choose how much result coverage each keyword and location receives. Higher coverage can find more jobs and take more time.

## Actor input object example

```json
{
  "searchTerm": "data engineer\nanalytics engineer",
  "maxItems": 500,
  "postedWithinDays": "7",
  "sortBy": "relevance",
  "excludeCompanies": "",
  "searchDepth": "standard"
}
```

# Actor output Schema

## `dataset` (type: `string`):

Unique Naukri job rows saved by this run.

## `summary` (type: `string`):

Search, candidate, dedupe, filter, source-state, and stop-reason counts.

# 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 = {
    "searchTerm": `data engineer
analytics engineer`,
    "maxItems": 500
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchTerm": """data engineer
analytics engineer""",
    "maxItems": 500,
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchTerm": "data engineer\\nanalytics engineer",
  "maxItems": 500
}' |
apify call chronometrica/naukri-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,chronometrica/naukri-jobs-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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