# Reed.co.uk Jobs Scraper: UK Jobs, Salaries & New-Job Monitor (`localwire/reed-jobs`) Actor

UK jobs from Reed.co.uk by keyword, town and distance: title, company, salary as numbers (per year, day or hour), contract type, remote/hybrid, posting date and optional full descriptions. Same schema as Career Site Jobs API. Monitor mode returns only new jobs. Respects robots.txt.

- **URL**: https://apify.com/localwire/reed-jobs.md
- **Developed by:** [Local Wire](https://apify.com/localwire) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.80 / 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.

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

## Reed.co.uk Jobs Scraper: UK Jobs, Salaries & New-Job Monitor

Get **UK jobs from Reed.co.uk** for any keyword, town and distance as structured JSON for **$0.80 per 1,000 jobs** ($0.0008 per job, no start fee). This Reed jobs scraper reads Reed's public search results and returns one record per job: title, company or agency, location, **salary as numbers** (min, max, per year, day or hour), **contract type**, **remote / hybrid / on-site**, posting and update dates and, optionally, the **full job description**.

It is built for job alerts, salary benchmarking, recruitment market research, lists of hiring companies and AI agents. Schedule it with **monitor mode** and you get only the jobs that are new since the last run.

It uses no proxies, no browser and no login. It makes plain requests to public pages, about one every 2 seconds, and follows Reed's robots.txt.

### What you get

One record per job, in the same schema as our [Career Site Jobs API](https://apify.com/localwire/ats-jobs), so Reed jobs and jobs from company career sites can share one dataset:

- **Identity:** a stable `id` (`reed:company:jobId`), Reed's own `jobId` and the `jobUrl`.
- **The role:** `title`, `company` (the employer or the recruitment agency that posted it), `employmentType` (contract, temporary, full-time, part-time…) and Reed's wording in `employmentTypeRaw` ("Contract, full-time").
- **Where:** `location`, `locations`, `country` (always `GB`), a `remote` flag and `workplaceType` (remote, hybrid or onsite).
- **Pay:** `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` (year, month, week, day or hour) and a readable `salaryText`, whenever the advert states a salary.
- **Dates:** `postedAt`, `updatedAt` and `scrapedAt`.
- **Description:** `descriptionText` (and `descriptionHtml`) when you turn on `includeDescriptions`.
- **Monitor fields:** `changeType` and `firstSeenAt` in monitor mode.

A full record looks like this:

```json
{
  "id": "reed:intec-select-limited:57418395",
  "ats": "reed",
  "atsName": "Reed",
  "source": "reed.co.uk",
  "companySlug": "intec-select-limited",
  "jobId": "57418395",
  "title": "Python Developers",
  "company": "INTEC SELECT LIMITED",
  "department": null,
  "team": null,
  "employmentType": "contract",
  "employmentTypeRaw": "Contract, full-time",
  "location": "London",
  "locations": ["London"],
  "country": "GB",
  "countries": ["GB"],
  "remote": false,
  "workplaceType": "hybrid",
  "salaryMin": 650,
  "salaryMax": 750,
  "salaryCurrency": "GBP",
  "salaryPeriod": "day",
  "salaryText": "£650 - £750 per day",
  "descriptionText": null,
  "descriptionHtml": null,
  "jobUrl": "https://www.reed.co.uk/jobs/python-developers/57418395",
  "applyUrl": null,
  "postedAt": "2026-10-02T16:58:06.813Z",
  "updatedAt": "2026-10-14T17:02:17.437Z",
  "changeType": null,
  "firstSeenAt": null,
  "input": "python developer | London",
  "detectedBy": "search",
  "scrapedAt": "2026-11-07T10:45:00.000Z"
}
```

- `input` is the search that found the job, written as `keyword | location`.
- `department` and `team` are part of the shared schema and are always empty for Reed.
- `applyUrl` is filled only when the advert sends applicants to an external site.
- With `includeDescriptions` on, `descriptionText` holds the full advert, cut at 20,000 characters.

The dataset has table views for the key columns. The run's key-value store also gets an `OUTPUT` record that summarises each search: its URL, the total number of jobs Reed reported, pages read, jobs returned and any problem.

### Quick start

Give `keywords`, `locations` or both. This input returns up to 50 Python developer jobs in London and costs at most $0.04:

```json
{
  "keywords": ["python developer"],
  "locations": ["London"],
  "maxResults": 50
}
```

In Apify Console the form opens with these values already filled in, so you can press **Start** straight away. When you call the Actor from the API and leave `maxResults` out, it defaults to 100 jobs.

Contract Python roles within 10 miles of London, posted this week:

```json
{
  "keywords": ["python developer"],
  "locations": ["London"],
  "radius": 10,
  "postedWithinDays": 7,
  "employmentTypes": ["contract"],
  "maxResults": 300
}
```

A daily alert for remote accountancy jobs anywhere in the UK:

```json
{
  "keywords": ["accountant"],
  "workplace": ["remote"],
  "monitorMode": true,
  "monitorStoreName": "remote-accountants"
}
```

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `keywords` | list of text | none | What to search for: job titles, skills or company names. One search per entry. |
| `locations` | list of text | none | UK towns, cities or regions. Every keyword is searched in every location. Empty means the whole of the UK. |
| `radius` | number 1-200 | Reed's own | Miles around each location. Only used with a location. |
| `postedWithinDays` | number 1-365 | none | Keep jobs posted in the last N days. Jobs without a date are kept. |
| `workplace` | list | none | `remote`, `hybrid`, `onsite`. |
| `employmentTypes` | list | none | `full-time`, `part-time`, `contract`, `temporary`, `internship`, `apprenticeship`, `other`. |
| `excludeKeywords` | list of text | none | Drop jobs whose title contains ANY of these, matched at the start of a word. |
| `monitorMode` | true/false | `false` | Return only jobs that earlier runs of the same search have not returned. |
| `monitorEmitExistingOnFirstRun` | true/false | `true` | On a monitor's first run, return the current jobs. Set to `false` to record them silently and pay nothing for the backlog. |
| `monitorStoreName` | text | `reed-jobs-monitor` | Name of the key-value store that holds the monitor's memory. Letters, digits and hyphens. |
| `includeDescriptions` | true/false | `false` | Read each job's page for the full description. One extra request per job. |
| `includeHtml` | true/false | `false` | Also return the description as HTML. Needs `includeDescriptions`. |
| `maxResults` | number 1-10,000 | `100` | Stop the run after this many jobs in total. |
| `maxResultsPerSearch` | number 1-10,000 | same as `maxResults` | Stop each keyword/location search after this many jobs. |

At least one of `keywords` and `locations` is needed. Keywords × locations can make at most 50 searches per run. Invalid input fails at once with a message that lists every problem.

#### How the filters work

- **Distance** is Reed's own filter and is sent with the search.
- **Date posted:** for 14 days or fewer, Reed's own date filter (3, 7 or 14 days) narrows the search first. The exact cut is then applied to each job's posting date, so `postedWithinDays: 5` really means five days.
- **Workplace and employment type:** a single value that Reed can filter on (`remote`, `hybrid`, `onsite`; `contract`, `temporary`, `part-time`, `full-time`) is sent to Reed's search. With several values, or with `internship`, `apprenticeship` or `other`, the Actor filters on the data in the results page. Where the results page does not say, the job page is read to decide, and jobs that still do not say are dropped.
- **Exclude keywords** are applied to the job title by the Actor.

### Monitor mode: only new Reed jobs

With `monitorMode` on, the Actor remembers which jobs each search has returned, in a key-value store in your account (named by `monitorStoreName`). Each run returns, and charges for, only jobs it has not returned before.

- Each search (keyword and location) has its own memory. Changing the filters, the radius or the date window starts a new one.
- After the first run, a search stops paging once two results pages in a row hold nothing new, so a scheduled run usually reads only a page or two.
- A job that was found but not returned because a limit was reached is not remembered, so it comes through next time.
- To start a monitor without paying for the existing backlog, set `monitorEmitExistingOnFirstRun` to `false` for the first run.

Save the input as a **Task** and add a **Schedule**, for example every few hours.

### Use cases

- **Job alerts.** New roles for a keyword and town, delivered as they appear.
- **Salary benchmarking.** Day rates and salaries as numbers with currency and period, ready to average by title or town.
- **Recruitment market research.** Which agencies and employers are advertising, for which roles, and how many adverts are remote or hybrid.
- **Lead lists of hiring companies.** Companies advertising a given role in a given area.
- **Job boards and aggregators.** UK listings in the same schema as our other job Actors.
- **AI agents.** A small, predictable JSON schema that an agent can call as a tool through Apify's MCP server.

### Pricing

**$0.0008 per job returned, which is $0.80 per 1,000 jobs.** There is no start fee and no monthly rental.

You pay for each job the Actor returns. You pay nothing for jobs that your filters drop or, in monitor mode, for jobs already returned. Full descriptions cost nothing extra.

| What you run | Jobs returned | Cost |
|---|---|---|
| The pre-filled first run | 50 | $0.04 |
| The default API run | 100 | $0.08 |
| One search read to the end | about 2,500 | about $2.00 |
| The largest possible run | 10,000 | $8.00 |
| A monitor of four searches that finds 60 new jobs a day | about 1,800 a month | about $1.44 a month |

To cap spending, set **Max cost per run** in the run options, or lower `maxResults`. The Actor stops cleanly at the limit and says so in its status message.

### Use it from the API

Run the Actor and get the jobs back in one request:

```bash
curl -X POST "https://api.apify.com/v2/acts/localwire~reed-jobs/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["python developer"], "locations": ["London"], "maxResults": 25}'
```

That endpoint waits up to five minutes. A hundred jobs from results pages take about ten seconds; with `includeDescriptions` each job adds about two seconds, so for larger runs start the Actor with `POST /v2/acts/localwire~reed-jobs/runs` and read the run's dataset when it has finished.

With the Apify client for JavaScript:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("localwire/reed-jobs").call({
  keywords: ["data analyst"],
  locations: ["Manchester", "Leeds"],
  radius: 10,
  maxResults: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

With the Apify client for Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("localwire/reed-jobs").call(run_input={
    "keywords": ["accountant"],
    "workplace": ["remote"],
    "maxResults": 100,
})
jobs = list(client.dataset(run["defaultDatasetId"]).iterate_items())
```

Results can be downloaded from the dataset as JSON, CSV, Excel, XML or JSON Lines.

### Use it from an AI agent (MCP)

Apify's hosted MCP server is at `https://mcp.apify.com`. Add it to any MCP client that supports remote servers and sign in with your Apify account when the browser opens (or send an `Authorization: Bearer <APIFY_TOKEN>` header).

To give the agent only this Actor as a tool, use this server URL:

```
https://mcp.apify.com?tools=localwire/reed-jobs
```

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=localwire/reed-jobs"
    }
  }
}
```

The agent then sees the Actor's input fields with their descriptions and defaults. It needs to send `keywords`, `locations` or both; when it leaves `maxResults` out, the run returns at most 100 jobs. Questions that work well:

- "What day rates are contract Python developers getting in London?"
- "How many remote accountant jobs were posted on Reed this week, and who is hiring?"
- "Compare advertised salaries for data analysts in Manchester and Leeds."

### Integrations

Runs can be started on a schedule or by another system, and results can be sent on:

- **Make, n8n and Zapier** have Apify integrations that run an Actor and pass its dataset to the next step, for example to a spreadsheet, a CRM, email or a chat channel.
- **Webhooks** call your endpoint when a run succeeds or fails.
- **LangChain** and other agent frameworks can use Apify Actors as tools.
- **The Apify API** and the JavaScript and Python clients cover everything else.

### FAQ

#### Is there a Reed jobs API?

Yes. Reed has an official [Jobseeker API](https://www.reed.co.uk/developers/jobseeker), which needs an API key from Reed. This Actor is an alternative that needs no Reed key: it reads the public search results pages and returns each job with salary numbers, contract type and the remote or hybrid flag, with monitor mode and scheduling on Apify. It never calls Reed's `/api/` paths.

#### How do I scrape jobs from Reed.co.uk?

Put what you would type into Reed's search box in `keywords` and the town in `locations`, then start the run. Each job on the results pages becomes one record. Add `radius`, `postedWithinDays`, `workplace` or `employmentTypes` to narrow it down.

#### How do I get salary data from Reed?

Every job whose advert states a salary comes back with `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod`. Run a search for the job title and location you care about, then average or chart the numbers. Adverts that say "competitive" or give no figure have empty salary fields.

#### Can I get the full job description?

Yes. Turn on `includeDescriptions`. The Actor then reads each job's own page, which takes one more request per job (about two seconds each). The price per job is the same.

#### How do I get only new Reed jobs each day?

Turn on `monitorMode` and schedule the Actor. Each run returns, and charges for, only jobs that earlier runs of the same search did not return.

#### How many jobs can I get from one search?

The Actor reads up to 100 results pages of 25 jobs, so about 2,500 jobs per search, and up to 10,000 jobs per run across at most 50 searches. For more, split the search by location or by keyword.

#### Can I search the whole UK without a location?

Yes. Leave `locations` empty and give `keywords`. You can also give only `locations` to get every job in a town.

#### How much does it cost to scrape 1,000 Reed jobs?

$0.80. The price is $0.0008 per job returned, with or without descriptions.

#### Does it need proxies or a login?

No. It makes plain requests to public pages with one ordinary browser User-Agent, and never logs in.

#### Is it legal to scrape Reed?

This is not legal advice. The Actor reads only public job adverts, follows Reed's robots.txt and keeps personal contact details out of the output. Job content belongs to the employers and agencies who published it, and you are responsible for how you use it, including Reed's terms and any rules that apply to you.

### Limitations

- **UK only.** Reed.co.uk lists UK jobs; `country` is always `GB`.
- **If Reed refuses requests, the run stops.** On an HTTP 403, a 429 or a bot-check page the Actor waits once (30 seconds, or what `Retry-After` says) and tries one more time. If Reed still refuses, the whole run stops, keeps the jobs it already has and says so in the status message; a run that got nothing is marked failed. It does not use proxies, rotate headers or solve challenges.
- **Pace.** About one request every 2 seconds, or slower if robots.txt asks. Results pages carry 25 jobs each, so results-only runs are quick; descriptions add a request per job.
- **robots.txt is followed.** Reed's `/api/` paths and its sorting parameter are disallowed there and are never used, so results come in Reed's default order.
- **2,500 jobs per search** (100 results pages), 10,000 per run and 50 searches per run.
- **Salaries** are present only when the advert states one. Benefits and bonus text are not parsed.
- **Recruitment agencies.** Many Reed adverts are posted by agencies, so `company` is often the agency, not the end employer.
- **No removed-job tracking.** Monitor mode reports new jobs only.
- **Internship and apprenticeship filters** rely on the job title or the job page, because Reed's results data only distinguishes permanent, contract, temporary, full-time and part-time.

### Data, privacy and terms

The Actor reads public job adverts only and never logs in.

Personal data is kept out of the output. There are no fields for recruiter or contact names. In descriptions, email addresses and phone numbers are replaced with `[email removed]` and `[phone removed]`, `mailto:` and `tel:` links are unwrapped, and full UK postcodes are shortened to their district. Names that an employer wrote into its own description text cannot be removed reliably and can remain.

Not affiliated with or endorsed by Reed. Job content belongs to the employers and agencies who published it.

### More from this developer

Jobs:

- [Career Site Jobs API](https://apify.com/localwire/ats-jobs): jobs straight from company career sites on Workday, Greenhouse, Lever and eight more platforms, in the same schema.
- [Workday Jobs API](https://apify.com/localwire/workday-jobs): every job from a Workday career site.
- [Wellfound Jobs Scraper](https://apify.com/localwire/wellfound-jobs): startup jobs in the same schema, with pay and equity.
- [Hacker News API](https://apify.com/localwire/hacker-news): stories, comments and structured "Who is hiring?" jobs.

Other data:

- [Public Tenders API](https://apify.com/localwire/uk-public-tenders): UK and EU tenders and contract awards.
- [Gumtree Scraper](https://apify.com/localwire/gumtree-listings): UK classified listings.
- [Google Trends Trending Now](https://apify.com/localwire/google-trends-trending-now): trending searches for 125 countries.
- [App Store Reviews](https://apify.com/localwire/app-store-reviews): reviews, app details and top charts.
- [Telegram Channel Scraper](https://apify.com/localwire/telegram-channels): posts from public channels.
- [ESPN Sports Data](https://apify.com/localwire/espn-sports) and [Flashscore Results & Fixtures](https://apify.com/localwire/flashscore-sports): scores, standings and fixtures.
- [Eventbrite Scraper](https://apify.com/localwire/eventbrite-events) and [Meetup Scraper](https://apify.com/localwire/meetup-events): events by place and topic.

### Feedback

Found a search that does not work, or need a field we do not return? Open an issue on the Actor's **Issues** tab and we will reply within a few days.

# Actor input Schema

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

What to search for: job titles, skills or company names, one search per line, e.g. "python developer". Each keyword is searched in every location, up to 50 searches per run. Give keywords, locations or both; a run with neither fails. Reed's own search filters (distance, date posted, remote, contract type) are used where they match your input.

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

UK towns, cities or regions, e.g. London, Leeds. Leave empty to search the whole of the UK for your keywords. Locations without keywords return every job in that place.

## `radius` (type: `integer`):

Search this many miles around each location (Reed's own distance filter). Only used when a location is given. Leave empty for Reed's own default distance.

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

Keep jobs posted in the last N days, e.g. 3 or 7. Up to 14 days Reed's own date filter narrows the search first; the exact cut is then applied to each job's posting date. Jobs without a date are kept.

## `workplace` (type: `array`):

Keep only these work arrangements. When the results page doesn't say, the job page is read to decide (slower); jobs that still don't say are dropped.

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

Keep only these employment types. When the results page doesn't say, the job page is read to decide (slower); jobs that still don't say are dropped.

## `excludeKeywords` (type: `array`):

Drop jobs whose title contains ANY of these words, e.g. senior, recruiter.

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

Remember which jobs each search returned before and return only new ones (changeType "new"). Schedule the Actor (e.g. every few hours) to get a feed of new openings. Keep the same filters for a monitor.

## `monitorEmitExistingOnFirstRun` (type: `boolean`):

On a monitor's first run every current job counts as new. Turn this off to record them silently (and not be charged for them).

## `monitorStoreName` (type: `string`):

Name of the key-value store in your account that holds the monitor's memory. Use a different name for each monitor. Letters, digits and hyphens.

## `includeDescriptions` (type: `boolean`):

Read each job's page for the full description (plus employment type, remote flag and salary where published). One extra request per job, so runs take longer.

## `includeHtml` (type: `boolean`):

Also include the description as HTML (descriptionHtml). Needs full descriptions on.

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

Stop the run after this many jobs in total. Each job returned is charged once, so this is also the cost cap. 100 when left out; the form starts at 50 so that a first run is small. You can also cap spending with the run's maximum cost.

## `maxResultsPerSearch` (type: `integer`):

Stop each keyword/location search after this many jobs, so one busy search can't use up the whole run. Leave empty to use the total limit. At most 100 results pages (about 2,500 jobs) are read per search.

## Actor input object example

```json
{
  "keywords": [
    "python developer",
    "accountant"
  ],
  "locations": [
    "London",
    "Leeds"
  ],
  "monitorMode": false,
  "monitorEmitExistingOnFirstRun": true,
  "monitorStoreName": "reed-jobs-monitor",
  "includeDescriptions": false,
  "includeHtml": false,
  "maxResults": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

The key facts for each job.

## `salaries` (type: `string`):

Pay as published by the employer, as numbers.

## `monitor` (type: `string`):

In monitor mode: new jobs and which search found them.

## `allResults` (type: `string`):

Every record in the run's default dataset, all fields.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "python developer"
    ],
    "locations": [
        "London"
    ],
    "maxResults": 50
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": ["python developer"],
    "locations": ["London"],
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("localwire/reed-jobs").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 '{
  "keywords": [
    "python developer"
  ],
  "locations": [
    "London"
  ],
  "maxResults": 50
}' |
apify call localwire/reed-jobs --silent --output-dataset

```

## MCP server setup

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

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/iipHFasL3A6vdcd3D/builds/0BHMyCh8I247eeD1d/openapi.json