# AFDC EV Stations Scraper (`parseforge/afdc-ev-stations-scraper`) Actor

Scrape 60,000+ electric vehicle charging stations across the US. Get station names, addresses, coordinates, connector types, network info, pricing, access hours, and charger counts (Level 1/2/DC Fast). Filter by state.

- **URL**: https://apify.com/parseforge/afdc-ev-stations-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.50 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## ⚡ AFDC EV Charging Stations Scraper

Whether you're building an EV charging app, analyzing infrastructure coverage, or planning fleet electrification, this tool makes it easy to collect structured data on electric vehicle charging stations across the United States.

> **The AFDC EV Stations Scraper collects charging station data including station names, addresses, connector types, charging levels, networks, pricing, and access hours. Filter by US state.**

### What Does It Do

- 📍 **Station locations** - collect station names, full addresses, GPS coordinates, and intersection directions
- 🔌 **Charger details** - get Level 1, Level 2, and DC fast charger counts with connector types (J1772, CCS, CHAdeMO, Tesla)
- 🌐 **Network info** - identify which network operates each station (ChargePoint, Tesla, EVgo, Electrify America, etc.)
- 💲 **Pricing data** - extract charging costs and pricing details for each station
- 🕐 **Access info** - see hours of operation, access codes, and which groups can use each station
- 📊 **Station status** - track open dates, last confirmed dates, and current operational status

### Input

- **State** - select a US state to search for EV charging stations (all 50 states plus DC)
- **Max Items** - how many stations to collect (free users get 10 items, paid users up to 1,000,000)

