# NHS Jobs Scraper - UK Healthcare Vacancies (`studio-amba/nhs-jobs-scraper`) Actor

Scrape job listings from jobs.nhs.uk, the official NHS England jobs site. Search by keyword and location, extract job titles, employers, salary bands, contract types, and closing dates. No login or cookies required.

- **URL**: https://apify.com/studio-amba/nhs-jobs-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

### What does NHS Jobs Scraper do?

**NHS Jobs Scraper** extracts job listings from [jobs.nhs.uk](https://www.jobs.nhs.uk), the official NHS England recruitment site with thousands of live healthcare vacancies. Give it a keyword and (optionally) a location, and it returns structured data for every matching job: title, employer (NHS trust, GP practice, or other organisation), salary band, contract type, working pattern, posting date, closing date, and a direct link to the advert. It reads the site's own server-rendered search pages, so there is no login, no cookies, and no browser automation required.

Run it on the Apify platform to get UK healthcare job market data via API, schedule recurring scrapes, and pipe results into tools like Zapier, Make, Google Sheets, Airtable, and Slack.

### How to scrape NHS Jobs data

1. Go to the NHS Jobs Scraper on the Apify Store.
2. Click **Try for free** to open the actor in the Apify Console.
3. Enter a search query (e.g. "nurse", "midwife", "paramedic", "radiographer", "administrator").
4. Optionally enter a UK location (e.g. "London", "Manchester", "Leeds") and a distance in miles. Leave both empty to search all of England and Wales.
5. Set the maximum number of results you want (default: 50).
6. Leave the proxy configuration on GB residential (the default) for the most reliable results.
7. Click **Start** and wait for the run to finish.
8. Download your data as JSON, CSV, Excel, or HTML from the Output tab, or pull it via the Apify API.

### Why use NHS Jobs Scraper?

- **Healthcare salary benchmarking** — NHS adverts almost always show a salary band (Agenda for Change bands or a stated range), so you can compare pay across roles, trusts, and regions.
- **Recruitment intelligence** — see which trusts, practices, and care providers are hiring, for what roles, and where. Spot staffing pressure before it makes the news.
- **Workforce and policy research** — clean, structured data for studies on NHS staffing, vacancy rates, and regional shortages.
- **Lead generation** — find NHS organisations actively hiring to target with staffing, training, or workforce software services.
- **Job aggregation** — feed structured NHS listings into your own healthcare job board, career site, or candidate-alert system.
- **Relocation and career planning** — track vacancies for a specific role across the country, including salary and contract details.

### About jobs.nhs.uk

NHS Jobs is the official recruitment service for the National Health Service in England and Wales, run by the NHS Business Services Authority. It is the primary channel through which NHS trusts, GP practices, and related organisations advertise vacancies. Key characteristics:

- **Coverage**: England and Wales, from large London teaching hospitals to rural GP practices.
- **Roles**: Clinical (nursing, medical, midwifery, allied health) and non-clinical (administration, estates, IT, management).
- **Salary data**: Most adverts show a salary band or range (e.g. "£32,073 to £39,043 a year"); some GP practice roles show "Depends on experience".
- **Contract types**: Permanent, fixed term, bank, apprenticeship, and secondment positions, full and part time.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | string | No | Job keyword to search for. Defaults to `nurse` if empty. |
| `location` | string | No | UK postcode, town, or city (e.g. `London`). Leave empty to search everywhere. |
| `distance` | integer | No | Search radius in miles around the location (5, 10, 20, 30, 50, or 100). |
| `maxResults` | integer | No | Maximum number of listings to scrape. Default `50`. |
| `proxyConfiguration` | object | No | Apify proxy settings. Defaults to GB residential. |

#### Example input

```json
{
  "searchQuery": "nurse",
  "location": "London",
  "distance": 20,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "GB"
  }
}
````

### Output

Each job listing is a flat JSON object with the following fields:

| Field | Type | Example |
|-------|------|---------|
| `jobReference` | string | `C9262-26-1074` |
| `jobTitle` | string | `Community Nurse - Night Nurse` |
| `employer` | string | `North Cumbria Integrated Care NHS Foundation Trust` |
| `location` | string | `Carlisle CA1 3TP` |
| `salary` | string | `£32,073 to £39,043 a year` |
| `contractType` | string | `Permanent` |
| `workingPattern` | string | `Part time` |
| `postedDate` | string | `2026-07-08` |
| `closingDate` | string | `2026-07-26` |
| `url` | string | `https://www.jobs.nhs.uk/candidate/jobadvert/C9262-26-1074` |
| `scrapedAt` | string | `2026-07-10T09:12:54.779Z` |

#### Example output

```json
{
  "jobReference": "C9262-26-1074",
  "jobTitle": "Community Nurse - Night Nurse",
  "employer": "North Cumbria Integrated Care NHS Foundation Trust",
  "location": "Carlisle CA1 3TP",
  "salary": "£32,073 to £39,043 a year",
  "contractType": "Permanent",
  "workingPattern": "Part time",
  "postedDate": "2026-07-08",
  "closingDate": "2026-07-26",
  "url": "https://www.jobs.nhs.uk/candidate/jobadvert/C9262-26-1074",
  "scrapedAt": "2026-07-10T09:12:54.779Z"
}
```

### Cost estimate

This actor is billed on Apify's Pay Per Result model. The site returns 10 jobs per results page and pages load fast, so a typical run of a few hundred listings finishes in under a minute of compute. You pay per job returned plus a small per-run start fee. Check the actor's pricing tab for the exact current rate.

### Limitations and known issues

- **Search results only** — the actor reads the listing data shown on the search pages (title, employer, location, salary, contract type, working pattern, dates, links). It does not open each advert to pull the full job description body.
- **Salary as advertised** — most NHS listings show a band or range; some (mainly GP practice roles) show "Depends on experience", which is returned as-is in the `salary` field.
- **England and Wales** — jobs.nhs.uk covers NHS England and Wales. Scotland (jobs.scot.nhs.uk) and Northern Ireland use separate systems that this actor does not cover.
- **10 results per page** — the site paginates in fixed pages of 10, so very large `maxResults` values will walk many pages. Keep `maxResults` reasonable for the query you actually need.
- **Date parsing** — the site shows dates like "8 July 2026"; the actor converts them to ISO format (`2026-07-08`). If the site ever changes its date format, the raw text is returned instead.

### Related scrapers

- **Reed Scraper** — the UK's largest general job board, with salary ranges and sectors.
- **IrishJobs Scraper** — Ireland's leading job board, including healthcare roles.
- Browse the Studio AMBA profile on the Apify Store for more European job and marketplace scrapers.

### FAQ

**Do I need an NHS Jobs account or API key?**
No. This actor reads the public search results. There is no login, no cookies, and no API key required.

**Can I filter by salary band, contract type, or employer?**
The current version filters by keyword, location, and distance. Salary, contract type, working pattern, and employer are returned on every result so you can filter them yourself after scraping.

**Does it include Scotland and Northern Ireland?**
No. jobs.nhs.uk covers England and Wales. Scottish and Northern Irish health service vacancies are advertised on separate national systems.

**Is scraping NHS Jobs legal?**
This actor collects publicly available job listing data. You are responsible for using the data in line with the site's terms and applicable law. Do not use it to send unsolicited communications in breach of regulations.

# Actor input Schema

## `searchQuery` (type: `string`):

Job keyword to search for (e.g. 'nurse', 'midwife', 'paramedic', 'radiographer', 'administrator'). Defaults to 'nurse' if empty.

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

UK location to filter by -- a postcode, town, or city (e.g. 'London', 'Manchester', 'Leeds'). Leave empty to search all of England and Wales.

## `distance` (type: `integer`):

Search radius in miles around the location. Only used when a location is set. NHS Jobs accepts 5, 10, 20, 30, 50, or 100.

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

Maximum number of job listings to scrape.

## `proxyConfiguration` (type: `object`):

Proxy settings. jobs.nhs.uk is a UK government site -- GB residential proxies are recommended.

## Actor input object example

```json
{
  "searchQuery": "nurse",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}
```

# 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 = {
    "searchQuery": "nurse",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "GB"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/nhs-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 = {
    "searchQuery": "nurse",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "GB",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/nhs-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 '{
  "searchQuery": "nurse",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "GB"
  }
}' |
apify call studio-amba/nhs-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHS Jobs Scraper - UK Healthcare Vacancies",
        "description": "Scrape job listings from jobs.nhs.uk, the official NHS England jobs site. Search by keyword and location, extract job titles, employers, salary bands, contract types, and closing dates. No login or cookies required.",
        "version": "0.1",
        "x-build-id": "WxHd213bOYCPFsXQl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/studio-amba~nhs-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-studio-amba-nhs-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/studio-amba~nhs-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-studio-amba-nhs-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/studio-amba~nhs-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-studio-amba-nhs-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": {
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Job keyword to search for (e.g. 'nurse', 'midwife', 'paramedic', 'radiographer', 'administrator'). Defaults to 'nurse' if empty."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "UK location to filter by -- a postcode, town, or city (e.g. 'London', 'Manchester', 'Leeds'). Leave empty to search all of England and Wales."
                    },
                    "distance": {
                        "title": "Distance (miles)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Search radius in miles around the location. Only used when a location is set. NHS Jobs accepts 5, 10, 20, 30, 50, or 100."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to scrape.",
                        "default": 50
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. jobs.nhs.uk is a UK government site -- GB residential proxies are recommended."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
