# Reed.co.uk Jobs Scraper (`boncross/reed-jobs-scraper`) Actor

Scrape Reed.co.uk jobs by keyword and location with Reed's own filters: salary, contract, hours, remote, sector, agency or employer, graduate and visa. Get full descriptions, salary breakdown, postcode, skills, posting and expiry dates and recruiter details, or only new jobs. $1.00 per 1,000 jobs.

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

## Pricing

from $0.70 / 1,000 job-details

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

## Reed.co.uk Jobs Scraper

### What is Reed.co.uk Jobs Scraper?

Reed.co.uk is one of the largest UK job boards, and Reed.co.uk Jobs Scraper gets you its postings whole: more than 50 fields per job, with the salary as numbers you can sort on and the date the advert expires. You search by keyword and location using the filters Reed itself offers. There's no Reed account or API key to arrange.

Why pick this one:

- It's quick. 1,409 jobs with full details took about 52 seconds, and big runs settle at about 1,600 jobs a minute.
- Reed does the filtering. Salary, contract, hours, sector and the rest go to Reed, and a job Reed filters out never costs you a page.
- A scheduled run can return just the postings added since last time. Jobs you've already had cost $0.00005 each to skip.
- Salaries compare like for like. You get minimum, maximum, period and currency, plus Reed's yearly equivalent for hourly, daily, weekly and monthly pay.
- $1.00 per 1,000 jobs with full details on the Free plan, $0.70 on Business. A daily monitor across three cities comes to about $0.037 a run.

**BonCross Verified** means we tested this actor against the live site before release and kept the record:

- 37 of 37 live checks on its inputs and filters passed on 7 October 2026
- 7 searches run the same day across Glasgow, Cardiff, Truro and Belfast: 99 jobs, none empty
- 8 of 8 sampled adverts matched Reed's own pages, text and link
- Charges checked against the 99 rows

The rest of what it does, briefly:

- Extract job title, company, location, full description and posting date
- Get the expiry date and drop a stale posting from your feed on the day it lapses
- Keep Reed's original salary wording next to the parsed numbers
- Apply Reed's filters for remote working, graduate roles and visa sponsorship as well
- Separate direct employers from recruitment agencies
- Get the postcode, town, county and region for each job
- Search several locations in one run
- Take it out as JSON, CSV, Excel, XML or HTML

### What can you use it for?

Most people who scrape Reed are doing one of these:

- Feeding a UK job board or aggregator with fresh postings and their expiry dates
- Benchmarking salaries by sector, region and contract type from the parsed numbers
- Watching a role and location daily, with an alert only when something new appears
- Telling direct employers from agencies for recruitment intelligence
- Tracking which sectors and skills are hiring in a region
- Building graduate scheme and visa-sponsorship lists
- Enriching a CRM with recruiter names and references
- Running a personal job search with tight title and salary filters

### What data can you extract?

| | |
|---|---|
| 💼 Job title | 🏢 Company name, profile URL and logo |
| 📍 Location, town, county and region | 📮 Postcode |
| 📅 Posting date and last update | ⏳ Expiry date |
| 💷 Salary minimum, maximum and period | Salary text, OTE and pro-rata flags |
| 📄 Full description | Search snippet |
| Contract type | 🕒 Hours, full-time or part-time |
| 🏡 Remote flag | Sector and sub-sector |
| Skills and Reed taxonomy | 🎓 Graduate flag |
| 🛂 UK eligibility requirement | Agency or direct employer |
| Easy Apply flag | 🔗 Job URL and job id |
| 🧑 Recruiter name and reference | Live or suspended status |
| Salary as a yearly figure, whatever the period | Promoted and Reed Recruitment flags |

### How to scrape Reed jobs

If you can run a search on Reed, you can run this. It's a form, and the result is a spreadsheet.

