# NRC Reactor Status Scraper (`compute-edge/nrc-reactor-status-scraper`) Actor

Scrapes NRC (Nuclear Regulatory Commission) reactor power status data and operating reactor facility details.

- **URL**: https://apify.com/compute-edge/nrc-reactor-status-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

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/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

## NRC Nuclear Reactor Status Scraper

Extract **nuclear reactor power status and facility data** from the **U.S. Nuclear Regulatory Commission (NRC)**. This Actor retrieves daily power output levels for all **93 commercial nuclear reactor units** in the United States, along with detailed facility information including reactor type, licensee, and location.

The NRC maintains real-time operational data on every commercial nuclear power plant in the country. This Actor provides that data in clean, structured JSON format — ideal for **energy market analysis**, **grid reliability monitoring**, **nuclear industry research**, and **ESG reporting**. Track which reactors are at full power, in planned outages, or operating at reduced capacity.

### Key Features

| Feature | Description |
|---------|-------------|
| **Three data modes** | Power Status (365 days), Reactor Details (facility info), Combined (merged) |
| **93 reactor units** | Every commercial nuclear reactor in the United States |
| **365-day history** | Daily power output percentage for the past year |
| **Unit name filtering** | Search by reactor name (partial match) |
| **Power level filtering** | Only include reactors above a minimum power level |
| **No authentication** | Uses freely available NRC public data — no API key needed |

### What Data Can You Extract?

| Field | Description |
|-------|-------------|
| `unitName` | Reactor unit name (e.g., "Diablo Canyon 1") |
| `powerLevel` | Current power output (0-100%) |
| `reportDate` | Date of the power status reading |
| `docketNumber` | NRC docket number |
| `licenseNumber` | Operating license number |
| `reactorType` | PWR (Pressurized Water) or BWR (Boiling Water) |
| `location` | City and state |
| `licensee` | Operating company |
| `nrcRegion` | NRC regulatory region |

### How to Scrape NRC Reactor Data

1. **Go to this Actor's page** on the Apify Store
2. **Click "Start"** to open the input form
3. **Set your filters:**
   - Select a **Data Type**: Power Status, Reactor Details, or Combined
   - Enter a **Unit Name** for partial name search (e.g., "Diablo") — or leave blank for all
   - Set a **Minimum Power Level** (0-100) to filter reactors by output — only applies to power status data
   - Set **Max Results** (default: 500; set to 0 for all records)
4. **Click "Start"** to run the Actor
5. **Download your data** in JSON, CSV, or Excel format from the Dataset tab

### Input Example

