# Colorado Water Rights & Structures Screener — CDSS Search (`malonestar/water-rights-availability-screener`) Actor

Colorado water rights and water-infrastructure screening from CO DWR CDSS. Radius-search any site for ditches, wells and reservoirs with water source, seniority sampling (pre-1950 appropriations) and a per-asset availability summary. Built for data-center and land siting.

- **URL**: https://apify.com/malonestar/water-rights-availability-screener.md
- **Developed by:** [Kyle Maloney](https://apify.com/malonestar) (community)
- **Categories:** Real estate, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.40 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Colorado Water Rights & Structures Screener — CDSS Radius Search

Screen any list of coordinates against the **Colorado Division of Water Resources (CO DWR) CDSS** database — the state's authoritative registry of water structures (ditches, wells, reservoirs) and the water rights attached to them. For every site you pass in, the actor returns every nearby structure with its **water source, distance, county/division/water-district**, plus **seniority context** (appropriation date, priority admin number, decreed uses) for the closest structures — and a one-line **water-availability rollup** per site.

Answers, by coordinate: *What water structures are near this site? Whose water rights are they, and how senior? Is this a water-stressed area?*

### Who it's for
- **Data-center site selectors** — Colorado's water fights over hyperscale cooling demand are national news; screen candidate sites for existing water infrastructure and senior-rights pressure before committing to a parcel.
- **Renewable energy & agricultural land developers** — check for competing wells/ditches/reservoirs and their priority dates near a proposed project or farmland acquisition.
- **Water brokers & water-rights attorneys** — a fast first-pass inventory of nearby structures and priority context before a full title/decree search.
- **Land agents & real-estate due-diligence teams** — add a water-availability check to a Phase-I-style site screen, alongside the other CO siting actors in this portfolio.
- **AI agents & data pipelines** — a chainable geospatial water-rights lookup for siting and due-diligence workflows via MCP.

### How it works
1. You supply `assets` — a list of `{lat, lon, label}` sites.
2. For each asset, the actor queries the **CDSS Structures API** (`/api/v2/structures/`) for a radius search around the coordinate, returning geocoded ditches, wells, reservoirs, and other diversion/storage structures.
3. Distances are **recomputed locally** with the haversine formula (not trusted from API ordering) and structures are sorted **nearest-first**.
4. For the nearest `seniorityDetailLimit` structures (default 10), the actor looks up **water-rights seniority** via the CDSS net-amount endpoint (`/api/v2/waterrights/netamount/`) — appropriation date, priority admin number, decreed units/uses, and net absolute amount — and flags rights with an appropriation date **before 1950-01-01** as a coarse "senior right" proxy.
5. One row is emitted per nearby structure (capped by `maxResultsPerAsset`), plus **one summary row per asset** with structure-type counts, nearest distance, and a `water_stress_note`.

Coordinates outside Colorado are still queried — CDSS simply returns 0 structures, and you get an explicit clear/summary row noting that CDSS only covers Colorado.

### Example input
```json
{
  "assets": [
    { "lat": 40.423, "lon": -104.709, "label": "Greeley CO ag parcel" },
    { "lat": 39.739, "lon": -104.99, "label": "Denver downtown control" }
  ],
  "radiusMiles": 5,
  "structureTypes": [],
  "seniorityDetailLimit": 10,
  "maxResultsPerAsset": 200
}
````

### Output fields

One `"structure"` row per nearby water structure (nearest-first) plus one `"summary"` row per asset (`row_type` distinguishes them):

| Field | Meaning |
|-------|---------|
| `asset_label`, `asset_lat`, `asset_lon`, `radius_miles` | Echo of the site you submitted |
| `wdid`, `structure_name`, `structure_type`, `water_source` | CDSS structure identity and water source |
| `county`, `water_district`, `division` | CO DWR administrative location |
| `distance_miles` | Locally recomputed great-circle distance from the asset |
| `ciu_code`, `por_start`, `por_end` | Current-in-use code and period of record |
| `appropriation_date`, `priority_admin_number`, `decreed_uses`, `net_absolute` | Seniority detail for the most senior right found (structure rows only, nearest N per `seniorityDetailLimit`) |
| `senior_pre1950_flag` | `true` when the most senior appropriation predates 1950-01-01 |
| `structures_within_radius`, `wells_count`, `ditches_count`, `reservoirs_count` | Summary rows only: structure-type counts within the radius |
| `nearest_structure_distance_mi` | Summary rows only: distance to the single closest structure |
| `senior_rights_sampled`, `senior_pre1950_count` | Summary rows only: how many nearest structures had seniority sampled, and how many are pre-1950 |
| `water_stress_note` | Summary rows only: one-line human-readable rollup |
| `error` | Null on success; a message when an asset couldn't be screened |
| `source_url`, `checked_at` | CDSS endpoint used and run timestamp |

### Use as an MCP tool

This actor is a clean, chainable tool for AI agents (Claude, Cursor, etc.) via **mcp.apify.com**. Every output field carries a schema description, so an agent can pass a coordinate and reason directly over `structures_within_radius`, `senior_pre1950_flag`, and `water_stress_note` — e.g. as one step in a site-selection or due-diligence pipeline alongside this portfolio's other siting screeners.

### FAQ

**How do I find water rights near my property in Colorado?** Pass the lat/lon as an asset and read the `structure` rows for every nearby ditch, well, or reservoir, and the `summary` row for a quick rollup.

**Is this the CDSS water rights API?** Yes — this actor wraps the Colorado DWR's public CDSS REST API v2 (`/api/v2/structures/` and `/api/v2/waterrights/netamount/`), no key required.

**What does "senior" mean here?** `senior_pre1950_flag` is a coarse proxy: the most senior appropriation date found for a structure predates 1950-01-01. It is **not** a call-status or priority-administration determination — always verify with CO DWR / the Division Engineer and a water-rights professional.

**Does this cover water availability for a data-center site?** It gives you the raw inventory and seniority context CO water-availability due diligence starts with — existing structures, whose rights they are, and how old those rights are. Pair with local aquifer/basin studies and a water-rights attorney for a full determination.

**Do I need an API key?** No. CDSS is public and keyless. To respect CDSS's anonymous request budget, the actor caps seniority lookups per asset (`seniorityDetailLimit`) and assets per run.

**What about states other than Colorado?** v1 covers Colorado only. A v1.1 roadmap adds New Mexico (OSE), Utah, and Idaho as those states' public water-rights APIs are mapped.

### Data source

Colorado Division of Water Resources (CO DWR) — Colorado's Decision Support Systems (CDSS) REST API v2. https://dwr.state.co.us/

# Actor input Schema

## `assets` (type: `array`):

List of sites to screen against Colorado DWR CDSS water structures. Each entry is an object {"lat": number, "lon": number, "label": string}. One or more structure rows plus a per-asset summary row are produced for each entry. Coordinates outside Colorado are still queried (CDSS just returns 0 structures) and get an explicit clear/summary row.

## `radiusMiles` (type: `integer`):

Search radius in miles around each asset within which CDSS water structures (ditches, wells, reservoirs, etc.) are inventoried.

## `structureTypes` (type: `array`):

Optional list of structure-type keywords to keep (case-insensitive substring match against CDSS structureType, e.g. "Ditch", "Well", "Reservoir"). Leave empty to return every structure type found within the radius.

## `seniorityDetailLimit` (type: `integer`):

Max number of the nearest structures per asset for which the actor looks up water-rights seniority (appropriation date, priority admin number, decreed uses) via the CDSS net-amount endpoint. Kept modest to respect the anonymous CDSS request budget (~1,000 requests/day). Structures beyond this limit still appear as rows, just without seniority detail.

## `maxResultsPerAsset` (type: `integer`):

Max number of nearest-first structure rows emitted per asset (in addition to the one summary row). Does not limit the counts reported in the summary row, which always reflect every structure found within the radius.

## Actor input object example

```json
{
  "assets": [
    {
      "lat": 40.423,
      "lon": -104.709,
      "label": "Greeley CO ag parcel"
    },
    {
      "lat": 39.739,
      "lon": -104.99,
      "label": "Denver downtown control"
    }
  ],
  "radiusMiles": 5,
  "structureTypes": [],
  "seniorityDetailLimit": 10,
  "maxResultsPerAsset": 200
}
```

# Actor output Schema

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

The default dataset.

# 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 = {
    "assets": [
        {
            "lat": 40.423,
            "lon": -104.709,
            "label": "Greeley CO ag parcel"
        },
        {
            "lat": 39.739,
            "lon": -104.99,
            "label": "Denver downtown control"
        }
    ],
    "radiusMiles": 5,
    "structureTypes": [],
    "seniorityDetailLimit": 10,
    "maxResultsPerAsset": 200
};

// Run the Actor and wait for it to finish
const run = await client.actor("malonestar/water-rights-availability-screener").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 = {
    "assets": [
        {
            "lat": 40.423,
            "lon": -104.709,
            "label": "Greeley CO ag parcel",
        },
        {
            "lat": 39.739,
            "lon": -104.99,
            "label": "Denver downtown control",
        },
    ],
    "radiusMiles": 5,
    "structureTypes": [],
    "seniorityDetailLimit": 10,
    "maxResultsPerAsset": 200,
}

# Run the Actor and wait for it to finish
run = client.actor("malonestar/water-rights-availability-screener").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 '{
  "assets": [
    {
      "lat": 40.423,
      "lon": -104.709,
      "label": "Greeley CO ag parcel"
    },
    {
      "lat": 39.739,
      "lon": -104.99,
      "label": "Denver downtown control"
    }
  ],
  "radiusMiles": 5,
  "structureTypes": [],
  "seniorityDetailLimit": 10,
  "maxResultsPerAsset": 200
}' |
apify call malonestar/water-rights-availability-screener --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=malonestar/water-rights-availability-screener",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Colorado Water Rights & Structures Screener — CDSS Search",
        "description": "Colorado water rights and water-infrastructure screening from CO DWR CDSS. Radius-search any site for ditches, wells and reservoirs with water source, seniority sampling (pre-1950 appropriations) and a per-asset availability summary. Built for data-center and land siting.",
        "version": "1.0",
        "x-build-id": "nisAHyTC8hnfY29N5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/malonestar~water-rights-availability-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-malonestar-water-rights-availability-screener",
                "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/malonestar~water-rights-availability-screener/runs": {
            "post": {
                "operationId": "runs-sync-malonestar-water-rights-availability-screener",
                "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/malonestar~water-rights-availability-screener/run-sync": {
            "post": {
                "operationId": "run-sync-malonestar-water-rights-availability-screener",
                "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",
                "required": [
                    "assets"
                ],
                "properties": {
                    "assets": {
                        "title": "Assets (sites to screen)",
                        "type": "array",
                        "description": "List of sites to screen against Colorado DWR CDSS water structures. Each entry is an object {\"lat\": number, \"lon\": number, \"label\": string}. One or more structure rows plus a per-asset summary row are produced for each entry. Coordinates outside Colorado are still queried (CDSS just returns 0 structures) and get an explicit clear/summary row."
                    },
                    "radiusMiles": {
                        "title": "Radius (miles)",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Search radius in miles around each asset within which CDSS water structures (ditches, wells, reservoirs, etc.) are inventoried.",
                        "default": 5
                    },
                    "structureTypes": {
                        "title": "Structure types (optional filter)",
                        "type": "array",
                        "description": "Optional list of structure-type keywords to keep (case-insensitive substring match against CDSS structureType, e.g. \"Ditch\", \"Well\", \"Reservoir\"). Leave empty to return every structure type found within the radius.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "seniorityDetailLimit": {
                        "title": "Seniority detail limit",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Max number of the nearest structures per asset for which the actor looks up water-rights seniority (appropriation date, priority admin number, decreed uses) via the CDSS net-amount endpoint. Kept modest to respect the anonymous CDSS request budget (~1,000 requests/day). Structures beyond this limit still appear as rows, just without seniority detail.",
                        "default": 10
                    },
                    "maxResultsPerAsset": {
                        "title": "Max structure rows per asset",
                        "minimum": 1,
                        "maximum": 2000,
                        "type": "integer",
                        "description": "Max number of nearest-first structure rows emitted per asset (in addition to the one summary row). Does not limit the counts reported in the summary row, which always reflect every structure found within the radius.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