```json
{
    "state": "CA",
    "maxItems": 100
}
````

### Output

Each station record includes 30+ data fields. Download as JSON, CSV, or Excel.

| Field | Description |
|-------|-------------|
| stationName | Name of the charging station |
| streetAddress | Street address |
| city | City |
| state | State code |
| zip | ZIP code |
| latitude | GPS latitude |
| longitude | GPS longitude |
| evLevel1Count | Number of Level 1 chargers |
| evLevel2Count | Number of Level 2 chargers |
| evDcFastCount | Number of DC fast chargers |
| evConnectorTypes | Connector types available (J1772, CCS, etc.) |
| evNetwork | Charging network name |
| evPricing | Pricing information |
| accessCode | Public or private access |
| accessDaysTime | Hours of operation |
| facilityType | Type of facility (parking, gas station, etc.) |
| openDate | Date the station opened |
| statusCode | Current operational status |

```json
{
    "id": 64587,
    "stationName": "ChargePoint Charging Station",
    "streetAddress": "1234 Main Street",
    "city": "Los Angeles",
    "state": "CA",
    "zip": "90001",
    "country": "US",
    "latitude": 33.9425,
    "longitude": -118.2551,
    "accessCode": "public",
    "accessDaysTime": "24 hours daily",
    "evLevel1Count": null,
    "evLevel2Count": 4,
    "evDcFastCount": 2,
    "evConnectorTypes": ["J1772", "CCS"],
    "evNetwork": "ChargePoint Network",
    "evPricing": "Free",
    "facilityType": "PARKING_LOT",
    "openDate": "2022-03-15",
    "statusCode": "E",
    "scrapedAt": "2026-04-09T12:00:00.000Z"
}
```

### Why Choose the AFDC EV Stations Scraper?

| Feature | Our Tool | Manual AFDC Search |
|---------|----------|--------------------|
| Batch collection | Up to 1M stations | Browse one at a time |
| State-wide data | All stations in a state at once | Paginated results |
| Structured output | JSON, CSV, Excel | Map-based interface |
| Automated scheduling | Daily/weekly monitoring | Manual visits |
| GPS coordinates | Latitude/longitude included | Click each pin |
| Charger counts | Level 1, 2, DC fast breakdown | Visual icons only |

### How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - select your state and how many stations you want
3. **Run It** - click "Start" and get structured station data in seconds

No coding, no setup, no manual browsing required.

### Business Use Cases

- 🚗 **EV fleet managers** - map charging infrastructure coverage to plan routes and identify gaps
- 📱 **App developers** - build charging station finders and trip planners with up-to-date location data
- 📊 **Market researchers** - analyze charging network market share and infrastructure growth by state
- 🏢 **Real estate developers** - evaluate EV charging availability near properties and development sites
- 🔋 **Utility companies** - assess charging infrastructure density for grid planning and demand forecasting
- 🏛️ **Government agencies** - monitor EV infrastructure buildout progress and identify underserved areas

### FAQ

⚡ **What is AFDC?**
The Alternative Fuels Data Center (AFDC) is maintained by the U.S. Department of Energy and provides the most comprehensive database of alternative fuel stations in the United States, including over 70,000 EV charging locations.

🔌 **What connector types are tracked?**
The data includes J1772 (Level 2), CCS (DC fast), CHAdeMO (DC fast), Tesla (Supercharger/Destination), and NEMA connectors.

🌐 **Which charging networks are covered?**
All major networks including ChargePoint, Tesla, EVgo, Electrify America, Blink, SemaConnect, and many others.

**How long does a run take?**
About 1-2 seconds per 100 stations. A full state like California with 15,000+ stations finishes in a few minutes.

📅 **How often is station data updated?**
Station data is updated continuously as new stations open and existing ones are verified. Set up a scheduled run for weekly monitoring.

### Integrate AFDC EV Stations Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate station monitoring workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts when new stations open in your area
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified in your team channel
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export station data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### Recommended Actors

Looking for more infrastructure and government data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Grants.gov Scraper | Collect federal grant opportunities | [Link](https://apify.com/parseforge/grants-gov-scraper) |
| GSA eLibrary Scraper | Collect government contract data from GSA | [Link](https://apify.com/parseforge/gsa-elibrary-scraper) |
| FAA Aircraft Registry Scraper | Extract aircraft registration data | [Link](https://apify.com/parseforge/faa-aircraft-registry-scraper) |
| USASpending Scraper | Gather federal spending and award data | [Link](https://apify.com/parseforge/usaspending-scraper) |
| FINRA BrokerCheck Scraper | Look up broker registration data | [Link](https://apify.com/parseforge/finra-brokercheck-scraper) |

**Pro Tip:** Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to the Alternative Fuels Data Center (AFDC), the National Renewable Energy Laboratory (NREL), or the U.S. Department of Energy. It accesses only publicly available data.

# Actor input Schema

## `state` (type: `string`):

US state code to search for EV charging stations

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "state": "CA",
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "state": "CA",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/afdc-ev-stations-scraper").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 = {
    "state": "CA",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/afdc-ev-stations-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "state": "CA",
  "maxItems": 10
}' |
apify call parseforge/afdc-ev-stations-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/afdc-ev-stations-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AFDC EV Stations Scraper",
        "description": "Scrape 60,000+ electric vehicle charging stations across the US. Get station names, addresses, coordinates, connector types, network info, pricing, access hours, and charger counts (Level 1/2/DC Fast). Filter by state.",
        "version": "0.0",
        "x-build-id": "5zYIs1HjpfY47ebFS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~afdc-ev-stations-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-afdc-ev-stations-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~afdc-ev-stations-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-afdc-ev-stations-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~afdc-ev-stations-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-afdc-ev-stations-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "state"
                ],
                "properties": {
                    "state": {
                        "title": "State",
                        "enum": [
                            "AL",
                            "AK",
                            "AZ",
                            "AR",
                            "CA",
                            "CO",
                            "CT",
                            "DE",
                            "FL",
                            "GA",
                            "HI",
                            "ID",
                            "IL",
                            "IN",
                            "IA",
                            "KS",
                            "KY",
                            "LA",
                            "ME",
                            "MD",
                            "MA",
                            "MI",
                            "MN",
                            "MS",
                            "MO",
                            "MT",
                            "NE",
                            "NV",
                            "NH",
                            "NJ",
                            "NM",
                            "NY",
                            "NC",
                            "ND",
                            "OH",
                            "OK",
                            "OR",
                            "PA",
                            "RI",
                            "SC",
                            "SD",
                            "TN",
                            "TX",
                            "UT",
                            "VT",
                            "VA",
                            "WA",
                            "WV",
                            "WI",
                            "WY",
                            "DC"
                        ],
                        "type": "string",
                        "description": "US state code to search for EV charging stations"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
