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

\[💰 $0.95 / 1K] Extract UK job listings from Reed.co.uk by keyword, location, salary, contract type, and posted-by source. Get titles, companies, salaries, descriptions, employment types, posted dates, and direct apply URLs — every row a flat job posting.

- **URL**: https://apify.com/solidcode/reed-co-uk-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.95 / 1,000 results

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Reed.co.uk Jobs Scraper

Pull live UK job listings from Reed.co.uk at scale — titles, hiring company, salary parsed into min/max/currency/period, location, employment-type flags, posted date, full HTML descriptions, recruiter profile, sector, and direct apply URLs. Built for UK recruiters, salary-benchmark analysts, and HR-tech sales teams who need a clean Reed feed without writing scrapers.

### Why This Scraper?

- **Every Reed-native filter wired through** — 5 employment-type toggles (permanent, contract, temp, full-time, part-time), agency vs. direct-employer source filter, 7 distance bands (exact location to 40 miles), 5 date-posted windows (today / last 3 days / last week / last 2 weeks / any), and GBP min/max salary range — none of which the multi-board aggregators expose.
- **Salary parsed into structured fields** — every row carries `salaryMin`, `salaryMax`, `salaryCurrency` (always GBP), and `salaryPeriod` (annual / hourly / daily / weekly / monthly) alongside the original Reed text. No custom regex on your end to filter "£40-60k" candidates.
- **Up to 5,000 jobs per run** — pagination handled automatically; works equally well at 50 rows for a quick lead pull or 5,000 rows for a region-wide salary survey.
- **Free-form keyword + UK location** — no preset role lists, no fixed locations. Type `"data engineer"` + `"se1"` (postcode) or `"warehouse operative"` + `"manchester"` and Reed's own geocoder handles the rest.
- **Detail-page enrichment with rich-HTML descriptions** — the full posting body, sector category, and recruiter Reed profile URL are pulled from each job's detail page; toggle off for cheaper, snippet-only scans.
- **Accepts pasted Reed URLs** — drop in a search-results URL straight from the Reed website (sector picker, graduate, easy-apply, and visa-sponsorship flags all carry through) or an individual job-detail URL — both work side-by-side with free-text queries in the same run.
- **Per-row search echo** — every row records the `searchKeywords` and `searchLocation` that produced it, so multi-query batch runs stay filterable downstream in CSV / Excel / Postgres.
- **No login. No API key. No setup.** Enter a keyword and a UK city and you have a clean dataset in minutes.

### Use Cases

**Recruitment Lead Generation**
- Build target lists of recruitment agencies actively advertising in your sector
- Identify direct employers hiring for the same role you place candidates into
- Track which agencies dominate a given UK region or job category

**Salary Benchmarking**
- Live UK pay data by role, region, and seniority, refreshed on demand
- Compare permanent vs. contract day-rates for the same job title
- Surface salary-band shifts week-on-week for compensation reviews

**Job-Aggregator & White-Label Boards**
- Backfill a niche or regional jobs board with curated Reed listings
- Power a Slack/email alerting product for new roles in a specific stack
- Build a sector-specific newsletter (FinTech London, NHS healthcare, etc.)

**Workforce & Skills Market Research**
- Track demand for skills like "Python", "AWS", "Salesforce" by region over time
- Map remote vs. hybrid vs. on-site mix in your industry
- Quantify graduate, contract, and permanent supply per UK city

**Competitive Intelligence for HR-Tech Sales**
- Identify recruitment agencies as warm leads for ATS, CRM, or sourcing tools
- Track which competitors of your target customer are hiring (and for what)
- Monitor hiring spikes to time outbound campaigns

### Getting Started

#### Basic Search

A single keyword + city — fastest path to a useful dataset:

