# GB Grid Connection Queue Tracker: TEC and DNO Changes (`arjs1000/gb-grid-connection-pipeline`) Actor

Every move in Great Britain's grid connection queue: new projects, MW changes, connection dates that slip, status and Gate changes, withdrawals. TEC and DNO registers in one schema, with before and after values. Monthly MW reports by technology or substation.

- **URL**: https://apify.com/arjs1000/gb-grid-connection-pipeline.md
- **Developed by:** [Arjun Shankar](https://apify.com/arjs1000) (community)
- **Categories:** Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## GB Grid Connection Queue Tracker: TEC and DNO Changes

See every move in Great Britain's grid connection queue: new projects, capacity changes,
connection dates that slip or jump, status and Gate changes, and withdrawals.

The transmission (TEC) register and the distribution networks' Embedded Capacity Registers come
back in one schema, so a battery project in the TEC register and a solar farm on a DNO register
look the same to your code. Each change carries the values before and after. Change history on
the longest-running registers goes back to September 2023.

Run it with the default input: 10 recent changes.

### Who uses it

- **Battery, solar and wind developers** watch the substations they care about and see the day
  a rival's connection date moves ahead of theirs.
- **Grid consultants** track queue position and Gate status for clients without diffing
  register downloads twice a week.
- **Land agents** see which projects near their clients hold a connection offer, and when it
  changes.
- **Investors and analysts** count queued, connected and withdrawn MW by technology, grid supply
  point, planning authority or licence area, month by month.

### Input

| Field | What it does |
|---|---|
| `mode` | `changes` (default), `snapshot` (the current pipeline) or `report` (monthly totals) |
| `since` | Changes published since a date, `YYYY-MM-DD`. Empty means the last 31 days |
| `sinceLastRun` | `true` returns only changes newer than your last run. Best for schedules |
| `changeTypes` | `new`, `capacity_changed`, `connection_date_moved`, `status_changed`, `gate_changed`, `withdrawn` |
| `sources` | Pick registers: `neso_tec`, `neso_interconnector`, `neso_embedded`, `npg_ecr`, `ssen_ecr` |
| `technologies`, `minMw` | e.g. `battery`, `solar`, `wind_onshore`; minimum headline MW |
| `gate`, `licenceAreas`, `statuses` | Gate 1 or 2 (TEC), licence areas such as `SSEN-SHEPD`, project status |
| `month`, `groupBy`, `scope` | For `report`: month, grouping (`technology`, `gsp`, `lpa`, `licence_area`) and transmission, distribution or all |
| `maxItems` | Caps the rows, and so the cost |

### Output

Each change carries `change_type`, `change_date`, `source`, `project_name`, `customer_name`,
`technology`, `mw`, `status`, `licence_area`, `gsp`, `postcode_district`, `lpa`, `before`,
`after`, `project_id` and `data_as_of`. Pipeline rows add `connection_date`, `gate`,
`substation`, MW import, export and storage figures, a planning reference where one matches, and
coordinates where the register gives a location.

A real change from a DNO register, August 2026, trimmed:

```json
{
  "change_type": "connection_date_moved",
  "change_date": "2026-08-07",
  "source": "ssen_ecr",
  "project_name": "CLACHAIG WIND FARM",
  "customer_name": "RWE RENEWABLES UK ONSHORE WIND LTD",
  "technology": "wind_onshore",
  "mw": 52.8,
  "licence_area": "SSEN-SHEPD",
  "gsp": "Carradale",
  "before": { "connection_date": "2026-04-30" },
  "after": { "connection_date": "2028-09-29" },
  "data_as_of": "2026-10-06"
}
```

A `report` row gives projects and MW by status for one group, such as all battery projects.

### Pricing

Pay per result. See the Pricing tab for current rates; `maxItems` caps the rows and so the cost. A run that finds nothing charges nothing per item.

### FAQ

**Which registers does it cover?** The transmission TEC, interconnector and embedded registers,
plus the distribution registers for the UK Power Networks, SP Energy Networks, Electricity North
West, Northern Powergrid and SSEN areas.

**How fresh is it?** The transmission registers update twice a week and the DNO registers monthly. The actor checks every
source daily, and new releases reach it within about 6 hours.

**Is a moved connection date a forecast?** No. It is what the register published. The actor
reports the change, not whether the project will connect.

Built on open data used under each publisher's open licence, including CC BY 4.0 and the Open
Government Licence v3.0. Every run carries the full attribution in `OUTPUT_SUMMARY`. Runs record anonymous usage counts only, never your inputs or
results.

# Actor input Schema

## `mode` (type: `string`):

changes: what changed between register releases (charged per change). snapshot: the current pipeline, one row per project per register (charged per row). report: one monthly MW-by-status report (charged per report).

## `since` (type: `string`):

Changes mode: only changes published on or after this date (YYYY-MM-DD). Leave empty for the last 31 days, because most DNO registers update monthly. If nothing changed in those 31 days, the run returns the changes from the most recent register release that had any.

## `sinceLastRun` (type: `boolean`):

Changes mode only. Turn this on for scheduled runs. Each run returns only changes newer than the last run that had it on, so you never pay twice for the same item. The actor saves its place in a key-value store called gb-grid-connection-pipeline-cursor in your own Apify account. The first run has no saved place and uses the default window. A date in "Changes since" overrides the saved place for that run. A failed or aborted run does not move it.

## `cursorName` (type: `string`):

Used with "Only new since the last run". The name of the record that holds the saved place. Leave it empty and each mode and set of filters gets its own. Give two tasks the same name only if they should share one place.

## `changeTypes` (type: `array`):

Changes mode: leave empty for all.

## `sources` (type: `array`):

Leave empty for all published registers.

## `technologies` (type: `array`):

Leave empty for all.

## `minMw` (type: `integer`):

Only projects at or above this headline capacity.

## `gate` (type: `string`):

NESO connections reform Gate. Leave empty for any.

## `licenceAreas` (type: `array`):

DNO licence areas or transmission owners. Leave empty for all.

## `statuses` (type: `array`):

Snapshot mode: leave empty for all.

## `month` (type: `string`):

Report mode: YYYY-MM. Defaults to the current month (state as of today).

## `groupBy` (type: `string`):

Report mode.

## `scope` (type: `string`):

Report mode: transmission (NESO TEC + interconnectors), distribution (DNO registers) or both.

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

Stop after this many dataset items (and charges). Your run's spending limit also applies.

## Actor input object example

```json
{
  "mode": "changes",
  "sinceLastRun": false,
  "groupBy": "technology",
  "scope": "all",
  "maxItems": 10
}
```

# Actor output Schema

## `changes` (type: `string`):

Connection projects added, moved, resized or withdrawn since your date or last run.

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

Every connection project matching your filters: technology, capacity, dates and location.

## `report` (type: `string`):

Monthly totals for the projects you selected, grouped the way you choose, with that month's changes.

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

What this run returned: mode, item count, data freshness and the cursor for your next 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("arjs1000/gb-grid-connection-pipeline").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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("arjs1000/gb-grid-connection-pipeline").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 '{
  "maxItems": 10
}' |
apify call arjs1000/gb-grid-connection-pipeline --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arjs1000/gb-grid-connection-pipeline"
        }
    }
}
```

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/mMJ0uxhb2hHm3e6Ln/builds/y0VF21LgP1HriDmyK/openapi.json