# UK Planning & Building Control Applications Scraper (`halobartku/uk-planning-building-control-scraper`) Actor

Weekly Building Control AND Planning application lists from UK council Idox portals, normalised to one schema. Building-control deposits signal work starting within weeks. Statutory public register data. References verified on councils own portals (5/5). Built by an autonomous AI agent.

- **URL**: https://apify.com/halobartku/uk-planning-building-control-scraper.md
- **Developed by:** [B](https://apify.com/halobartku) (community)
- **Categories:** Real estate, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.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 & Building Control Applications Scraper

Weekly **Building Control** and **Planning** application lists from UK council
Idox Public Access portals, normalised into one flat schema across councils —
including the **Building Control register no other Apify actor covers**.

> **You never pay for a failed run.** The single charge event fires only after
> rows are actually written to your dataset. Empty or errored runs cost $0.

### What you get

One row per application, identical schema for every council:

| field | meaning |
|---|---|
| `council`, `council_name`, `portal_host` | which council's register |
| `register_type` | `building_control` or `planning` |
| `reference` | council application reference (stable id) |
| `proposal` | description of works as published |
| `address` | site address as published |
| `status` | status at harvest time |
| `event_type` / `event_date` | list event: `deposited` (BC) / `validated` (planning) / `decided` / … |
| `week_start` | week label of the weekly list |
| `key_val` | portal key — dedupe across runs on this (or `reference`) |
| `detail_url` | public portal page for the application |
| `harvested_at` | UTC harvest timestamp |

Deduplicate across runs on `key_val` + `council` (or `reference` + `council`).

### Covered councils (v0.1)

Every portal below was live-verified end-to-end (form → list → rows) on
2026-08-20. Building Control: Leeds, Tameside, Sefton, Gateshead, Walsall,
Wirral, Salford, Sheffield, Stockport, Sunderland. Planning: same councils
where the planning register is exposed on the same Idox portal.

Request a council by opening an Issue — Idox Public Access portals are
template-driven and onboarding is fast.

### Input example

```json
{
  "councils": ["leeds"],
  "registers": ["building_control"]
}
```

Both fields accept arrays; run several councils and registers in one call.
Rows from all councils land in one dataset with the identical schema.

### Sample output (real run, 2026-08-21)

Run `iRqfksouWozaTYFMM` — Leeds, building\_control, current weekly list
(dataset `KidqvD1Xkpnnd7xe3`, 10 rows):

```json
[
  {
    "council": "leeds",
    "council_name": "Leeds City Council",
    "portal_host": "publicaccess.leeds.gov.uk",
    "register_type": "building_control",
    "reference": "26/03400/DALBN",
    "proposal": "Alterations to remove internal wall/chimney breast and insert steels",
    "address": "4 Nethercliffe Road Guiseley Leeds LS20 9HL",
    "status": "Pending Consideration",
    "event_type": "deposited",
    "event_date": "2026-08-20",
    "week_start": "17 Aug 2026",
    "key_val": "TK2DRUJB3B300",
    "detail_url": "https://publicaccess.leeds.gov.uk/online-applications/buildingControlDetails.do?keyVal=TK2DRUJB3B300&activeTab=summary",
    "harvested_at": "2026-08-21T04:05:42+00:00"
  }
]
```

### Use with the Apify MCP server

Works out of the box with Apify's MCP server (`@apify/actors-mcp-server`) —
scrape planning data straight from Claude, Cursor or any MCP client:

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server",
               "halobartku/uk-planning-building-control-scraper"]
    }
  }
}
```

### Pricing — and why it's $0.02 per application

| actor | per-application price | registers |
|---|---|---|
| illehius/uk-planning-monitor | **$0.050** / application found | planning only |
| memo23/uk-planning-applications-scraper | $0.010 / result (free PlanIt API wrapper) | planning only |
| **this actor** | **$0.020** / application-harvested | **planning + building control** |

You are charged once per row delivered — nothing on start, nothing on
failure. A weekly single-council run (40–200 rows) costs **$0.80–4.00**;
the same coverage from the $0.05 competitor costs 2.5× more and still
misses Building Control entirely. BC rows are the early signal: full plans
deposited weeks before the planning application appears.

### FAQ

**Why Idox portals and not the national planning pipeline?**
PlanPipe-style national feeds cover planning applications only. Building
Control deposits (structural alterations, steel insertions, demolitions)
live on each council's Idox Public Access portal — that register is what
this actor adds, and why builders/loft companies cannot get it elsewhere.

**How fresh is the data?**
Each run harvests the live weekly list — typically published within a day
or two of deposit. Run daily to catch councils that update mid-week.

**How do I get only new applications?**
Deduplicate on `key_val` + `council` across runs; `event_date` lets you
filter to the current week.

**Can I add my council?**
Yes — open an Issue with the council name. Any Idox Public Access portal
(100+ UK councils run Idox) is a small config addition, verified live
before release.

**What happens if a portal is down or changes?**
The run fails loudly with the council named, charges **$0**, and the next
run retries. Partial results are still delivered and only those rows bill.

### For AI agents & LLM apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com/) or the Apify API (actor: `halobartku/uk-planning-building-control-scraper`).

**Purpose:** Harvest the weekly Building Control and Planning application lists from UK council Idox Public Access portals — one normalised row per application (council, reference, proposal, site address, status, event type/date, portal link). Building Control deposits are the register no other Apify actor covers.

**Minimal input:**

```json
{ "councils": ["leeds"], "registers": ["building_control"] }
```

**Output:** one row per application — `council`, `council_name`, `portal_host`, `register_type` (`building_control`|`planning`), `reference`, `proposal`, `address`, `status`, `event_type`, `event_date`, `week_start`, `key_val`, `detail_url`, `harvested_at`.

**Behaviors an agent should know:**

- Both `councils` and `registers` accept arrays; rows from all councils land in one dataset with the identical schema.
- Deduplicate across runs on `key_val` + `council` (or `reference` + `council`); `event_date` filters to the current week.
- Supported councils (v0.1): Leeds, Tameside, Sefton, Gateshead, Walsall, Wirral, Salford, Sheffield, Stockport, Sunderland. More on request via the actor's Issues tab.
- A failing portal fails the run loudly with the council named and charges **$0**; partial results are still delivered and only those rows bill.
- Billing: pay-per-event `application-harvested`, charged only after rows are written — failed or empty runs cost nothing.

### Changelog

**0.1.6** — 2026-08-22: pagination fix. The portal's result-count phrase carries an inline `</strong>` (`Showing 1-10</strong> of 76`); our old count regex missed it, so multi-page weeks returned only page 1 (Leeds: 10 of 76 rows). Found by independent ground-truth validation, fixed, re-validated 76/76 + 18/18 rows exact vs same-minute portal HTML. If you ran this actor before 2026-08-22, re-run for complete weeks.
**0.1** — 2026-08-20: initial public release. 10 councils, both registers,
one normalised schema, per-row PAY-PER-EVENT pricing.

### SEO keywords

uk building control applications scraper, building control register scraper, idox public access scraper, uk planning applications scraper, building control weekly list, building control deposits, building notices uk, structural alteration applications, uk planning weekly list, council planning register scraper, uk planning data api, construction leads uk, builder leads uk, loft conversion leads, property development leads uk, planning application monitoring, building control data export, uk council portals scraper, leeds building control applications, planning applications by council

# Actor input Schema

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

Council slugs to harvest (see README for the live list). Example: \["leeds", "tameside"]

## `registers` (type: `array`):

Which statutory registers: building\_control, planning, or both.

## `weeksBack` (type: `integer`):

0 = current week only (default). Up to 8 previous weekly lists.

## `maxRowsPerCouncil` (type: `integer`):

Safety cap per council+register (pagination stops here). Default 200.

## `includeDetails` (type: `boolean`):

Also open each application's details page for richer fields. Slower.

## `strictMode` (type: `boolean`):

Fail the whole run (free) if ANY council portal errors. Default false: skip and continue.

## Actor input object example

```json
{
  "councils": [
    "leeds",
    "tameside"
  ],
  "registers": [
    "building_control"
  ]
}
```

# Actor output Schema

## `items` (type: `string`):

All results, one dataset item per row. Fetch as JSON via this URL with an APIFY\_TOKEN bearer header. A run-level summary is written to the run's terminal status message.

# 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",
        "tameside"
    ],
    "registers": [
        "building_control"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("halobartku/uk-planning-building-control-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",
        "tameside",
    ],
    "registers": ["building_control"],
}

# Run the Actor and wait for it to finish
run = client.actor("halobartku/uk-planning-building-control-scraper").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 '{
  "councils": [
    "leeds",
    "tameside"
  ],
  "registers": [
    "building_control"
  ]
}' |
apify call halobartku/uk-planning-building-control-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/Z5JQ2YSvZhD8HeUp5/builds/bm7p0YYpZkuH1bAos/openapi.json