# Reed.co.uk Job Scraper (`automation-lab/reed-jobs-scraper`) Actor

Extract job listings from Reed.co.uk — UK's #1 job board with 300,000+ vacancies. Search by keyword, location, salary, and contract type. Exports to JSON, CSV, or Excel.

- **URL**: https://apify.com/automation-lab/reed-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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 Job Scraper

Extract job listings from [Reed.co.uk](https://www.reed.co.uk) — the UK's #1 job board with **300,000+ live vacancies**. Search by keyword, location, salary range, job type, and date posted. Get structured data including salary, employer, location, job description, and more — exported to JSON, CSV, or Excel.

### What does Reed.co.uk Job Scraper do?

Reed.co.uk Job Scraper extracts structured job listing data directly from [Reed.co.uk](https://www.reed.co.uk), the UK's largest online job board. It uses **pure HTTP requests** (no browser required) to scrape search results efficiently, pulling data from Reed's embedded JSON to deliver complete, structured job records.

For each job listing you get: title, employer, location, salary range, contract type, category, posting date, job description, and direct URL. Enable the **full job details** option to also fetch the complete HTML description from each job's detail page.

No login, no API key, and no browser needed — just enter your search terms and run.

### Who is Reed.co.uk Job Scraper for?

**🔍 UK job seekers** — Monitor new listings for your target role before they fill up. Set up scheduled runs to alert you when new "data engineer" jobs appear in London.

**📊 UK recruitment agencies** — Track candidate pipelines, monitor competitor job postings, and identify emerging skills demand across industries.

**💼 HR and talent teams** — Benchmark salaries across roles and locations. Understand what competitors are hiring for and what they're paying.

**📈 Market researchers and analysts** — Track employment trends, sector growth, and salary movements across the UK. Build datasets for workforce analytics reports.

**🤖 Developers and data engineers** — Feed job data into pipelines, dashboards, or AI tools. Use the API or MCP to integrate with your existing workflows.

### Why use Reed.co.uk Job Scraper?

- ✅ **300,000+ live UK job listings** — full coverage of the UK's #1 job board
- ✅ **Rich structured data** — salary ranges, employer details, categories, and more
- ✅ **Pure HTTP, no browser** — fast, lightweight, and cost-efficient
- ✅ **Paginated results** — scrape as many or as few jobs as you need (up to 5,000 per run)
- ✅ **Multiple filters** — keyword, location, distance, salary, job type, date posted, direct employer vs agency
- ✅ **Full job descriptions** — optional deep scraping for complete job text and skills
- ✅ **No login required** — works out of the box, no Reed account needed
- ✅ **Scheduled runs** — monitor new jobs daily, weekly, or hourly

### What data can you extract?

| Field | Description |
|-------|-------------|
| `jobId` | Unique Reed job ID |
| `jobUrl` | Direct URL to the job listing |
| `jobTitle` | Job title |
| `employerName` | Hiring company name |
| `employerId` | Reed employer ID |
| `locationName` | City or region |
| `county` | UK county |
| `minimumSalary` | Minimum salary (numeric, GBP) |
| `maximumSalary` | Maximum salary (numeric, GBP) |
| `salary` | Formatted salary string (e.g., "£45,000 - £55,000 per annum") |
| `salaryType` | Salary period (per annum, per day, per hour) |
| `currency` | Always GBP for Reed.co.uk |
| `jobType` | Contract type + schedule (e.g., "Permanent, Full-time") |
| `jobTypeCode` | Contract type code (Permanent, Contract, Temporary) |
| `date` | Date the job was posted |
| `expirationDate` | Date the listing expires |
| `description` | Short job description/snippet from search results |
| `fullDescription` | Full job description HTML (requires fetchJobDetails=true) |
| `category` | Reed job category (e.g., "Engineer") |
| `subCategory` | Reed sub-category (e.g., "Software Engineer") |
| `remoteWorking` | Remote working option (Remote, Hybrid, NotSpecified) |
| `isEasyApply` | Whether Easy Apply is enabled |
| `isPromoted` | Whether the listing is promoted |
| `scrapedAt` | ISO timestamp of when the data was extracted |

### How much does it cost to scrape Reed.co.uk jobs?

This actor uses **Pay-Per-Event** pricing — you only pay for results you get.

| Event | FREE plan | BRONZE | SILVER | GOLD |
|-------|-----------|--------|--------|------|
| Run started | $0.025 | $0.025 | $0.025 | $0.025 |
| Per job scraped | $0.002 | $0.0018 | $0.0014 | $0.00108 |

**Real-world cost examples:**

| Use case | Jobs | Approx. cost |
|----------|------|-------------|
| Quick search (10 jobs) | 10 | ~$0.045 |
| Standard batch (100 jobs) | 100 | ~$0.225 |
| Large research run (500 jobs) | 500 | ~$1.025 |
| Full sector scrape (1,000 jobs) | 1,000 | ~$2.025 |

**Free plan:** With Apify's $5 free credit, you can scrape approximately **2,400 jobs** on the free tier — enough to explore most UK job sectors.

### How to scrape Reed.co.uk jobs

1. **[Open Reed.co.uk Job Scraper](https://apify.com/automation-lab/reed-jobs-scraper)** on Apify Store
2. Click **Try for free**
3. Enter your **search keywords** (e.g., "software engineer", "nurse", "accountant")
4. Set your **location** (city or region, e.g., "London", "Manchester", "Edinburgh")
5. Optionally set **filters**: salary range, job type, date posted
6. Set **Max Results** to control how many jobs to extract
7. Click **Start** and wait for results (typically 1-3 minutes)
8. **Download results** as JSON, CSV, or Excel

**Example inputs for different use cases:**

Search for IT contract jobs in London:
```json
{
  "keywords": ["software engineer", "data engineer"],
  "locationName": "London",
  "distanceMiles": 10,
  "jobType": "contract",
  "salaryFrom": 400,
  "maxResults": 100
}
````

Monitor nursing vacancies in the North of England:

```json
{
  "keywords": ["nurse", "staff nurse", "senior nurse"],
  "locationName": "Manchester",
  "distanceMiles": 30,
  "maxResults": 200
}
```

Salary benchmarking for marketing roles:

```json
{
  "keywords": ["marketing manager"],
  "maxResults": 500,
  "fetchJobDetails": false
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `keywords` | array | `["software engineer"]` | Job search keywords. Each keyword performs a separate search. |
| `locationName` | string | (empty) | City, region, or postcode. Leave empty to search all of UK. |
| `distanceMiles` | integer | `10` | Search radius in miles from location. |
| `jobType` | string | (all) | Filter by type: `permanent`, `contract`, `temp`, `parttime`, `volunteer` |
| `salaryFrom` | integer | (none) | Minimum salary in GBP. |
| `salaryTo` | integer | (none) | Maximum salary in GBP. |
| `postedBy` | string | (all) | Filter by poster: `employer` (direct) or `recruiter` (agency) |
| `datePostedWithin` | integer | (any) | Only jobs posted within this many days. |
| `maxResults` | integer | `50` | Max jobs to return per keyword search (1–5,000). |
| `fetchJobDetails` | boolean | `false` | Fetch full HTML description from each job's detail page. Increases run time. |

### Output examples

**Standard job output (no detail fetching):**

```json
{
  "jobId": 56619262,
  "jobUrl": "https://www.reed.co.uk/jobs/software-developer/56619262",
  "jobTitle": "Software Developer",
  "employerName": "Quantock Talent Limited",
  "employerId": 110751,
  "locationName": "Reading",
  "county": "Berkshire",
  "minimumSalary": 40000,
  "maximumSalary": 40000,
  "salary": "£40,000 per annum",
  "salaryType": "per annum",
  "currency": "GBP",
  "jobType": "Permanent, Full-time",
  "jobTypeCode": "Permanent",
  "date": "2026-03-10T15:46:43.583Z",
  "expirationDate": "2026-04-21T23:59:59",
  "description": "Our Reading based client is seeking a Software Developer...",
  "fullDescription": "",
  "category": "Developer",
  "subCategory": "Software Developer",
  "remoteWorking": "Remote",
  "isEasyApply": true,
  "isPromoted": false,
  "keywords": "software engineer",
  "scrapedAt": "2026-04-03T10:00:00.000Z"
}
```

**With full details fetching (`fetchJobDetails: true`):**
The `fullDescription` field will contain the complete HTML job description with all requirements, responsibilities, and benefits.

### Tips for best results

- 🔍 **Use specific keywords** — "senior software engineer" returns more targeted results than "engineer"
- 📍 **Set a location with distance** — searching "London" with 15 miles covers Greater London well
- 💡 **Start small** — test with 20 results first to verify your search before running at scale
- 📅 **Use datePostedWithin** — set to 7 for fresh listings only, avoiding old jobs
- 💰 **Salary filters use GBP** — for day rate contractors, use smaller numbers (e.g., salaryFrom=300 for £300/day)
- ⚡ **Skip fetchJobDetails for speed** — the description field from search results is usually enough for most use cases
- 🔄 **Schedule daily runs** — set up a scheduled run to monitor new jobs automatically

### Integrations

**📊 Reed jobs → Google Sheets for salary benchmarking**
Export 500 marketing manager jobs to a spreadsheet, then use Sheets formulas to calculate average salary by region and contract type. Useful for salary review discussions.

**📬 Reed jobs → Slack/Telegram alerts for job monitoring**
Run a scheduled daily scrape for your target role + location. Use an Apify webhook to POST new listings to your Slack channel. Never miss a hot opening again.

**🔗 Reed jobs → Make/Zapier → CRM pipeline**
Use Make.com to trigger when new Reed jobs are scraped, filter by salary/keywords, and add matching contacts to your recruitment CRM automatically.

**📈 Reed jobs → Tableau/Power BI for workforce analytics**
Pull 2,000+ jobs per sector and feed into your BI tool to track hiring trends, in-demand skills, and regional salary differences over time.

**🤖 Reed jobs → OpenAI/Anthropic for skills gap analysis**
Pipe job descriptions into an LLM to extract required skills automatically, then aggregate to find the most in-demand technologies in your target sector.

### Using the Apify API

Run this actor programmatically using the Apify API:

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/reed-jobs-scraper').call({
  keywords: ['software engineer'],
  locationName: 'London',
  distanceMiles: 10,
  maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} jobs`);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/reed-jobs-scraper').call(run_input={
    'keywords': ['software engineer'],
    'locationName': 'London',
    'distanceMiles': 10,
    'maxResults': 100,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(f"{item['jobTitle']} at {item['employerName']} — {item['salary']}")
```

**cURL:**

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~reed-jobs-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": ["software engineer"],
    "locationName": "London",
    "maxResults": 100
  }'
```

### Use with AI agents via MCP

Reed.co.uk Job Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/reed-jobs-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

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

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/reed-jobs-scraper to find all senior data engineer jobs in London with salary above £70,000 posted in the last 7 days"
- "Scrape 200 nursing jobs in Manchester from Reed.co.uk and tell me which hospitals are hiring the most"
- "Get the top 100 software engineer contract roles on Reed.co.uk and extract the most commonly required skills from the descriptions"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to scrape Reed.co.uk?

Reed.co.uk job listings are publicly accessible to anyone without logging in. This actor collects only publicly available data in the same way a browser would when you visit the site.

Web scraping public data is generally legal when:

- You are not bypassing authentication or paywalls
- You are not storing personal data without a legal basis (GDPR)
- You are not reproducing content at scale in a competing product

This actor does not collect personal data (no CVs, no candidate profiles, no private employer information). All data extracted is from publicly visible job listings.

You are responsible for how you use the scraped data. Always comply with Reed.co.uk's Terms of Service, GDPR regulations, and applicable local laws. If you plan to use this data commercially, consult a legal advisor.

For general guidance on web scraping legality, see [Apify's blog on web scraping legality](https://apify.com/blog/is-web-scraping-legal).

### FAQ

**How fast does the scraper run?**
Typically 25 jobs per second for search-only mode (without fetchJobDetails). With full job detail fetching enabled, it slows to ~2 jobs per second due to the additional HTTP request per job. For 100 jobs in standard mode, expect under 30 seconds.

**How many jobs can I get on the free plan?**
Apify's free plan includes $5 in monthly credits. With per-job pricing at $0.002 on the FREE tier, plus the $0.025 run-started fee, you can scrape approximately **2,400 jobs** per month on the free plan.

**Why do some jobs have empty salary fields?**
Reed allows employers to mark salary as "Competitive" or "Negotiable" without disclosing a range. The `minimumSalary`/`maximumSalary` fields will be `null` for these listings, and the `salary` field will say "Competitive salary" or "Salary negotiable".

**Why are results empty or fewer than expected?**
This usually means: (1) your keyword has no matching jobs for the location — try a broader location or remove the location filter; (2) the `datePostedWithin` filter is too narrow; (3) salary filters exclude most listings. Start with no filters and add them gradually to narrow results.

**Does it work for all UK regions?**
Yes — Reed.co.uk covers the entire UK. Use city names ("London", "Manchester", "Edinburgh"), region names ("South West", "East Midlands"), or postcodes ("M1", "SW1"). Leave `locationName` empty to search nationwide.

**Can I scrape multiple job categories at once?**
Yes — use the `keywords` array to run multiple searches in a single run. Each keyword is searched separately and results are combined. Set `maxResults` high enough to accommodate all keywords.

**How often is Reed.co.uk updated?**
Reed updates listings continuously. New jobs appear within minutes of being posted. For near-real-time monitoring, schedule runs every few hours and filter by `datePostedWithin: 1`.

### Other job scraper tools

Looking for more job board scrapers? Check out these other automation-lab scrapers:

- 🔍 [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper) — Scrape job listings from Google Jobs search
- 🟢 [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) — Extract jobs from LinkedIn
- 📊 [Glassdoor Jobs Scraper](https://apify.com/automation-lab/glassdoor-jobs-scraper) — Scrape Glassdoor with salary insights
- 🦘 [Seek.com.au Job Scraper](https://apify.com/automation-lab/seek-scraper) — Australia's #1 job board
- 🌿 [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper) — Direct company job boards via Greenhouse ATS
- 🔵 [Indeed Scraper](https://apify.com/automation-lab/indeed-scraper) — Indeed job listings worldwide

# Actor input Schema

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

Enter job search keywords. Each keyword performs a separate search. Examples: "software engineer", "nurse", "data analyst", "marketing manager".

## `locationName` (type: `string`):

City, region, or postcode to search in. Examples: "London", "Manchester", "Birmingham", "Edinburgh", "M1". Leave empty to search across the UK.

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

Search radius in miles around the specified location. Only applies when a location is provided.

## `jobType` (type: `string`):

Filter by employment type. Leave empty to include all types.

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

Minimum salary in GBP. Leave empty to skip minimum salary filter. Example: 30000.

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

Maximum salary in GBP. Leave empty to skip maximum salary filter. Example: 60000.

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

Filter by who posted the job — direct employers or recruitment agencies.

## `datePostedWithin` (type: `integer`):

Only include jobs posted within this many days. Leave empty for all dates.

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

Maximum number of job listings to scrape per keyword. Reed shows 25 jobs per page.

## `fetchJobDetails` (type: `boolean`):

Visit each job's detail page to extract the full description, skills, and additional info. Increases run time and cost but returns much richer data.

## Actor input object example

```json
{
  "keywords": [
    "software engineer"
  ],
  "locationName": "London",
  "distanceMiles": 10,
  "jobType": "",
  "postedBy": "",
  "maxResults": 20,
  "fetchJobDetails": false
}
```

# Actor output Schema

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

No description

# 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": [
        "software engineer"
    ],
    "locationName": "London",
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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": ["software engineer"],
    "locationName": "London",
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/reed-jobs-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": [
    "software engineer"
  ],
  "locationName": "London",
  "maxResults": 20
}' |
apify call automation-lab/reed-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reed.co.uk Job Scraper",
        "description": "Extract job listings from Reed.co.uk — UK's #1 job board with 300,000+ vacancies. Search by keyword, location, salary, and contract type. Exports to JSON, CSV, or Excel.",
        "version": "0.1",
        "x-build-id": "Y5cud04Q4qVLj62pA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~reed-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-reed-jobs-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/automation-lab~reed-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-reed-jobs-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/automation-lab~reed-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-reed-jobs-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": "array",
                        "description": "Enter job search keywords. Each keyword performs a separate search. Examples: \"software engineer\", \"nurse\", \"data analyst\", \"marketing manager\".",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locationName": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "City, region, or postcode to search in. Examples: \"London\", \"Manchester\", \"Birmingham\", \"Edinburgh\", \"M1\". Leave empty to search across the UK."
                    },
                    "distanceMiles": {
                        "title": "📏 Distance (miles)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Search radius in miles around the specified location. Only applies when a location is provided.",
                        "default": 10
                    },
                    "jobType": {
                        "title": "💼 Job Type",
                        "enum": [
                            "",
                            "permanent",
                            "contract",
                            "temp",
                            "parttime",
                            "volunteer"
                        ],
                        "type": "string",
                        "description": "Filter by employment type. Leave empty to include all types.",
                        "default": ""
                    },
                    "salaryFrom": {
                        "title": "💷 Min Salary (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Minimum salary in GBP. Leave empty to skip minimum salary filter. Example: 30000."
                    },
                    "salaryTo": {
                        "title": "💷 Max Salary (£)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum salary in GBP. Leave empty to skip maximum salary filter. Example: 60000."
                    },
                    "postedBy": {
                        "title": "🏢 Posted By",
                        "enum": [
                            "",
                            "employer",
                            "recruiter"
                        ],
                        "type": "string",
                        "description": "Filter by who posted the job — direct employers or recruitment agencies.",
                        "default": ""
                    },
                    "datePostedWithin": {
                        "title": "📅 Date Posted",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Only include jobs posted within this many days. Leave empty for all dates."
                    },
                    "maxResults": {
                        "title": "📊 Max Results",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape per keyword. Reed shows 25 jobs per page.",
                        "default": 50
                    },
                    "fetchJobDetails": {
                        "title": "📄 Fetch Full Job Descriptions",
                        "type": "boolean",
                        "description": "Visit each job's detail page to extract the full description, skills, and additional info. Increases run time and cost but returns much richer data.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