```json
{
    "dataType": "combined",
    "minPower": 50,
    "maxResults": 100
}
````

### Output Example

```json
{
    "unitName": "Diablo Canyon 1",
    "powerLevel": 100,
    "reportDate": "03/12/2026",
    "docketNumber": "05000275",
    "licenseNumber": "DPR-80",
    "licensee": "Pacific Gas & Electric Co.",
    "reactorType": "PWR",
    "location": "San Luis Obispo, CA",
    "nrcRegion": "4"
}
```

### Pricing

This Actor uses **pay-per-result** pricing:

| Event | Price |
|-------|-------|
| Actor start | $0.00005 |
| Per result | $0.002 |

NRC data is free and public. You only pay for Apify compute resources plus the per-result fee above. A typical combined run of all 93 reactors costs approximately $0.19 in Actor fees.

### Use Cases

- **Energy Trading**: Monitor reactor outages and power reductions that affect electricity supply and pricing
- **Grid Reliability Analysis**: Track the nuclear fleet's contribution to baseload power generation
- **Nuclear Industry Research**: Analyze reactor performance, uptime, and seasonal patterns
- **ESG & Climate Reporting**: Quantify nuclear energy's role in carbon-free electricity generation
- **Regulatory Monitoring**: Track NRC-regulated facilities and their operational status
- **Insurance & Risk Assessment**: Evaluate nuclear facility operations for insurance underwriting

### Integrations

Connect this Actor to your existing workflows:

- Export to **Google Sheets** for collaborative analysis
- Send results to **Slack** or **email** for automated alerts
- Feed into **Zapier**, **Make**, or **n8n** for custom automation
- Use the Apify API to integrate directly with your application

### FAQ

#### Is it legal to scrape NRC reactor status data?

Yes. NRC reactor status data is publicly available from the U.S. Nuclear Regulatory Commission website. The data is in the public domain and freely available for any use. This Actor accesses publicly posted data and does not bypass any authentication or access restrictions.

#### How much does it cost to scrape NRC reactor data?

The Actor charges $0.002 per result plus a $0.00005 Actor start fee. A typical combined run of all 93 reactors costs approximately $0.19 in Actor fees. See the pricing table above for details.

#### Can I export NRC reactor data to Excel or CSV?

Yes. Apify supports exporting data in JSON, CSV, Excel, XML, HTML, and RSS formats. After the Actor run completes, go to the Dataset tab and choose your preferred export format.

#### How often is the NRC reactor data updated?

You can schedule this Actor to run at any interval — daily, weekly, or monthly. The NRC updates the power status feed daily, and the dataset includes the last 365 days of daily readings for all reactor units.

#### How many nuclear reactors are in the US?

There are currently 93 operating commercial nuclear reactor units at 54 nuclear power plant sites across 28 states. The two reactor types are PWR (Pressurized Water Reactor, ~65 units) and BWR (Boiling Water Reactor, ~28 units).

### Other Scrapers by SeatSignal

- [EIA Energy Data Scraper](https://apify.com/seatsignal/eia-energy-scraper) — Extract U.S. energy production and consumption data
- [NREL Alternative Fuel Stations Scraper](https://apify.com/seatsignal/nrel-alt-fuel-stations-scraper) — Extract EV charging and alternative fuel station data
- [Energy Star Certified Products Scraper](https://apify.com/seatsignal/energystar-scraper) — Search 290K+ EPA Energy Star certified products
- [FEMA Disaster Declarations Scraper](https://apify.com/seatsignal/fema-disasters-scraper) — Extract 60K+ FEMA disaster declaration records
- [EPA ECHO Environmental Compliance Scraper](https://apify.com/seatsignal/epa-echo-scraper) — Extract compliance data for 800K+ EPA-regulated facilities

### Legal Disclaimer

This Actor accesses publicly available data from the NRC website, a free public service provided by the U.S. Nuclear Regulatory Commission. The data is in the public domain and freely available for any use.

This Actor does not bypass any authentication, does not violate any terms of service, and respects server resources. The Actor is provided as-is without warranty. Users are responsible for ensuring their use of the data complies with applicable laws and regulations.

For questions or support, please open an issue on this Actor's page.

# Actor input Schema

## `dataType` (type: `string`):

Which NRC dataset to retrieve

## `unitName` (type: `string`):

Filter by reactor unit name (partial match, e.g., 'Diablo'). Leave empty for all.

## `minPower` (type: `integer`):

Only include status entries at or above this power level (0-100). Only applies to powerStatus/combined.

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

Maximum number of records to return (0 = all)

## Actor input object example

```json
{
  "dataType": "powerStatus",
  "unitName": "",
  "minPower": 0,
  "maxResults": 500
}
```

# Actor output Schema

## `dataset` (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("compute-edge/nrc-reactor-status-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/nrc-reactor-status-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 '{}' |
apify call compute-edge/nrc-reactor-status-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=compute-edge/nrc-reactor-status-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "NRC Reactor Status Scraper",
        "description": "Scrapes NRC (Nuclear Regulatory Commission) reactor power status data and operating reactor facility details.",
        "version": "0.1",
        "x-build-id": "Mxvi1DyfHUOrrALMl"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~nrc-reactor-status-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-nrc-reactor-status-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/compute-edge~nrc-reactor-status-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-nrc-reactor-status-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/compute-edge~nrc-reactor-status-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-nrc-reactor-status-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": {
                    "dataType": {
                        "title": "Data Type",
                        "enum": [
                            "powerStatus",
                            "reactorDetails",
                            "combined"
                        ],
                        "type": "string",
                        "description": "Which NRC dataset to retrieve",
                        "default": "powerStatus"
                    },
                    "unitName": {
                        "title": "Unit Name",
                        "type": "string",
                        "description": "Filter by reactor unit name (partial match, e.g., 'Diablo'). Leave empty for all.",
                        "default": ""
                    },
                    "minPower": {
                        "title": "Minimum Power Level",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only include status entries at or above this power level (0-100). Only applies to powerStatus/combined.",
                        "default": 0
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of records to return (0 = all)",
                        "default": 500
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
