# Washington State Electric Vehicle Population Scraper (`parseforge/data-wa-gov-electric-vehicle-scraper`) Actor

Scrape Washington State electric vehicle registrations: VIN prefix, make, model, year, EV type, electric range, base MSRP, county, city, ZIP, legislative district, and utility provider. Export EV adoption data to JSON, CSV, or Excel for market research, policy, and analytics.

- **URL**: https://apify.com/parseforge/data-wa-gov-electric-vehicle-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $13.00 / 1,000 result items

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://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🔌 Washington State Electric Vehicle Population Scraper

> 🚀 **Export 200k+ Washington State EV registrations in seconds.** Filter by make, model, year, county, or vehicle type. Get geocoded coordinates, electric range, and CAFV eligibility. No login, no manual CSV wrangling.

> 🕒 **Last updated:** 2026-05-23 · **📊 18 fields** per record · **🔌 200k+ EV registrations** · **🇺🇸 Washington State** · **⚡ BEV + PHEV**

The **Washington State EV Population Scraper** taps the data.wa.gov Department of Licensing dataset and returns clean, structured records covering every **Battery Electric Vehicle (BEV)** and **Plug-in Hybrid Electric Vehicle (PHEV)** registered in Washington State. The underlying dataset is published by the Washington DOL, refreshed regularly, and is one of the most widely cited open EV datasets in the US.

Coverage spans **200k+ EV registrations** with make, model, year, county, city, electric range, CAFV (Clean Alternative Fuel Vehicle) eligibility, electric utility, legislative district, 2020 census tract, and geocoded lat/lon coordinates. This Actor exports them as CSV, Excel, JSON, or XML in under a minute, with server-side filtering so you skip pulling the full file.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| EV market analysts, automotive intelligence, sustainability researchers, infrastructure planners, charging-network operators, policy think tanks, automotive press | EV adoption modeling, market-share tracking, charger siting, regional demand forecasting, sustainability reporting, fleet research |

---

### 📋 What the Washington EV Scraper does

One streamlined workflow with rich filters:

- 🏷️ **Make filter.** Restrict to TESLA, NISSAN, CHEVROLET, FORD, RIVIAN, HYUNDAI, KIA, and more.
- 🚗 **Model filter.** Pull only MODEL Y, MODEL 3, LEAF, BOLT EV, MUSTANG MACH-E, etc.
- 📅 **Model year range.** Filter by `modelYearFrom` and `modelYearTo` for cohort analysis.
- 📍 **County filter.** King, Snohomish, Pierce, Spokane, or any of WA's 39 counties.
- ⚡ **Vehicle type filter.** BEV only, PHEV only, or both.

Each record returns make, model, year, EV type, electric range, CAFV eligibility, county, city, ZIP, legislative district, census tract, electric utility, and geocoded coordinates ready for mapping.

> 💡 **Why it matters:** Washington State is one of the fastest-growing EV markets in the US, and its open data publishes registration-level detail other states keep locked. This Actor makes that dataset queryable in seconds.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded EV dataset._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>resourceId</td><td>string</td><td>"f6w7-q2d2"</td><td>Socrata resource ID. Default is the Electric Vehicle Population dataset.</td></tr>
<tr><td>make</td><td>string</td><td><i>any</i></td><td>Vehicle make, exact match. TESLA, NISSAN, etc.</td></tr>
<tr><td>model</td><td>string</td><td><i>any</i></td><td>Vehicle model, exact match. MODEL Y, LEAF, etc.</td></tr>
<tr><td>county</td><td>string</td><td><i>any</i></td><td>WA county name. King, Snohomish, Pierce.</td></tr>
<tr><td>modelYearFrom</td><td>integer</td><td><i>any</i></td><td>Minimum model year (inclusive).</td></tr>
<tr><td>modelYearTo</td><td>integer</td><td><i>any</i></td><td>Maximum model year (inclusive).</td></tr>
<tr><td>vehicleType</td><td>string</td><td><i>any</i></td><td>BEV, PHEV, or empty for both.</td></tr>
</tbody>
</table>

**Example: 100 Tesla Model Y registrations in King County, 2023+.**

