# NHS UK Scraper (`dromb/nhs-uk-scraper`) Actor

Scrapes NHS services, including GP, Dentist, and Pharmacy details.

- **URL**: https://apify.com/dromb/nhs-uk-scraper.md
- **Developed by:** [Dmitriy Gyrbu](https://apify.com/dromb) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

## NHS UK Scraper 🏥

Extract comprehensive data from NHS UK services including GP surgeries, dental practices, and pharmacies. Get detailed information such as names, categories, addresses, phone numbers, URLs, distances, and more. Perfect for healthcare directories, location-based services, and market research.

### Features

- **Multiple Service Types**: Access data for GPs, dentists, and pharmacies across England
- **Location-Based Search**: Find services by town, city, or postcode
- **Advanced Filtering**: Apply specific filters to narrow down results (e.g., accepting new patients)
- **Detailed Profiles**: Extract comprehensive service information including contact details, opening hours, and facilities
- **Pagination Support**: Efficiently retrieve large datasets with configurable page and limit parameters
- **Structured Output**: Clean, standardized data format ready for integration

### Use Cases

- **Healthcare Directories**: Build comprehensive local healthcare service databases
- **Location-Based Services**: Enable users to find nearby medical services
- **Market Research**: Analyze healthcare service distribution and availability
- **Contact Management**: Build databases for healthcare outreach campaigns
- **Service Availability**: Check service status and acceptance policies

### Operations

#### 🔍 search
Search for services near a location with optional filters.
```json
{
  "operation": "search",
  "category": "gp",
  "location": "London",
  "filters": ["GpAcceptingNewPatients"],
  "limit": 24
}
````

#### 📋 categories

List all supported service categories available for scraping.

```json
{
  "operation": "categories"
}
```

#### 🎯 search\_filters

Get available filter tokens for a specific category to refine your search.

```json
{
  "operation": "search_filters",
  "category": "gp"
}
```

#### 📄 item

Fetch detailed service profile including full contact information, opening hours, facilities, and additional metadata.

```json
{
  "operation": "item",
  "url": "https://www.nhs.uk/services/..."
}
```

#### 🏷️ category

Alias for the search operation - provides the same functionality.

```json
{
  "operation": "category",
  "category": "dentist",
  "location": "Manchester"
}
```

#### 💓 probe

Health check for the NHS site. Returns build and data version information.

```json
{
  "operation": "probe"
}
```

### Input Parameters

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| operation | string | Yes | Operation to perform: `probe`, `categories`, `search_filters`, `search`, `category`, `item` |
| category | string | No | Service category: `gp`, `dentist`, `pharmacy` |
| location | string | No | Town, city, or postcode in England |
| filters | array | No | List of filter tokens (e.g., `GpAcceptingNewPatients`) |
| url | string | No | Full URL for item operation |
| slug | string | No | Slug identifier for item operation |
| page | integer | No | Page number for pagination (default: 1) |
| limit | integer | No | Number of results per page (default: 24) |

### Output Fields

Each result includes:

- **id**: Unique service identifier
- **name**: Service name
- **category**: Service type (GP, Dentist, Pharmacy)
- **address**: Full address
- **phone**: Contact phone number
- **url**: Service profile URL
- **distance\_miles**: Distance from search location
- **source**: Data source information

### Getting Started

1. **Basic Search** - Find GPs in London:
   ```json
   {
     "operation": "search",
     "category": "gp",
     "location": "London"
   }
   ```

2. **With Filters** - Find dentists accepting new patients:
   ```json
   {
     "operation": "search",
     "category": "dentist",
     "location": "Manchester",
     "filters": ["DentistAcceptingNewPatients"]
   }
   ```

3. **Detailed Profile** - Get full service information:
   ```json
   {
     "operation": "item",
     "url": "https://www.nhs.uk/services/gps/..."
   }
   ```

### Data Source

Data is sourced from the official NHS UK website (nhs.uk), ensuring accurate and up-to-date information about healthcare services across England.

### Support

For issues or questions, please contact the actor maintainer or refer to the Apify documentation.

# Actor input Schema

## `operation` (type: `string`):

Select the operation to perform: search for services, list categories, get filters, or fetch detailed profiles.

## `category` (type: `string`):

Service category to search: 'gp' for GP surgeries, 'dentist' for dental practices, 'pharmacy' for pharmacies.

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

Search location: enter a town name, city, or postcode in England (e.g., 'London', 'Manchester', 'SW1A1AA').

## `filters` (type: `array`):

Optional filters to refine results (e.g., 'GpAcceptingNewPatients', 'DentistAcceptingNewPatients'). Use search\_filters operation to get available tokens.

## `url` (type: `string`):

Full NHS service profile URL to fetch detailed information (required for item operation).

## `slug` (type: `string`):

Service slug identifier as an alternative to URL for item operation.

## `page` (type: `integer`):

Page number for pagination - use to navigate through large result sets.

## `limit` (type: `integer`):

Maximum number of results to return per page (default: 24, max: 100).

## Actor input object example

```json
{
  "operation": "search",
  "page": 1,
  "limit": 24
}
```

# Actor output Schema

## `results` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("dromb/nhs-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("dromb/nhs-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 '{}' |
apify call dromb/nhs-uk-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NHS UK Scraper",
        "description": "Scrapes NHS services, including GP, Dentist, and Pharmacy details.",
        "version": "0.1",
        "x-build-id": "AqH4vXmGY7RfNQ0dx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dromb~nhs-uk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dromb-nhs-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/dromb~nhs-uk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-dromb-nhs-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/dromb~nhs-uk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-dromb-nhs-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",
                "required": [
                    "operation"
                ],
                "properties": {
                    "operation": {
                        "title": "Operation",
                        "enum": [
                            "probe",
                            "categories",
                            "search_filters",
                            "search",
                            "category",
                            "item"
                        ],
                        "type": "string",
                        "description": "Select the operation to perform: search for services, list categories, get filters, or fetch detailed profiles.",
                        "default": "search"
                    },
                    "category": {
                        "title": "Service Category",
                        "type": "string",
                        "description": "Service category to search: 'gp' for GP surgeries, 'dentist' for dental practices, 'pharmacy' for pharmacies."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Search location: enter a town name, city, or postcode in England (e.g., 'London', 'Manchester', 'SW1A1AA')."
                    },
                    "filters": {
                        "title": "Filters",
                        "type": "array",
                        "description": "Optional filters to refine results (e.g., 'GpAcceptingNewPatients', 'DentistAcceptingNewPatients'). Use search_filters operation to get available tokens.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "url": {
                        "title": "Service URL",
                        "type": "string",
                        "description": "Full NHS service profile URL to fetch detailed information (required for item operation)."
                    },
                    "slug": {
                        "title": "Service Slug",
                        "type": "string",
                        "description": "Service slug identifier as an alternative to URL for item operation."
                    },
                    "page": {
                        "title": "Page Number",
                        "type": "integer",
                        "description": "Page number for pagination - use to navigate through large result sets.",
                        "default": 1
                    },
                    "limit": {
                        "title": "Results Limit",
                        "type": "integer",
                        "description": "Maximum number of results to return per page (default: 24, max: 100).",
                        "default": 24
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
