# UK Planning Applications Scraper & Intelligence API (`interactapps/uk-planning-applications-scraper`) Actor

Track UK planning applications across 24 verified council portals. Filter by work type, date and decision status. Clean JSON with postcode, lead type and residential flags. Monitor mode returns only new applications — and charges only for those. For builders, developers and AI agents.

- **URL**: https://apify.com/interactapps/uk-planning-applications-scraper.md
- **Developed by:** [Nina Mackie](https://apify.com/interactapps) (community)
- **Categories:** Lead generation, Real estate, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $80.00 / 1,000 application delivereds

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## UK Planning Applications Scraper & Intelligence API

Track planning applications across 24 UK council portals as clean, consistent JSON. Filter by work type, date and decision status, and get only what's new since your last run. Built for builders, architects, developers, suppliers and AI agents.

*Every council listed below was verified against its live portal on 28 July 2026. Coverage claims here are measured, not estimated.*

### Five-minute quick start

1. Click **Try for free**.
2. The default input is pre-filled with Leeds, Bradford and York — just press **Start**.
3. Within a couple of minutes you'll have live applications in the dataset tab, exportable as JSON, CSV or Excel.

No API keys, no council registrations, no scraping to maintain yourself.

### Why not just use the free government data?

The official register at `planning.data.gov.uk` is genuinely open and well structured, and for most lead-generation purposes it is unusable. As of July 2026 its most recent planning application entry dates from **September 2025**, and it covers roughly **four** local authorities.

This actor reads council portals directly, so records appear the same day they are validated.

### Verified coverage — 24 councils

| Region | Councils |
| --- | --- |
| Yorkshire | Leeds, Bradford, York, Wakefield, Hull |
| North East | Northumberland, Durham, North Tyneside, Gateshead |
| North West | Cheshire West and Chester, Bury, Knowsley |
| London | Brent, Ealing, Lambeth, Greenwich, Tower Hamlets |
| Scotland | Glasgow |
| South West | Plymouth, North Somerset |
| South East | Adur & Worthing |
| East | Thurrock, Southend-on-Sea |
| West Midlands | Solihull |

**Measured volume: 3,866 applications in 30 days** across these councils.

Highest volume: Leeds (500/month), Bradford (433), Northumberland (350), Cheshire West (236), Ealing (227), Glasgow (210), York (187), Lambeth (181).

### Presets

Ordered by measured volume, not guesswork.

| Preset | Applications/month | Typical buyer |
| --- | --- | --- |
| Extensions & loft conversions | ~1,185 | Builders, architects |
| Tree works & TPO | ~545 | Tree surgeons, arborists |
| New builds & developments | ~256 | Developers, materials suppliers |
| Commercial conversions | ~182 | Fit-out contractors |
| Renewables & retrofit | ~149 | Solar and heat pump installers |
| Approved applications only | — | Anyone wanting decided, not pending |
| Daily monitor | — | Change-only tracking |

### Output

One record per application. Every documented field is always present, null when unavailable.

```json
{
  "council": "Gateshead Council",
  "council_id": "gateshead",
  "region": "North East",
  "reference": "DC/26/00586/GPDE",
  "description": "Single storey rear extension measuring 5m long by 4.5m wide",
  "address": "12 Example Road, Chester-le-Street",
  "postcode": "DH3 1BB",
  "received_date": "2026-07-23",
  "validated_date": "2026-07-23",
  "decision_date": null,
  "status": "Registered",
  "decision": null,
  "lead_type": "extension",
  "is_residential": true,
  "is_decided": false,
  "detail_url": "https://public.gateshead.gov.uk/online-applications/applicationDetails.do?keyVal=...",
  "_first_seen": "2026-07-28T09:12:44.000Z",
  "_last_seen": "2026-07-28T09:12:44.000Z",
  "_record_hash": "a41f..."
}
```

Field completeness measured across 3,866 live records: reference **100%**, address **100%**, detail link **100%**, validated date **98%**, postcode **90%**.

#### Enrichment (included, no extra charge)

- **lead\_type** — extension, loft\_conversion, new\_build, tree\_works, solar, heat\_pump, insulation, ev\_charging, change\_of\_use, demolition, advertisement.
- **postcode** — extracted from the site address so you can filter by travel radius.
- **is\_residential** — separates household work from commercial schemes.
- **is\_decided** — whether the application has been determined.
- **\_first\_seen / \_last\_seen** — how long an application has been tracked across your runs.

### Monitor mode (recommended)

Select **Daily monitor**, or set `onlyNew: true`, and schedule the actor daily.

The actor remembers every application it has delivered to you and returns only new ones, or ones whose status or decision has changed. **You are charged only for what is returned** — on a quiet day the run costs you nothing.

This is the difference between buying a list once and having a pipeline.

### Use it from anywhere

**Python**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("InteractApps/uk-planning-applications-scraper").call(
    run_input={"preset": "extensions_and_lofts",
               "councils": ["leeds", "bradford", "york"],
               "daysBack": 7})
for app in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(app["council"], app["postcode"], app["description"])
```

**AI agent prompt**

```
Run uk-planning-applications-scraper with preset="extensions_and_lofts",
councils=["leeds"], onlyNew=true. Summarise new extension applications
by postcode district and flag any over 100 sqm.
```

### Honest limitations

- **24 councils, not national.** There are roughly 400 planning authorities in the UK. The councils above are the ones verified working. Manchester, Birmingham, Liverpool and Camden run Northgate PlanningExplorer, a different system this actor does not yet read.
- **These are planning applications, not warm leads.** An application tells you a specific property is having specific work done, with an address and a date. It does not include the homeowner's phone number, and nobody has asked to be contacted. Outreach is your job.
- **Southend-on-Sea** does not publish dates in its results list, so date fields are null for that council.
- **Agent and applicant names** are not included; they sit on each application's detail page, which this version does not fetch.
- **Public data only.** No logins, no personal data of private individuals beyond what councils publish on the statutory register.

### Pricing and support

**$0.08 per application delivered.** Platform usage is included — there is no second bill.

You are charged only for applications actually returned. Failed councils, empty result sets and applications filtered out by monitor mode all cost nothing, and `maxResults` is a hard ceiling so a run can never bill beyond your cap.

For scale: a builder monitoring three councils for extensions pays roughly **$13/month**. A single shared lead on a trade platform costs £15–60.

Support: message via the Issues tab — responses within 24 hours on weekdays.

***

*Changelog — v0.1 (28 July 2026): first release. 24 councils verified live; unreachable and Northgate portals excluded rather than listed optimistically.*

# Actor input Schema

## `preset` (type: `string`):

One-click configurations. A preset fills sensible defaults; anything you set explicitly still wins.

## `councils` (type: `array`):

Council IDs to search, or leave empty for all covered councils. See the README for the verified coverage list.

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

Search application descriptions for these terms, e.g. \["solar", "heat pump"]. Each term is a separate search. Leave empty to return everything in the date window.

## `daysBack` (type: `integer`):

How far back to search from today. Ignored if you set explicit dates.

## `dateFrom` (type: `string`):

ISO date (YYYY-MM-DD). Overrides 'days back'.

## `dateTo` (type: `string`):

ISO date (YYYY-MM-DD). Defaults to today.

## `decidedOnly` (type: `boolean`):

Returns applications decided in the window rather than submitted in it. An approved application is a hotter lead than a new submission.

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

Hard cap on charged results across all councils and keywords.

## `onlyNew` (type: `boolean`):

Compares against your previous runs and returns only new applications, or ones whose status or decision changed. You are charged only for those. Ideal for a daily schedule.

## `enrich` (type: `boolean`):

Adds derived fields: postcode, lead type, residential/commercial, decided flag. No extra charge.

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

Proxy settings.

## Actor input object example

```json
{
  "preset": "none",
  "councils": [
    "leeds",
    "bradford",
    "york"
  ],
  "daysBack": 30,
  "decidedOnly": false,
  "maxResults": 100,
  "onlyNew": false,
  "enrich": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `applications` (type: `string`):

One record per planning application, including council, reference, description, site address, postcode, lead type, status, validation and decision dates, and a link to the application on the council portal.

# 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 = {
    "councils": [
        "leeds",
        "bradford",
        "york"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("interactapps/uk-planning-applications-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 = { "councils": [
        "leeds",
        "bradford",
        "york",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("interactapps/uk-planning-applications-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 '{
  "councils": [
    "leeds",
    "bradford",
    "york"
  ]
}' |
apify call interactapps/uk-planning-applications-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/i83btipQY2fsoMeL1/builds/pLWJkk5uUjRXu8S7M/openapi.json