# EPA Motorcycle, ATV, UTV & Marine Engine Certificates (`prudent_businessman/epa-powersports-engine-certification`) Actor

Search & export 16,000+ EPA certificates for motorcycles, scooters, dirt bikes, ATVs, UTVs, e-motorcycles, snowmobiles and marine outboard/PWC engines. Look up by model, engine family or certificate no.; filter by maker, origin country, year, cc. Monitor new certificates.

- **URL**: https://apify.com/prudent_businessman/epa-powersports-engine-certification.md
- **Developed by:** [Benningfield Data](https://apify.com/prudent_businessman) (community)
- **Categories:** E-commerce, Lead generation, Other
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 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?

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

## EPA Motorcycle, ATV, UTV, Snowmobile & Marine Engine Certificate Search

Search, export and monitor **16,000+ US EPA certificates of conformity** for powersports vehicles and marine engines, taken straight from EPA's official *Annual Certification Data for Vehicles, Engines, and Equipment* files:

| Category | Records (approx.) | Years |
|---|---|---|
| On-highway motorcycles & scooters | 6,800 | 2006 – present |
| Off-road motorcycles, ATVs, UTVs, go-karts & recreational vehicles | 6,100 | 2006 – present |
| Electric motorcycles | 250 | 2015 – present |
| Snowmobiles | 320 | 2015 – present |
| Marine spark-ignition engines (outboards, sterndrives, inboards, PWC, jet boats) | 2,500 engine families | 2011 – present |

The Actor finds the current file links on EPA's page at run time, so it stays current when EPA posts new files.

### Why use it?

- **Importers, dealers & customs brokers**: before importing or selling a scooter, dirt bike, ATV or UTV (many come from China and Taiwan), confirm the model has a valid EPA certificate. Look up by **model name**, by **engine family** (printed on the emission label) or by **certificate number**.
- **Marketplace & e-commerce compliance**: check listings for uncertified off-road vehicles in bulk.
- **Market research & lead generation**: list every manufacturer, engine maker and factory country certifying ATVs/UTVs for the 2027 model year, track new entrants, compare displacement classes.
- **Marine dealers**: look up outboard/sterndrive/PWC engine families, power (kW), displacement and emission certification levels.
- **Monitoring**: schedule it with `only_new` to get only newly issued certificates.

### Input

| Field | Description |
|---|---|
| `categories` | Any of `highway_motorcycle`, `offroad_motorcycle_atv_utv`, `electric_motorcycle`, `snowmobile`, `marine_spark_ignition` (empty = all) |
| `models` | Model names to look up in "Models Certified" (exact, ignoring case/spaces/dashes, or `*` wildcards). Unmatched names return a "not found" row. |
| `engine_families` | Exact engine family names or certificate numbers |
| `manufacturers` | Certificate holder, engine OEM or vehicle OEM name (contains) |
| `countries` | OEM country of origin (contains), e.g. `China` |
| `vehicle_classes` | EPA category text (contains), e.g. `ATV`, `Utility`, `Class III`, `Outboard` |
| `keywords` | Free text across manufacturer, models, family, class, fuel |
| `model_year_from` / `model_year_to` | Model year range |
| `min_displacement` / `max_displacement` | cc (litres for marine) |
| `include_details` | Add every EPA column, including emission levels and test vehicles (default `true`) |
| `only_new`, `report_removed`, `state_store_name` | Monitor mode |
| `max_items` | Max records (0 = no limit) |

#### Examples

Is this ATV EPA-certified?

```json
{ "categories": ["offroad_motorcycle_atv_utv"], "models": ["Alterra 300", "*Sportsman 570*"] }
```

All 2027 Chinese-made scooters and motorcycles:

```json
{ "categories": ["highway_motorcycle"], "countries": ["China"], "model_year_from": 2027, "max_items": 0 }
```

Look up an engine family from an emission label:

```json
{ "engine_families": ["V3AXX.2712KM"] }
```

Weekly monitor of new UTV certificates:

```json
{ "categories": ["offroad_motorcycle_atv_utv"], "vehicle_classes": ["Utility"], "only_new": true, "state_store_name": "utv-certs" }
```

### Output

One record per certificate (EPA repeats a certificate once per test vehicle; those rows are merged into `testVehicles`).

```json
{
  "category": "offroad_motorcycle_atv_utv",
  "modelYear": 2027,
  "manufacturer": "Arctic Cat",
  "engineFamily": "V3AXX.2712KM",
  "certificateNumber": "V3AXX.2712KM-004",
  "vehicleClass": "ATVA-Meet EPA & ARB ATV Definition",
  "modelsCertified": "Alterra 300, Tracker 300",
  "modelNames": ["Alterra 300", "Tracker 300"],
  "engineManufacturer": "Kwang Yang Motor Co., Ltd.",
  "engineManufacturerCountry": "Taiwan",
  "vehicleManufacturer": "Kwang Yang Motor Co., Ltd.",
  "vehicleManufacturerCountry": "Taiwan",
  "displacement": 271,
  "displacementUnit": "cc",
  "fuelType": "GAS",
  "salesArea": "49S",
  "catalyticConverter": "Y",
  "details": { "catalystType": "TWC, single bed, open loop", "certificationLevelCo": "26.3", "certificationLevelHcNox": "1.3", "...": "..." },
  "testVehicles": [{ "edvModel": "Alterra 300", "edvEngineCode": "AC60", "edvRatedPower": "16.3" }]
}
```

Lookup misses look like `{ "query": "XYZ 125", "queryType": "model", "epaCertified": false, "note": "..." }`.

### Pricing

Pay per result: you are charged only for records in the dataset. No start fee. Use `max_items` to cap cost.

### Notes

- Data is from US EPA's public certification files. EPA updates them periodically, so very recent certificates may not appear yet. A missing model is not legal proof that it is uncertified: check spelling, try a wildcard, and confirm with the manufacturer or EPA.
- Test vehicle VINs are removed from the output.
- This Actor is not affiliated with or endorsed by the US EPA.

# Actor input Schema

## `categories` (type: `array`):

Which EPA certification lists to search. Leave empty for all five.

## `models` (type: `array`):

Check whether a model appears on an EPA certificate's 'Models Certified' list. Exact match ignores case, spaces and dashes (e.g. 'Alterra 300'). Use \* as wildcard (e.g. '*TRX*'). Unmatched exact names are returned as 'not found' rows.

## `engine_families` (type: `array`):

Exact EPA engine family names (as printed on the emission label, e.g. V3AXX.2712KM) or certificate numbers.

## `manufacturers` (type: `array`):

Matches the certificate holder, engine OEM or vehicle OEM name (partial, case-insensitive), e.g. 'Honda', 'Kwang Yang', 'Segway'.

## `countries` (type: `array`):

Engine/vehicle OEM country, e.g. 'China', 'Taiwan', 'Japan'.

## `vehicle_classes` (type: `array`):

Filter by EPA category text, e.g. 'ATV', 'Utility', 'Class III', 'Outboard', 'Personal Watercraft'.

## `keywords` (type: `array`):

Free-text match across manufacturer, models, engine family, class and fuel.

## `model_year_from` (type: `integer`):

Earliest model year (lists start 2006, 2011 or 2015).

## `model_year_to` (type: `integer`):

Latest model year.

## `min_displacement` (type: `integer`):

Minimum engine displacement (cc for motorcycles/ATVs/snowmobiles, litres for marine).

## `max_displacement` (type: `integer`):

Maximum engine displacement.

## `include_details` (type: `boolean`):

Add a 'details' object with every column of the EPA file (emission levels, fuel system, catalyst, test vehicles...).

## `output_not_found` (type: `boolean`):

For exact model lookups, return a row for each model with no EPA certificate.

## `only_new` (type: `boolean`):

Return only certificates not seen in the previous run (first run saves a baseline). Schedule daily/weekly.

## `report_removed` (type: `boolean`):

In monitor mode, also output certificates that disappeared.

## `state_store_name` (type: `string`):

Named key-value store that keeps the monitor baseline. Use a different name per saved filter set.

## `max_items` (type: `integer`):

Maximum records to output (0 = no limit). You pay per record.

## Actor input object example

```json
{
  "categories": [
    "offroad_motorcycle_atv_utv"
  ],
  "include_details": true,
  "output_not_found": true,
  "only_new": false,
  "report_removed": true,
  "state_store_name": "epa-powersports-cert-state",
  "max_items": 1000
}
```

# Actor output Schema

## `results` (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 = {
    "categories": [
        "offroad_motorcycle_atv_utv"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("prudent_businessman/epa-powersports-engine-certification").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 = { "categories": ["offroad_motorcycle_atv_utv"] }

# Run the Actor and wait for it to finish
run = client.actor("prudent_businessman/epa-powersports-engine-certification").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 '{
  "categories": [
    "offroad_motorcycle_atv_utv"
  ]
}' |
apify call prudent_businessman/epa-powersports-engine-certification --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,prudent_businessman/epa-powersports-engine-certification"
        }
    }
}
```

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/lzseBZlkRdzCPwpfc/builds/AzN7Ykg7rtCABPVYx/openapi.json