# ENERGY STAR Certified Products Scraper (`automation-lab/energy-star-certified-products`) Actor

Search official ENERGY STAR certified models by category, brand, keyword and certification date. Export identifiers, markets, efficiency attributes and source provenance for procurement and compliance analysis.

- **URL**: https://apify.com/automation-lab/energy-star-certified-products.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $11.16 / 1,000 item extracteds

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

## ENERGY STAR Certified Products Scraper

Search and export official ENERGY STAR certified products for procurement comparisons, compliance checks, and product-market analysis. Choose from 59 supported product datasets, filter models by keyword, brand and certification date, and receive normalized identifiers alongside the original category-specific efficiency attributes.

This independent tool reads EPA's public ENERGY STAR open-data service. It is not affiliated with or endorsed by EPA or ENERGY STAR.

### What does this Actor do?

The Actor retrieves current certified-model records from `data.energystar.gov`, without requiring source credentials or browser rendering. It exports product records, not retailer listings, prices, stock levels, or individual physical appliances.

Each run is a current snapshot. Schedule runs and compare exports downstream if you need change detection; the Actor itself does not retain a history or send alerts.

### Who is it for?

- Procurement teams assembling certified-product shortlists.
- Compliance analysts reconciling manufacturer model numbers with official certification records.
- Energy researchers comparing category-specific efficiency fields.
- Market analysts tracking brands and certification dates in recurring snapshots.

### Why use this scraper?

It combines a consistent product envelope with the original source attributes. That avoids discarding useful efficiency measurements simply because refrigerators, heat pumps, computers and commercial ovens have different specifications.

Stable product IDs and dataset provenance support reproducible joins. Partner names remain null if absent rather than being guessed from the brand. A certification-body model identifier is kept separately from the ENERGY STAR product ID.

### Getting started

1. Select product categories using the dataset IDs in the input editor.
2. Optionally enter a brand, model/brand/partner keyword, or certification date threshold.
3. Set a global result cap and start the Actor.
4. Inspect the Products output tab.
5. Export JSON, CSV, Excel or XML through Apify's dataset export controls.

The default example is deliberately small:

```json
{"datasets":["p5st-her9"],"maxItems":5}
```

### Input parameters

| Field | Default | Behavior |
| --- | --- | --- |
| `datasets` | `["p5st-her9"]` | Supported official dataset IDs in processing order; duplicate IDs are removed. |
| `keyword` | omitted | Case-insensitive literal substring in any available model number, model name, brand or partner field. |
| `brand` | omitted | Case-insensitive whole-field equality after trimming input. |
| `certifiedSince` | omitted | Inclusive source certification-date threshold, `YYYY-MM-DD`. |
| `maxItems` | 100 | Global unique dataset/product rows, integer 1–10000. |

All supplied filters combine with AND. Keyword matches ANY of the available fields; it is one substring, not a tokenized search. Outer input whitespace is trimmed; internal whitespace and punctuation are retained. `%`, `_` and backslash are rejected in keywords because they have special SQL pattern meaning.

Brand filtering uses `brand_name`, or `outdoor_unit_brand_name` for HVAC datasets. Keyword search includes the same outdoor-unit brand field. It does not search arbitrary efficiency attributes or indoor-unit component brands.

Categories are visited in the supplied order. A category can consume the entire global cap, leaving later categories unvisited. Within each dataset, source row IDs define pagination order; no ranking is implied. Unsupported fields and malformed filters fail rather than being silently ignored. Zero does not mean unlimited.

### Supported categories

The editor lists 59 certified-product datasets from the official catalog, including residential refrigerators, clothes washers, dishwashers, heat pumps, water heaters, computers, displays and commercial equipment. Examples:

| Category | Dataset ID |
| --- | --- |
| Residential Refrigerators | `p5st-her9` |
| Residential Clothes Washers | `bghd-e2wd` |
| Residential Dishwashers | `q8py-6w3f` |
| Heat Pumps | `83eb-xbyy` |
| Commercial Dishwashers | `pk8q-dim8` |
| Displays | `qbg3-d468` |

The supported dataset list is shipped with this version, not discovered afresh on every run. New source categories require an update. Most Efficient-only datasets, connected-product lists, the model index and tax-credit-only lists are not separate selectable modes. Some official categories can legitimately be empty.

### Extracted data

| Field | Meaning |
| --- | --- |
| `productId` | Official ENERGY STAR unique ID as a string. |
| `brand`, `modelNumber`, `modelName` | Published product identity; optional names can be null. |
| `partner` | Published partner name, or null. |
| `category` | Official dataset category. |
| `certificationDate` | Source certification date, not a modification timestamp. |
| `modelIdentifier` | Published certification-body model identifier, or null. |
| `markets` | Array of published market names. |
| `attributes` | Remaining source attributes with original keys, units and value types. |
| `sourceDataset`, `sourceUrl` | Official dataset ID and landing page. |
| `retrievedAt` | UTC retrieval timestamp. |

