# EIPA Charging Poland API – Official EV Stations (`enterprising_hamster/polish-ev-charging-stations-eipa`) Actor

EIPA charging Poland: every public EV charger from the official UDT register — operator, address, GPS, power, CCS/Type 2/CHAdeMO, live free/occupied status and ad-hoc prices per kWh. Runs without a token; export CSV, JSON or Excel. No personal data.

- **URL**: https://apify.com/enterprising_hamster/polish-ev-charging-stations-eipa.md
- **Developed by:** [Kamil Kaczmarek](https://apify.com/enterprising_hamster) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.40 / 1,000 stations

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Poland EV Charging Stations API – Official EIPA Register

**Poland EV charging stations API**: every public EV charger, CNG/LNG and hydrogen station in Poland (about 7,500 stations, 15,000 charging points, 610 operators) from **EIPA**, the official register of the Polish Office of Technical Inspection (UDT). One item per station: operator, address, GPS, opening hours, power in kW, connectors (CCS2, CHAdeMO, Type 2, MCS), **live free/occupied status** and **ad-hoc prices per kWh**. Press Start without any account to get the 100 newest stations in about 30 seconds; export CSV, JSON or Excel. Polski opis: lista stacji ładowania samochodów elektrycznych w Polsce z rejestru EIPA (UDT), z cenami i dostępnością na żywo.

**Try it without an account, then use your own free EIPA account.** EIPA gives its data only to registered readers and limits downloads per account. With the token field empty the Actor runs on its shared demo account, which every user shares and which EIPA may lock for an hour when busy. For regular runs register an e-mail at **https://eipa.udt.gov.pl/reader/register**, click the link EIPA sends, and paste the token from the second e-mail into the Actor. See [How to use](#how-to-use).

**No personal data.** Stations of operators who may be natural persons are anonymised or left out. See [Privacy](#privacy).

### What data can you get

About **7,500 stations** (7,430 EV chargers, 60 CNG/LNG, 12 hydrogen) with **15,000 points** at **6,100 sites** of **610 operators** (October 2026):

- **Station:** EIPA id, type (ELECTRIC, GAS, HYDROGEN), suspension, last update.
- **Operator:** name, short name, EIPA code (the prefix of EVSE ids such as `PL-GRW-E...`), type (company, public body, non-profit), role (operator, service provider or both), customer phone, e-mail (role or brand mailboxes only) and website. The organisation hosting the site (e.g. a retailer) when the operator registered one.
- **Place:** site name, street, number, postal code, city, commune, county, voivodeship, latitude and longitude, directions, opening hours, planned closures.
- **Access:** authentication (open access, app, RFID, PIN pad, ISO 15118...), payment methods (card, app, fleet card, free charging...).
- **Points:** EVSE code, power in kW per charging mode (Mode 3 AC, Mode 4 DC), connectors with power and tethered cable, CNG/LNG output, hydrogen pressure.
- **Live:** status of each point (operational, free) with its timestamp, and the prices EIPA publishes for customers without a contract (PLN per kWh, minute, m³ or kg, with the operator's note). Station totals: free, occupied and out-of-service points, highest power, DC available, lowest price per kWh.

### How to use

1. **Optional, to try it:** press **Start** with the token empty. The run uses the shared demo account.
2. **Get a token (once, free) for regular use:** open https://eipa.udt.gov.pl/reader/register, enter an e-mail, accept the two data-processing consents and confirm the link EIPA e-mails you. A second e-mail lists download links ending in a 32-character token.
3. Paste the token (or a whole link) into **EIPA reader token**. The field is secret: Apify stores it encrypted and the Actor never writes it to the dataset, logs or storage.
4. Press **Start**. With no other changes you get the 100 most recently registered stations with live status (about 30 seconds).
5. Narrow down with **voivodeships**, **cities**, **communes**, **operators**, **connector types**, **minimum power**, **only with a free point now** or **only free charging**, and raise **Max stations** for more. The whole register is about 7,500 stations.
6. For monitoring, schedule runs with **Only new or changed**: each run delivers only stations whose register data, status or prices changed.

EIPA deletes reader accounts that download nothing for 30 days, so keep at least one run a month on a schedule.

### Download limits and the cache

EIPA allows each account **10 downloads an hour of the static files** and **240 of the live file**; going over locks the account for an hour. A run downloads the five static files (dictionary, operators, sites, stations, points) and the live file once. The register after the privacy pass is cached in your Apify account (named key-value store `polish-ev-charging-stations-eipa-cache`, keyed by a hash of the token) and reused for **6 hours** by default (`staticCacheHours`), so frequent schedules cost one live download per run. Set it to 0 to always download. If EIPA refuses a download, the run fails with a message that names the file and the limit; no retries are made on refusals.

### Input

Quick DC ≥50 kW chargers in Warsaw that are free now:

```json
{ "cities": ["Warszawa"], "minPowerKw": 50, "onlyAvailableNow": true, "maxItems": 50 }
```

Specific operators in one voivodeship (competitor analysis):

```json
{ "operators": ["GreenWay", "Orlen"], "provinces": ["śląskie"], "maxItems": 500 }
```

| Field | Default | What it does |
|---|---|---|
| `eipaToken` | empty (shared demo account) | Your EIPA reader token, or any download link from the EIPA e-mail. Secret. Empty = the Actor's shared demo account, limited to 10 static downloads an hour for all users together. |
| `provinces` | all | Voivodeships, e.g. `["mazowieckie", "śląskie"]`. |
| `cities` | none | Places (miejscowość), e.g. `Warszawa`. Case and Polish letters do not matter. |
| `communities` | none | Communes (gmina) as EIPA names them. Also matches anonymised stations. |
| `stationTypes` | all | `ELECTRIC`, `GAS`, `HYDROGEN`. |
| `operators` | none | Text in the operator name, short name, EIPA code or site operator, e.g. `GreenWay`, `PL-TSL`. |
| `connectorTypes` | any | EIPA connector names, e.g. `IEC-62196-T2-COMBO` (CCS2), `CHADEMO`, `IEC-62196-T2-F-NOCABLE` (Type 2 socket). |
| `minPowerKw` | `0` | At least one point with this power, e.g. `50` or `150`. |
| `onlyAvailableNow` | `false` | At least one point operational and free at download time. |
| `onlyFreeCharging` | `false` | Free charging listed as a payment method. |
| `includeLiveData` | `true` | Download live status and prices (one extra download). |
| `privateOperators` | `ANONYMIZE` | `ANONYMIZE` (commune level) or `SKIP` for stations of possible natural persons. |
| `staticCacheHours` | `6` | Reuse the static register for this many hours (0-168). |
| `maxItems` | `100` | Hard cap of stations, and so of cost. Newest registrations come first. |
| `onlyNew` | `false` | Skip stations delivered before with unchanged data. |
| `stateKey` | `default` | Separate memory for each schedule. |

```json
{
  "eipaToken": "<your EIPA token>",
  "cities": ["Warszawa"],
  "stationTypes": ["ELECTRIC"],
  "minPowerKw": 50,
  "maxItems": 200
}
```

### Output

One item per station. Trimmed example:

```json
{
  "stationId": "226818",
  "stationType": "ELECTRIC",
  "operatorDisclosed": true,
  "siteName": "Business Garden Warszawa – B3 parking wewnętrzny level -01",
  "operatorCode": "PL-GJC",
  "operatorName": "EV PLUS Spółka z ograniczoną odpowiedzialnością",
  "operatorType": "COMPANY",
  "operatorEmail": "biuro@evplus.com.pl",
  "street": "ul.Żwirki i Wigury",
  "houseNumber": "16B",
  "postalCode": "02-092",
  "city": "Warszawa",
  "province": "mazowieckie",
  "latitude": 52.18947,
  "longitude": 20.98338,
  "openAroundTheClock": true,
  "paymentMethods": ["PAYMENT_CARD", "PREPAID_CARD", "FLEET_CARD"],
  "pointsCount": 2,
  "maxPowerKw": 11.0,
  "dcCharging": false,
  "connectorTypes": ["IEC-62196-T2-F-NOCABLE"],
  "availablePoints": 1,
  "occupiedPoints": 0,
  "outOfServicePoints": 1,
  "points": [{"evseCode": "PL-GJC-E82472475", "maxPowerKw": 11.0,
              "chargingModes": [{"mode": "Mode3-AC-3p", "powerKw": 11.0}],
              "status": {"operational": false, "free": true, "updatedAt": "2026-04-29T15:51:50+02:00"},
              "prices": [], "pricesCount": 0}],
  "registryGeneratedAt": "2026-10-22T08:05:06+02:00",
  "source": "Urząd Dozoru Technicznego, Ewidencja Infrastruktury Paliw Alternatywnych (EIPA), https://eipa.udt.gov.pl"
}
```

Every field is described in the dataset schema. The run's `SUMMARY` record holds the register times, the number of matching stations, stations of private operators, withheld e-mail addresses and whether the spending limit stopped the run.

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| `station` | $0.003 | One delivered station of a company or public body, with operator, address, GPS, points, status and prices. |
| `anonymized-station` | $0.001 | One delivered station of a private operator, at commune level (no operator, address or position). |

No start fee. Set a maximum cost per run in Apify and the Actor stops at it. Platform usage is included in the price.

### Use cases

- **Charging apps and route planners:** live free/occupied status and ad-hoc prices for every public charger in Poland, from the official source.
- **Fleet and logistics:** DC and MCS chargers along routes, opening hours, fleet-card acceptance, LNG and hydrogen stations for trucks.
- **Site selection and grid planning:** charger density per commune and county, power mix, gaps between fast chargers.
- **Market and competitor analysis:** network size per operator, new registrations, price per kWh by operator and region.
- **Price monitoring:** schedule with *Only new or changed* to receive price and status changes.

### Privacy

EIPA publishes the operator's name and customer contacts. Many small operators in Poland are natural persons running a business (jednoosobowa działalność gospodarcza) or civil partnerships, and their business names are their own names. This Actor does not process their personal data any further:

- An operator is **named** only when its name carries a legal form or public-body marker (sp. z o.o., S.A., GmbH, UAB, gmina, urząd, spółdzielnia, wspólnota mieszkaniowa...) and contains no first name followed by a surname, or when its EIPA code is on a short list of operators checked by hand in the National Court Register (KRS): EleportPL and ChargeIn CPO. A partnership counts only when its partner is a company (e.g. *Sp. z o.o. Sp. k.*).
- Everyone else is a **private operator**: sole traders, civil and general partnerships of people, and names without a legal form. Sites that the operator assigned to an organisation without a legal form or to a person are treated the same way.
- **Stations of private operators** are delivered anonymised (or left out with `privateOperators: SKIP`): commune, county, voivodeship, technical data, access and payment methods, live status and prices only. No station, site, point or operator ids, no EVSE codes, operator name or contacts, site name, address, city, coordinates, directions, opening hours or price notes.
- For named operators, e-mail addresses that may belong to a person (first name or surname in the address) are withheld, site names that contain a person's name are dropped, and phone numbers, e-mail addresses and names are removed from free-text directions and price notes. Photos are never read.
- The rule errs towards hiding: some companies whose registered names show no legal form are anonymised too.
- The cached register in your account already went through these rules; the token is stored only as a hash.

This is a mechanical rule on names, not a legal opinion; contact us if you find personal data in the output.

### Source and terms

- Data: **Urząd Dozoru Technicznego, Ewidencja Infrastruktury Paliw Alternatywnych (EIPA)**, https://eipa.udt.gov.pl. Every item carries the source, the time EIPA generated the files and the retrieval time.
- EIPA FAQ: downloading data from EIPA is free for both commercial and non-commercial purposes; downloaded data may be presented on your own site or processed in other ways; hourly download limits apply. Registration asks only for an e-mail and two GDPR consents.
- UDT's terms for re-use of public sector information (https://bip.udt.gov.pl): name UDT as the source, give the date the data were obtained, mark that the data were processed, and UDT bears no responsibility for processed data. The `source`, `retrievedAt`, `registryGeneratedAt` and `processingNote` fields carry this in every item.
- UDT does not guarantee that operators keep their data up to date. Live status timestamps show when the operator last reported; some are months old.

### FAQ

**Is there an API for EV charging stations in Poland?** Yes: EIPA publishes JSON files for registered readers; this Actor turns them into one clean table with filters, live status and prices, callable from the Apify API.

**How do I export all charging stations in Poland to CSV/Excel?** Set Max stations to 10000 and download the dataset as CSV or Excel.

**Can I get charging prices per kWh?** Yes, as reported to EIPA for customers without a contract (`lowestPricePerKwh` and per-point prices).

**Does it work without an EIPA account?** Yes, on a shared demo account; use your own free token for regular runs.

**Why should I use my own token?** EIPA gives data only to registered readers and limits each account. The shared demo account puts every user under one limit (10 static downloads an hour, two uncached runs), so it can be refused when busy; the run then fails with a message asking for your own token. Registration is free and takes a minute.

**How fresh is the data?** EIPA regenerates the files continuously; the live file is read at run time. The static part may be up to `staticCacheHours` old.

**Why are some stations without operator and address?** They belong to operators who may be natural persons; see Privacy.

**Does it cover private home chargers?** No. EIPA lists publicly accessible stations only.

**Why does a run fail with HTTP 403?** The token is wrong, or the account went over EIPA's hourly limit and is locked for an hour.

### Integrations

Use the Apify API, scheduler, webhooks, Make, Zapier, n8n or Google Sheets export as with any Actor. Combine with *Only new or changed* to feed a database with changes only.

### Development

```bash
python3 -m venv .venv && .venv/bin/pip install -r requirements-dev.txt
.venv/bin/python -m pytest
EIPA_READER_TOKEN=... examples/run-local-ppe.sh examples/fast-chargers-warsaw-live.json
```

Tests run offline on a synthetic register (`tests/eipa_builder.py`) that contains every privacy case. `scripts/gen_dataset_schema.py` writes the dataset schema.

### Disclaimer

Not affiliated with UDT. The data are the operators' reports to EIPA, processed by this Actor; check prices and availability with the operator before relying on them.

### 🇵🇱 Po polsku

Aktor zwraca wszystkie ogólnodostępne stacje ładowania samochodów elektrycznych, stacje CNG/LNG i wodorowe w Polsce z Ewidencji Infrastruktury Paliw Alternatywnych (EIPA) prowadzonej przez Urząd Dozoru Technicznego: operatora, adres, współrzędne, godziny otwarcia, metody płatności i autoryzacji, punkty z mocą, trybami ładowania i złączami, aktualny status punktów (wolny, zajęty, niedostępny) i ceny dla klientów bez umowy. Filtry: województwo, miejscowość, gmina, operator, typ stacji, złącze, minimalna moc, wolny punkt teraz, bezpłatne ładowanie.

Bez tokenu aktor działa na wspólnym koncie demonstracyjnym (wspólny limit dla wszystkich użytkowników, przy dużym ruchu EIPA blokuje je na godzinę). Do regularnej pracy potrzebne jest własne, bezpłatne konto czytelnika EIPA (https://eipa.udt.gov.pl/reader/register) i token z maila od EIPA, wpisywany w polu tajnym. EIPA pozwala na 10 pobrań plików statycznych i 240 pobrań pliku dynamicznego na godzinę na konto; aktor zapamiętuje przetworzone dane statyczne w Twoim koncie Apify (domyślnie na 6 godzin), więc częste uruchomienia pobierają tylko plik dynamiczny.

Ochrona danych (osoby fizyczne): operatorzy mogący być osobami fizycznymi (jednoosobowe działalności, spółki cywilne i jawne osób, nazwy bez formy prawnej) nie są ujawniani. Ich stacje trafiają do wyników tylko na poziomie gminy, z danymi technicznymi, statusem i cenami, bez nazwy, kontaktów, adresu, miejscowości, współrzędnych i kodów (albo są pomijane: `privateOperators: SKIP`). U pozostałych operatorów wstrzymywane są adresy e-mail mogące należeć do osoby, a z opisów dojazdu i cen usuwane są telefony, e-maile oraz imiona i nazwiska. Osoby fizyczne nie są więc w żaden sposób identyfikowane.

Źródło: Urząd Dozoru Technicznego, Ewidencja Infrastruktury Paliw Alternatywnych (EIPA), https://eipa.udt.gov.pl. Dane przetworzone przez aktora; UDT nie ponosi odpowiedzialności za ich treść po przetworzeniu. Pobieranie danych z EIPA jest bezpłatne w celach komercyjnych i niekomercyjnych.

# Changelog

This Actor's version history is a separate document: https://apify.com/enterprising_hamster/polish-ev-charging-stations-eipa/changelog.md

# Actor input Schema

## `eipaToken` (type: `string`):

Optional: your own free EIPA reader token. Leave empty to try the Actor on its shared demo account, which all users share under EIPA's limit of 10 static downloads an hour, so it may be refused when busy. For regular or scheduled runs register an e-mail at https://eipa.udt.gov.pl/reader/register, confirm it, and paste the 32-character token (or any download link) from the e-mail EIPA sends. The Actor caches the static files in your account, so one account is enough for frequent runs.

## `provinces` (type: `array`):

Only stations in these voivodeships. Empty = whole country.

## `cities` (type: `array`):

Only stations in these places (miejscowość), e.g. Warszawa, Kraków. Case and Polish letters do not matter.

## `communities` (type: `array`):

Only stations in these communes (gmina), as EIPA names them, e.g. Warszawa, Siemianowice Śląskie.

## `stationTypes` (type: `array`):

ELECTRIC = EV chargers, GAS = CNG/LNG, HYDROGEN = hydrogen. Empty = all.

## `operators` (type: `array`):

Only stations whose operator name, short name, EIPA code (e.g. PL-GRW) or site operator contains one of these, e.g. GreenWay, Orlen, Tesla. Private operators are never matched.

## `connectorTypes` (type: `array`):

Only stations with at least one of these connectors. Empty = any.

## `minPowerKw` (type: `integer`):

Only stations with at least one point of this power or more, e.g. 50 for fast DC, 150 for high-power charging. 0 = any.

## `onlyAvailableNow` (type: `boolean`):

Only stations where EIPA reports at least one point operational and free at download time. Needs live data.

## `onlyFreeCharging` (type: `boolean`):

Only stations that list free charging (bezpłatne ładowanie) as a payment method.

## `includeLiveData` (type: `boolean`):

Download EIPA's live file: point status (free, occupied, out of service) and ad-hoc prices. One extra download (limit 240 an hour).

## `privateOperators` (type: `string`):

Stations whose operator may be a natural person (sole traders, civil partnerships, names without a legal form). ANONYMIZE = deliver them at commune level with technical data, prices and status only (no operator, address, coordinates, codes or notes). SKIP = leave them out.

## `staticCacheHours` (type: `integer`):

Reuse the register (operators, sites, stations, points) downloaded by an earlier run with the same token for this many hours, saving 5 of your 10 static downloads an hour. Live data is always fresh. 0 = always download.

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

Stop after this many stations (newest registrations first). The whole register has about 7,500.

## `onlyNew` (type: `boolean`):

Skip stations delivered by an earlier run with the same state key whose data (including live status and prices, when included) has not changed.

## `stateKey` (type: `string`):

Name of the memory used by 'Only new or changed'. Use a different key per schedule.

## Actor input object example

```json
{
  "provinces": [],
  "cities": [],
  "communities": [],
  "stationTypes": [],
  "operators": [],
  "connectorTypes": [],
  "minPowerKw": 0,
  "onlyAvailableNow": false,
  "onlyFreeCharging": false,
  "includeLiveData": true,
  "privateOperators": "ANONYMIZE",
  "staticCacheHours": 6,
  "maxItems": 100,
  "onlyNew": false
}
```

# Actor output Schema

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

One item per EIPA station with its points, connectors, live status and prices.

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

Register time, matching stations, stations of private operators, withheld e-mails and charge limit.

# 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("enterprising_hamster/polish-ev-charging-stations-eipa").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("enterprising_hamster/polish-ev-charging-stations-eipa").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 enterprising_hamster/polish-ev-charging-stations-eipa --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,enterprising_hamster/polish-ev-charging-stations-eipa"
        }
    }
}
```

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/EvzZn1PHiS6ouxy01/builds/rCk0x7BK8QI7kBgBK/openapi.json