# LinkedIn Jobs Scraper: Salaries, Remote & Only-New Jobs (`panix/linkedin-jobs-scraper`) Actor

Scrape LinkedIn jobs without login: full description, salary, employment type, experience level, applicants, remote/hybrid, skills. Exact filters LinkedIn dropped and only-new mode for daily job alerts. For recruiting, lead generation, job boards and salary research.

- **URL**: https://apify.com/panix/linkedin-jobs-scraper.md
- **Developed by:** [PANIX AI LAB](https://apify.com/panix) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn Jobs Scraper: salaries, remote filter and only-new jobs, no login

Scrape LinkedIn job search results and job pages into clean rows: title, company, location, full description, employment type, experience level, industries, applicants, parsed salary, workplace type (Remote, Hybrid, On-site), Easy Apply, skills and more. It reads LinkedIn's public job pages, so you need **no LinkedIn account, no cookies and no login**, and nothing can get your account restricted.

You pay only for the jobs you get. Jobs left out by your filters, duplicates, removed jobs and jobs already delivered in earlier runs are free.

### What it does

1. Runs each search term in each location on LinkedIn's public job search (or the search URLs you paste), page by page, up to 1,000 jobs per search, or more with Deep search.
2. Reads each job's page for the full description and job criteria.
3. Applies the filters LinkedIn's 2026 AI search no longer applies itself (workplace type, employment type, experience level), plus salary, applicant, title, company and agency filters, exactly.
4. Delivers one flat row per job to the dataset (JSON, CSV, Excel, Google Sheets, API), with a status line per search and a run summary.

### Who uses it

- **Job seekers and job alert tools**: a daily schedule with *Only new jobs* sends just the jobs posted since the last run.
- **Recruiters and staffing firms**: see who is hiring for which roles and where, with applicant counts and pay.
- **Sales and lead generation (B2B)**: companies hiring for a role are buying signals; every row has the company's LinkedIn page and ID.
- **Labor market and salary research**: employment type, seniority, industries, yearly pay (hourly and monthly converted), skills and years of experience asked.
- **Job boards and aggregators**: fresh listings with descriptions in text, Markdown or HTML.
- **AI agents and RAG pipelines**: clean text descriptions and a stable, documented schema, callable from the Apify API or MCP server.

### Why this LinkedIn jobs scraper

- **Exact filters that LinkedIn dropped.** Since 2026 LinkedIn's public search ignores the remote, job type and experience level filters (`f_WT`, `f_JT`, `f_E`). This Actor reads every job page and keeps only real matches, also for filters inside pasted search URLs. Filtered jobs are free.
- **Salary you can sort by.** Pay ranges are parsed into `min`, `max`, `currency`, `period`, plus `annualMin`/`annualMax` (hourly x 2,080, monthly x 12), with `salarySource` telling you when the employer provided it. Filter by *Minimum yearly salary*.
- **Only new jobs for schedules.** Remembers what it delivered under a monitor name; the next run skips seen jobs before their page is read, so a daily check of a busy search costs cents.
- **Skills and requirements from the text.** Skills, years of experience, education level, visa sponsorship and description language.
- **Workplace type on every row** where the title, location or description says it, plus `isRecruitingAgency` and an option to leave agencies out.
- **Past the 1,000-result limit.** Deep search runs date and Easy Apply variants of a search and merges them without duplicates.
- **Cheap to run, fast and light.** Plain HTTP on datacenter proxy, no browser, 512 MB; the example run (20 jobs with full pages) finishes in about 20 seconds.
- **Clear run reports.** `SEARCHES` says per search how many pages were read, jobs seen, delivered and left out, and why it stopped; `SUMMARY` counts jobs left out per filter.

### Coming from another LinkedIn jobs scraper?

| Common problem in this category | How this Actor handles it |
|---|---|
| Remote / job type / experience filters return the same jobs as without them | Applied exactly after reading each job page; one chosen value is also added to the search words, as LinkedIn advises |
| Salary only as a raw string | Parsed min, max, currency, period and yearly values; minimum yearly salary filter |
| Re-running a schedule returns the same jobs and charges again | Only new jobs mode: seen jobs are skipped and free |
| Duplicates when several searches overlap | Each job is delivered once per run; duplicates are free |
| Charged for empty or failed pages | Removed jobs, filtered jobs and failed searches are not charged |
| Needs a LinkedIn login or cookies | Public guest pages only, nothing to log in |
| Stops at 1,000 jobs per search | Deep search merges variants of the search |
| Big browser image, slow starts | Plain HTTP, 512 MB, starts in seconds |

### How to use it

1. Type one or more **Search terms** (for example `python developer`) and **Locations** (`United States`, `London, England, United Kingdom`, `Germany`).
2. Or paste **LinkedIn search URLs** from your browser (open linkedin.com/jobs in a private window, search, copy the address), single **job links**, or job IDs.
3. Set **Max jobs per search** and any filters, then click **Start**.
4. Download the dataset or connect it to Google Sheets, Make, n8n, Zapier or your code.

For daily alerts: turn on **Only new jobs**, set **Date posted** to *Past 24 hours*, give the schedule its own **Monitor name**, and create a schedule in Apify (Schedules -> Create new).

### Input examples

Search terms x locations, last week:

```json
{
  "searchTerms": ["data engineer", "analytics engineer"],
  "locations": ["Germany", "Netherlands"],
  "datePosted": "pastWeek",
  "maxJobsPerSearch": 100
}
```

Remote jobs with a salary of at least 120,000 a year, no agencies:

```json
{
  "searchTerms": ["software engineer"],
  "locations": ["United States"],
  "workplaceTypes": ["Remote"],
  "minAnnualSalary": 120000,
  "excludeRecruitingAgencies": true,
  "maxJobsPerSearch": 200
}
```

Pasted LinkedIn URLs and job links (old filters in the URL are applied exactly):

```json
{
  "startUrls": [
    "https://www.linkedin.com/jobs/search/?keywords=product%20manager&location=London&f_WT=2&f_E=4",
    "https://www.linkedin.com/jobs/view/4432486930"
  ]
}
```

Every job at given companies (company IDs come from `f_C=` in LinkedIn URLs or the `companyId` field of earlier results):

```json
{ "companyIds": ["1441", "1035"], "locations": ["United States"], "maxJobsPerSearch": 500 }
```

Daily new-jobs alert:

```json
{
  "searchTerms": ["registered nurse"],
  "locations": ["California, United States"],
  "datePosted": "past24Hours",
  "onlyNewJobs": true,
  "monitorName": "nurse-california-daily",
  "maxJobsPerSearch": 500
}
```

Cheap list only (search-card fields, no job pages):

```json
{ "searchTerms": ["barista"], "locations": ["Austin, Texas, United States"], "jobDetails": false, "maxJobsPerSearch": 1000 }
```

### Output

One row per job. A real row from a run (description shortened):

```json
{
  "jobId": "4465379983",
  "url": "https://www.linkedin.com/jobs/view/4465379983",
  "title": "Senior Software Engineer - Python",
  "company": "Venmo",
  "companyUrl": "https://www.linkedin.com/company/venmo",
  "companyId": "552278",
  "location": "Austin, TX",
  "countryCode": "US",
  "workplaceType": "On-site",
  "postedDate": "2026-10-22",
  "postedTimeAgo": "2 weeks ago",
  "employmentType": "Full-time",
  "experienceLevel": "Not Applicable",
  "industries": ["Financial Services"],
  "applicants": 200,
  "applicantsIsMinimum": true,
  "applicantsText": "Over 200 applicants",
  "easyApply": false,
  "isClosed": false,
  "isRecruitingAgency": false,
  "salary": null,
  "description": "The Company\nPayPal has been revolutionizing commerce globally for more than 25 years...",
  "skills": ["Python", "Django", "Flask", "Git", "Distributed Systems", "AWS", "Terraform", "SQL", "Redis", "CI/CD"],
  "experienceYears": 3,
  "educationLevel": "bachelor",
  "visaSponsorship": null,
  "descriptionLanguage": "en",
  "badges": [],
  "detailsMissing": false,
  "searchTerm": "python developer",
  "searchLocation": "United States",
  "rank": 7,
  "scrapedAt": "2026-11-05T19:47:54Z"
}
```

A job with pay shows it like this:

```json
"salary": {"min": 60, "max": 100, "currency": "USD", "period": "hour", "text": "$60.00/hr - $100.00/hr",
           "annualMin": 124800, "annualMax": 208000},
"salarySource": "employer"
```

#### Main fields

| Field | What it is |
|---|---|
| `jobId`, `url` | LinkedIn job ID and link |
| `title`, `company`, `companyUrl`, `companyId`, `companyLogo` | The job and the hiring company |
| `location`, `countryCode`, `workplaceType` | Where, and Remote / Hybrid / On-site when the posting says it |
| `postedDate`, `postedTimeAgo`, `postedAtEstimate` | LinkedIn's date, its "2 hours ago" text, and an estimated time for recent jobs |
| `employmentType`, `experienceLevel`, `industries` | Job criteria from the job page |
| `applicants`, `applicantsIsMinimum`, `applicantsText` | Applicant count ("Over 200" = 200 and a minimum) |
| `easyApply`, `isClosed`, `isRecruitingAgency` | Apply on LinkedIn, no longer accepting applications, posted by an agency |
| `salary`, `salarySource` | Parsed pay and its source |
| `description`, `descriptionMarkdown`, `descriptionHtml` | In the format you choose |
| `skills`, `experienceYears`, `educationLevel`, `visaSponsorship`, `descriptionLanguage` | Read from the description |
| `badges` | LinkedIn badges such as "Actively Hiring" or "Be an early applicant" |
| `searchTerm`, `searchLocation`, `searchUrl`, `rank` | Which search found the job and at which position |
| `detailsMissing` | `true` if LinkedIn refused the job page after retries (the row still has the search-card fields) |

The Output tab has views for **Jobs**, **Pay and requirements**, **Details** and **Search and rank**.

### Pricing

Pay per event, no monthly fee:

| Event | Free plan | Starter (Bronze) | Scale (Silver) | Business (Gold) and up |
|---|---|---|---|---|
| Job with its job page read (per 1,000) | $1.00 | $0.80 | $0.70 | $0.60 |
| Job, search card only (*Read job pages* off, per 1,000) | $0.40 | $0.30 | $0.25 | $0.20 |
| Actor start (per run, per GB of memory) | $0.001 | $0.001 | $0.001 | $0.001 |

Free: jobs left out by filters, duplicates, removed jobs, failed searches and jobs already delivered in earlier runs (only-new mode). With the default 512 MB a run pays one start event. Set a spending limit on the run and the Actor stops before it.

Examples: 1,000 jobs with full pages on the Starter plan cost $0.80 plus $0.001; a daily alert that finds 15 new jobs costs about $0.013.

### Use it from code, n8n, Make, Zapier and AI agents

Python ([apify-client](https://pypi.org/project/apify-client/) 3.x):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("panix/linkedin-jobs-scraper").call(run_input={
    "searchTerms": ["python developer"],
    "locations": ["United States"],
    "workplaceTypes": ["Remote"],
    "maxJobsPerSearch": 100,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["location"], (job["salary"] or {}).get("annualMax"))
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('panix/linkedin-jobs-scraper').call({ searchTerms: ['nurse'], locations: ['United Kingdom'] });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((j) => [j.title, j.company, j.employmentType]));
```

One HTTP call that runs the Actor and returns the rows (n8n HTTP Request node, Make HTTP module, any script):

```
POST https://api.apify.com/v2/acts/panix~linkedin-jobs-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>
Content-Type: application/json

{"searchTerms": ["python developer"], "locations": ["United States"], "maxJobsPerSearch": 20}
```

n8n, Make and Zapier also have Apify apps: choose **Run Actor**, pick `panix/linkedin-jobs-scraper`, paste the input JSON, then read the dataset items. AI agents can call it through the Apify MCP server (`https://mcp.apify.com`).

### FAQ

**Do I need a LinkedIn account?** No. The Actor reads the job pages LinkedIn shows to everyone who is not logged in. No login, cookies or session tokens.

**Why do LinkedIn's own remote or job type filters not work?** In 2026 LinkedIn moved its public job search to AI search, which ignores `f_WT`, `f_JT` and `f_E` in search URLs (we tested: the same jobs come back). This Actor applies those filters itself after reading each job page, and adds a chosen value to the search words so more results already match.

**How is workplace type found?** From "(Remote)" or "Hybrid" in the title or location, then the first part of the description. When nothing says it the field is empty; with a workplace filter such jobs are left out unless you turn on *Keep jobs with unknown workplace*.

**How many jobs can I get?** LinkedIn shows up to 1,000 jobs per search. Add more locations or search terms, or turn on Deep search (date and Easy Apply variants, merged without duplicates).

**How does Only new jobs work?** The Actor stores the job IDs it delivered in a named key-value store in your account (`linkedin-jobs-scraper-monitors`, one record per monitor name, kept 120 days). The first run delivers everything; later runs with the same monitor name skip jobs already delivered. Seen jobs are free.

**Is every job page read?** Yes, unless *Read job pages* is off. If LinkedIn refuses a page after several retries on new IPs, the job is still delivered with its search-card fields and `detailsMissing: true`.

**Why is the salary empty for many jobs?** LinkedIn shows pay only when the employer or LinkedIn provides it, mostly in the US, Canada and the UK.

**Can I get the recruiter's name or email?** No. LinkedIn's public pages do not show the poster, and this Actor never collects emails or phone numbers; contact details inside descriptions are removed.

### Limits

- Public job pages only: no salary insights, applicant demographics or poster names that need a login.
- LinkedIn's search order and results can differ between visits. Use Only new jobs for monitoring rather than comparing two full runs.
- Workplace type, skills, years of experience and education are read from the text and can miss or misread unusual wording.
- Company pages (headcount, followers) are not scraped: LinkedIn blocks them for logged-out visitors from data center IPs.

### Data and legal

The Actor collects job postings that employers published for everyone to see. Rows contain company data and no personal contact details. You are responsible for using the data lawfully, including LinkedIn's terms and data protection laws such as the GDPR where they apply.

### Support

Open an issue on the Actor's **Issues** tab with the run ID; it is answered quickly. Feature requests are welcome.

# Actor input Schema

## `searchTerms` (type: `array`):

Job titles, skills or company names, as you would type them in LinkedIn's job search (e.g. "python developer"). Every term is searched in every location.

## `locations` (type: `array`):

Countries, regions or cities as LinkedIn writes them ("United States", "London, England, United Kingdom", "Germany"), or a LinkedIn geoId number. Empty = Worldwide.

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

Paste LinkedIn job search URLs (every filter in them is kept; old filters LinkedIn no longer applies, like remote, job type and experience level, are applied exactly by this Actor), single job links (linkedin.com/jobs/view/...), or job IDs.

## `maxJobsPerSearch` (type: `integer`):

Jobs to deliver for each search term x location and each pasted search URL. LinkedIn shows up to 1,000 per search; turn on Deep search to go further.

## `maxJobs` (type: `integer`):

Stop the whole run after this many jobs (0 = no limit). You can also set a spending limit on the run.

## `datePosted` (type: `string`):

Only jobs posted within this time.

## `postedWithinHours` (type: `integer`):

Any window in hours (e.g. 6 or 48); overrides Date posted. 0 = off.

## `companyIds` (type: `array`):

LinkedIn company numbers, from f_C= in a LinkedIn search URL or the companyId field of earlier results (e.g. 1441 = Google). Gives every job of those companies.

## `easyApplyOnly` (type: `boolean`):

Only jobs you can apply to on LinkedIn.

## `under10Applicants` (type: `boolean`):

Only jobs with fewer than 10 applicants.

## `distanceMiles` (type: `integer`):

Search radius around a city location. 0 = LinkedIn's default.

## `workplaceTypes` (type: `array`):

Keep only Remote, Hybrid or On-site jobs, read from the title, location and description (LinkedIn's own filter no longer works in its public search).

## `employmentTypes` (type: `array`):

Keep only these employment types, as written on the job page.

## `experienceLevels` (type: `array`):

Keep only these seniority levels, as written on the job page.

## `titleIncludes` (type: `array`):

Keep a job only if its title contains all words of at least one of these phrases (any order, case-insensitive).

## `titleExcludes` (type: `array`):

Leave out jobs whose title contains all words of one of these phrases (e.g. "senior", "sales manager").

## `companyNames` (type: `array`):

Keep only jobs from companies with these names. With no search terms, each name is also used as the search term.

## `excludeCompanies` (type: `array`):

Leave out jobs from these company names.

## `excludeRecruitingAgencies` (type: `boolean`):

Leave out jobs posted by staffing and recruiting agencies (by LinkedIn industry and company name).

## `onlyWithSalary` (type: `boolean`):

Keep only jobs that show a pay range.

## `minAnnualSalary` (type: `integer`):

Keep only jobs whose yearly pay (hourly and monthly pay converted) reaches this amount, in the job's own currency. Jobs without pay are left out.

## `maxApplicants` (type: `integer`):

Leave out jobs with more applicants than this.

## `includeClosedJobs` (type: `boolean`):

Keep jobs that no longer accept applications (left out by default).

## `keepUnknownWorkplace` (type: `boolean`):

With a workplace filter, also keep jobs whose page does not say Remote, Hybrid or On-site.

## `addFilterWordsToSearch` (type: `boolean`):

With one workplace, employment type or experience level chosen, add it to the search words (e.g. "remote"), as LinkedIn advises for its AI search, so more results already match.

## `onlyNewJobs` (type: `boolean`):

Deliver only jobs not delivered in earlier runs with the same monitor name. Already-seen jobs are skipped before their page is read and are free.

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

Name of the memory used by Only new jobs. Use a different name for each schedule.

## `jobDetails` (type: `boolean`):

Read each job's page for the description, employment type, experience level, industries, applicants, salary and Easy Apply. Off = search-card fields only, at a lower price.

## `descriptionFormat` (type: `string`):

Text is best for spreadsheets and AI, Markdown keeps headings and lists, HTML keeps the original markup.

## `extractInsights` (type: `boolean`):

Add skills, years of experience, education level, visa sponsorship and language read from the description.

## `deepSearch` (type: `boolean`):

When Max jobs per search is over 100, also run the search with date and Easy Apply variants and merge the results without duplicates, to get past LinkedIn's 1,000-result limit.

## `maxConcurrency` (type: `integer`):

Job pages read at the same time.

## `proxyConfiguration` (type: `object`):

Apify datacenter proxy works for LinkedIn's public job pages and is the default.

## Actor input object example

```json
{
  "searchTerms": [
    "python developer"
  ],
  "locations": [
    "United States"
  ],
  "maxJobsPerSearch": 20,
  "maxJobs": 0,
  "datePosted": "any",
  "postedWithinHours": 0,
  "easyApplyOnly": false,
  "under10Applicants": false,
  "distanceMiles": 0,
  "excludeRecruitingAgencies": false,
  "onlyWithSalary": false,
  "includeClosedJobs": false,
  "keepUnknownWorkplace": false,
  "addFilterWordsToSearch": true,
  "onlyNewJobs": false,
  "monitorName": "default",
  "jobDetails": true,
  "descriptionFormat": "text",
  "extractInsights": true,
  "deepSearch": false,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Delivered jobs. Jobs left out by filters, duplicates, removed jobs and jobs seen in earlier runs (only-new mode) are not in the dataset and are not charged.

## `searches` (type: `string`):

Pages read, jobs seen and delivered, and why each search or job link stopped.

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

Totals, jobs left out per filter, jobs without their job page, request statistics and warnings.

# 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 = {
    "searchTerms": [
        "python developer"
    ],
    "locations": [
        "United States"
    ],
    "maxJobsPerSearch": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("panix/linkedin-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 = {
    "searchTerms": ["python developer"],
    "locations": ["United States"],
    "maxJobsPerSearch": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("panix/linkedin-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 '{
  "searchTerms": [
    "python developer"
  ],
  "locations": [
    "United States"
  ],
  "maxJobsPerSearch": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call panix/linkedin-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,panix/linkedin-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/WCf9u8lYLfkRzgxQD/builds/32wB8strCLR5qzhnZ/openapi.json