# Grid Interconnection Queue Scraper — CAISO & MISO Projects (`deadwood_data_solutions/grid-interconnection-queue-tracker`) Actor

See tomorrow's power plants today. This CAISO & MISO interconnection queue scraper turns official generator interconnection queue data into one clean feed: solar, wind, storage & gas projects with MW capacity, location, developer, and status. Official data that doesn't break.

- **URL**: https://apify.com/deadwood\_data\_solutions/grid-interconnection-queue-tracker.md
- **Developed by:** [K O](https://apify.com/deadwood_data_solutions) (community)
- **Categories:** News, Jobs, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 queue project 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

## Grid Interconnection Queue Tracker — CAISO & MISO Queue Scraper API

A **CAISO interconnection queue API** and **MISO interconnection queue
scraper** in one actor. It pulls the official generator interconnection
queue — the list of every solar, wind, storage, and gas project formally
waiting for permission to connect to the power grid — directly from CAISO's
public queue report and MISO's public queue API, and normalizes both into
one structured feed.

Use it to build a **renewable energy pipeline dataset**, a power-plant
siting/development tracker, an ISO queue monitoring tool, or a data feed for
energy-transition and grid capacity research — all from the same normalized
interconnection queue data.

### Why this is worth charging for

The interconnection queue is the single best leading indicator of where new
power generation capacity is actually headed, years before it shows up in
capacity auctions, EIA filings, or news coverage — a project has to enter the
queue long before it breaks ground. Firms that specialize in exactly this data
(queue analytics, siting intelligence, energy-transition research) sell it as
a premium subscription product, not a free download, because:

- The source files are real, messy, ISO-maintained artifacts — CAISO's report
  has a metadata header block before the real table and repeats MW/fuel-type
  columns for hybrid (e.g. solar+storage) projects; MISO exposes it as a raw,
  undocumented JSON API with inconsistent field casing. Reading either
  correctly, every time, is the actual work.
- The buyers are well-funded and recurring: renewable energy developers doing
  site selection, transmission planners, PE/infra funds underwriting energy
  transition deals, utilities tracking competitor projects, and journalists
  / researchers covering the pace of the energy transition.
- There is no unified cross-ISO API for this anywhere. Commercial equivalents
  (queue analytics platforms sold to the power sector) price in the tens of
  thousands of dollars per year for coverage across ISOs.

### Output

Each dataset item is one normalized interconnection queue project:

```json
{
  "iso": "CAISO",
  "projectName": "Sunridge Hybrid Energy Center",
  "queuePosition": "CAISO-2201",
  "developer": null,
  "utility": "PG&E",
  "county": "Fresno",
  "state": "CA",
  "fuelTypes": ["Solar", "Storage"],
  "totalMw": 225,
  "fuelCapacityMw": { "MW-1": 150, "MW-2": 75 },
  "applicationStatus": "Active",
  "studyProcess": "Cluster 15",
  "currentPhase": null,
  "requestDate": "2025-04-01",
  "proposedOnlineDate": null,
  "actualOnlineDate": null,
  "withdrawnDate": null,
  "fixedTracking": null,
  "sourceUrl": "https://www.caiso.com/documents/publicqueuereport.xlsx",
  "headerDetectionConfidence": "high"
}
```

`fuelCapacityMw` and `fuelTypes` are arrays/objects rather than single values
on purpose: hybrid projects (solar+storage is now the majority of new CAISO
capacity) report multiple fuel/MW pairs, and collapsing them to one field
would silently understate capacity.

### Input

| Field | Description |
|---|---|
| `isos` | Which grid operators to pull (`CAISO`, `MISO` at launch — see Roadmap). |
| `fuelTypeContains` | Case-insensitive substring filter, e.g. `Storage`, `Solar`, `Wind`. |
| `maxItems` | Stop after this many normalized project records. |
| `includeRawRecord` | Attach the untouched original row/object for audit — recommended for MISO, since it's a live API. |

### Pricing (Pay-Per-Event)

- **`iso-source-refresh`** — $0.25, charged once per ISO per run, for having
  refreshed and re-validated that source (covers the cost of the fetch/parse
  even if a fuel-type filter narrows visible output to zero rows).
- **`queue-project-record`** — $0.03 per normalized project record pushed.
  This is the primary event.
- `apify-actor-start` (synthetic, Apify-managed) — covers the first 5 seconds
  of compute per run.

A scheduled weekly refresh (checking for new/changed entries across both
ISOs) typically costs under a dollar per run; a full historical pull across
CAISO's several-thousand-row queue scales with row count but stays priced
well below commercial queue-analytics subscriptions.

### Why MISO is handled defensively

CAISO's file is a stable, dated ISO publication. MISO's queue is a live,
undocumented JSON API (`src/parsers/miso.js`) that can change field names,
casing, or availability without notice. Rather than assuming exact key names,
the MISO normalizer pattern-matches keys case-insensitively and always
preserves the full original object under `raw`, so a MISO-side change degrades
individual fields to `null` instead of crashing the run or silently returning
wrong data. If the endpoint stops returning a JSON array entirely, that ISO is
skipped with a clear warning and the run continues with any other requested
ISOs. Run `npm test` for the offline self-test covering both parsers,
including a deliberately hostile MISO payload.

### Roadmap

Architecture is pluggable: add an entry to `src/sources.js`, implement a
parser under `src/parsers/`, and wire it into `ISO_HANDLERS` in `src/main.js`.
ERCOT, PJM, and SPP are natural next additions once each ISO's current public
access method (file vs. API vs. registration-gated portal) is reconfirmed.

### FAQ

**Is there an API for the CAISO interconnection queue?**
Yes — this actor is that API. It fetches CAISO's official public queue
report and returns structured JSON you can pull via the Apify API, webhook,
or direct export (JSON/CSV/Excel), instead of manually downloading and
re-parsing the spreadsheet yourself.

**Does this cover MISO too?**
Yes. CAISO and MISO are both supported in a single run — set the `isos`
input to `["CAISO", "MISO"]` (the default) to pull both, or just one.

**What does "interconnection queue" data actually show?**
Every project — solar, wind, battery storage, or gas — that has formally
applied to connect to the grid, including capacity in MW, location,
utility/transmission owner, study phase, and application status. It's the
earliest structured signal of where new generation capacity is headed,
well before construction or news coverage.

**Can I filter by fuel type or capacity?**
Yes. Use `fuelTypeContains` (e.g. `"Solar"`, `"Storage"`, `"Wind"`) to filter
at the source, or filter the output dataset by `totalMw` after the run.

**How is this different from reading the CAISO/MISO websites directly?**
CAISO's report has a messy multi-row header block and repeats MW/fuel-type
columns for hybrid projects; MISO's API returns raw, undocumented JSON with
inconsistent field casing. This actor normalizes both into one consistent
schema so you don't have to reverse-engineer either source yourself.

***

### Need the rest of the record on these companies?

This actor returns one source. **[KYB Company Data Enrichment](https://apify.com/deadwood_data_solutions/company-intel-enrichment)** takes a company name and returns what the public record says about it across up to nine sources — state business registries, UCC lien filings, tax warrants and WARN layoff notices, the FMCSA motor-carrier census, the CMS NPI Registry, USAspending federal awards, EPA ECHO compliance, SEC EDGAR filings and CourtListener federal dockets.

Every enriched field carries its source and its match confidence. Only matches above the accept threshold are merged — anything weaker is surfaced as a suggestion and never folded into the record, because a false join is worse than returning nothing.

# Actor input Schema

## `isos` (type: `array`):

CAISO publishes a single public queue workbook. MISO exposes a public queue API. Each ISO adds one 'iso-source-refresh' charge per run.

## `fuelTypeContains` (type: `string`):

Case-insensitive substring filter on fuel type, e.g. 'Solar', 'Storage', 'Wind', 'Battery'. Leave blank to return all fuel types.

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

Stop once this many normalized project records have been pushed to the dataset. Leave blank for no limit.

## `includeRawRecord` (type: `boolean`):

Attach the original, unmodified source row/object as 'raw' on every record. Recommended for MISO since it is a live API that can change shape without notice.

## Actor input object example

```json
{
  "isos": [
    "CAISO",
    "MISO"
  ],
  "includeRawRecord": false
}
```

# Actor output Schema

## `results` (type: `string`):

All normalized records from this run as JSON.

## `resultsCsv` (type: `string`):

All normalized records from this run as CSV.

# 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("deadwood_data_solutions/grid-interconnection-queue-tracker").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("deadwood_data_solutions/grid-interconnection-queue-tracker").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 deadwood_data_solutions/grid-interconnection-queue-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deadwood_data_solutions/grid-interconnection-queue-tracker"
        }
    }
}
```

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/gDldvMw88we4IqGDW/builds/fCLr5TmnQvdiB7unt/openapi.json