# EV Charging Stations Scraper – OpenStreetMap Charger Data (`dataquarry/ev-charging-stations`) Actor

Extract EV charging station locations from OpenStreetMap by area, radius, or name. Get operator, network, connector/socket types (Type 2, CCS, CHAdeMO, Tesla), power kW to spot fast DC chargers, capacity, fee and access. No API key; open (ODbL) data.

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

## Pricing

from $3.00 / 1,000 results

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

## EV Charging Stations Scraper – OpenStreetMap Charger Data

Extract **electric-vehicle charging stations from OpenStreetMap** by area, radius, or name — **no API key, no rate-limited charging-network API, no anti-bot battles**. Open, legal (ODbL) data you can redistribute.

Give it an area like `"Amsterdam, Netherlands"` and get back tidy rows for every EV charger: name, operator, network, number of charging points, **connector/socket types** (Type 2, CCS, CHAdeMO, Tesla — as tagged in OSM), **maximum power (kW)** so you can spot **fast DC chargers**, fee, access, full address, coordinates, and the raw OpenStreetMap tags. You can also search **around a point** (every charger within X km of an address) or **filter by name/network** (e.g. every `"Tesla"` or `"Ionity"` station).

### Why use this scraper?

- **EV-specific fields.** Not just a generic POI dump — connector/socket types (Type 2, CCS/Combo, CHAdeMO, Tesla), max power in kW, per-socket counts, capacity, fee and access are parsed out of the OpenStreetMap tags for you — enough to identify fast DC charging sites.
- **Legal & open.** OpenStreetMap data is licensed under the ODbL — redistributable with attribution. No Terms-of-Service violation, no login.
- **No API key.** No charging-network developer account, no per-call quota.
- **Search by area, radius, or name/network.** A whole city/country, everything within X metres of a point, or every station of one operator.
- **No duplicates.** When OpenStreetMap maps one station twice (a node and an area), you get a single, richer row.
- **Honest data.** Every value comes straight from OpenStreetMap; anything not mapped is left empty (`null`) — never guessed or padded. `max_power_kw` is read only from explicit power tags.
- **Global coverage & reliable.** Anywhere OSM has data; retries across multiple Overpass mirrors.

### Great for

- EV apps, route planners, and charger-finder maps
- Charging-network market research and coverage analysis
- Site selection for new charging infrastructure
- Fleet & mobility datasets, dashboards, and AI/RAG pipelines

### Input

| Field | Type | Description |
|---|---|---|
| `area` | string | Place to search within, e.g. `"London, United Kingdom"`. Geocoded to a bounding box. |
| `aroundLocation` | string | *(optional)* Address/place to search **around** within a radius, e.g. `"Schiphol Airport"`. Pair with `radiusMeters`. |
| `radiusMeters` | integer | *(optional)* Radius in metres for around-a-location search (default `5000`). |
| `centerPoint` | object | *(advanced)* Explicit center `{ "lat":.., "lon":.. }` to search around. |
| `boundingBox` | object | *(advanced)* Explicit `{ "south":.., "west":.., "north":.., "east":.. }`. Overrides `area`. |
| `searchTerm` | string | *(optional)* Only return stations whose **name** contains this text (case-insensitive), e.g. `"Tesla"`. |
| `maxResults` | integer | Maximum number of stations to return (default `1000`). |

#### Example input

```json
{
  "area": "Amsterdam, Netherlands",
  "maxResults": 500
}
```

Every Tesla station within 10 km of a point:

```json
{
  "aroundLocation": "Utrecht Centraal",
  "radiusMeters": 10000,
  "searchTerm": "Tesla"
}
```

### Output

One row per charging station:

| Field | Description |
|---|---|
| `name` | Station name |
| `operator`, `brand`, `network` | Who runs / brands / networks the station |
| `branch` | Branch / location name of a chain outlet (OSM `branch`), e.g. `Times Square`; `null` when not a tagged branch |
| `brand_wikidata` | Wikidata id of the brand/network (e.g. `Q478214`) — stable entity id for analysis, when tagged |
| `brand_logo` | Official brand logo image URL, from the brand's Wikidata entity (P154) when it has one; `null` otherwise. Optional enrichment — never guessed |
| `capacity` | Number of charging points |
| `max_power_kw` | Highest charging power in kW found across the station's power tags |
| `socket_types` | Array of socket types present, e.g. `["type2","ccs","chademo"]` |
| `capacity_by_socket` | Map of socket type → count, when OSM tags a per-socket count |
| `fee`, `access` | Whether a fee applies; access (public / customers / …) |
| `latitude`, `longitude` | Coordinates |
| `street`, `housenumber`, `city`, `postcode`, `country` | Address |
| `state` | State / province (`addr:state` / `addr:province`); common in US/CA/AU, `null` where not tagged |
| `phone`, `website`, `opening_hours` | Contact + hours |
| `osm_id`, `osm_type`, `all_tags`, `source_url` | OpenStreetMap identifiers, raw tags, and link |
| `full_address` | All present address parts in one string (e.g. `Main St 1, 10115 Berlin`) |
| `map_url` | Google Maps link to the coordinates |

#### Example output