Numeric measurements in `attributes` often arrive as strings. Do not strip unit-bearing keys or compare measurements across incompatible product categories. UPC and efficiency fields are included only when the source supplies them.

### Output example

A refrigerator record from the live source, abbreviated to illustrate the envelope:

```json
{
  "productId":"4015668",
  "brand":"ABL",
  "modelNumber":"AREF18**",
  "modelName":null,
  "partner":null,
  "category":"Residential Refrigerators",
  "certificationDate":"2025-04-15T00:00:00.000",
  "modelIdentifier":"ES_1148590_AREF18**_04152025120303_80247440",
  "markets":["United States","Canada"],
  "attributes":{"annual_energy_use_kwh_yr":"360","type":"Top Freezer"},
  "sourceDataset":"p5st-her9",
  "sourceUrl":"https://data.energystar.gov/d/p5st-her9",
  "retrievedAt":"2026-10-28T12:00:00.000Z"
}
```

The timestamp is illustrative. Actual output retains all additional published attributes, not only the two shown above.

### How much does it cost to export ENERGY STAR certified products?

Pay per event: a one-time **$0.001 start fee** plus a per-product-record fee. BRONZE pricing is **$0.0186 per record**. Other plan tiers are shown in the Actor's Pricing tab.

BRONZE example invoice totals, including the start fee: 5 products → $0.094; 25 products → $0.466; 100 products → $1.861. Rejected, duplicate and nonexistent products have no item event charge. An empty successful search still incurs the start fee. Dataset/product-ID pairs are distinct output units: a product appearing in different selected datasets can produce more than one record.

Set `maxItems` and your Apify spending limit to control collection. A platform spending limit may stop output before the requested cap.

### Reliability and limitations

Requests use a 45-second timeout and at most three attempts. Transient network errors, HTTP 429 and server errors are retried with bounded backoff; permanent request errors fail without blind retries. No paid proxy fallback is enabled.

Source outages, response-shape changes and malformed products fail honestly. If a later category fails after earlier output was saved, rows are partial; do not treat the failed run as a complete export. Pagination is not a transactional database snapshot, so upstream changes during a long run can affect coverage. Duplicates within a dataset are removed by product ID.

Published model wildcards are preserved, not expanded into fabricated SKUs. Certification does not establish stock availability, retailer pricing, tax-credit eligibility, or that a particular purchased item exactly matches a certified model.

### Integrations

Send JSON exports to a warehouse and join on `(sourceDataset, productId)`. Flatten selected efficiency keys into spreadsheet columns after choosing compatible categories. Schedule recurring exports through Apify and compare snapshots in your own database; use an Apify webhook to notify your pipeline when a run finishes.

For procurement, combine certification data with your own vendor catalog rather than treating official models as sale offers. Keep the source link and retrieval time with derived comparisons.

### API usage

Keep your Apify token private. The synchronous endpoint below returns dataset rows for a bounded run:

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~energy-star-certified-products/run-sync-get-dataset-items' \
  -H "Authorization: Bearer $APIFY_TOKEN" -H 'Content-Type: application/json' \
  -d '{"datasets":["p5st-her9"],"maxItems":5}'
```

JavaScript with the official client:

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/energy-star-certified-products').call({ maxItems: 5 });
if (run.status !== 'SUCCEEDED') throw new Error(`Run ${run.id}: ${run.status}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 5 });
console.log(items);
```

Python:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/energy-star-certified-products').call(run_input={'maxItems': 5})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError(run['status'])
print(client.dataset(run['defaultDatasetId']).list_items(limit=5).items)
```

### MCP use

For Claude Code:

```bash
claude mcp add --transport http apify \
  'https://mcp.apify.com?tools=automation-lab/energy-star-certified-products'
```

