# UK Planning Applications Scraper & Alerts (`komos_solutions/uk-planning-applications`) Actor

New and decided UK planning applications and planning permission decisions from 400+ councils: reference, address, postcode, description, status, decision, dates, lat/lng. Daily alerts.

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

## Pricing

from $8.00 / 1,000 planning applications

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

### What is UK Planning Applications Scraper & Alerts?

**UK Planning Applications Scraper & Alerts** gets **new and decided UK planning applications and planning permission decisions from 400+ council planning registers** as clean, flat rows. Filter by **council, postcode + radius, keyword, decision status, application type or size**, and switch on **daily planning alerts** that return only applications you haven't seen before.

Try it now: click **Start** with the default input to get the 10 most recent planning applications from across the UK in a few seconds.

- 🏗️ **400+ local planning authorities** in England, Scotland, Wales and Northern Ireland in one search, via [UK PlanIt](https://www.planit.org.uk)
- 🔔 **Alert mode** (`onlyNew`): schedule it daily and get only new applications, by email, Slack, Google Sheets or webhook
- 📍 **Postcode radius search** and lat/lng on most rows, ready for maps
- 🔒 **No personal names**: applicant, agent and case-officer names are never collected
- ⚙️ Runs on the Apify platform: API, scheduling, integrations, monitoring, no servers

### What data can you get from UK planning applications?

One row = one planning application.

| Field | Example |
|---|---|
| `council` | Aberdeenshire |
| `reference` | APP/2026/1743 |
| `address` | Steading At Hallhead Mains Craigievar Alford AB33 8LR |
| `postcode` | AB33 8LR |
| `ward` / `parish` | Huntly, Strathbogie And Howe Of Alford / Donside |
| `description` | Installation Of Cast Iron Wall Vents |
| `applicationType` / `appType` | Listed Building Consent / Heritage |
| `appSize` | Small, Medium or Large |
| `status` / `appState` / `decision` | Awaiting decision / Undecided / null |
| `receivedDate`, `validatedDate`, `consultationEndDate`, `targetDecisionDate`, `decidedDate` | 2026-10-16 … 2026-12-15 |
| `nDwellings`, `nDocuments`, `nComments` | null, 4, 0 |
| `applicantCompany`, `agentCompany` | only when clearly a business, otherwise null |
| `lat`, `lng` | 57.17027, -2.787002 |
| `councilUrl`, `documentsUrl`, `commentUrl`, `planitUrl` | links to the council register and PlanIt |

Download results as JSON, CSV, Excel, XML or HTML, or read them via the Apify API.

### Who uses UK planning data?

- 🔨 **Builders, contractors and trades**: find new extensions, conversions and new-build schemes in your area before the work goes out to quote
- ☀️ **Solar, heat-pump and EV-charger installers**: track applications mentioning `solar`, `heat pump` or `battery`
- 📐 **Architects, planning consultants and surveyors**: monitor decisions and refusals for a council or postcode
- 🏠 **Estate agents, land promoters and developers**: spot `change of use`, `dwellings` and large schemes early (`appSize = Large`)
- 🏘️ **Residents, campaigners and local journalists**: get a daily list of new applications near a postcode
- 📊 **Analysts and proptech**: build datasets of planning permission decisions by council, type and date

### How to scrape UK planning applications

1. Click **Try for free** / **Start** with the default input to see a sample.
2. Set **Council / planning area** (e.g. `Leeds`, `Cornwall`, `London`, `Scotland`) or a **postcode** plus **radius (km)**. Leave both empty for the whole UK.
3. Optionally add **keywords** (e.g. `solar`, `"change of use"`, `demolition`) and filter by **decision status**, **application type** or **development size**.
4. Set **Max results** to cap cost, then click **Start**.
5. Export the dataset, or connect it to Google Sheets, Slack, email, Zapier, Make, n8n or a webhook.

#### Example input

```json
{
  "area": "Leeds",
  "daysBack": 7,
  "keywords": ["solar", "heat pump"],
  "status": "all",
  "maxItems": 100
}
```

### Daily planning alerts (only new applications)

Set **Alert mode: only new applications** (`onlyNew = true`). The Actor remembers returned applications in a named key-value store (`stateStoreName`) and on the next run outputs only applications it hasn't returned before, so you pay only for new rows. Use a different store name per saved search.

1. Run once with your filters and `onlyNew: true`, then **Save as a new task**.
2. **Schedules → Create new**, e.g. `0 7 * * *` (07:00, Europe/London), and add the task.
3. Add an **Integration** (email, Slack, Google Sheets via Zapier/Make/n8n, or a webhook) on *Run succeeded*.

Councils publish once a day, so daily is plenty.

### How much does it cost to get UK planning applications?

Pay per result: **$8 per 1,000 planning applications** ($0.008 per row, plus a tiny $0.00005 Actor start fee). No platform usage charges on top. `maxItems` caps every run.

| Example | Rows | Cost |
|---|---|---|
| Default input (sample) | 10 | ~$0.08 |
| One council's week, e.g. 100 applications | 100 | $0.80 |
| Daily alert averaging 20 new applications a day | ~600 / month | ~$4.80 / month |

### Speed and limits

Up to 300 applications come back in a few seconds. To respect the data source's fair-use limits, the Actor pauses ~60 seconds between each further batch of 300 (max 1,500 per run). Use alert mode or narrower filters rather than very large runs.

### FAQ

#### Which councils are covered?

Coverage follows UK PlanIt, which aggregates 400+ council planning registers across the UK. Coverage and freshness depend on each council's register; some are occasionally stale or missing.

#### Does it include applicant names or addresses?

No. Applicant, agent and case-officer names are never collected, and company fields that look like private individuals are removed. Only the site address of the application is included, as published on the public register.

#### Why do some rows have no location?

About 9% of applications have no coordinates; some locations are postcode centroids.

#### What do the status values mean?

`status` and `decision` are the council's own wording, which varies. `appState` is a normalised version: Undecided, Permitted, Conditions, Rejected, Withdrawn, Referred, Unresolved or Other.

#### Can I use this with the API, Python or an AI agent?

Yes. Every run is available through the Apify API and clients (Python, JavaScript) and through the Apify MCP server for AI agents.

#### Is it legal to scrape planning applications?

Planning registers are public by law. If you contact anyone using this data, comply with UK GDPR and PECR. Plans and drawings linked from council sites are protected by copyright (CDPA 1988 s.47): view them there, don't republish. Not affiliated with UK PlanIt or any council. Data courtesy of UK PlanIt (planit.org.uk); please consider supporting it.

### Related UK data Actors by Komos Solutions

- 🏛️ [UK Government Tenders & Contracts Scraper](https://apify.com/komos_solutions/uk-contracts-finder-tenders): public-sector tenders and contract awards from Contracts Finder, with daily tender alerts.
- 🌐 [UK Company Website Enricher](https://apify.com/komos_solutions/uk-company-website-enricher): emails, phones, Companies House number and VAT number from a list of company websites.

More UK data tools: [komossolutions.com/data-tools](https://www.komossolutions.com/data-tools/). Questions or a council missing? Open an issue on the **Issues** tab.

# Actor input Schema

## `area` (type: `string`):

Planning authority name as used by PlanIt, e.g. Leeds, Wiltshire, Cornwall, or a region such as London or Scotland. Empty = all of the UK.

## `postcode` (type: `string`):

Search around this UK postcode instead of / within an area. Use with radius.

## `radiusKm` (type: `number`):

Used only with a postcode.

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

Applications whose start (received/validated) date is within this many days. Ignored if a start date is given.

## `startDate` (type: `string`):

YYYY-MM-DD. Overrides daysBack.

## `endDate` (type: `string`):

YYYY-MM-DD.

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

Any of these words/phrases in the description, e.g. solar, "change of use", demolition, dwellings.

## `status` (type: `string`):

Normalised decision state.

## `appType` (type: `string`):

Normalised application type.

## `appSize` (type: `string`):

Large = 40+ dwellings or 100+ documents; Medium = 10+ dwellings or major application.

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

Only output applications not returned by previous runs using the same state store. Ideal for daily schedules.

## `stateStoreName` (type: `string`):

Named key-value store remembering seen applications. Use one per saved search.

## `maxItems` (type: `integer`):

You pay per result. Up to 300 results are fetched per request; larger runs take ~1 minute per extra 300 to respect the data source's rate limits.

## Actor input object example

```json
{
  "area": "",
  "radiusKm": 2,
  "daysBack": 14,
  "keywords": [],
  "status": "all",
  "appType": "all",
  "appSize": "all",
  "onlyNew": false,
  "stateStoreName": "uk-planning-seen",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (type: `string`):

All results (one billable item each), overview view.

# 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 = {
    "area": "",
    "daysBack": 14,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("komos_solutions/uk-planning-applications").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 = {
    "area": "",
    "daysBack": 14,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("komos_solutions/uk-planning-applications").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "area": "",
  "daysBack": 14,
  "maxItems": 10
}' |
apify call komos_solutions/uk-planning-applications --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,komos_solutions/uk-planning-applications"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ztAqTl5Hk8bslggpf/builds/Vh1HAlXuMT5sszwyG/openapi.json