```json
{
  "name": "London - Canary Wharf Supercharger",
  "operator": "Tesla",
  "brand": "Tesla Supercharger",
  "network": "Tesla",
  "capacity": 12,
  "max_power_kw": 250,
  "socket_types": ["tesla_supercharger", "tesla_supercharger_ccs", "type2_combo"],
  "capacity_by_socket": { "tesla_supercharger": 12 },
  "fee": "yes",
  "access": "customers",
  "city": "London",
  "postcode": "E14 5EW",
  "country": "GB",
  "latitude": 51.5049,
  "longitude": -0.0195,
  "osm_type": "node",
  "source_url": "https://www.openstreetmap.org/node/..."
}
```

Any field is `null` (or an empty array) when the station hasn't tagged it in OpenStreetMap — values are never guessed.

### FAQ

**Do I need an API key or account?**
No — give it an area (plus optional radius/name filters) and run. No data-provider key, no quota, no setup.

**Is the data legal to use and redistribute?**
Yes. It comes from OpenStreetMap under the Open Database License (ODbL): public data you can redistribute with attribution (© OpenStreetMap contributors). No logins, no Terms-of-Service violations.

**How is this different from a Google Maps or PlugShare scraper?**
It uses open OpenStreetMap data instead of scraping a site behind anti-bot defenses and Terms of Service — so it's legal, needs no API key, and returns an honest `null` for anything OSM hasn't mapped instead of guessing. You also get charger-specific fields like socket types and power (kW).

**Can I find fast (DC) chargers or filter by connector type?**
Yes — every row carries `socket_types` (e.g. `type2`, `type2_combo` = CCS, `chademo`, `tesla_supercharger`) and `max_power_kw`, so after the run you can keep only rows with `max_power_kw >= 50` (typical DC fast charging) or a specific connector.

**How much does it cost?**
Pay-per-result: **$3 per 1,000 results** — you only pay for the rows you actually get.

**Which countries does it cover?**
Worldwide — anywhere OpenStreetMap has data.

**How fresh is the data?**
It's pulled live from OpenStreetMap at run time, so it reflects the current map.

### Data source & license

Data comes from **OpenStreetMap** via the public **Nominatim** (geocoding) and **Overpass** (querying) APIs. OpenStreetMap data is **© OpenStreetMap contributors**, licensed under the **Open Database License (ODbL)**. If you publish or redistribute results, attribute "© OpenStreetMap contributors".

### Notes

- Coverage and tag richness vary by region — OSM is community-mapped, so dense urban areas are richer.
- Charging stations are sparser than general POIs, so the radius default is wider (5 km).

⭐ **Found this useful?** A quick rating on this actor's Store page helps others discover it — and if something is off or you wish it did more, open an issue on the actor. I read every one.

### More OpenStreetMap data actors

Part of **dataquarry**'s family of clean, ODbL OpenStreetMap extractors — same flexible **area / radius / bounding-box / name** search, same honest-null data (a field that isn't mapped is left empty, never guessed):

- [OpenStreetMap Places Scraper](https://apify.com/dataquarry/osm-places-scraper) — POI & local business, 115+ categories
- [EV Charging Stations Scraper](https://apify.com/dataquarry/ev-charging-stations) — socket types, power (kW), networks
- [Hotels & Lodging Scraper](https://apify.com/dataquarry/hotels-lodging) — stars, rooms, brands
- [Healthcare Facilities Scraper](https://apify.com/dataquarry/healthcare-facilities) — pharmacies, doctors, dentists, clinics
- [Tourist Attractions & Museums Scraper](https://apify.com/dataquarry/tourist-attractions) — Wikidata & Wikipedia links
- [Fuel Station Scraper](https://apify.com/dataquarry/fuel-stations) — fuel types, brands, payment methods
- [Supermarket & Grocery Scraper](https://apify.com/dataquarry/supermarkets) — brands, organic, payment methods

# Actor input Schema

## `area` (type: `string`):

Place to search within, e.g. "London, United Kingdom". Geocoded to a bounding box via Nominatim. Provide this OR a bounding box OR a center for radius search.

## `aroundLocation` (type: `string`):

Optional. An address or place to search AROUND within a radius, e.g. "Schiphol Airport". Geocoded to a center point; set the radius with "radiusMeters".

## `radiusMeters` (type: `integer`):

Radius in meters for the around-a-location search (used with Around Location or Center Point). Default 5000.

## `centerPoint` (type: `object`):

Optional advanced alternative: an explicit center as {"lat":.., "lon":..} to search around. Overrides Around Location when set.

## `boundingBox` (type: `object`):

Explicit bounding box as {"south":..,"west":..,"north":..,"east":..}. Overrides Area when set.

## `searchTerm` (type: `string`):

Optional. Only return stations whose name contains this text (case-insensitive), e.g. "Tesla", "Ionity", "BP Pulse".

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

Maximum number of charging stations to return.

## Actor input object example

```json
{
  "area": "Amsterdam, Netherlands",
  "radiusMeters": 5000,
  "maxResults": 1000
}
```

# 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 = {
    "area": "Amsterdam, Netherlands"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataquarry/ev-charging-stations").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 = { "area": "Amsterdam, Netherlands" }

# Run the Actor and wait for it to finish
run = client.actor("dataquarry/ev-charging-stations").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 '{
  "area": "Amsterdam, Netherlands"
}' |
apify call dataquarry/ev-charging-stations --silent --output-dataset

```

## MCP server setup

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

```

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/ZKBqFxsUigKeRD1zR/builds/sGT0TYHjTQlzH9hHn/openapi.json