# Danish Grid Capacity Map (Energinets Kapacitetskort) (`codeclouds/dk-elnet-kapacitetskort`) Actor

Available grid capacity per transformer station in Denmark from Energinet's official Kapacitetskort: consumption and production MW, 132/150 kV and 60/10 kV, nearest station to a coordinate, status, change signals, free country-wide summary. From $0.01/station (PPE).

- **URL**: https://apify.com/codeclouds/dk-elnet-kapacitetskort.md
- **Developed by:** [Dennis](https://apify.com/codeclouds) (community)
- **Categories:** Other, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 netstation resultats

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

## Danish Grid Capacity Map (Energinets Kapacitetskort) 🇩🇰⚡

Check **available grid capacity per transformer station in Denmark** — for consumption and for
production (solar, wind, batteries) — straight from the official national **Kapacitetskort for
elnettet** published by **Energinet** (the Danish state-owned TSO) with **Dansk Energi / Green Power
Denmark**.

Denmark's grid is under pressure: more than 60 GW of connection requests are queued against a
realistic peak load in the order of 7 GW, and Energinet halted transmission grid reinforcement
because there is no capacity to build it with. The Kapacitetskort shows, per substation, how much
room is left for a new connection. That map lives in an ArcGIS viewer — find the station, zoom in,
open a popup. **This Actor does the same thing as one structured JSON extraction.** It reads the
public dataset behind the map, normalises it to one record per substation, and reports the distance
from your project coordinate.

### Who is this for?

- **Renewable project developers (solar, wind, battery, Power-to-X)** — screen which substations
  have room before committing to a site.
- **Data centre and heavy industry developers** — find where the next megawatts can physically sit.
- **Municipalities, regions and grid planners** — monthly monitoring of areas opening up or closing.
- **Energy consultants and analysts** — figures with a source and a date instead of a map screenshot.
- **AI agents** — structured JSON with a stable schema, Danish domain field names, and a free
  summary record. MCP-ready.

### When should an AI agent use this?

- "Is there room on the Danish grid for a 15 MW battery near Aarhus?"
- "Which substations in Jutland still have spare production capacity for a solar farm?"
- "What is the closest substation to 56.1629, 10.2039 and how much capacity is left there?"
- "Which Danish substations lost available consumption capacity since last month?"
- "Find substations above 132 kV with more than 100 MW of headroom."
- "Summarise Danish grid capacity: how many stations are fully booked and how many have room?"

### What this Actor does

- Reads **three layers** from Energinet's public ArcGIS Feature Service `Kapacitetskortet_V2`:
  298 rows in the **transmission grid** (132/150 kV, `transmissionsnet`), 963 rows in the
  **distribution grid** (60/10 kV, `distributionsnet`), and 186 rows in the **"ledige felter"**
  layer (station area Forbrug/Produktion, status Aktuel/Fremtidig). Merged per substation this gives
  **1,097 records — one per physical transformer station** (see FAQ: the raw source has more rows).
- Computes **capacity status** from one documented threshold rule: set `tilslutningskravMW` (the
  connection size you are evaluating) and each station becomes `opbrugt` (exhausted), `knap`
  (tight), `ledig` (available) or `ukendt` (unknown).
- Separates the **existing grid** from the **reinforced (planned) grid** — the source publishes both
  figures for most 132/150 kV stations.
- Finds the **nearest stations to a coordinate**, sorted by haversine distance in kilometres, and
  auto-corrects swapped latitude/longitude when unambiguous.
- Flags **changes since the previous run** via a shared persistent key-value store, for scheduled
  monitoring when a station changes status.
- Delivers a **free summary record** covering the **full, untruncated** selection: counts, totals,
  the most and least congested stations, how much solar and wind is already connected, and a
  **step-by-step filter trace** so an empty result is never unexplained.

### Scope and limitations

- **No connection queue dates.** The source holds available capacity, not a queue with expected
  connection dates. No date, no forecast.
- **No priority category classification.** Denmark's "akutplan for elnettet" with four priority
  categories is still a bill (lovforslag L 23, introduced 20 August 2026, in consultation). The
  Actor does not guess a category that is not final.
- **No postcode geocoding.** Provide a coordinate, a station code or a name. The open Danish address
  APIs (Dataforsyningen/DAWA) were unreachable without an account when checked on 29 September 2026,
  and a keyed service would make the Actor depend on an account on our side. The Actor works with
  zero setup instead.
- **Capacity is not a connection.** "ledig: 100 MW" means there is physically room at that station
  right now; an actual connection still depends on an agreement with the grid operator.
- **Capacity status is a threshold rule, not a forecast.** It depends only on `tilslutningskravMW`.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `nettype` | array | both | `transmissionsnet` (132/150 kV) or `distributionsnet` (60/10 kV) |
| `netstationer` | array | all | Look up stations by code, e.g. `MAL_150`, `FBY` |
| `stationsnavnIndeholder` | string | — | Free text on station name or code. **Danish å/ø/æ search both ways**: `Aarhus` finds `Århus`, `Koebenhavn` finds `København` |
| `breddegrad` | number | — | Latitude (WGS84) — **must be used together with** `længdegrad` |
| `længdegrad` | number | — | Longitude (WGS84) |
| `maksAfstandKm` | number | 25 | Radius around the coordinate |
| `maksAntalNærmeste` | number | 10 | How many nearest stations to return for a point query |
| `tilslutningskravMW` | number | 20 | The connection size you evaluate against |
| `minLedigForbrugMW` | number | — | Minimum available consumption capacity |
| `minLedigProduktionMW` | number | — | Minimum available production capacity |
| `forbrugsstatus` | array | all | `opbrugt` / `knap` / `ledig` / `ukendt` |
| `produktionsstatus` | array | all | `opbrugt` / `knap` / `ledig` / `ukendt` |
| `netforstærkning` | array | all | `existing_grid` (exists today) or `reinforced_grid` (planned grid only) |
| `minSpændingsniveauKV` | number | — | E.g. 132 returns only 132/150 kV stations |
| `kunNyeEllerAendrede` | boolean | false | Only new or changed stations (monitoring) |
| `maksAntal` | number | 200 | Max records per run |

Value matching in `nettype`, `forbrugsstatus`, `produktionsstatus` and `netforstærkning` is case- and
whitespace-tolerant (`TransmissionsNet`, `OPBRUGT`); unknown values are rejected with a message
listing the valid ones.

Example — the 10 nearest stations to Aarhus with at least 20 MW available consumption capacity:

```json
{
  "breddegrad": 56.1629,
  "længdegrad": 10.2039,
  "maksAfstandKm": 25,
  "maksAntalNærmeste": 10,
  "minLedigForbrugMW": 20
}
```

### Output

One record per substation (`type: "netstation"`), plus one summary (`type: "resumé"`). **Field names
and values are in Danish** — the terminology of the source and the market.

```json
{
  "type": "netstation",
  "netstation": "MAL_150",
  "stationsnavn": "Malling",
  "nettype": "transmissionsnet",
  "spændingsniveauKV": 150,
  "ledigForbrugMW": 0,
  "forbrugsstatus": "opbrugt",
  "ledigProduktionMW": 42,
  "produktionsstatus": "knap",
  "ledigProduktionMWForstærketNet": 385,
  "netforstærkning": "existing_grid",
  "solcelleandelPct": 4,
  "vindandelPct": 5,
  "afstandKm": 63.42,
  "breddegrad": 56.0483,
  "længdegrad": 10.1404,
  "nyStation": false,
  "ændretStation": true,
  "tidligereLedigForbrugMW": 20,
  "kildeDato": "2026-02-01T00:00:00.000Z",
  "hentetTidspunkt": "2026-09-29T12:00:00.000Z",
  "kildeUrl": "https://kapacitetskort.dk/"
}
```

**Existing grid versus reinforced grid.** The source lists every 132/150 kV station twice: the grid
as it exists today, and after planned reinforcement. `MAL_150` has 42 MW now and 385 MW in the
reinforced grid.

- `ledigForbrugMW` / `ledigProduktionMW` always carry the **existing grid** figure — what you can
  count on today. These drive the status calculation.
- `netforstærkning` says which source row the figure came from. `reinforced_grid` means the station
  exists only in the planned grid, so the headline figure is an expectation — verify it before
  building a business case on it.
- `ledigForbrugMWForstærketNet` / `ledigProduktionMWForstærketNet` carry the reinforced figure
  alongside. `null` when there is no reinforced row, and always `null` for distribution stations.

**How to read `forbrugsstatus` and `produktionsstatus`** (with `tilslutningskravMW = 20`):

| Available capacity | Status | Meaning |
|---|---|---|
| below 20 MW | `opbrugt` | Cannot host a connection of your size |
| 20 up to 100 MW | `knap` | Fits, but no room to expand |
| 100 MW or more | `ledig` | Room for five times your requirement |
| field missing in the source | `ukendt` | Never silently interpreted as 0 |

The boundary is `5 × tilslutningskravMW`. Set it to 50 MW and the boundary moves to 250 MW — the
same applies to every status filter. The raw MW figure is always included so you can recompute.

**The summary record** (`type: "resumé"`) is free and always covers the **full, untruncated**
selection — not just the records you receive. That is why a country-wide overview costs $2.01 by
setting `maksAntal` to 200. Key fields: `totalNetstationer` / `antalLeveret`,
`antalTransmissionsnet` / `antalDistributionsnet`, `antalKunIForstærketNet`,
`forbrugsstatusOptælling` / `produktionsstatusOptælling`, `totalLedigForbrugMW` /
`totalLedigProduktionMW`, `antalMedSolcellerTilsluttet` / `totalTilsluttedeSolcellerMW` (same for
wind), `mestBelægnedeProduktionsstationer` / `mestLedigeForbrugsstationer` /
`mestLedigeProduktionsstationer`, `filtertrin`, `leveringsrekkefolge`, `koordinater` /
`koordinaterByttetOm`, `afkortet` / `antalFoerAfkortelse`, `foerespurgteRaekker` / `modtagneRaekker` /
`sammenlagteRaekker`, `kildeDato` / `hentetTidspunkt`.

**Delivery order.** With a coordinate: ascending distance. Without coordinate or filters:
**descending available production capacity, then descending available consumption capacity, then
station code** — so a run with no input shows the most interesting stations first, not "AAA, AAB".
The order is deterministic.

### Use cases

- **Site selection before due diligence** — compare candidate areas on actual available capacity
  instead of a green/red colour on a map.
- **Renewable projects** — find stations where `minLedigProduktionMW` exceeds your plant size, and
  read `tilsluttedeSolcellerMW` / `tilsluttedeVindMW` to see how packed a station already is.
- **Electrification of heavy industry** — set `tilslutningskravMW` to your real demand, e.g. 60 MW.
- **Data centre and Power-to-X screening** — find transmission stations above 132 kV still `ledig`.
- **Municipal and regional planning** — run monthly with `kunNyeEllerAendrede: true`.

### Pricing

Pay per event (PPE), no subscription:

- `netstation-resultat` — **$0.01** per delivered substation record. Records that could not be
  written to the dataset are not charged.
- `aendringssignal` — **$0.02** on top, when a station is new or changed since the previous run.
- `apify-actor-start` — Apify's standard start charge.
- **The summary is free**, which is why a country-wide screening costs $2.01 for 200 records instead
  of $10.97 for all 1,097: set `maksAntal` or use filters and read the summary for the totals.

### Legal and source

- **Source:** Energinet + Dansk Energi, *Kapacitetskort for elnettet* (kapacitetskort.dk), read via
  the ArcGIS Feature Service `Kapacitetskortet_V2` in Esri's public ArcGIS Online, publicly
  queryable without authentication. Nothing is cached beyond the run.
- **No personal data.** Records describe transformer stations, voltage levels and megawatts — not
  applicants — so there is no data-processing obligation, unlike a connection queue with company
  names.
- **Licence:** the AGOL item specifies no `licenseInfo` or `termsOfUse`. The data is publicly
  available without an explicit reuse licence, and the Actor does not resell it as its own.
  `robots.txt` of both `energinet.dk` and `arcgis.com` permits the endpoints used.
- **No advice.** The Actor reproduces the latest official figures only; no investment, location or
  project advice, and no prediction of when capacity is released.

### FAQ

**Why does every 132/150 kV station say `opbrugt`?** Because that is what the source says: available
consumption capacity in the transmission grid is 0 MW at all 298 transmission rows. Not an Actor
bug — the grid crisis in one number. Always check `kildeDato`.

**I got 0 results. Why?** Read `filtertrin` in the summary — it shows how many stations remained
after each filter. For `{"nettype": ["transmissionsnet"], "minLedigForbrugMW": 500}` it reads
`1097 → nettype 160 → minLedigForbrugMW 0`: there are 160 transmission stations and none has 500 MW
of consumption headroom (correct, theirs is 0 MW). Lower the threshold, or use
`netforstærkning: ["reinforced_grid"]` for the planned grid.

**Only one coordinate is filled in — why an error instead of the whole country?** Because you would
receive 200 unrelated stations and pay for them. Coordinates come in pairs, and half an input is
rejected with a clear message instead of guessing. A failed run is not charged.

**I swapped latitude and longitude. Will the answer be wrong?** Not when it is unambiguous: if the
order you supplied is invalid, or the swapped order is the only one inside the Danish latitude band,
the Actor corrects it and sets `koordinaterByttetOm: true`. If both readings are valid and neither
resembles Denmark, nothing is changed — a latitude of 10° is valid for a user in the tropics.

**Why does `stationsnavnIndeholder: "Aarhus"` find "Århus"?** The Actor folds å/ø/æ when comparing,
because Denmark uses both spellings. Station codes are *not* folded, so `netstationer: ["MAL_150"]`
must be spelled exactly as in the source.

**Why are there 1,097 records when the source has 298 + 963 rows?** The source has no single row per
physical station:

1. **Transmission grid (298 rows → 160 stations).** Each station appears twice (existing + reinforced
   grid); the Actor delivers one record per station with both figures. 20 stations exist only in the
   reinforced grid, where `netforstærkning` is `reinforced_grid`.
2. **Distribution grid (963 rows → 937 stations).** 89 codes are used twice. 26 pairs are the **same**
   station listed twice under a different parent substation (same name, same coordinates) — merged,
   newest row wins. The other 63 are **two different** stations sharing an abbreviation: `HES` is
   both "Hestlund" and "Herning sydvest", `ØST` is both "Østerlars" and "Østergaarde". Both are kept,
   because the code alone does not identify the station.

   So `netstationer: ["HES"]` can return two different stations — use `stationsnavnIndeholder` when
   the code alone is too vague. The number of merged rows is in `sammenlagteRaekker`.

**What is the difference between `ledigForbrugMW` and `ledigForbrugVedTSOMedlMW`?** For distribution
stations the source gives the capacity without a TSO transformer (used for the status) and the
capacity when connected via a TSO transformer. Only the first counts for the status.

**How often is the data updated?** Energinet updates the map continuously. Each record carries
`kildeDato`; the run's `hentetTidspunkt` says when it was fetched.

**Can I monitor my area?** Yes: set filters (e.g. `stationsnavnIndeholder: "Aarhus"`), set
`maksAntal` high enough, and `kunNyeEllerAendrede: true`. The snapshot always covers the entire
filtered selection — including records `maksAntal` truncates. Note it is shared across all runs of
this Actor, so it suits monitoring the whole country or one bounded area, not comparing two filter
configurations.

**Why is my first run charged?** Because you get usable data from it, and a one-off run should not
subsidise a monitoring user.

### Ofte stillede spørgsmål (dansk)

Denne Actor læser Energinets officielle **kapacitetskort for elnettet** og gør det til strukturerede
data. Alle feltnavne og værdier i outputtet er på dansk, fordi det er kildens og markedets egne ord
(`ledigForbrugMW`, `forbrugsstatus`, `transmissionsnet`, `reinforced_grid` og så videre).

- **Hvad får jeg?** Én post pr. transformerstation i Danmark (1.097 i alt: 160 i transmissionsnettet
  132/150 kV og 937 i distributionsnettet 60/10 kV) med ledig forbrugs- og produktionskapacitet i MW,
  kapacitetsstatus (`opbrugt`, `knap`, `ledig`), afstand til dit koordinat og ændringssignaler siden
  sidste kørsel.
- **Hvad koster det?** $0,01 pr. leveret netstationspost og $0,02 oveni når en station er ny eller
  ændret. Resuméet er **gratis** og dækker altid hele det filtrerede udvalg — en landsdækkende
  screening kan derfor koste $2,01 for 200 poster i stedet for $10,97.
- **Hvordan søger jeg?** Skriv et stednavn (`Aarhus` finder også `Århus`, fordi å/ø/æ foldes), en
  stationskode som `MAL_150`, eller et koordinat. Postnumre understøttes ikke.
- **Hvordan ser jeg, hvor der er plads?** Sæt `minLedigProduktionMW` (f.eks. 20 MW), eller læs
  `mestLedigeProduktionsstationer` i resuméet.
- **Hvorfor står der `opbrugt` overalt i transmissionsnettet?** Fordi den ledige forbrugskapacitet
  dér er 0 MW på samtlige stationer i kilden. Det er netkrisen, ikke en fejl.
- **Hvad betyder `netforstærkning`?** `existing_grid` er kapaciteten i det net, der findes i dag.
  `reinforced_grid` betyder, at stationen kun findes i det **planlagte** net — potentiale, ikke
  virkelighed endnu. `*ForstærketNet`-felterne viser tallet ved siden af.
- **Hvorfor er der 1.097 poster, når kilden har 298 + 963 rækker?** Fordi hver transmissionsstation
  står to gange (eksisterende og forstærket net, slået sammen til én post), og fordi 63
  distributionskoder deles af to forskellige stationer (f.eks. `HES` = både Hestlund og Herning
  sydvest). Dem holdes adskilt på navn og koordinater.
- **Er der persondata?** Nej. Kilden beskriver stationer, spændingsniveauer og MW — ikke ansøgere.

### Related Actors

- [NL Netcongestie Monitor](https://apify.com/codeclouds/nl-netcongestie-monitor) — the same problem
  for the Dutch grid, per postcode/address/coordinate via the official Capaciteitskaart.
- [UK Grid Capacity Tracker](https://apify.com/codeclouds/uk-netcongestie-grid-capacity-tracker) —
  the UK connection queue from NESO's TEC register.

### Keywords

kapacitetskort, kapacitetskort for elnettet, netkapacitet, ledig kapacitet, ledig
forbrugskapacitet, ledig produktionskapacitet, elnettet, transformerstation, netstation,
tilslutning elnet, nettilslutning, nettilslutning Danmark, Energinet, Energinet data, Dansk Energi,
Green Power Denmark, netforstærkning, forstærket net, distributionsnet, transmissionsnet, 132 kV,
150 kV, 60/10 kV, VE-anlæg, solcelleanlæg, solceller tilslutning, vindmøllepark, batterilager,
batteri tilslutning, elproduktion, Power-to-X, datacenter Danmark, tung industri, elektrificering,
kapacitetsstatus, flaskehals, netudbygning, ændringssignal, overvågning af elnettet, grid capacity
Denmark, Denmark grid capacity, Danish grid capacity map, Energinet capacity map, Danish substation
capacity, interconnection queue Denmark, grid congestion Denmark, energy permitting Denmark,
transformer station Denmark, renewable energy siting Denmark, solar grid connection Denmark, wind
farm grid connection Denmark.

### Changelog

#### 0.1.0

- First release. Reads Energinet's `Kapacitetskortet_V2` (transmission grid, distribution grid and
  ledige felter), classifies capacity status, computes distance from a coordinate, detects changes
  since the previous run, and delivers a free summary.
- The source's duplicate rows are handled explicitly: existing grid vs. reinforced grid for
  132/150 kV stations, and code duplicates in the distribution grid are separated by name and
  coordinates, so no physical station disappears and no two stations merge.
- Unknown capacity values get status `ukendt` instead of being read as 0 MW.
- The result is explicitly flagged as truncated when `maksAntal` removed records.
- Free-text filters fold å/ø/æ, so `Aarhus` finds `Århus` and `Koebenhavn` finds `København`.
- Swapped latitude/longitude are corrected automatically when unambiguous; unreadable coordinates
  produce a clear error instead of an empty list.
- The summary always covers the full, untruncated selection and includes `filtertrin`, so it is
  always visible which filter made a result empty.
- Without filters and coordinates the stations with the most available capacity are delivered
  first, instead of alphabetically — a run with no input is now a usable overview.
- Enum filter matching is case- and whitespace-tolerant; negative `maksAntal`, `maksAfstandKm` and
  `tilslutningskravMW` are rejected instead of producing odd results.

# Actor input Schema

## `nettype` (type: `array`):

Which grid to read. "transmissionsnet" = Energinet's 132/150 kV transmission grid (160 stations). "distributionsnet" = the 60/10 kV distribution substations (937 stations). Empty = both.

## `netstationer` (type: `array`):

Look up specific substations by their code, e.g. "MAL\_150" (transmission) or "FBY" (distribution). Case is ignored. Empty = all. Note that some distribution codes are shared by two different stations — use stationsnavnIndeholder when the code alone is too vague.

## `stationsnavnIndeholder` (type: `string`):

Free-text filter on station name or substation code, e.g. "Aarhus" or "Sønder". Danish å/ø/æ are searchable both ways: "Aarhus" finds "Århus", "Koebenhavn" finds "København". Multiple filters combine with AND.

## `breddegrad` (type: `number`):

Latitude in decimal degrees (WGS84) for a point query. Must be used together with længdegrad — supplying only one raises an error, so you never accidentally buy the whole country. If latitude and longitude are swapped, the Actor corrects them automatically when it is unambiguous (and reports it in the summary).

## `længdegrad` (type: `number`):

Longitude in decimal degrees (WGS84). Must be used together with breddegrad. Results are sorted by distance and afstandKm is filled in per station.

## `maksAfstandKm` (type: `number`):

Only stations within this distance of the coordinate are included. Default 25 km.

## `maksAntalNærmeste` (type: `number`):

How many of the nearest stations are delivered for a point query. Default 10.

## `tilslutningskravMW` (type: `number`):

The connection size you evaluate a station against. This drives kapacitetsstatus: below the requirement = "opbrugt", between the requirement and 5x it = "knap", 5x or more = "ledig". Default 20 MW (a small commercial installation).

## `minLedigForbrugMW` (type: `number`):

Only stations with at least this much available consumption capacity (ledig forbrugskapacitet). Stations without a consumption figure in the source (null) are excluded when this field is set.

## `minLedigProduktionMW` (type: `number`):

Only stations with at least this much available production capacity (ledig produktionskapacitet), e.g. for solar, wind or other generation.

## `forbrugsstatus` (type: `array`):

Filter on capacity status for consumption. "opbrugt" = below the connection requirement, "knap" = between the requirement and 5x it, "ledig" = 5x or more, "ukendt" = the source gives no consumption figure for this station.

## `produktionsstatus` (type: `array`):

Filter on capacity status for production (solar, wind, other generation). Same rule as consumption status.

## `netforstærkning` (type: `array`):

Filter on which grid the capacity figure comes from. "existing\_grid" = capacity in the grid that exists today (the value used for status). "reinforced\_grid" = stations that exist ONLY in the planned, reinforced grid — potential, not reality yet. Only transmission stations (132/150 kV) carry this value.

## `minSpændingsniveauKV` (type: `number`):

Filter on the station's voltage level. For distribution stations the first (highest) level in the field is used, so "60/10" counts as 60 kV. E.g. 132 returns only 132/150 kV stations.

## `kunNyeEllerAendrede` (type: `boolean`):

Default false: every run delivers the full filtered selection. Set to true for monitoring — then only stations that are new or whose capacity/status changed since the previous run are delivered (and charged as change signals). Comparison uses a shared, persistent snapshot in a named key-value store, which scheduled runs also update.

## `maksAntal` (type: `number`):

Maximum number of substation records delivered per run (at least 1). Default 200. Without filters and coordinates the stations with the most available capacity come first, so a run with no input shows the most relevant ones. The free summary ALWAYS covers the full, untruncated selection — a country-wide overview therefore costs only 200 records. Truncation is flagged in the summary with afkortet=true and antalFoerAfkortelse, so a result never looks complete when it is not.

## Actor input object example

```json
{
  "breddegrad": 56.1629,
  "længdegrad": 10.2039,
  "maksAfstandKm": 15,
  "maksAntalNærmeste": 3,
  "tilslutningskravMW": 20,
  "kunNyeEllerAendrede": false,
  "maksAntal": 200
}
```

# Actor output Schema

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

All matched substations (type = "netstation") plus one free summary (type = "resumé") in the default dataset.

# 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 = {
    "breddegrad": 56.1629,
    "længdegrad": 10.2039,
    "maksAfstandKm": 15,
    "maksAntalNærmeste": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("codeclouds/dk-elnet-kapacitetskort").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 = {
    "breddegrad": 56.1629,
    "længdegrad": 10.2039,
    "maksAfstandKm": 15,
    "maksAntalNærmeste": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("codeclouds/dk-elnet-kapacitetskort").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 '{
  "breddegrad": 56.1629,
  "længdegrad": 10.2039,
  "maksAfstandKm": 15,
  "maksAntalNærmeste": 3
}' |
apify call codeclouds/dk-elnet-kapacitetskort --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,codeclouds/dk-elnet-kapacitetskort"
        }
    }
}
```

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/oha2bcSA3ZcWYU2Lu/builds/sH6kk4dlSWImrpimo/openapi.json