# Bureau of Reclamation Water Data Scraper (`compute-edge/usbr-water-data-scraper`) Actor

Extract water data from the Bureau of Reclamation RISE API. Download reservoir levels, dam operations, water storage, and streamflow for western US dams. Browse 7700+ USBR datasets. No auth required.

- **URL**: https://apify.com/compute-edge/usbr-water-data-scraper.md
- **Developed by:** [Compute Edge](https://apify.com/compute-edge) (community)
- **Categories:** Lead generation, Automation
- **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

## Bureau of Reclamation Water Data Scraper

Extract water resource data from the **Bureau of Reclamation RISE (Reclamation Information Sharing Environment) API**. Download daily reservoir levels, dam operations, water storage volumes, streamflow measurements, and more for every major western US dam and reservoir. Browse and search the full USBR catalog of **7,700+ datasets** spanning decades of hydrological records. No authentication or API key required.

### Key Features

- **Time Series Data** -- Download daily measurements for any catalog item: reservoir storage (acre-feet), water elevation (feet), release volumes (cfs), inflow, evaporation, and more
- **Catalog Search** -- Browse or search the full USBR dataset catalog by keyword to discover available data for specific dams, reservoirs, rivers, or parameters
- **Complete Location Metadata** -- Every record includes facility name, state, GPS coordinates, Reclamation region, facility type, timezone, and measurement units
- **Historical Coverage** -- Many datasets go back to the 1930s-1960s, providing decades of continuous daily observations
- **Zero Authentication** -- The RISE API is fully public. No API keys, tokens, or credentials needed

### Data Fields

#### Time Series Output

| Field | Description | Example |
|-------|-------------|---------|
| `itemId` | USBR catalog item identifier | `509` |
| `locationName` | Dam or reservoir name | `Lake Powell Glen Canyon Dam and Powerplant` |
| `state` | US state abbreviation | `AZ` |
| `latitude` | GPS latitude (WGS84) | `37.05778` |
| `longitude` | GPS longitude (WGS84) | `-111.30332` |
| `reclamationRegion` | Bureau of Reclamation region code | `UC` (Upper Colorado) |
| `facilityType` | Type of facility | `Lake/Reservoir`, `Dam`, `Diversion` |
| `parameterName` | What is being measured | `Lake/Reservoir Storage` |
| `units` | Measurement units | `af` (acre-feet), `cfs`, `ft` |
| `timestep` | Measurement frequency | `daily`, `monthly` |
| `dateTime` | Observation timestamp (UTC) | `2024-01-01 07:00:00` |
| `value` | Measured value as a number | `8429440` |
| `resultType` | Observed vs modeled | `observed` |

#### Catalog Output

| Field | Description | Example |
|-------|-------------|---------|
| `itemId` | Catalog item ID (use with timeseries mode) | `6124` |
| `name` | Dataset title | `Lake Mead Daily Storage-af Time Series Data` |
| `locationName` | Facility name | `Lake Mead Hoover Dam and Powerplant` |
| `state` | State(s) | `AZ, NV` |
| `parameterName` | Measurement parameter | `Lake/Reservoir Storage` |
| `units` | Units of measurement | `af` |
| `timestep` | Data frequency | `daily` |
| `temporalStart` | Earliest available data | `1934-04-01` |
| `temporalEnd` | Most recent data | `2026-03-16` |

### How to Scrape Bureau of Reclamation Water Data

#### Step 1: Download Time Series by Item ID

If you already know the catalog item ID, set the following input:

```json
{
    "dataType": "timeseries",
    "itemId": 509,
    "startDate": "2024-01-01",
    "endDate": "2024-12-31",
    "maxResults": 500
}
````

This downloads daily Lake Powell storage data for all of 2024. Common item IDs include:

- **509** -- Lake Powell reservoir storage (acre-feet)
- **6124** -- Lake Mead reservoir storage (acre-feet)
- **513** -- Lake Powell water elevation (feet)
- **6127** -- Lake Mead water elevation (feet)

#### Step 2: Search the Catalog

If you need to find the right dataset, use catalog mode:

```json
{
    "dataType": "catalog",
    "searchQuery": "Hoover Dam",
    "maxResults": 20
}
```

This returns all datasets mentioning "Hoover Dam" with their item IDs, parameters, units, and date ranges. Use the `itemId` from the results to download time series data.

#### Step 3: Search and Download in One Step

Provide a search query in timeseries mode without an item ID, and the actor automatically finds and downloads data for the first matching dataset:

```json
{
    "dataType": "timeseries",
    "searchQuery": "Lake Powell",
    "startDate": "2024-06-01",
    "endDate": "2024-06-30",
    "maxResults": 30
}
```

### Pricing

This actor uses the pay-per-result pricing model:

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

Users also pay standard Apify platform compute costs. A typical run downloading 365 days of daily data for one reservoir costs approximately $0.73 in result fees plus minimal compute costs.

### Common Use Cases

- **Drought Monitoring** -- Track reservoir storage levels across the Colorado River Basin to monitor drought conditions in real time
- **Water Supply Forecasting** -- Feed historical storage and inflow data into predictive models for agricultural water allocation
- **Environmental Compliance** -- Document dam release volumes for regulatory reporting and environmental impact assessments
- **Infrastructure Planning** -- Analyze long-term reservoir capacity trends for water infrastructure investment decisions
- **Academic Research** -- Access decades of hydrological time series data for climate science, hydrology, and water policy research
- **RAG Pipelines** -- Structured JSON output feeds directly into retrieval-augmented generation systems for AI-powered water analytics

### Input Reference

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `dataType` | string | No | `timeseries` | `timeseries` for measurement data, `catalog` to browse/search datasets |
| `itemId` | integer | No | -- | Catalog item ID to download (e.g., 509 for Lake Powell storage) |
| `searchQuery` | string | No | -- | Search keyword (e.g., "Lake Mead", "Colorado River") |
| `startDate` | string | No | 30 days ago | Start date for time series (YYYY-MM-DD) |
| `endDate` | string | No | Today | End date for time series (YYYY-MM-DD) |
| `maxResults` | integer | No | 500 | Maximum number of records to return |

### Example Output (Time Series)

```json
{
    "itemId": 509,
    "locationName": "Lake Powell Glen Canyon Dam and Powerplant",
    "state": "AZ",
    "latitude": 37.05778,
    "longitude": -111.30332,
    "reclamationRegion": "UC",
    "facilityType": "Lake/Reservoir",
    "parameterName": "Lake/Reservoir Storage",
    "units": "af",
    "timestep": "daily",
    "timezone": "MT",
    "aggregation": "instant",
    "dateTime": "2024-01-01 07:00:00",
    "value": 8429440,
    "timeStep": "day",
    "resultType": "observed"
}
```

### FAQ

#### Is it legal to scrape Bureau of Reclamation water data?

Yes. This Actor accesses publicly available data from the Bureau of Reclamation RISE API. The data is provided by a U.S. government agency and is in the public domain. No authentication is required.

#### How Much Does It Cost to Scrape USBR Water Data?

See the pricing table above. At $0.002 per result, downloading 365 days of daily reservoir data costs approximately $0.73 in Actor fees plus minimal Apify compute costs.

#### Can I export water data to Excel or CSV?

Yes. Apify supports exporting results in JSON, CSV, Excel, XML, and other formats directly from the Dataset tab after a run completes.

#### How often is the USBR data updated?

Most operational datasets (storage, elevation, releases) are updated daily. Some datasets have monthly or irregular update frequencies. You can schedule this Actor to run at any interval.

#### What dams and reservoirs are covered?

The database includes over 1,200 catalog records covering major facilities like Lake Powell, Lake Mead, Shasta Lake, Folsom Lake, and hundreds of smaller reservoirs across 17 western states.

### Other Scrapers by SeatSignal

- [USGS Earthquake Data Scraper](https://apify.com/seatsignal/usgs-earthquake-scraper) — Extract earthquake event data from USGS
- [EPA Drinking Water Scraper](https://apify.com/seatsignal/epa-drinking-water-scraper) — Extract drinking water system data
- [FEMA Disasters Scraper](https://apify.com/seatsignal/fema-disasters-scraper) — Extract federal disaster declaration data
- [EIA Energy Data Scraper](https://apify.com/seatsignal/eia-energy-scraper) — Extract petroleum, natural gas, and electricity data
- [EPA ECHO Scraper](https://apify.com/seatsignal/epa-echo-scraper) — Extract environmental compliance and enforcement data

### Legal Disclaimer

This actor accesses publicly available data from the Bureau of Reclamation RISE API. The data is provided by the US government and is in the public domain. Data are provisional and subject to revision. Users should consider the provisional nature of the information before making decisions based on it. This actor is not affiliated with or endorsed by the Bureau of Reclamation.

For support, open an issue on GitHub or contact us through the Apify platform.

# Actor input Schema

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

Choose 'timeseries' to download actual measurement data (reservoir levels, flows, etc.) or 'catalog' to browse/search available datasets in the USBR RISE catalog.

## `itemId` (type: `integer`):

Specific catalog item ID to download time series data for. For example: 509 = Lake Powell storage, 6124 = Lake Mead storage, 513 = Lake Powell elevation. Find IDs by running in 'catalog' mode first.

## `searchQuery` (type: `string`):

Search for catalog items by name (e.g., 'Lake Mead', 'Hoover Dam', 'Colorado River'). In catalog mode, returns matching datasets. In timeseries mode without an itemId, downloads data for the first matching item.

## `startDate` (type: `string`):

Start date for time series data in YYYY-MM-DD format. Defaults to 30 days ago if not specified.

## `endDate` (type: `string`):

End date for time series data in YYYY-MM-DD format. Defaults to today if not specified.

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

Maximum number of records to return. For time series, this limits the number of data points. For catalog, this limits the number of datasets returned.

## Actor input object example

```json
{
  "dataType": "timeseries",
  "searchQuery": "Lake Powell",
  "startDate": "2024-01-01",
  "endDate": "2024-12-31",
  "maxResults": 500
}
```

# 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 = {
    "searchQuery": "Lake Powell",
    "startDate": "2024-01-01",
    "endDate": "2024-12-31"
};

// Run the Actor and wait for it to finish
const run = await client.actor("compute-edge/usbr-water-data-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 = {
    "searchQuery": "Lake Powell",
    "startDate": "2024-01-01",
    "endDate": "2024-12-31",
}

# Run the Actor and wait for it to finish
run = client.actor("compute-edge/usbr-water-data-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 '{
  "searchQuery": "Lake Powell",
  "startDate": "2024-01-01",
  "endDate": "2024-12-31"
}' |
apify call compute-edge/usbr-water-data-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Bureau of Reclamation Water Data Scraper",
        "description": "Extract water data from the Bureau of Reclamation RISE API. Download reservoir levels, dam operations, water storage, and streamflow for western US dams. Browse 7700+ USBR datasets. No auth required.",
        "version": "0.1",
        "x-build-id": "xEpfe99gd4c0dvOhg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/compute-edge~usbr-water-data-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-compute-edge-usbr-water-data-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~usbr-water-data-scraper/runs": {
            "post": {
                "operationId": "runs-sync-compute-edge-usbr-water-data-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~usbr-water-data-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-compute-edge-usbr-water-data-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": [
                            "timeseries",
                            "catalog"
                        ],
                        "type": "string",
                        "description": "Choose 'timeseries' to download actual measurement data (reservoir levels, flows, etc.) or 'catalog' to browse/search available datasets in the USBR RISE catalog.",
                        "default": "timeseries"
                    },
                    "itemId": {
                        "title": "Catalog Item ID",
                        "type": "integer",
                        "description": "Specific catalog item ID to download time series data for. For example: 509 = Lake Powell storage, 6124 = Lake Mead storage, 513 = Lake Powell elevation. Find IDs by running in 'catalog' mode first."
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Search for catalog items by name (e.g., 'Lake Mead', 'Hoover Dam', 'Colorado River'). In catalog mode, returns matching datasets. In timeseries mode without an itemId, downloads data for the first matching item."
                    },
                    "startDate": {
                        "title": "Start Date",
                        "type": "string",
                        "description": "Start date for time series data in YYYY-MM-DD format. Defaults to 30 days ago if not specified."
                    },
                    "endDate": {
                        "title": "End Date",
                        "type": "string",
                        "description": "End date for time series data in YYYY-MM-DD format. Defaults to today if not specified."
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of records to return. For time series, this limits the number of data points. For catalog, this limits the number of datasets returned.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
