# Ireland Planning Applications (`devon_gtme/ireland-planning-applications`) Actor

Ireland Planning Applications Scraper

Every planning application in the Republic of Ireland, all 31 local authorities, a full archive back to 2010, and the documents that were actually filed.

It opens the planning file, so you get the drawings, the planner's report and the Chief Executive's Order.

- **URL**: https://apify.com/devon\_gtme/ireland-planning-applications.md
- **Developed by:** [Devon Kellar](https://apify.com/devon_gtme) (community)
- **Categories:** Real estate, Lead generation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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/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

## Ireland Planning Applications Scraper

Every planning application in the Republic of Ireland — all 31 local authorities, a full archive back to 2010, and the documents that were actually filed.

Most planning tools give you the register listing: address, decision, dates. This one also opens the planning file, so you get the drawings, the planner's report and the Chief Executive's Order — and it tells you honestly which councils publish nothing.

It is built on the Irish government's own **National Planning Application Database**, published under a CC-BY 4.0 licence that explicitly permits commercial reuse, plus the councils' live portals to cover the week or more that the national feed lags behind.

### Features

- **All 31 planning authorities.** Not a sample, not the big cities. The actor asserts that the national register still returns exactly 31 authorities and refuses to publish a partial register if it does not.
- **Documents from 28 of the 31**, covering about 87% of national volume. Type, description, date, category and a direct link — optionally the full extracted text.
- **A real archive.** 500,000+ applications, earliest 1991, the bulk from 2010. Ireland does not expire its planning files the way some registers do, so you can backfill years rather than only watch a rolling window.
- **Honest coverage reporting.** Every run logs which councils publish no documents, and how far behind each council's data actually is. See "Honest limits" below — this is the part most tools leave out.
- **Geocoded.** Latitude and longitude on every record, reprojected from Irish Transverse Mercator server-side.
- **Appeals included.** An Bord Pleanála (An Coimisiún Pleanála) case reference, status and decision arrive inline with the application.
- **Agent contacts** — the planning agent or architect's name, and on the Agile councils their business email and phone. That is the lead-generation field.
- **No API key, no login, no account** with any council.

### Use cases

- **Construction and trade suppliers** — find schemes months before they break ground. Irish planning has an 8-week statutory decision period, so an application spotted at lodgement is a long way ahead of anyone reading commencement notices.
- **Specification-led sales** (lifts, HVAC, glazing, roofing, cladding) — the product you sell is named in the drawings long before it is named in the application description. Turn on text extraction and search the drawings.
- **Estate agents and developers** — track competitor land activity, unit counts and site areas by county.
- **Architects and planning consultants** — see what is being approved and refused near a site, and read the planner's report that explains why.
- **Proptech and market analysts** — a clean national time series of applications, units, decisions and appeal outcomes.
- **Insurers and surveyors** — protected-structure flags, site areas, floor areas and one-off rural housing classification.
- **Journalists and researchers** — a licensed, citable national dataset with the source document attached.

### Input parameters

- **councils** (array) — which of the 31 authorities to cover. Empty means all; one county is **prefilled** so that a first run returns in well under a minute rather than harvesting the country. Accepts full names, the legal name (`Limerick City and County Council`), short forms (`Co. Kildare`, `DLR`) or portal codes. An unrecognised name stops the run rather than being silently dropped.
- **daysBack** (integer, default `30`) — how far back to look. The archive supports large values.
- **dateFrom** / **dateTo** (string, `YYYY-MM-DD`) — explicit window; overrides `daysBack` and disables the live pass.
- **searchTerms** (array) — keep only applications matching one of these. Applied locally, deliberately: the portals' own text search matches word-initial stems only, so a server-side search for `uplift` returns nothing on a record containing the word six times.
- **appStatus** / **appTypes** (array) — filter by status or application type.
- **excludeComplianceSubmissions** (boolean, default `true`) — drop `…Sub01`-style references. These are condition-compliance filings against an already-decided application, not new schemes; they are about a quarter of Dublin City's rows and near-zero elsewhere.
- **freshMode** (boolean, default `true`) — also read the councils' live portals. Strongly recommended; see "Honest limits".
- **includeAgileCouncils** (boolean, default `false`) — read the Agile Applications API for the 7 councils on it. Adds agent email and phone. Off by default; see "A note on the Agile councils".
- **includeDocuments** (boolean, default `false`) — attach the document index.
- **extractDocumentText** (boolean, default `false`) — download and extract text. Billed separately from the per-application charge; see "What it costs".
- **documentCategories** (array, default plans / decision notice / planner's report) — which document types to download when extracting.
- **allowOcr** (boolean, default `true`) — OCR fallback for scanned or stamp-only files. Worth leaving on: it is the only way to read Kildare's and Wicklow's drawings.
- **maxDocumentMb** (integer, default `25`) — skip documents above this size. A single large drawing can consume a gigabyte of memory while being parsed.
- **maxResults** (integer, default `1000`).
- **proxy** — optional. Nothing here blocked a direct connection in testing.

### What it costs

**$0.01 per application** returned, including its full document index — type, description, date, category and a direct link for every document on the file. That is half what comparable UK planning actors charge, and Ireland has no other source.

**Text extraction is charged separately, per document that actually yields legible text.** Nothing is charged for a document that is missing, that turns out to be a scan carrying only the council's stamp, that produces unreadable output from a broken embedded font, or that OCR cannot recover.

| Documents in a run | Price each |
|---|---|
| 1 – 999 | $0.050 |
| 1,000 – 1,999 | $0.040 |
| 2,000+ | $0.035 |

Bands are graduated like tax brackets: each document is charged at the band its own position falls in.

So a month of the whole country — roughly 3,000 applications with their document indexes — is about **$30**, and you only pay more if you ask for the drawings themselves.

### Honest limits

Read this section before you rely on a count.

**The national register lags, and it lags very unevenly.** Its headline freshness is about a week, but that is an average that hides the councils that matter. Measured 2026-08-01: 25 of 31 authorities were within 21 days, but **Kildare was 106 days behind, Wicklow 107, Cork County 85, and Cork City 270**. A 30-day query against the register alone returns *nothing* for Kildare, which looks exactly like a county that approved no development for a month. `freshMode` exists for this reason and is on by default; every run logs each council's actual lag, and warns explicitly where neither source can reach.

**The live portals only look back 42 days.** That is the councils' own limit, not ours. Where a council's register lag exceeds 42 days there is a genuine gap in the middle that no source covers, and the run says so by name.

**Three councils publish no documents online at all:** Donegal, Galway County and Monaghan — about 13% of national volume. Their applications are still returned; only the documents are missing. Donegal is the largest council in this group.

**Cork City is missing from the national register.** It moved to a different portal and its feed died with the old system: 728 applications in 2022, 344 in 2025, zero in 2026. It is reachable only with `includeAgileCouncils` enabled.

**A national run is not a quick run.** The live pass reads one detail page per application from `eplanning.ie`, which answers in about two seconds, so the cost of a run is driven by how many applications match rather than by how many councils you asked for. Measured 2026-08-02 over a 30-day window: Leitrim 33 applications in 40s, Carlow 46 in 36s, Meath 168 in 107s, Kildare 196 in 138s — roughly 20 seconds of fixed cost per council plus 0.6s an application. All 31 authorities together is therefore about **half an hour**, which is why a single county is prefilled. Turn `freshMode` off and the same national query is a couple of minutes, at the cost of the last week of applications.

**Documents arrive after the application.** Dublin City and Dún Laoghaire-Rathdown both state that scanning can take up to 10 working days. A newly lodged application will often have an empty or partial file; re-run over the same window a fortnight later to pick up the drawings.

**Some drawings are scans, and a character count will not tell you which.** Most drawings are born-digital and extract cleanly — one Galway City drawing contains the room label `lift`, exactly the sort of detail that never appears in an application description. But a substantial minority are scans of paper, and every council stamps its scans, so the page extracts as nothing but `Kildare County Council - Inspection Purposes Only`. It follows what the agent submitted rather than which council received it, so it varies **document by document**: in testing, one Kildare application had all seven of its drawings come back as stamps while the very next application's were perfectly clean. Leave OCR on. A third case — drawings exported with a font that carries no character map, which extract as thousands of unreadable placeholder characters — the actor repairs automatically.

**None of those three cases is charged for.** A document is billed only when it yields genuinely legible text, and the `warning` field says which case a failure was.

### Personal data

Irish planning applications are a public statutory register, and much of the file names private individuals — the applicant on a domestic extension is a householder, and third-party observations are filed by named neighbours.

Publication on a statutory register and republication at scale in a commercial dataset are different acts. So:

- **Applicant names are returned only where the applicant is an organisation** — a company, council, club, school or other body corporate. Individuals' names are withheld, and `applicantIsOrganisation` tells you which case you are in.
- **Applicant email, phone and home address are never returned**, even where a council publishes them.
- **Council officers' names and emails are never returned.** They are public servants, not sales leads.
- **Agent details are returned**, because a planning agent or architect is a business acting in trade.

### A note on the Agile councils

Seven authorities — all four Dublin authorities, both Cork authorities and Wexford — run Agile Applications rather than the shared ePlan portal. Their API is the richest source in Ireland: it publishes the agent's email address and phone number, which nothing else does.

It is **off by default** because `planning.agileapplications.ie` serves a `robots.txt` of `User-agent: * / Disallow: /`. All seven councils are covered by the national register regardless, so the default configuration still gives you complete national coverage. The switch is there so the decision is yours and explicit, rather than made for you silently.

### Output

One record per application. Core fields:

`council` · `source` · `reference` · `applicationType` · `status` · `description` · `address` · `postcode` · `latitude` · `longitude` · `eastings` · `northings` · `receivedDate` · `decisionDueDate` · `decisionDate` · `decision` · `grantDate` · `expiryDate` · `fiRequestDate` · `fiReceivedDate` · `appealReference` · `appealStatus` · `appealDecision` · `siteArea` · `floorArea` · `residentialUnits` · `storeys` · `oneOffHouse` · `protectedStructure` · `applicantName` · `applicantIsOrganisation` · `agentName` · `agentEmail` · `agentPhone` · `portalUrl` · `documentsUrl` · `documentCount` · `documents[]` · `sourceUpdated` · `scrapedAt`

`source` tells you which feeds a record was built from — `npad`, `eplan`, `agile`, or a combination like `eplan+npad` where the live portal enriched a register row.

Each entry in `documents[]` carries `docType`, `description`, `date`, `category` and `url`. Categories are `plans`, `decision_notice`, `officer_report`, `further_information`, `appeal`, `consultation`, `supporting`, `site_location`, `site_notice` and `administrative`. With text extraction on, each also carries `text`, `pages`, `chars`, `method`, `ocr` and `readable`. Treat `readable` as the real test, not `chars`.

Note that **site location maps are a separate category from plans**. A site location map is a parcel outline on an Ordnance Survey extract; it can never carry building detail, and counting it as a drawing inflates every coverage figure you compute.

### Input examples

Everything lodged nationally in the last fortnight:

```json
{ "daysBack": 14 }
```

Large residential schemes in the Greater Dublin commuter counties, with drawings:

```json
{
  "councils": ["Kildare County Council", "Meath County Council", "Wicklow County Council", "Louth County Council"],
  "daysBack": 90,
  "searchTerms": ["apartment", "residential development", "housing"],
  "includeDocuments": true
}
```

Read the drawings for a specification signal:

```json
{
  "councils": ["Cork County Council"],
  "daysBack": 30,
  "extractDocumentText": true,
  "documentCategories": ["plans"],
  "includeAgileCouncils": true
}
```

Backfill a county's history:

```json
{
  "councils": ["Galway County Council"],
  "dateFrom": "2015-01-01",
  "dateTo": "2026-01-01",
  "maxResults": 50000
}
```

### Data sources

- **National Planning Application Database** — Department of Housing, Local Government and Heritage, via data.gov.ie. Licensed **CC-BY 4.0**. Attribute it if you republish.
- **LGMA ePlan** portals and their iDocs document repositories, for the 24 ePlan councils.
- **Agile Applications**, for the 7 councils on it, when enabled.

Planning documents remain the copyright of their originators. Reading them to derive facts is not the same as republishing them; if you intend to redistribute drawings, check that separately.

### Bugs, fixes and updates

Version 0.1 — first release.

Custom builds and other national planning datasets are available; get in touch through the Apify Store contact form.

# Actor input Schema

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

Which of Ireland's 31 local authorities to cover. Clear the field to cover all 31; that is a full national harvest and takes about half an hour with the live pass on, so a single county is prefilled to keep a first run quick. Accepts full names ('Kildare County Council'), the legal name ('Limerick City and County Council'), short forms ('Co. Kildare', 'DLR') or portal codes ('KildareCC'). An unrecognised name stops the run rather than being silently dropped.

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

How far back to look, counted from today. The national register goes back to 2010, so large values are fine for history. Note that live-portal freshness only covers the last 42 days (see Live freshness below).

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

Explicit start of the received-date window. Overrides 'Days back'. Setting an explicit window disables the live freshness pass, which can only search relative to today.

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

Explicit end of the received-date window. Overrides 'Days back'.

## `searchTerms` (type: `array`):

Keep only applications whose description, address or type contains one of these (case-insensitive, any match). Applied locally on purpose: the portals' own text search matches word-initial stems only, so searching them directly misses words that appear mid-phrase.

## `appStatus` (type: `array`):

Filter by status as the national register spells it, e.g. 'NEW APPLICATION', 'FURTHER INFORMATION', 'APPLICATION FINALISED'. Leave empty for all.

## `appTypes` (type: `array`):

Filter by type, e.g. 'PERMISSION', 'RETENTION', 'OUTLINE PERMISSION'. Leave empty for all.

## `excludeComplianceSubmissions` (type: `boolean`):

Drop references ending 'Sub01', 'Sub02' and so on. These are condition-compliance filings against an application that was already decided, not new schemes. They are about a quarter of Dublin City's rows and near-zero elsewhere, so leaving them in overstates the largest authority.

## `freshMode` (type: `boolean`):

Also read the councils' live portals, not just the national register. The national database refreshes weekly, so an application lodged in the last few days may not be in it yet. This closes that gap for the 24 ePlan councils. The portals cap their own listing at 42 days.

## `includeAgileCouncils` (type: `boolean`):

Read the Agile Applications API directly for the 7 councils on it (all four Dublin authorities, both Cork authorities, Wexford). It adds the planning agent's email address and phone number, live status, and documents. It is OFF by default because planning.agileapplications.ie publishes a robots.txt that disallows all automated agents; those councils are covered by the national register regardless. Turn it on only if you have decided that is appropriate for your use. Cork City is the one council the national register no longer receives, so it needs this.

## `includeDocuments` (type: `boolean`):

Attach the list of documents filed with each application: type, description, date and a direct link. Covers 28 of the 31 authorities. Donegal, Galway County and Monaghan publish no documents online.

## `extractDocumentText` (type: `boolean`):

Download the documents and return their full text, including drawings. This is the billed part of the actor and is charged per document that actually yields text -- documents that are missing, or scanned so badly that OCR finds nothing, cost nothing. Turning this on also turns on 'Include documents'.

## `documentCategories` (type: `array`):

Which document types to download when extracting text. Site notices and site location maps are excluded by default: both are near-content-free, and a site location map is a parcel outline on an Ordnance Survey extract that can never carry building detail.

## `maxDocumentMb` (type: `integer`):

Skip documents larger than this. Architectural drawings can be very large and a single one can consume a gigabyte of memory while being parsed, so this is a safety limit rather than a cost control.

## `allowOcr` (type: `boolean`):

Fall back to OCR when a document has no text layer. Irish planning files are about 97% machine-readable, so this rarely fires, but it is slow when it does.

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

Stop after this many applications.

## `proxy` (type: `object`):

Optional. None of these sources blocked a direct connection during testing, so a proxy is not normally needed. If you do use one, an Irish exit is the closest match to the audience these portals serve.

## Actor input object example

```json
{
  "councils": [
    "Carlow County Council"
  ],
  "daysBack": 30,
  "searchTerms": [],
  "appStatus": [],
  "appTypes": [],
  "excludeComplianceSubmissions": true,
  "freshMode": true,
  "includeAgileCouncils": false,
  "includeDocuments": false,
  "extractDocumentText": false,
  "documentCategories": [
    "plans",
    "decision_notice",
    "officer_report"
  ],
  "maxDocumentMb": 25,
  "allowOcr": true,
  "maxResults": 1000,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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": [
        "Carlow County Council"
    ],
    "searchTerms": [],
    "appStatus": [],
    "appTypes": [],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("devon_gtme/ireland-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 = {
    "councils": ["Carlow County Council"],
    "searchTerms": [],
    "appStatus": [],
    "appTypes": [],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("devon_gtme/ireland-planning-applications").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": [
    "Carlow County Council"
  ],
  "searchTerms": [],
  "appStatus": [],
  "appTypes": [],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call devon_gtme/ireland-planning-applications --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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