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

Scrapes EV charging station data from the Alternative Fuels Data Center for a selected US state. Returns each station as a flat row with details like name, address, and connector types.

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

## Pricing

from $1.62 / 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/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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### AFDC EV Stations Scraper

**Scrape EV charging station data from the Alternative Fuels Data Center for any US state.** Get station names, addresses, connector types, and more in a clean dataset. No API key required.

The AFDC station locator is the authoritative source for US electric vehicle charging stations, but its data is locked behind a web interface. This Actor reads the public station list for any state and returns each station as a flat row, ready for analysis or integration.

| Who uses it | What they scrape AFDC for |
|---|---|
| EV infrastructure analysts | Mapping charging station distribution across states |
| Fleet managers | Planning routes based on available charging locations |
| Market researchers | Tracking growth of charging networks by region |
| App developers | Building EV trip planning tools with current station data |

### What it does

This Actor collects EV charging station records from the AFDC for a selected US state and returns each station as a flat row with its details.

- 📍 **State selection:** Choose any US state or DC from a dropdown to target your scrape.
- 🔢 **Result limit:** Set a maximum number of stations to collect per run, up to 1,000,000.
- 📊 **Structured output:** Each station is returned as a flat row with consistent fields for easy export.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with AFDC data

**🗺️ Map charging infrastructure.**

An analyst selects California to get all stations and maps their distribution to identify coverage gaps.

**🚚 Plan fleet routes.**

A fleet manager scrapes Texas stations to find charging points along delivery routes and optimize stops.

**📈 Track network growth.**

A researcher runs the Actor monthly for New York to monitor new station additions and market trends.

**📱 Build a trip planner.**

A developer collects stations for multiple states to populate an app that suggests charging stops for EV drivers.

### Why choose this scraper

|  | What you get |
|---|---|
| **No API key** | Access AFDC data without registration or authentication |
| **State-level targeting** | Get stations for any US state or DC in one run |
| **Scalable collection** | Collect up to a million stations per run |
| **Clean dataset** | Each station is a flat row with consistent fields |

### How it compares

No other Store actor targets AFDC the same way, so the honest comparison is with the alternatives teams actually weigh.

| | AFDC EV Stations Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When AFDC changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the Actor by selecting a US state and optionally limiting the number of stations returned. The Actor then collects all matching stations from the AFDC public listing. The Input tab lists every parameter.

A first run with the defaults:

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

A larger pull:

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

### Pricing

Pay-per-result: **$0.0036 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $0.36 |
| 1,000 results | $3.60 |
| 10,000 results | $36.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [AFDC EV Stations Scraper](https://apify.com/parseforge/afdc-ev-stations-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to AFDC through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/afdc-ev-stations-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Ensure you selected a valid state from the dropdown. Also check if the AFDC website is accessible and if your maxItems is set to a positive number.

**The run is taking too long.**

Reduce the maxItems value to limit the number of stations collected. Large states like California may have many stations, so a lower limit will speed up the run.

**Some fields are empty in the output.**

Not all stations have complete information on AFDC. Empty fields indicate missing data for that station, which is normal.

**I got an error about the state code.**

Use the two-letter state code exactly as listed in the input options, such as 'CA' for California or 'NY' for New York.

### FAQ

| Question | Answer |
|---|---|
| What data does this Actor return for each station? | Each station is returned as a flat row with fields like station name, address, city, state, ZIP code, connector types, and more. The exact fields are listed in the sample output. |
| Can I scrape multiple states at once? | The Actor accepts one state per run. To collect multiple states, run the Actor multiple times with different state inputs or use a scheduler. |
| Is there a limit on how many stations I can collect? | You can set a maximum number of stations per run, up to 1,000,000. The default is 10. |
| Do I need an API key or registration? | No, the Actor reads the public AFDC station listing directly, so no API key or registration is required. |
| How current is the data? | The data is scraped live from the AFDC website at the time of the run, so it reflects the latest available information. |
| What output formats are supported? | The Actor returns data in JSON, CSV, Excel, and XML formats, which you can download from the run results. |
| Can I filter by connector type or other criteria? | The Actor currently collects all stations for the selected state without additional filters. You can filter the output dataset after collection. |
| Does this Actor work for all US states? | Yes, it supports all 50 states plus the District of Columbia. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by U.S. Department of Energy. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

US state code to search for EV charging stations

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

Maximum number of stations to collect per run.

## 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(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 '{
  "state": "CA",
  "maxItems": 10
}' |
apify call parseforge/afdc-ev-stations-scraper --silent --output-dataset

```

## MCP server setup

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

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/l0Llj5GzddPj4eRcN/builds/GRdgihFRBnsanjViQ/openapi.json