For Claude Desktop, Cursor, and VS Code clients that support remote HTTP MCP, use the equivalent client configuration (or the client's documented remote-server adapter):

```json
{"mcpServers":{"apify":{"url":"https://mcp.apify.com?tools=automation-lab/energy-star-certified-products"}}}
```

Authenticate through your client's supported Apify setup. Example prompts: “Export five ENERGY STAR refrigerator models and compare their published annual energy use.” Or: “Find Samsung certified refrigerators with certification dates on or after 2025-01-01, maximum five records.”

Discover actual tools and argument schemas with scoped `tools/list`. Actor selection also adds run and storage tools; it does not expose exactly one tool. Discovery is read-only, not permission to run anything.

For an authorized invocation, start once and retain the returned run ID and storage IDs. If the run is nonterminal, use `get-actor-run` to check that same run with bounded backoff (2, 4, 8 seconds, capped at 10) and a 120-second total deadline. Set client timeouts above the selected server wait plus transport margin. On timeout, recover the known run instead of restarting. If its ID is unknown, report uncertainty. At deadline, report pending with the run ID.

After success, use `get-dataset-items` with the returned `defaultDatasetId`. For example, pass these arguments according to the discovered tool schema (`fields` is a comma-separated string):

```json
{
  "datasetId": "<defaultDatasetId>",
  "limit": 20,
  "offset": 0,
  "fields": "productId,brand,modelNumber,certificationDate,sourceDataset,sourceUrl"
}
```

Prefer untransformed JSON and advance the source offset by the source page size, not by a transformed or summarized row count. Read bounded pages of 20 source rows up to 100 rows and 64 KiB of serialized UTF-8 result content across all pages admitted to model context, whichever comes first. Enforce the byte budget host-side; summarize or omit oversized rows with disclosure. Track source offsets, report partial/truncated results and the continuation offset, and keep full exports outside model context. A client that cannot intercept oversized responses cannot guarantee this byte ceiling. Run and storage IDs are metadata, not results. Failed runs may contain partial rows, not a complete successful export. No numeric context-saving claim is made.

### Legality, responsible use and diagnostics

Use the official data under the applicable [EPA data license](https://edg.epa.gov/EPA_Data_License.html). Verify critical certification conclusions against the source and current program requirements; this tool does not provide legal advice.

Failed operations send sanitized diagnostic input, exceptions and Actor/build/run IDs to our private GlitchTip service for repair. Secret fields and URL queries are removed and reports are retained for 30 days.

Runtime extraction does not use AI or send product data to a model provider. Apify hosts run datasets and logs under your account's retention settings; this Actor does not create persistent global caches or sessions. Delete run storage in Apify to remove exported copies. For help, open an issue on this Actor's Apify Issues tab.

### FAQ and troubleshooting

**Why is partner null?** Some categories do not publish a partner field. Brand is not substituted for a legal partner identity.

**Why are there no products?** Check the category and filter intersection. An empty category or restrictive keyword/brand/date combination can legitimately return zero rows. Source errors instead fail the run.

**Why are some values strings?** The source uses strings for many numeric and date fields. Original representations and unit-bearing field names are retained in attributes.

**Can I monitor changes?** Schedule snapshots and compare them downstream. This Actor does not provide persistent change events or historical reconstruction.

**Why did later categories return nothing?** The global cap is consumed in input category order. Increase it or run categories separately.

### Related Actors

For a separate product-safety workflow, use our [CPSC Product Recalls & Remedies Monitor](https://apify.com/automation-lab/cpsc-recalls-remedies-monitor). Certification and recall records answer different questions and should not be treated as equivalent regulatory status.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/energy-star-certified-products/changelog.md

# Actor input Schema

## `datasets` (type: `array`):

Official certified-product dataset IDs. Processed in supplied order with duplicates removed. All 59 supported categories are listed; no arbitrary URLs. The default exports residential refrigerators.

## `keyword` (type: `string`):

Case-insensitive literal substring after trimming outer whitespace. Matches ANY available brand_name, outdoor_unit_brand_name, model_number, model_name, partner_name or energy_star_partner field. One phrase, not tokenized. SQL wildcard characters %, \_ and backslash are rejected.

## `brand` (type: `string`):

Case-insensitive whole-field equality against brand_name (or outdoor_unit_brand_name in HVAC datasets) after trimming input. Combined with keyword and date filters using AND. Unsupported category/filter combinations fail before retrieval.

## `certifiedSince` (type: `string`):

Inclusive YYYY-MM-DD threshold on the source certification date. Categories without a supported certification-date field fail before retrieval. Not a change-history filter.

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

Global maximum unique dataset/product-ID rows across all selected categories, in category order. Default 100; allowed 1–10000. No zero/unlimited mode. Pagination stops at this cap; later categories may not be visited.

## Actor input object example

```json
{
  "datasets": [
    "p5st-her9"
  ],
  "maxItems": 5
}
```

# Actor output Schema

## `dataset` (type: `string`):

Normalized certified products with category-specific attributes and provenance.

# 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 = {
    "datasets": [
        "p5st-her9"
    ],
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/energy-star-certified-products").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 = {
    "datasets": ["p5st-her9"],
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/energy-star-certified-products").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 '{
  "datasets": [
    "p5st-her9"
  ],
  "maxItems": 5
}' |
apify call automation-lab/energy-star-certified-products --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/energy-star-certified-products"
        }
    }
}
```

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/GzZfqda7K36bNfxCe/builds/Qgk5lEe6q1PkFXLRX/openapi.json