```json
{
    "keywords": "python developer",
    "location": "london"
}
````

#### Filtered Search

Narrow to fixed-term contract data engineers in Manchester within 20 miles, paying £60k+:

```json
{
    "keywords": "data engineer",
    "location": "manchester",
    "distance": "20",
    "permanent": false,
    "contract": true,
    "temp": false,
    "minSalary": 60000,
    "maxResults": 200
}
```

#### URL List with Detail Enrichment

Mix two pre-filtered Reed search URLs and pull full descriptions for both:

```json
{
    "urls": [
        "https://www.reed.co.uk/jobs/python-jobs-in-bristol",
        "https://www.reed.co.uk/jobs/devops-jobs-in-edinburgh"
    ],
    "fetchDescription": true,
    "maxResults": 500
}
```

### Input Reference

#### Search

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `keywords` | string | `"python developer"` | Job title or skill to search, such as `"python developer"` or `"marketing manager"`. Leave empty to scrape Reed's general listing. |
| `location` | string | `"london"` | UK city, region, or postcode (e.g., `"london"`, `"manchester"`, `"se1"`, `"remote"`). Reed accepts full or partial postcodes and town names. |
| `distance` | select | `10 miles` | Search radius from the location: `Exact location only`, `5 miles`, `10 miles`, `15 miles`, `20 miles`, `30 miles`, `40 miles`. Ignored when location is empty. |
| `urls` | string\[] | `[]` | Optional. Paste Reed.co.uk search URLs or individual job URLs. Filters baked into pasted URLs are honored as-is. |

#### Job Type

A single posting can carry multiple flags (e.g., a role can be both contract AND full-time). Each toggle includes any role tagged with that flag.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `permanent` | boolean | `true` | Include permanent contract roles. |
| `contract` | boolean | `true` | Include fixed-term contract roles. |
| `temp` | boolean | `true` | Include temporary roles. |
| `fullTime` | boolean | `true` | Include full-time roles. |
| `partTime` | boolean | `false` | Include part-time roles. |

#### Salary

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `minSalary` | integer | null | Minimum annual salary in GBP. Many Reed listings are tagged `"Competitive"` and may be excluded by Reed's server-side filter when set. |
| `maxSalary` | integer | null | Maximum annual salary in GBP. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `postedBy` | select | `Any (agency or direct employer)` | Filter by who listed the role: `Any (agency or direct employer)`, `Recruitment agency only`, or `Direct employer only`. |
| `datePosted` | select | `Any time` | Only show roles posted within this window: `Any time`, `Today`, `Last 3 days`, `Last week`, `Last 2 weeks`. |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `fetchDescription` | boolean | `true` | Fetch each role's full description from its detail page. Leave on for the most complete data. Turn off for faster, cheaper scans — only the short snippet, salary, and headline fields will be populated. |
| `maxResults` | integer | `100` | Cap on total job rows across all keywords and URLs. Hard upper bound is 5,000 — set to `0` to use that cap directly. The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots (up to ~100 results per page). |

### Output

Every row is a flat job posting. Here is a representative result:

```json
{
    "jobId": "56626200",
    "title": "Python Developer - Insurance Analytics",
    "company": "Lane Clark and Peacock LLP",
    "location": "London",
    "salary": "£40,000 - £60,000 per annum",
    "salaryMin": 40000,
    "salaryMax": 60000,
    "salaryCurrency": "GBP",
    "salaryPeriod": "annual",
    "employmentType": ["Permanent", "Full-time"],
    "postedBy": "directEmployer",
    "postedDate": "2026-04-28T10:27:23",
    "expiryDate": "2026-06-09T23:55:00",
    "applyUrl": "https://careers.lcp.com/job/python-developer/...",
    "jobUrl": "https://www.reed.co.uk/jobs/python-developer-insurance-analytics/56626200",
    "snippet": "We are looking for a Python developer to join our insurance analytics team...",
    "description": "We are looking for a Python developer to join our insurance analytics team. You will be working on...",
    "descriptionHtml": "<p>We are looking for a <strong>Python</strong> developer...</p><ul><li>5+ years experience</li></ul>",
    "sector": "IT & Telecoms",
    "recruiterName": "Lane Clark and Peacock LLP",
    "recruiterReedProfileUrl": "https://www.reed.co.uk/Profile/Lane-Clark-and-Peacock-LLP-100888",
    "searchKeywords": "python developer",
    "searchLocation": "london",
    "scrapedAt": "2026-05-09T14:30:00Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `jobId` | string | Reed's numeric job identifier. |
| `title` | string | Job title as posted. |
| `company` | string | null | Hiring company name. May be null when posted by an agency anonymously. |
| `location` | string | Location as Reed displays it (e.g., `"London"`, `"Manchester · Remote"`). |
| `snippet` | string | Short preview always present from the search results card. |
| `postedDate` | string | When the role was posted (ISO 8601). |
| `expiryDate` | string | null | When the listing closes (ISO 8601). |

#### Salary

| Field | Type | Description |
|-------|------|-------------|
| `salary` | string | null | Salary text as posted (e.g., `"£45,000 - £55,000 per annum"`, `"£18 per hour"`, `"Competitive"`). |
| `salaryMin` | number | null | Parsed minimum salary. Null when not parseable. |
| `salaryMax` | number | null | Parsed maximum salary. Null when not parseable. |
| `salaryCurrency` | string | Always `"GBP"` for Reed (UK-only board). |
| `salaryPeriod` | string | null | `"annual"`, `"monthly"`, `"weekly"`, `"daily"`, `"hourly"`, or null. |

#### Employment & Source

| Field | Type | Description |
|-------|------|-------------|
| `employmentType` | string\[] | Subset of `["Permanent", "Contract", "Temporary", "Full-time", "Part-time"]`. |
| `postedBy` | string | null | `"agency"` or `"directEmployer"`. |
| `sector` | string | null | Reed's sector category (e.g., `"IT & Telecoms"`, `"Healthcare"`). |
| `recruiterName` | string | null | Recruiter or company name on the listing page. |
| `recruiterReedProfileUrl` | string | null | Reed recruiter profile URL when present. |

#### Description & Links

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | null | Full job description (plain text). Populated when `fetchDescription` is on. |
| `descriptionHtml` | string | null | Full description with HTML markup preserved (`<p>`, `<ul>`, `<strong>`). |
| `applyUrl` | string | Direct apply URL — external ATS link when the role redirects, otherwise the Reed apply page. |
| `jobUrl` | string | Reed.co.uk URL for the job detail page. |

#### Search Context

| Field | Type | Description |
|-------|------|-------------|
| `searchKeywords` | string | null | The `keywords` input that produced this row (echoed for batch runs). |
| `searchLocation` | string | null | The `location` input that produced this row. |
| `scrapedAt` | string | ISO 8601 timestamp of the scrape. |

### Tips for Best Results

- **Use `distance` to control noise.** `Exact location only` returns just the postings tagged with that town or postcode; bumping to `40 miles` widens the catchment for commuter-belt or remote-friendly roles. Ignored when `location` is empty.
- **Reed's salary filter overlaps with stated bands.** A posting at `£50,000-£80,000` will appear in a `minSalary: 70000` search because the band crosses your floor — useful for surfacing roles where you're at the top of the range, but expect overlap rather than strict cutoffs.
- **Set `maxResults: 0` to fetch every available row** (capped at the internal 5,000 ceiling). Best paired with a tight keyword + location for a clean salary survey.
- **Paste Reed search URLs to bring filters Reed exposes that this actor doesn't surface as top-level inputs.** Sector picker (`multipleParentSectorIds`), graduate-only, easy-apply, and visa-sponsorship flags are honored when present in the URL — dial in the search on the Reed website, then paste the full URL into the `urls` field.
- **Combine `keywords` + `urls` in one run.** A free-text search and a list of pre-filtered Reed URLs run side-by-side; deduplication by job ID is automatic, so the same posting found twice only counts once.
- **Turn off `fetchDescription` for fast lead-list scans.** When you only need title, company, salary, and apply URL (e.g., counting agency activity in a sector), skipping the per-job detail fetch is significantly faster and cheaper.
- **Use `postedBy: "Recruitment agency only"` for agency lead lists.** Pair it with a sector-filtered URL to surface every agency actively placing into your vertical — name, recruiter Reed profile, and contact route in one pull.

### Pricing

**$0.95 per 1,000 results.** No compute charges — you only pay per result returned.

| Results | Total cost |
|---------|------------|
| 100 | $0.10 |
| 1,000 | $0.95 |
| 10,000 | $9.50 |
| 100,000 | $95.00 |

A "result" is any job row in the output dataset. Roughly 4× cheaper than the closest comparable multi-board scraper on the Apify store.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate recruitment, salary-benchmarking, market research, and lead-generation work. Users are responsible for complying with applicable laws and Reed.co.uk's terms of service. Do not use extracted data for spam, harassment, or any illegal purpose. Be mindful of UK GDPR when storing or processing personal data appearing in job posts.

# Actor input Schema

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

Job title or skill to search, such as 'python developer' or 'marketing manager'. Leave empty to scrape Reed's general listing.

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

UK city, region, or postcode (e.g., 'london', 'manchester', 'se1', 'remote'). Reed accepts full or partial postcodes and town names.

## `distance` (type: `string`):

Search radius from the location. Ignored when location is empty.

## `urls` (type: `array`):

Optional. Paste Reed.co.uk search URLs (e.g., https://www.reed.co.uk/jobs/python-jobs-in-london) or individual job URLs (e.g., https://www.reed.co.uk/jobs/job/55123456). Filters baked into pasted URLs are honored as-is — useful when you have already dialed in a search on the Reed website.

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

Include permanent contract roles.

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

Include fixed-term contract roles.

## `temp` (type: `boolean`):

Include temporary roles.

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

Include full-time roles.

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

Include part-time roles.

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

Minimum annual salary in pounds sterling. Leave empty for no lower bound. Note: many Reed listings have unspecified salary text (e.g., 'Competitive') and may be excluded by Reed's own server-side filter when this is set.

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

Maximum annual salary in pounds sterling. Leave empty for no upper bound.

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

Filter by who listed the role. Reed marks every posting as either an agency listing or a direct-employer listing.

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

Only show roles posted within this window.

## `fetchDescription` (type: `boolean`):

Fetch each role's full description from its detail page. Leave on for the most complete data. Turn off for faster, cheaper scans — only the short snippet, salary, and headline fields will be populated.

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

Cap on total job rows across all keywords and URLs. Default 100. Hard upper bound is 5,000 to prevent runaway pagination — set to 0 to use that internal cap directly. The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots (up to ~100 results per page).

## Actor input object example

```json
{
  "keywords": "python developer",
  "location": "london",
  "distance": "10",
  "urls": [],
  "permanent": true,
  "contract": true,
  "temp": true,
  "fullTime": true,
  "partTime": false,
  "postedBy": "any",
  "datePosted": "any",
  "fetchDescription": true,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of scraped job listings with key fields.

## `detail` (type: `string`):

Complete job data including descriptions, parsed salary fields, and recruiter info.

# 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",
    "location": "london",
    "distance": "10",
    "urls": [],
    "permanent": true,
    "contract": true,
    "temp": true,
    "fullTime": true,
    "partTime": false,
    "postedBy": "any",
    "datePosted": "any",
    "fetchDescription": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/reed-co-uk-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": "python developer",
    "location": "london",
    "distance": "10",
    "urls": [],
    "permanent": True,
    "contract": True,
    "temp": True,
    "fullTime": True,
    "partTime": False,
    "postedBy": "any",
    "datePosted": "any",
    "fetchDescription": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/reed-co-uk-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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",
  "location": "london",
  "distance": "10",
  "urls": [],
  "permanent": true,
  "contract": true,
  "temp": true,
  "fullTime": true,
  "partTime": false,
  "postedBy": "any",
  "datePosted": "any",
  "fetchDescription": true,
  "maxResults": 100
}' |
apify call solidcode/reed-co-uk-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/reed-co-uk-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reed.co.uk Jobs Scraper",
        "description": "[💰 $0.95 / 1K] Extract UK job listings from Reed.co.uk by keyword, location, salary, contract type, and posted-by source. Get titles, companies, salaries, descriptions, employment types, posted dates, and direct apply URLs — every row a flat job posting.",
        "version": "1.0",
        "x-build-id": "uztsRDrkTKVmQww2A"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~reed-co-uk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-reed-co-uk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~reed-co-uk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-reed-co-uk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~reed-co-uk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-reed-co-uk-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job title or skill to search, such as 'python developer' or 'marketing manager'. Leave empty to scrape Reed's general listing."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "UK city, region, or postcode (e.g., 'london', 'manchester', 'se1', 'remote'). Reed accepts full or partial postcodes and town names."
                    },
                    "distance": {
                        "title": "Distance from Location (miles)",
                        "enum": [
                            "0",
                            "5",
                            "10",
                            "15",
                            "20",
                            "30",
                            "40"
                        ],
                        "type": "string",
                        "description": "Search radius from the location. Ignored when location is empty.",
                        "default": "10"
                    },
                    "urls": {
                        "title": "Direct Reed URLs",
                        "type": "array",
                        "description": "Optional. Paste Reed.co.uk search URLs (e.g., https://www.reed.co.uk/jobs/python-jobs-in-london) or individual job URLs (e.g., https://www.reed.co.uk/jobs/job/55123456). Filters baked into pasted URLs are honored as-is — useful when you have already dialed in a search on the Reed website.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "permanent": {
                        "title": "Permanent",
                        "type": "boolean",
                        "description": "Include permanent contract roles.",
                        "default": true
                    },
                    "contract": {
                        "title": "Contract",
                        "type": "boolean",
                        "description": "Include fixed-term contract roles.",
                        "default": true
                    },
                    "temp": {
                        "title": "Temporary",
                        "type": "boolean",
                        "description": "Include temporary roles.",
                        "default": true
                    },
                    "fullTime": {
                        "title": "Full-time",
                        "type": "boolean",
                        "description": "Include full-time roles.",
                        "default": true
                    },
                    "partTime": {
                        "title": "Part-time",
                        "type": "boolean",
                        "description": "Include part-time roles.",
                        "default": false
                    },
                    "minSalary": {
                        "title": "Minimum Salary (GBP, annual)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum annual salary in pounds sterling. Leave empty for no lower bound. Note: many Reed listings have unspecified salary text (e.g., 'Competitive') and may be excluded by Reed's own server-side filter when this is set."
                    },
                    "maxSalary": {
                        "title": "Maximum Salary (GBP, annual)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum annual salary in pounds sterling. Leave empty for no upper bound."
                    },
                    "postedBy": {
                        "title": "Posted By",
                        "enum": [
                            "any",
                            "agency",
                            "directEmployer"
                        ],
                        "type": "string",
                        "description": "Filter by who listed the role. Reed marks every posting as either an agency listing or a direct-employer listing.",
                        "default": "any"
                    },
                    "datePosted": {
                        "title": "Date Posted",
                        "enum": [
                            "any",
                            "today",
                            "lastThreeDays",
                            "lastWeek",
                            "lastTwoWeeks"
                        ],
                        "type": "string",
                        "description": "Only show roles posted within this window.",
                        "default": "any"
                    },
                    "fetchDescription": {
                        "title": "Fetch Full Job Descriptions",
                        "type": "boolean",
                        "description": "Fetch each role's full description from its detail page. Leave on for the most complete data. Turn off for faster, cheaper scans — only the short snippet, salary, and headline fields will be populated.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap on total job rows across all keywords and URLs. Default 100. Hard upper bound is 5,000 to prevent runaway pagination — set to 0 to use that internal cap directly. The actor stops requesting new pages once this number is reached but keeps the full final page even if it slightly overshoots (up to ~100 results per page).",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```