```json
{
    "maxItems": 100,
    "make": "TESLA",
    "model": "MODEL Y",
    "county": "King",
    "modelYearFrom": 2023
}
````

**Example: all PHEVs in Snohomish County.**

```json
{
    "maxItems": 500,
    "county": "Snohomish",
    "vehicleType": "PHEV"
}
```

> ⚠️ **Good to Know:** make, model, and county filters are case-insensitive but use exact matching (no partial wildcards). For "MODEL 3" vs "Model 3" both work, but partial like "MODEL" returns nothing. Geocoded coordinates depend on the original DOL geocoding pass and may be null for records with non-standard addresses.

***

### 📊 Output

Each EV registration record contains **18 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `vinPrefix` | string | `"5YJ3E1EA1L"` |
| 🆔 `dolVehicleId` | string | `"200000123"` |
| 🏷️ `make` | string | `"TESLA"` |
| 🚗 `model` | string | `"MODEL Y"` |
| 📅 `modelYear` | integer | `2023` |
| ⚡ `evType` | string | `"BEV"` |
| ✅ `cafvEligibility` | string | `"Clean Alternative Fuel Vehicle Eligible"` |
| 🔋 `electricRange` | integer | `330` |
| 🏞️ `county` | string | `"King"` |
| 🏙️ `city` | string | `"Seattle"` |
| 📍 `state` | string | `"WA"` |
| 📮 `zipCode` | string | `"98101"` |
| 🏛️ `legislativeDistrict` | string | `"43"` |
| 🗺️ `censusTract2020` | string | `"53033007402"` |
| ⚡ `electricUtility` | string | `"CITY OF SEATTLE"` |
| 📍 `latitude` | number | null | `47.6062` |
| 📍 `longitude` | number | null | `-122.3321` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-23T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>⚡ Tesla Model Y in Seattle (BEV)</strong></summary>

```json
{
    "vinPrefix": "5YJ3E1EA1L",
    "dolVehicleId": "200000123",
    "make": "TESLA",
    "model": "MODEL Y",
    "modelYear": 2023,
    "evType": "BEV",
    "cafvEligibility": "Clean Alternative Fuel Vehicle Eligible",
    "electricRange": 330,
    "county": "King",
    "city": "Seattle",
    "state": "WA",
    "zipCode": "98101",
    "legislativeDistrict": "43",
    "censusTract2020": "53033007402",
    "electricUtility": "CITY OF SEATTLE - (WA)",
    "latitude": 47.6062,
    "longitude": -122.3321,
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🔋 Nissan Leaf in Tacoma (BEV)</strong></summary>

```json
{
    "vinPrefix": "1N4AZ0CP4K",
    "make": "NISSAN",
    "model": "LEAF",
    "modelYear": 2019,
    "evType": "BEV",
    "cafvEligibility": "Clean Alternative Fuel Vehicle Eligible",
    "electricRange": 150,
    "county": "Pierce",
    "city": "Tacoma",
    "zipCode": "98402",
    "electricUtility": "TACOMA POWER",
    "latitude": 47.2529,
    "longitude": -122.4443,
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🚙 Toyota RAV4 Prime in Spokane (PHEV)</strong></summary>

```json
{
    "vinPrefix": "JTMEB3FV2M",
    "make": "TOYOTA",
    "model": "RAV4 PRIME",
    "modelYear": 2022,
    "evType": "PHEV",
    "cafvEligibility": "Clean Alternative Fuel Vehicle Eligible",
    "electricRange": 42,
    "county": "Spokane",
    "city": "Spokane",
    "zipCode": "99201",
    "electricUtility": "AVISTA CORPORATION",
    "latitude": 47.6588,
    "longitude": -117.4260,
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🔌 | **200k+ registrations.** Every BEV and PHEV currently registered with Washington DOL. |
| 🗺️ | **Geocoded.** Lat/lon coordinates per registration for mapping and territory analysis. |
| 🏞️ | **County-level filtering.** All 39 WA counties supported. |
| ⚡ | **Range + utility data.** Electric range in miles, plus the serving electric utility per record. |
| ✅ | **CAFV eligibility flag.** Quickly identify Clean Alternative Fuel Vehicle qualifying registrations. |
| 🔁 | **Always fresh.** Every run hits the live data.wa.gov endpoint. |
| 🚫 | **No authentication.** Public open-data endpoint, no API key required. |

> 📊 EV adoption tracking, charger siting, and grid-impact modeling all need clean registration data. This Actor exports it on demand.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ WA EV Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **200k+ WA registrations** | **Live per run** | make, model, year, county, type | ⚡ 2 min |
| Commercial EV intelligence platforms | $5,000+/year | Multi-state, modeled | Monthly | Many | 🐢 Days |
| Bulk CSV download from data.wa.gov | Free | Full file | Manual | None | 🐌 Heavy parsing |
| State DMV FOIA requests | Free | Per-request | Quarterly | Custom | ⏳ Weeks |

Pick this Actor when you want filtered, geocoded WA EV data without parsing a 200k-row flat file.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Washington State EV Population Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick make / model / county / vehicle type filters and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor pull filtered registrations.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### ⚡ EV Market Intelligence

- Market-share tracking by make and model
- Cohort analysis by model year
- BEV vs PHEV mix per county
- Brand penetration in target metro areas

</td>
<td width="50%" valign="top">

#### 🔌 Charging Network Planning

- Charger siting based on EV density by ZIP
- Utility-by-utility EV load forecasting
- Underserved county mapping
- Coordinated planning with electric utilities

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🚗 Automotive Intelligence

- Competitive benchmarking by brand
- Year-over-year registration deltas
- Geographic trend mapping
- Fleet-vs-consumer pattern analysis

</td>
<td width="50%" valign="top">

#### 📊 Sustainability & Policy

- Track WA progress on EV adoption goals
- ESG reporting with verifiable open data
- Legislative-district-level adoption stats
- Census-tract equity analysis

</td>
</tr>
</table>

***

### 🔌 Automating Washington EV Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Pull a monthly snapshot for trend tracking, or refresh county-level slices weekly.

***

### 🌟 Beyond business use cases

Open EV data feeds research, civic projects, classrooms, and personal sustainability initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Adoption-curve studies for transportation policy
- Geographic equity research on EV access
- Reproducible datasets for sustainability MSc
- Open-data exercises on transportation electrification

</td>
<td width="50%">

#### 🎨 Personal and creative

- Personal "is my neighbor driving electric?" maps
- Hobbyist dashboards comparing makes
- Newsletter research for EV beats
- Portfolio dataviz projects on sustainability

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Community EV co-op planning
- Rural-county charging-access advocacy
- Civic transparency on transportation electrification
- Open mapping projects for local journalism

</td>
<td width="50%">

#### 🧪 Experimentation

- Train EV market-forecast ML models
- Prototype a charger-recommender agent
- Build a "best EV for my ZIP" Slack bot
- Test data warehouse loaders on EV schemas

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Washington%20State%20EV%20Population%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Washington%20State%20EV%20Population%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Washington%20State%20EV%20Population%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Washington%20State%20EV%20Population%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Pick filters for make, model, county, model year, or vehicle type, then run the Actor. It applies the filters server-side and returns one structured record per EV registration.

#### 📏 How accurate is the data?

Records come straight from the Washington Department of Licensing. Geocoded coordinates are typically accurate to the address, though a small share of records have null coordinates where geocoding failed.

#### 🔁 How often is the dataset refreshed?

Washington State refreshes the Electric Vehicle Population dataset on a regular cadence (typically monthly). Every run of this Actor pulls the latest snapshot.

#### 🚗 Which makes are covered?

Every make registered as an EV in Washington State: TESLA, NISSAN, CHEVROLET, FORD, HYUNDAI, KIA, RIVIAN, TOYOTA, VOLKSWAGEN, AUDI, BMW, VOLVO, PORSCHE, POLESTAR, LUCID, and dozens more.

#### 🏞️ Which counties are covered?

All 39 Washington counties. Filter by county name (case-insensitive exact match).

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to trigger this Actor on any cron interval.

#### ⚖️ Is this data legal to use?

Yes. The Washington State Open Data Portal publishes this dataset under permissive terms for public use.

#### 💼 Can I use this data commercially?

Yes. Open data published by Washington State is generally permitted for commercial use. Review the data.wa.gov terms for your specific scenario.

#### 💳 Do I need a paid Apify plan?

No. The free Apify plan handles small runs (10 records). Paid plans lift the cap and unlock scheduling.

#### 🔁 What happens if a run fails?

Apify retries transient errors automatically. Failed runs preserve partial datasets so no progress is lost.

#### 🛬 What if I need other states?

This Actor covers Washington State only. For other state DMV EV data, request a companion scraper via the contact form below.

#### 🆘 What if I need help?

Reach our support team through the Apify platform or the Tally form linked below.

***

### 🔌 Integrate with any app

Washington State EV Population Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get monthly EV updates in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe EV data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh registrations into your product backend, or alert your planning team in Slack when a new county threshold is hit.

***

### 🔗 Recommended Actors

- [**🔌 AFDC EV Stations Scraper**](https://apify.com/parseforge/afdc-ev-stations-scraper) - U.S. alternative fuel and EV charging stations
- [**🚗 Kelley Blue Book Scraper**](https://apify.com/parseforge/kelley-blue-book-scraper) - Vehicle valuations and listings
- [**🏎️ AutoTrader Scraper**](https://apify.com/parseforge/autotrader-scraper) - Used and new vehicle listings
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode any address via OpenStreetMap
- [**✈️ OurAirports Global Airport Database Scraper**](https://apify.com/parseforge/ourairports-scraper) - 85,000+ airports and airfields worldwide

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by the Washington State Department of Licensing, data.wa.gov, Tesla, Nissan, or any vehicle manufacturer. All trademarks mentioned are the property of their respective owners. Only publicly available open Washington State EV data is collected.

# Actor input Schema

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

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

## `resourceId` (type: `string`):

Socrata resource ID on data.wa.gov. Defaults to the Electric Vehicle Population dataset (f6w7-q2d2). Try '4mse-x54r' for monthly EV registrations.

## `make` (type: `string`):

Filter by vehicle make, exact match. Examples: TESLA, NISSAN, CHEVROLET, FORD.

## `model` (type: `string`):

Filter by vehicle model, exact match. Examples: MODEL Y, MODEL 3, LEAF, BOLT EV.

## `county` (type: `string`):

Filter by county in Washington State. Examples: King, Snohomish, Pierce, Spokane.

## `modelYearFrom` (type: `integer`):

Minimum model year (inclusive).

## `modelYearTo` (type: `integer`):

Maximum model year (inclusive).

## `vehicleType` (type: `string`):

Battery Electric (BEV) or Plug-in Hybrid (PHEV).

## Actor input object example

```json
{
  "maxItems": 10,
  "resourceId": "f6w7-q2d2"
}
```

# 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 = {
    "maxItems": 10,
    "resourceId": "f6w7-q2d2"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/data-wa-gov-electric-vehicle-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 = {
    "maxItems": 10,
    "resourceId": "f6w7-q2d2",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/data-wa-gov-electric-vehicle-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 '{
  "maxItems": 10,
  "resourceId": "f6w7-q2d2"
}' |
apify call parseforge/data-wa-gov-electric-vehicle-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Washington State Electric Vehicle Population Scraper",
        "description": "Scrape Washington State electric vehicle registrations: VIN prefix, make, model, year, EV type, electric range, base MSRP, county, city, ZIP, legislative district, and utility provider. Export EV adoption data to JSON, CSV, or Excel for market research, policy, and analytics.",
        "version": "1.0",
        "x-build-id": "Jnf5AGsS48ba0m4CD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~data-wa-gov-electric-vehicle-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-data-wa-gov-electric-vehicle-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~data-wa-gov-electric-vehicle-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-data-wa-gov-electric-vehicle-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~data-wa-gov-electric-vehicle-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-data-wa-gov-electric-vehicle-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",
                "properties": {
                    "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"
                    },
                    "resourceId": {
                        "title": "Dataset Resource ID",
                        "type": "string",
                        "description": "Socrata resource ID on data.wa.gov. Defaults to the Electric Vehicle Population dataset (f6w7-q2d2). Try '4mse-x54r' for monthly EV registrations."
                    },
                    "make": {
                        "title": "Make",
                        "type": "string",
                        "description": "Filter by vehicle make, exact match. Examples: TESLA, NISSAN, CHEVROLET, FORD."
                    },
                    "model": {
                        "title": "Model",
                        "type": "string",
                        "description": "Filter by vehicle model, exact match. Examples: MODEL Y, MODEL 3, LEAF, BOLT EV."
                    },
                    "county": {
                        "title": "County",
                        "type": "string",
                        "description": "Filter by county in Washington State. Examples: King, Snohomish, Pierce, Spokane."
                    },
                    "modelYearFrom": {
                        "title": "Model Year From",
                        "minimum": 1990,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Minimum model year (inclusive)."
                    },
                    "modelYearTo": {
                        "title": "Model Year To",
                        "minimum": 1990,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Maximum model year (inclusive)."
                    },
                    "vehicleType": {
                        "title": "Vehicle Type",
                        "enum": [
                            "",
                            "BEV",
                            "PHEV"
                        ],
                        "type": "string",
                        "description": "Battery Electric (BEV) or Plug-in Hybrid (PHEV)."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
