# UK Energy Project Pipeline Monitor (`dig_stays/uk-energy-project-pipeline-monitor`) Actor

Monitor UK renewable projects and twice-weekly grid connections using official REPD and NESO data. Get milestone changes, operator portfolios, planning lookups and commercial signals for sales, research and investment workflows.

- **URL**: https://apify.com/dig\_stays/uk-energy-project-pipeline-monitor.md
- **Developed by:** [Chris Hopkin](https://apify.com/dig_stays) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 baseline projects

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?

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 Energy Project Pipeline Monitor

Track renewable-energy, battery-storage and grid-connection projects across the United Kingdom using official REPD and optional NESO data.

The Actor turns the quarterly government planning database and NESO's twice-weekly Transmission Entry Capacity register into clean, filterable project records and a repeatable change feed. The first successful run creates a complete baseline for your filters. Schedule the same input and later runs return only projects that are newly seen, materially changed or removed from the latest filtered snapshot.

### What you can monitor

- Battery storage, solar, onshore and offshore wind, hydrogen, hydro, anaerobic digestion and other REPD technologies
- Planning, awaiting-construction, construction, operational, refused, withdrawn and expired statuses
- Countries, regions and planning authorities
- Minimum installed capacity
- Projects whose official record changed after a chosen date
- Contracted transmission projects by plant type, project status and host transmission owner
- Connection site, contracted connection date, connected MW, capacity change and Gate 1/2 when NESO reports them
- Each operator's project count and total MW across the full selected official source
- Cautious possible matches between NESO connections and REPD planning projects

Each record includes the project, operator/applicant, capacity, status, location, planning authority, planning reference and key milestone dates. Change events include the fields and previous values that changed.

Every event also has a `signalPriority` and plain-English `signalSummary`. High-priority signals include planning or construction milestones, grid dates, connection Gate changes and connected-capacity changes. Treat these as research leads and verify them against the linked official source.

For English REPD projects with a planning reference, `planningDataLookupUrl` links to the official Planning Data API. Coverage varies by planning authority because the national planning-application dataset is still developing.

### Common uses

#### Find battery projects entering construction

Use this to identify potential demand for civil works, equipment, security, recruitment, grid services or professional advice.

```json
{
  "technologyTypes": ["Battery"],
  "developmentStatuses": ["Under Construction"],
  "regions": [],
  "countries": ["England", "Scotland", "Wales"],
  "minCapacityMW": 20,
  "maxRecords": 1000
}
```

#### Monitor submitted solar and storage applications

```json
{
  "technologyTypes": ["Solar Photovoltaics", "Battery"],
  "developmentStatuses": ["Application Submitted"],
  "regions": ["South East", "Eastern"],
  "minCapacityMW": 5,
  "maxRecords": 2000
}
```

#### Watch one planning area

Planning-authority filters are case-insensitive fragments.

```json
{
  "technologyTypes": [],
  "developmentStatuses": [],
  "regions": [],
  "planningAuthorities": ["Manchester"],
  "minCapacityMW": 0,
  "maxRecords": 1000
}
```

#### Monitor high-capacity battery connections twice weekly

NESO uses “Energy Storage System” in its register; the friendly `Battery` filter is translated automatically. REPD location filters do not apply to NESO because the TEC register does not contain UK regions.

```json
{
  "technologyTypes": ["Battery"],
  "developmentStatuses": ["Under Construction"],
  "regions": ["North West"],
  "includeNesoConnections": true,
  "gridPlantTypes": ["Battery"],
  "gridStatuses": ["Awaiting Consents"],
  "gridHostOperators": ["NGET"],
  "minCapacityMW": 100,
  "maxRecords": 500
}
```

### Change detection

Comparison state is saved separately for every unique set of filters. Fields such as operator, capacity, status, planning reference, location and milestone dates are tracked.

- `baseline`: present during the first complete run
- `newly_seen`: absent from the previous complete filtered snapshot
- `changed`: one or more tracked fields changed
- `removed_from_source`: no longer present in the latest complete filtered snapshot

These labels describe observations in REPD. They do not, by themselves, prove that a project was announced, cancelled or acquired. Check the official source and planning authority before making a commercial or investment decision.

If the source download or schema is incomplete, the run fails before replacing the saved comparison state. If your filters exceed `maxRecords`, the Actor also fails rather than silently returning a partial pipeline.

### Output example

```json
{
  "projectId": "9404",
  "projectName": "Fiddlers Ferry Power Station - Battery storage",
  "operator": "SSE Enterprise (SSE PLC)",
  "technologyType": "Battery",
  "capacityMW": 150,
  "developmentStatus": "Under Construction",
  "region": "North West",
  "country": "England",
  "planningAuthority": "Warrington",
  "underConstruction": "2024-03-28",
  "changeType": "baseline",
  "changedFields": [],
  "previousValues": {},
  "observedAt": "2026-09-09T10:00:00.000Z"
}
```

### Scheduling and integrations

Run the Actor on a schedule using the same input. Use weekly or monthly runs for REPD-only monitoring. When NESO connections are enabled, run after the Tuesday and Friday register updates. Send the dataset to a webhook, Make, Zapier, Google Sheets, a CRM or your own application through the Apify API. An empty dataset on a repeat run means no tracked change was found; the `SUMMARY` output still records a successful scan and recommends the appropriate cadence.

#### Webhook payload example

Configure an Apify run-succeeded webhook to call your automation. Fetch `resource.defaultDatasetId` from the run payload and read that dataset's items. Process records where `signalPriority` is `high`, then route them to email, Slack, a CRM or a sheet. This keeps empty or low-value runs quiet.

### Data source and licence

Sources:

- [UK Government Renewable Energy Planning Database](https://www.gov.uk/government/publications/renewable-energy-planning-database-quarterly-extract), normally quarterly, under the Open Government Licence v3.0
- [NESO Transmission Entry Capacity register](https://www.neso.energy/data-portal/transmission-entry-capacity-tec-register), normally updated twice weekly, under the NESO Open Data Licence
- [Planning Data API](https://www.planning.data.gov.uk/docs), used only to create planning-application lookup links for England

The REPD tracks UK renewable electricity projects over 150 kW through planning, construction, operation and decommissioning. The NESO TEC register contains contracted transmission-entry projects and warns that aggregate capacities can create duplicate-looking rows. Possible cross-source matches use names and capacities and are deliberately labelled as candidates; they are not authoritative joins.

### Pricing

This Actor uses pay per event:

- `baseline-project`: $0.002 for each project returned when a new comparison baseline is created ($2 per 1,000)
- `project-change`: $0.02 for each newly seen, changed or removed project on a later run ($20 per 1,000)
- `apify-actor-start`: $0.00005 when a run starts

The default example returned 14 baseline projects in the final hosted test, costing approximately $0.02805 in total. The count can change with each official release. Repeat runs with no changes produce no paid project records and cost only the $0.00005 start event. Platform usage is included in these prices.

Enabling NESO can add hundreds of records. `maxRecords` is both a completeness guard and a cost guard: 500 baseline records cost about $1.00005, while 1,000 cost about $2.00005. Resetting a baseline charges those baseline records again, so check the limit and Apify's maximum run cost before a reset.

# Actor input Schema

## `technologyTypes` (type: `array`):

Select one or more REPD technologies. Leave empty for all technologies.

## `developmentStatuses` (type: `array`):

Select project stages to monitor. Leave empty for all statuses.

## `regions` (type: `array`):

Select one or more REPD regions. Leave empty for the whole UK.

## `countries` (type: `array`):

Optionally restrict results by UK nation.

## `planningAuthorities` (type: `array`):

Optional case-insensitive fragments, such as Manchester or National Infrastructure. A project matches if its authority contains any supplied fragment.

## `minCapacityMW` (type: `number`):

Exclude projects below this capacity. Records whose capacity is not reported are excluded when this value is above zero.

## `updatedSince` (type: `string`):

Optional date. Filters the official Record Last Updated field. Leave blank to include all dates.

## `includeNesoConnections` (type: `boolean`):

Also monitor the official Transmission Entry Capacity register, updated twice weekly. This can add many baseline records; use the grid filters and maxRecords to control the first-run charge.

## `gridPlantTypes` (type: `array`):

Optional case-insensitive fragments such as Battery, Solar or Wind. Applies only to NESO records; empty includes every plant type.

## `gridStatuses` (type: `array`):

Optional NESO connection-stage filter. Empty includes all statuses.

## `gridHostOperators` (type: `array`):

Optional host transmission-owner filter for NESO records.

## `maxRecords` (type: `integer`):

Safety and cost limit after filtering. A new or reset baseline costs $0.002 per project, so 1,000 records cost about $2.00005 including the run start. The run fails instead of returning a partial snapshot.

## `resetBaseline` (type: `boolean`):

Return all matching projects and replace the saved comparison baseline. This charges $0.002 per returned project again; check maxRecords and your Apify maximum run cost first.

## Actor input object example

```json
{
  "technologyTypes": [
    "Battery"
  ],
  "developmentStatuses": [
    "Under Construction"
  ],
  "regions": [
    "North West"
  ],
  "countries": [],
  "planningAuthorities": [],
  "minCapacityMW": 0,
  "includeNesoConnections": false,
  "gridPlantTypes": [],
  "gridStatuses": [],
  "gridHostOperators": [],
  "maxRecords": 1000,
  "resetBaseline": false
}
```

# Actor output Schema

## `projectEvents` (type: `string`):

Baseline, newly seen, changed and removed energy-project records.

## `summary` (type: `string`):

Source, counts, filters and comparison status.

## `snapshot` (type: `string`):

The complete filtered snapshot saved by this run.

# 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("dig_stays/uk-energy-project-pipeline-monitor").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("dig_stays/uk-energy-project-pipeline-monitor").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 '{}' |
apify call dig_stays/uk-energy-project-pipeline-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dig_stays/uk-energy-project-pipeline-monitor"
        }
    }
}

```

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/C2m7MEw63zbHurxle/builds/7bNUCiGqgxQy25Qoy/openapi.json