# WA EV Registrations - Electric Vehicle Population by County (`j0401/wa-ev-registrations`) Actor

Washington's electric vehicle population (294k registered EVs): which county, make, model, model year, EV type (battery / plug-in hybrid). Filter by county, make, year; aggregate adoption trends by model year, county share, Tesla vs others.

- **URL**: https://apify.com/j0401/wa-ev-registrations.md
- **Developed by:** [Wenhao Yang](https://apify.com/j0401) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.00 / 1,000 wa electric vehicle registration records

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

## WA EV Registrations (`wa-ev-registrations`)

Pull **Washington's electric vehicle population** - **293,432 registered EVs in WA** (one record per vehicle, from the state's free public open data). The source dataset carries a small ~0.3% tail of out-of-state registration rows (relocated vehicles); this tool **defaults to WA-only** so you always get Washington's fleet.

This answers the EV-adoption questions nobody else packages for Washington: **where the EVs are** (by county / city), **what people drive** (make / model mix, Tesla share), **what kind** (battery vs plug-in hybrid vs hybrid), and **how adoption grew** (by model year).

Built for **AI agents, developers, and market / policy / infrastructure researchers** tracking the EV transition in WA state.

### What this data is

Each record is **one registered EV** currently on Washington roads:

| Field | Meaning |
|---|---|
| `county` / `city` | Where it's registered |
| `make` / `model` | Vehicle make and model |
| `modelYear` | Model year (the adoption-history axis) |
| `evType` | `Battery Electric Vehicle (BEV)` / `Plug-in Hybrid (PHEV)` / `Hybrid` |
| `cafvType` | Clean-alt-fuel eligibility (e.g. CAFV-eligible) |
| `electricRange` | Electric range in miles |
| `dolVehicleId` | DOL vehicle ID |
| `electricUtility` | Home electric utility |

> **Note on what this is not**: this is a point-in-time *fleet snapshot* (EVs on WA roads now), not a real-time registration-event stream. Its power is distribution and trend analysis - model-year counts ARE the adoption curve (each row is a vehicle bought that year).

### Typical questions it answers

- **Which county has the most EVs?** Aggregate by `county` -> King 48%, Snohomish, Pierce...
- **What's the Tesla share?** Aggregate by `make` -> Tesla ~41% of the WA EV fleet.
- **How did adoption grow?** Aggregate by `modelYear` -> the year-by-year EV registrations curve.
- **Where are plug-in hybrids?** Filter `evType=Plug-in`, aggregate by county.
- **Long-range battery EVs** - `evType=Battery Electric`, `minElectricRange=250`.
- **A specific car / fleet mix** - `make=TESLA` + `model=MODEL Y`, or `county=King` + `modelYear=2024`.

### Aggregate mode

Turn on **`aggregate`** and it rolls up counts over the **whole 294k-vehicle fleet instantly**:

| Output field | Meaning |
|---|---|
| `key` | The make / county / model year / EV type / city |
| `vehicles` | Number of EVs in that group |
| `pctOfTotal` | Share of the (filtered) total |

Group by `make` (Tesla vs others), `county` (adoption geography), `modelYear` (the trend), `evType`, `model`, or `electricUtility`.

### Inputs (all optional)

| Input | What it does |
|---|---|
| `county` | County - "King" or "King County" both work (case-insensitive) |
| `make` | Make - substring works ("Tesla", "alfa", "land rover"), case-insensitive |
| `model` | Substring on model (e.g. `MODEL Y`) |
| `evType` | Substring on type: `Battery Electric`, `Plug-in`, `Hybrid` |
| `cafvType` | Substring on clean-alt-fuel eligibility |
| `city` | Substring on city |
| `electricUtility` | Substring on utility |
| `yearFrom` / `yearTo` | Model-year range (e.g. `2020`-`2026`) |
| `minElectricRange` | Only EVs at or above this electric range (miles) |
| `aggregate` + `groupBy` | Roll up by `make` / `county` / `modelYear` / `evType` / `model` / `city` / `electricUtility` -> vehicles + share |
| `maxResults` | Cap the number of records (default 200) |

### Low cost

**From $0.001 per record** - with a per-run charge cap so even a full-corpus aggregate can't surprise-bill.

Washington's *adoption-rate* charts look like queryable datasets, but their backends return nothing - so every county / year / make trend here is **computed from the underlying ~294k per-vehicle records**, not a pre-baked chart. We also strip the ~0.3% of rows that are out-of-state vehicles (California, Virginia plates) that sneak into WA's table, so a county count reflects actual Washington EVs. An unfiltered run returns the newest vehicles (highest model years) as a live slice of the fleet.

### Data source & freshness

- **Source**: [data.wa.gov - WA State EV Population](https://data.wa.gov/) (Socrata SODA API, free public, no login).
- **Update cadence**: DOL registration data, refreshed regularly - a live snapshot of WA's EV fleet.
- **Coverage**: every EV currently registered with WA DOL. (Note: the WA portal's EV *adoption-rate* charts are dashboard-only backends with no queryable API - the per-vehicle population dataset below carries that same trend.)

# Actor input Schema

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

Only return EVs registered in this county (case-insensitive, exact). E.g. "King", "Snohomish", "Pierce".

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

Only return EVs of this make (case-insensitive, exact). E.g. "TESLA", "CHEVROLET", "FORD".

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

Only return EVs whose model contains this substring (case-insensitive). E.g. "MODEL Y", "BOLT".

## `evType` (type: `string`):

Only return EVs whose type contains this substring (case-insensitive). E.g. "Battery Electric", "Plug-in" (hybrid), "Hybrid".

## `cafvType` (type: `string`):

Only return EVs whose clean-alt-fuel-vehicle (CAFV) eligibility contains this substring. E.g. "Eligible".

## `city` (type: `string`):

Only return EVs registered in cities containing this substring (case-insensitive). E.g. "Seattle", "Olympia".

## `electricUtility` (type: `string`):

Only return EVs whose electric utility contains this substring (case-insensitive). E.g. "PUGET SOUND ENERGY".

## `yearFrom` (type: `string`):

Only return EVs with model year at or after this (e.g. "2020"). Adoption trend: later years = more recent purchases.

## `yearTo` (type: `string`):

Only return EVs with model year at or before this (e.g. "2026").

## `minElectricRange` (type: `integer`):

Only return EVs with an electric range at or above this (miles). E.g. 200 for long-range battery EVs.

## `aggregate` (type: `boolean`):

When on, returns one summary record per group (see groupBy) with vehicle count and share of the filtered total - instead of individual vehicles. Computed server-side.

## `groupBy` (type: `string`):

Which dimension to aggregate over (only used when aggregate is on). 'make' -> Tesla vs others; 'county' -> where EVs concentrate; 'modelYear' -> the adoption trend by purchase year.

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

Cap the number of records pushed (0 = unlimited). A vehicle query can reach the run's charge cap; an aggregate over all 294k has at most dozens of groups.

## Actor input object example

```json
{
  "minElectricRange": 0,
  "aggregate": false,
  "groupBy": "make",
  "maxResults": 200
}
```

# Actor output Schema

## `recordsUrl` (type: `string`):

Washington electric-vehicle registrations - county, city, make, model, model year, EV type, electric range - as JSON

## `datasetUrl` (type: `string`):

No description

## `runUrl` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("j0401/wa-ev-registrations").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("j0401/wa-ev-registrations").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call j0401/wa-ev-registrations --silent --output-dataset

```

## MCP server setup

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

```

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/T6BpZHlzsneoH1e6L/builds/TvdB1bg6p6vfHKsde/openapi.json