# Reed.co.uk UK Job Listings & Pay Extractor (`vexaloom-labs/reed-co-uk-uk-job-listings-and-pay-extractor`) Actor

Search live Reed.co.uk vacancies by keyword and location and get structured job records with parsed pay ranges, job type, remote status and job descriptions.

- **URL**: https://apify.com/vexaloom-labs/reed-co-uk-uk-job-listings-and-pay-extractor.md
- **Developed by:** [vexaloom-labs](https://apify.com/vexaloom-labs) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Reed.co.uk UK Job Listings & Pay Extractor

Pull live UK vacancies from Reed.co.uk into a clean dataset with full job descriptions, parsed pay ranges, employer details, location metadata and direct job links. Search by keyword, location, salary band, contract type, work arrangement and posting date, or scrape Reed search and job URLs you already have.

### What this actor does

- Searches Reed.co.uk by keyword and location, with filters for salary, job type, full/part-time, remote/hybrid/on-site, date posted, agency vs employer, graduate roles, Easy Apply, visa sponsorship and 37 sectors
- Runs one search or several keyword searches in a single run, and accepts Reed search URLs or individual job URLs/IDs
- Opens each job page to capture the full description, the displayed salary, annualised pay for hourly/daily/weekly/monthly roles, postcode, region, sector, skills and recruiter reference
- Returns up to 10,000 jobs per search, deduplicated by Reed's job ID, with canonical job and employer URLs
- Omits fields Reed does not publish for a job, so every record contains only real data

### Output per job

Identity and links:

- `jobId` — Reed's numeric job identifier
- `sourceUrl` — canonical Reed job page
- `title`, `companyName`, `companyUrl`, `companyLogoUrl`
- `recordType` — always `job`
- `scrapedAt` — collection timestamp

Location:

- `location`, `town`, `county`, `region`, `country`, `countryCode`, `postCode`
- `remoteWorking` — Remote, Hybrid or On-site
- `isRemote`

Pay:

- `salaryDescription` — the salary text Reed displays
- `salaryFrom`, `salaryTo` — hourly, daily, weekly, monthly or annual bounds
- `salaryFromPerAnnum`, `salaryToPerAnnum` — annualised bounds for easy comparison
- `salaryCurrency`, `salaryType`
- `salaryIsNegotiable`, `salaryIsCompetitive`, `salaryIsOte`, `salaryIsProRata`

Job and employer:

- `jobType` — Permanent, Contract or Temporary
- `postedBy` — Agency, Employer or Reed
- `recruiterReference`
- `isFullTime`, `isPartTime`, `isEasyApply`
- `category`, `subcategory`, `sector`, `sectorParent`
- `skills`

Description and dates:

- `description` — full plain-text description
- `descriptionHtml` — full HTML description
- `datePosted`, `dateUpdated`, `displayDate`, `expiryDate`

Flags and provenance:

- `isGraduate`, `isPromoted`, `isFeatured`, `isEarlyBird`, `isTrainingJob`, `isSurveyJob`
- `eligibleUkOnly`, `requiresUkEligibility`, `eligibilityRequirement`
- `isLive`, `isRedirect`
- `searchQuery`, `searchLocation`
- `externalUrl` — kept for compatibility; Reed's public pages do not expose an external apply URL, so it is normally omitted

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` for keyword search, `byUrl` for Reed search/job URLs |
| `keywords` | string | – | Keywords for one search (mode=search) |
| `searchQueries` | array | – | Several keyword searches; replaces `keywords` (mode=search) |
| `location` | string | – | UK town, city, region or postcode (mode=search) |
| `sector` | string | `any` | One of 37 Reed parent sectors (mode=search) |
| `proximity` | string | `10` | Radius around the location in miles (mode=search) |
| `salaryFrom` | integer | – | Annual GBP salary floor (mode=search) |
| `salaryTo` | integer | – | Annual GBP salary ceiling (mode=search) |
| `postedWithin` | string | `anytime` | `anytime`, `today`, `lastThreeDays`, `lastWeek`, `lastTwoWeeks` (mode=search) |
| `postedBy` | string | `any` | `any`, `agency`, `employer`, `reed` (mode=search) |
| `remoteOption` | string | `any` | `any`, `remote`, `hybrid`, `onSite` (mode=search) |
| `permanent`, `contract`, `temporary` | boolean | false | Contract-type filters (mode=search) |
| `fullTime`, `partTime` | boolean | false | Working-hours filters (mode=search) |
| `graduateOnly` | boolean | false | Graduate roles only (mode=search) |
| `easyApplyOnly` | boolean | false | Reed Easy Apply only (mode=search) |
| `visaSponsorship` | boolean | false | Visa-sponsorship roles only (mode=search) |
| `hideNoSalary` | boolean | false | Exclude jobs without displayed pay (mode=search) |
| `hideTrainingJobs`, `hideSurveyJobs` | boolean | false | Exclude training and survey adverts (mode=search) |
| `searchUrls` | array | – | Reed search URLs; their filters are preserved (mode=byUrl) |
| `jobUrls` | array | – | Reed job URLs or numeric IDs (mode=byUrl) |
| `fetchDetails` | boolean | true | Open each job page for the full description and detailed pay/location |
| `maxItems` | integer | 50 | Maximum records (1–10,000) |

#### Example: software jobs in London with pay data

```json
{
  "mode": "search",
  "keywords": "software engineer",
  "location": "London",
  "salaryFrom": 55000,
  "postedWithin": "lastWeek",
  "fetchDetails": true,
  "maxItems": 200
}
```

#### Example: remote nursing roles across the UK

```json
{
  "mode": "search",
  "keywords": "registered nurse",
  "remoteOption": "remote",
  "postedBy": "employer",
  "maxItems": 100
}
```

#### Example: several searches in one run

```json
{
  "mode": "search",
  "searchQueries": ["data analyst", "business analyst", "product analyst"],
  "location": "Manchester",
  "permanent": true,
  "maxItems": 300
}
```

#### Example: scrape a Reed search page and specific jobs

```json
{
  "mode": "byUrl",
  "searchUrls": [
    "https://www.reed.co.uk/jobs/warehouse-jobs-in-leeds?permanent=true"
  ],
  "jobUrls": [
    "https://www.reed.co.uk/jobs/warehouse-operative/57400001",
    "57400002"
  ],
  "fetchDetails": true,
  "maxItems": 50
}
```

### Use cases

- **Salary benchmarking** — compare advertised pay for a role, region and contract type, including annualised day and hourly rates
- **Recruitment market monitoring** — track live vacancy volumes by sector, employer and work arrangement
- **Job-board aggregation** — feed Reed vacancies into a wider UK job search, newsletter or dashboard
- **Remote-work research** — isolate remote and hybrid roles and compare their pay with on-site equivalents
- **Recruiter lead generation** — find employers actively hiring in a skill area, city or salary band
- **Career planning** — collect full descriptions and required skills for a target role before applications

### FAQ

**Do I need a Reed account or API key?**
No. The actor reads Reed.co.uk's public job pages. There is no login, key or cookie to supply.

**Do I need to configure a proxy?**
No. The actor fetches Reed directly and can fall back to Apify's datacenter proxy automatically if Reed blocks the runner IP. There is no proxy setting to supply.

**Why do some jobs have no salary fields?**
Reed lets employers hide pay. When a listing has no pay data, the salary fields are left out of that record rather than filled with a guess.

**What does `salaryFromPerAnnum` add?**
It converts hourly, daily, weekly and monthly pay to an annual figure using Reed's own annualised values, so a £450/day contract can be compared with an £85,000 permanent role.

**How many jobs can one search return?**
Reed exposes at most 10,000 results per search. The actor stops at that window and tells you in the run message; split a broad search by keyword, location or sector to collect more.

**Why is `externalUrl` usually missing?**
Reed's public job pages do not include the employer's external application URL. The actor keeps the field for older integrations but does not invent a link.

**Why are `skills` or `postCode` missing on some jobs?**
Reed only publishes them when the employer supplies them. The description, pay, location and dates are still returned.

**Does `fetchDetails: false` still return descriptions?**
No. Turning details off makes runs faster and returns the listing fields only; the full description and detailed salary breakdown require opening the job page.

**What happens if a job page is unavailable?**
The listing record is still returned with its title, company, location and search-page pay data; only the detail-only fields such as the full description are omitted.

**Are duplicate jobs possible?**
The actor deduplicates by Reed's job ID across pages and searches. Reed's result order can shift slightly between requests, so this is necessary even on a single search.

**Is this affiliated with Reed.co.uk?**
No. It is an independent tool that reads publicly available job listings and is not endorsed by or affiliated with Reed.co.uk.

# Actor input Schema

## `mode` (type: `string`):

Search Reed's job listings, or scrape specific Reed search/job URLs.

## `keywords` (type: `string`):

Job title, skill or phrase to search for (mode=search).

## `searchQueries` (type: `array`):

Run several keyword searches in one run (mode=search). When set, this replaces Keywords.

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

UK town, city, region or postcode (mode=search). Leave blank for UK-wide.

## `sector` (type: `string`):

Limit results to one of Reed's parent sectors (mode=search).

## `proximity` (type: `string`):

Radius around the location (mode=search).

## `salaryFrom` (type: `integer`):

Annual salary floor in pounds (mode=search). Reed matches jobs whose salary range overlaps this floor.

## `salaryTo` (type: `integer`):

Annual salary ceiling in pounds (mode=search). Reed matches jobs whose salary range overlaps this ceiling.

## `postedWithin` (type: `string`):

Only return jobs posted in this window (mode=search).

## `postedBy` (type: `string`):

Filter by who advertised the job (mode=search).

## `remoteOption` (type: `string`):

Filter by remote, hybrid or on-site work (mode=search).

## `permanent` (type: `boolean`):

Only permanent contracts (mode=search).

## `contract` (type: `boolean`):

Only contract roles (mode=search).

## `temporary` (type: `boolean`):

Only temporary roles (mode=search).

## `fullTime` (type: `boolean`):

Only full-time roles (mode=search).

## `partTime` (type: `boolean`):

Only part-time roles (mode=search).

## `graduateOnly` (type: `boolean`):

Only graduate roles (mode=search).

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

Only jobs with Reed Easy Apply (mode=search).

## `visaSponsorship` (type: `boolean`):

Only jobs Reed marks as offering visa sponsorship (mode=search).

## `hideNoSalary` (type: `boolean`):

Exclude listings where no salary is displayed (mode=search).

## `hideTrainingJobs` (type: `boolean`):

Exclude training-course adverts (mode=search).

## `hideSurveyJobs` (type: `boolean`):

Exclude survey-job adverts (mode=search).

## `searchUrls` (type: `array`):

One or more Reed search URLs (mode=byUrl). Their filters are preserved; other filters here are added when absent.

## `jobUrls` (type: `array`):

One or more Reed job URLs or numeric job IDs (mode=byUrl).

## `fetchDetails` (type: `boolean`):

Open each job page for the full description, display salary, per-annum pay and location details. Turn off for a faster listing-only run.

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

Maximum number of job records to return (1-10,000). Reed exposes at most 10,000 results per search.

## Actor input object example

```json
{
  "mode": "search",
  "keywords": "software engineer",
  "sector": "any",
  "proximity": "10",
  "postedWithin": "anytime",
  "postedBy": "any",
  "remoteOption": "any",
  "permanent": false,
  "contract": false,
  "temporary": false,
  "fullTime": false,
  "partTime": false,
  "graduateOnly": false,
  "easyApplyOnly": false,
  "visaSponsorship": false,
  "hideNoSalary": false,
  "hideTrainingJobs": false,
  "hideSurveyJobs": false,
  "fetchDetails": true,
  "maxItems": 3
}
```

# Actor output Schema

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

Dataset containing all scraped Reed.co.uk job listings.

# 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 = {
    "mode": "search",
    "keywords": "software engineer",
    "sector": "any",
    "proximity": "10",
    "postedWithin": "anytime",
    "postedBy": "any",
    "remoteOption": "any",
    "permanent": false,
    "contract": false,
    "temporary": false,
    "fullTime": false,
    "partTime": false,
    "graduateOnly": false,
    "easyApplyOnly": false,
    "visaSponsorship": false,
    "hideNoSalary": false,
    "hideTrainingJobs": false,
    "hideSurveyJobs": false,
    "fetchDetails": true,
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("vexaloom-labs/reed-co-uk-uk-job-listings-and-pay-extractor").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 = {
    "mode": "search",
    "keywords": "software engineer",
    "sector": "any",
    "proximity": "10",
    "postedWithin": "anytime",
    "postedBy": "any",
    "remoteOption": "any",
    "permanent": False,
    "contract": False,
    "temporary": False,
    "fullTime": False,
    "partTime": False,
    "graduateOnly": False,
    "easyApplyOnly": False,
    "visaSponsorship": False,
    "hideNoSalary": False,
    "hideTrainingJobs": False,
    "hideSurveyJobs": False,
    "fetchDetails": True,
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("vexaloom-labs/reed-co-uk-uk-job-listings-and-pay-extractor").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 '{
  "mode": "search",
  "keywords": "software engineer",
  "sector": "any",
  "proximity": "10",
  "postedWithin": "anytime",
  "postedBy": "any",
  "remoteOption": "any",
  "permanent": false,
  "contract": false,
  "temporary": false,
  "fullTime": false,
  "partTime": false,
  "graduateOnly": false,
  "easyApplyOnly": false,
  "visaSponsorship": false,
  "hideNoSalary": false,
  "hideTrainingJobs": false,
  "hideSurveyJobs": false,
  "fetchDetails": true,
  "maxItems": 3
}' |
apify call vexaloom-labs/reed-co-uk-uk-job-listings-and-pay-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,vexaloom-labs/reed-co-uk-uk-job-listings-and-pay-extractor"
        }
    }
}
```

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/oH5FuQqgUuRsixihL/builds/PXJc0ImTfiwpuWFBr/openapi.json