1. [Sign up for Apify](https://console.apify.com/sign-up) (it's free) and open [Reed.co.uk Jobs Scraper](https://apify.com/boncross/reed-jobs-scraper).
2. Type your keywords and a location. If you've already set a search up on Reed, paste its URL and skip the next step.
3. Narrow it with the date window, salary bounds and whichever of Reed's filters you need.
4. Press Start. When the run finishes, download the jobs as Excel or CSV, or as JSON, XML or HTML.

### ⬇️ Input

Give it keywords and a location, or the URL of a Reed search. That's enough to run.

Left alone, it fetches the full details of each job, looks back three days, and hides training courses and surveys that Reed lists as jobs. Change any of those in the form.

You have two limits. "Max results per search" (25 to 5,000, default 100) applies to each keyword, location or URL separately: ten targets at 50 each scans 500. "Maximum results for the whole run" caps the jobs you're charged for across the run, and 0 means no cap. Nothing past it is charged for.

#### Today's jobs for two keywords in London

```json
{
  "keywords": ["paralegal", "legal administrator"],
  "location": "London",
  "proximity": 10,
  "datePosted": "today",
  "maxResultsPerSearch": 100
}
```

#### Salary band, contract type, hybrid, direct employers only

```json
{
  "keywords": ["compliance analyst"],
  "location": "Manchester",
  "datePosted": "lastWeek",
  "minSalary": 35000,
  "maxSalary": 55000,
  "hideJobsWithoutSalary": true,
  "contractTypes": ["Permanent"],
  "workingOption": "hybrid",
  "employerTypes": ["direct"],
  "sectors": ["Financial Services"]
}
```

#### A daily monitor across three cities, agencies excluded

```json
{
  "keywords": ["administrator", "office coordinator"],
  "locations": ["London", "Reading", "Bristol"],
  "datePosted": "today",
  "dedupStoreName": "reed-admin-seen",
  "titleExclude": ["sales", "recruitment consultant"],
  "excludeAgencies": true
}
```

#### A pasted Reed search URL

```json
{
  "startUrls": [{ "url": "https://www.reed.co.uk/jobs/graduate-jobs-in-london?salaryFrom=28000&graduate=True&dateCreatedOffSet=LastWeek" }],
  "maxResultsPerSearch": 200
}
```

| Field | Notes |
|---|---|
| `keywords`, `location`, `locations`, `proximity` | Search terms and where to search, with a radius in miles. |
| `startUrls` | Reed search URLs, with their filters preserved. |
| `datePosted`, `sortBy` | Today, last three days, last week, last two weeks or any; sorted by date or relevance. |
| `minSalary`, `maxSalary`, `hideJobsWithoutSalary` | Salary bounds, applied by Reed. |
| `contractTypes`, `hours`, `workingOption`, `employerTypes`, `sectors` | Reed's own filters for contract, hours, remote or hybrid, employer type and sector. |
| `graduate`, `easyApply`, `earlyBird`, `visaSponsorship` | Reed's flags for graduate schemes, Easy Apply, early applications and sponsorship. |
| `hideTrainingJobs`, `hideSurveyJobs` | Both on by default. |
| `titleInclude`, `titleExclude`, `companyExclude` | Free filters applied before any job page is fetched. |
| `excludeAgencies`, `remoteOnly`, `descriptionInclude`, `descriptionExclude`, `skillsInclude` | Filters applied after the job page is fetched. |
| `maxResultsPerSearch`, `maxItems` | The per-search cap and the run-wide cap. |
| `fetchDetails`, `maxNewJobs`, `dedupStoreName` | Detail fetching, a cap on jobs returned, and the only-new store. |
| `maxConcurrency`, `delayMs` | How many requests run at once, and an optional pause before each one (0 by default). |

#### For developers

- `maxResultsPerSearch` is the per-search limit and `maxItems` the run-wide one. `maxItems` counts each job charged, including one whose page was fetched and then dropped by a post-fetch filter, which is why a run can return slightly fewer rows than the cap.
- `titleInclude`, `titleExclude` and `companyExclude` run before any job page is fetched. A job they drop costs the scan rate only. `excludeAgencies`, `remoteOnly` and the description and skills filters run after the fetch, and a fetched page is charged as a detail even if one of them drops the job.
- `dedupStoreName` names the store that remembers what you've had. Each run returns only postings it hasn't returned before, and the ones it has seen cost the scan rate.
- If you only need the listing fields, set `fetchDetails` to false. Those rows bill as `job-listed`, a fifth of the detail price.
- `maxConcurrency` (default 8, from 1 to 32) is how many requests run at once.
- `delayMs` (default 0, up to 2,000) adds a pause before each request. We'd leave both alone.
- If Apify moves a run to another server part-way through, it carries on where it stopped. No job is returned or charged twice.
- Rows arrive in search order. Two runs of the same input read top to bottom the same way.

### ⬆️ Output

One record per job, which you can view as a table or as JSON in the Output tab.

```json
{
  "id": "57315414",
  "url": "https://www.reed.co.uk/jobs/residential-property-paralegal/57315414",
  "title": "Residential Property Paralegal",
  "company": "Brandon James Ltd",
  "companyUrl": "https://www.reed.co.uk/jobs/brandon-james-ltd",
  "companyLogo": "https://resources.reed.co.uk/profileimages/logos/thumbs/Logo_27871.png",
  "location": "London",
  "county": "London",
  "postedAt": "2026-09-07",
  "updatedAt": "2026-09-07",
  "closingAt": "2026-10-19",
  "salaryMin": 30000,
  "salaryMax": 35000,
  "salaryPeriod": "annual",
  "salaryCurrency": "GBP",
  "salaryText": "£ 30,000 - £ 35,000 per annum",
  "salaryIsOte": false,
  "salaryIsProRata": false,
  "salaryIsNegotiable": false,
  "isFullTime": true,
  "isPartTime": false,
  "isEasyApply": true,
  "contractType": "Permanent",
  "hours": "Full-time",
  "isRemote": false,
  "workingOption": "onSite",
  "sector": "Legal",
  "subSector": "Paralegal",
  "town": "London",
  "region": "South East England",
  "postcode": "WC2R",
  "country": "United Kingdom",
  "isAgency": true,
  "isEmployer": false,
  "isGraduate": false,
  "requiresUkEligibility": false,
  "skills": ["Paralegal | Law | Legal"],
  "taxonomy": "Occupation/KD: Legal/Paralegal/Property Paralegal/Home Property Paralegal",
  "snippet": "A well established law firm is seeking a Residential Property Paralegal…",
  "description": "A well established law firm is seeking a Residential Property Paralegal to join its London conveyancing team…",
  "recruiterName": "Brandon James Ltd",
  "recruiterReference": "22414CVAL",
  "isLive": true,
  "isSuspended": false,
  "scrapedAt": "2026-09-07T22:17:15.453Z"
}
```

Download the dataset as JSON, CSV, Excel, XML or HTML. You can pick or omit fields before you export.

Some columns aren't in that example, or need a word of explanation:

| Column | Meaning |
|---|---|
| `salaryMinPerAnnum`, `salaryMaxPerAnnum` | Reed's own yearly equivalent of the salary, whatever its period (hourly, daily, weekly, monthly), so jobs compare like for like |
| `descriptionHtml` | The full advert as HTML, beside the plain-text `description` |
| `isPromoted` | A job Reed shows as promoted in the results |
| `isReedRecruitment` | A job advertised by Reed's own recruitment agency |
| `isTrainingJob` | A training course listed as a job (dropped by default) |
| `workingOption` | `onSite`, `hybrid` or `remote`, as Reed classes the job |
| `snippet` | The short extract Reed shows in its search results |
| `detailError` | Present only when a job page could not be read; the row then carries the listing fields alone |
| `searchKeywords`, `searchUrl` | The search that found the job |

### How fast is it, and how many jobs can you get?

| Run | Result |
|---|---|
| One keyword ("administrator"), London, last week, up to 25 jobs | 25 jobs, all with full details, in about 3 seconds |
| Three keywords ("administrator", "accountant", "software developer"), London, last week, up to 100 jobs each | 294 jobs (jobs listed under two keywords appear once), all with full details, in about 14 seconds |
| Four keywords, London, last week, up to 100 jobs each | 363 jobs, all with full details, in about 10 seconds |
| Eight keywords, London, last week, up to 250 jobs each | 1,409 jobs (jobs listed under two keywords appear once), all with full details, in about 52 seconds |

These are whole runs on Apify, measured on 4 October 2026. Small runs finish in a few seconds, and larger ones settle at about 1,600 jobs a minute.

Reed paginates its search, and a broad keyword and location can return thousands. Your per-search cap decides how deep each search goes, and you can cover several locations in one go.

### How much does it cost to scrape Reed?

| Event | Free plan | Starter | Scale | Business |
|---|---|---|---|---|
| `actor-start`, per run | $0.002 | $0.002 | $0.002 | $0.002 |
| `job-scanned`, per search result seen, before dedup and filters | $0.00005 | $0.00005 | $0.00005 | $0.00005 |
| `job-detail`, per job returned with details | $0.001 | $0.0009 | $0.0008 | $0.0007 |
| `job-listed`, per job returned without details | $0.0002 | $0.00018 | $0.00016 | $0.00014 |

Enterprise plans pay the Business price.

**$1.00 per 1,000 jobs with full details** on the Free plan, $0.70 on Business. That's the whole price, with proxy usage and platform usage included.

What decides your bill is how many job pages get fetched. Jobs removed by deduplication, the only-new store or the title and company filters cost the scan rate only. A job whose page was fetched is charged as a detail, even if a post-fetch filter then drops it.

- A run that scans 100 results and returns 82 jobs with details: $0.002 + 100 × $0.00005 + 82 × $0.001 = **$0.089** ($0.064 on Business).
- A daily monitor across three cities that scans 300 results and finds 20 new jobs: $0.002 + 300 × $0.00005 + 20 × $0.001 = **$0.037** ($0.031 on Business).

Apify's Free plan includes $5 of usage credits a month. At the size of the first example that's 56 runs, or about 4,600 jobs with full details, before you pay anything.

### Run it daily, or from your own code

The daily monitor is the setup we'd recommend. Create an Apify Schedule, give `dedupStoreName` a name, and each run reports only the new postings. A webhook can fire when a run finishes, and the results can go on to Slack, Google Sheets, Google Drive, Zapier, Make, Airbyte or GitHub through Apify's integrations.

From code, `POST https://api.apify.com/v2/acts/boncross~reed-jobs-scraper/run-sync-get-dataset-items` with the input JSON as the body returns the jobs in a single call for short runs. The standard run endpoints handle longer ones. There's an `apify-client` package on NPM for Node.js and one on PyPI for Python.

An AI agent can use it too. Add the Apify MCP server (`mcp.apify.com`) to any MCP-capable client and the actor shows up as a tool under its own name. You could then ask for today's permanent roles above a salary threshold and have them summarised.

### FAQ

#### Do I need proxies, a Reed account or an API key?

None of the three. The actor reads Reed's public job search, and there's no login or key to manage. Proxy usage is included in the price, with nothing to set up.

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

Name an only-new store ("Only new jobs" in the form) and schedule the run. Each run then returns only postings it hasn't returned before, and the jobs it has already seen cost just the scan rate.

#### Which filters save me money?

The ones Reed applies: salary, contract type, hours, remote or hybrid, employer type, sector, graduate, Easy Apply, early bird and visa sponsorship. Reed drops those jobs before you ever pay for a page. Title and company filters are nearly as cheap, because they run before the page is fetched. Description, skills, agency and remote-only filters need the page first, and you pay for it.

#### Can I paste a search I've already set up on Reed?

Put its URL in Start URLs. The filters inside the URL are kept.

#### Can I compare an hourly rate with a yearly salary?

That's what the per-annum columns are for. `salaryMin`, `salaryMax`, `salaryPeriod` and `salaryCurrency` are parsed from the advert, the yearly equivalents sit beside them, and Reed's original wording is kept in `salaryText`.

#### Can I tell agencies from direct employers?

Each job has `isAgency` and `isEmployer`. If you don't want agency postings at all, switch on "Exclude recruitment agencies".

#### Why does a description end in "..."?

Reed truncates a few very long adverts on its own site, about 2 in 25 in one sample. You get those descriptions exactly as Reed publishes them.

#### What are the limits?

- Coordinates and Reed's listing badges aren't returned. Town, county, region and postcode are.
- A job page that keeps failing after retries is returned listing-only, with a `detailError` note, and billed as `job-listed`. The rest of the run is unaffected.
- **Most recent** order follows Reed's posting or refresh time, which rows show only to the day. A job refreshed recently can sit among newer postings.
- A run can return slightly fewer rows than your run-wide cap, because the cap counts each job charged, including one fetched and then dropped by a filter.
- Reed's own API is open to registered recruiters with a key and covers a different, smaller set of fields. This actor reads the public site.

#### Is scraping Reed legal?

The actor reads only job postings Reed serves to any logged-out visitor. Web scraping of publicly available data is generally legal, but you're responsible for complying with Reed's terms and applicable law in how you use the data.

### More from BonCross

- [UK Government & NHS Jobs Scraper](https://apify.com/boncross/uk-public-sector-jobs): NHS Jobs, Civil Service Jobs (every department) and Ministry of Justice vacancies in…
- [Workday Jobs Scraper](https://apify.com/boncross/workday-jobs): Every open job from a Workday careers board.
- [Ashby Jobs Scraper](https://apify.com/boncross/ashby-jobs): Every open job on an Ashby careers board.
- [ATS Jobs Scraper](https://apify.com/boncross/ats-jobs): Jobs from any company careers page.
- [CharityJob Scraper](https://apify.com/boncross/charityjob-jobs): UK charity and non-profit jobs from CharityJob.
- [Glassdoor Job Scraper](https://apify.com/boncross/glassdoor-jobs): Glassdoor job listings for a role and location.

### Your feedback

Is there something on Reed we're not picking up, or a job that looks wrong? Raise it on the Issues tab in Apify Console. BonCross reads each issue, and fixes ship as new builds of this actor.

# Changelog

This Actor's version history is a separate document: https://apify.com/boncross/reed-jobs-scraper/changelog.md

# Actor input Schema

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

One search per entry, for example "paralegal" or "compliance analyst". Results are deduplicated across searches.

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

Town, city, county or postcode, as you would type it on Reed. Ignored when the locations list is set.

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

Run every keyword against each of these locations and deduplicate the results.

## `proximity` (type: `integer`):

Distance from the location in miles, as on Reed.

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

Optional. Paste full reed.co.uk job-search URLs and every filter in them is kept.

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

Ceiling per keyword or URL. The search stops earlier when Reed runs out of matches.

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

A run-wide ceiling across every target. The per-target limit above applies to each one separately, so ten targets at 50 each returns 500; set this to cap the total. Zero means no run-wide limit. Rows that report an input the actor could not resolve are not counted here and are never charged for.

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

Reed's own date filter, applied by Reed. Defaults to the last three days: 'today' can legitimately return nothing early in the day, before employers have posted.

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

Most recent first, or Reed's relevance order.

## `minSalary` (type: `integer`):

Lowest annualised salary. Applied by Reed.

## `maxSalary` (type: `integer`):

Reed matches this against where a job's salary range STARTS, so a job advertised at 20,000-150,000 still comes back under a 25,000 ceiling. Measured, not assumed. Applied by Reed.

## `hideJobsWithoutSalary` (type: `boolean`):

Drop postings that say "Competitive" or show no salary. Applied by Reed.

## `contractTypes` (type: `array`):

Restrict to these contract types. These are the same values the output's `contractType` field uses, so you can filter on what you see.

## `hours` (type: `array`):

Restrict to these hours. These are the same values the output's `hours` field uses.

## `workingOption` (type: `string`):

Reed's remote, hybrid or on-site filter.

## `employerTypes` (type: `array`):

Restrict to jobs posted directly by employers, by agencies, or by Reed Recruitment itself.

## `sectors` (type: `array`):

Reed sector names as they appear in its filter sidebar, such as "Legal", "Admin, Secretarial & PA" or "Financial Services", or Reed's numeric sector ids. Applied by Reed.

## `graduate` (type: `boolean`):

Reed's graduate filter.

## `easyApply` (type: `boolean`):

Reed's Easy Apply filter.

## `earlyBird` (type: `boolean`):

Reed's early bird flag: fresh postings with few applicants so far.

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

Reed's visa sponsorship flag.

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

Reed mixes paid training courses in with jobs. Hide them.

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

Reed mixes paid-survey adverts in with jobs. Hide them.

## `remoteOnly` (type: `boolean`):

After the fetch, keep only jobs Reed flags as remote.

## `titleInclude` (type: `array`):

Jobs whose title contains none of these are dropped before the fetch, so they cost the scan rate only.

## `titleExclude` (type: `array`):

Jobs whose title contains any of these are dropped before the fetch.

## `companyExclude` (type: `array`):

Jobs from companies matching any of these are dropped before the fetch.

## `excludeAgencies` (type: `boolean`):

After the fetch, drop adverts that Reed flags as agency postings.

## `descriptionInclude` (type: `array`):

After the fetch, keep only jobs whose description contains one of these.

## `descriptionExclude` (type: `array`):

After the fetch, drop jobs whose description contains any of these.

## `skillsInclude` (type: `array`):

After the fetch, keep only jobs whose Reed skills tags include one of these.

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

Fetch each job's page for the full description, salary breakdown, contract, hours, remote flag, skills, sector, expiry and recruiter. Turn it off for a listing-only run.

## `maxNewJobs` (type: `integer`):

Stop after this many jobs. 0 means no cap.

## `dedupStoreName` (type: `string`):

Name a key-value store and the actor remembers every job id it has returned. Later runs skip those before the detail fetch, so a scheduled run gives you only what is new.

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

How many requests run at once across the whole run. The default is the fastest level measured clean; lower it only if a run reports refusals or errors.

## `delayMs` (type: `integer`):

Optional pause before each call, in milliseconds, up to 2,000. 0 (the default) runs as fast as the parallel limit allows.

## `restartAttempt` (type: `integer`):

Set by the actor when it restarts itself in a fresh container after being refused. Leave it alone.

## Actor input object example

```json
{
  "keywords": [
    "paralegal",
    "administrator"
  ],
  "location": "London",
  "locations": [],
  "proximity": 10,
  "maxResultsPerSearch": 100,
  "maxItems": 0,
  "datePosted": "last3days",
  "sortBy": "date",
  "minSalary": 0,
  "maxSalary": 0,
  "hideJobsWithoutSalary": false,
  "contractTypes": [],
  "hours": [],
  "workingOption": "any",
  "employerTypes": [],
  "sectors": [],
  "graduate": false,
  "easyApply": false,
  "earlyBird": false,
  "visaSponsorship": false,
  "hideTrainingJobs": true,
  "hideSurveyJobs": true,
  "remoteOnly": false,
  "titleInclude": [],
  "titleExclude": [],
  "companyExclude": [],
  "excludeAgencies": false,
  "descriptionInclude": [],
  "descriptionExclude": [],
  "skillsInclude": [],
  "fetchDetails": true,
  "maxNewJobs": 0,
  "dedupStoreName": "",
  "maxConcurrency": 8,
  "delayMs": 0,
  "restartAttempt": 0
}
```

# Actor output Schema

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

Reed jobs: every row the run returned.

## `stats` (type: `string`):

Counts for the run: what was resolved, fetched, filtered and returned.

# 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": [
        "paralegal",
        "administrator"
    ],
    "location": "London"
};

// Run the Actor and wait for it to finish
const run = await client.actor("boncross/reed-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 = {
    "keywords": [
        "paralegal",
        "administrator",
    ],
    "location": "London",
}

# Run the Actor and wait for it to finish
run = client.actor("boncross/reed-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 '{
  "keywords": [
    "paralegal",
    "administrator"
  ],
  "location": "London"
}' |
apify call boncross/reed-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,boncross/reed-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/pfSJ46YUYBe0aeGb5/builds/RhXdP1tTnPVXCas2d/openapi.json