# USWTDB Wind Turbine Proximity Screener — Nearest by Coordinate (`malonestar/uswtdb-turbine-proximity-screener`) Actor

Wind turbine proximity by coordinate from the US Wind Turbine Database (USWTDB): nearest wind turbine distance, count within a radius, tallest turbine, and total nearby capacity (MW) for each lat/lon. Keyless USGS/LBNL data for aviation, radar, setback and repowering screening.

- **URL**: https://apify.com/malonestar/uswtdb-turbine-proximity-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 $3.30 / 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

## USWTDB Wind Turbine Proximity Screener — Nearest by Coordinate

Screen any list of coordinates against the **U.S. Wind Turbine Database (USWTDB)** — ~72,000 land-based and offshore wind turbines maintained by the **USGS**, **Lawrence Berkeley National Laboratory (LBNL)**, and the **American Clean Power Association**. For every site you pass in, the actor returns the **nearest wind turbine**, how many turbines fall **within your radius**, the **tallest** turbine nearby, and the **total nameplate capacity (MW)** in range — one clean, billable row per asset.

Answers, by coordinate: *Is there a wind turbine near this site? How close? How tall? How many? How much capacity?*

### Who it's for
- **Aviation / obstruction analysts** — flag tall-structure and airspace-obstruction exposure near heliports, airstrips, low-level routes, and survey sites (USWTDB total height `t_ttlh` is tip height).
- **Radar, telecom & met-tower siting engineers** — screen candidate sites for wind-turbine clutter / interference before a detailed study.
- **Real-estate, land & renewable due-diligence** — property-line setback checks, viewshed/nuisance screening, Phase-I style site reviews.
- **Wind developers & asset managers** — find existing turbines (project, manufacturer, model, hub height, rotor diameter) near a parcel for **repowering** and greenfield-conflict analysis.
- **AI agents & data pipelines** — a chainable geospatial lookup that turns a coordinate into a structured turbine-proximity summary.

### How it works
1. You supply `assets` — a list of `{lat, lon, label, state?}` sites.
2. For each asset the actor fetches every turbine in that **state** from USWTDB, trying three interchangeable sources in order until one responds: the USGS **ArcGIS FeatureServer**, the USWTDB **REST (PostgREST) API**, then the full **CSV download** as a fallback. This multi-source design keeps the actor working even if one endpoint is temporarily down.
3. It computes the **haversine distance** to every turbine, keeps those within `radiusMiles`, and rolls the result up into one row.

Supplying `state` (2-letter, e.g. `IA`, `TX`) per asset is recommended; if omitted it is inferred from the coordinate by state bounding box (approximate near state borders).

### Example input
```json
{
  "assets": [
    { "lat": 42.03, "lon": -95.02, "label": "Storm Lake wind area, IA", "state": "IA" },
    { "lat": 40.7128, "lon": -74.006, "label": "Lower Manhattan, NY (control)", "state": "NY" }
  ],
  "radiusMiles": 10,
  "maxAssets": 500
}
````

### Output fields (one row per asset)

| Field | Meaning |
|-------|---------|
| `asset_label`, `asset_lat`, `asset_lon` | Echo of the site you submitted |
| `radius_miles` | Radius used for the aggregation |
| `turbine_count_within_radius` | Turbines within the radius |
| `nearest_distance_miles` | Distance to the closest turbine in the state (always reported) |
| `nearest_project` | Project/wind-farm name of the nearest turbine (`p_name`) |
| `nearest_manufacturer` | Manufacturer of the nearest turbine (`t_manu`) |
| `nearest_total_height_m` | Total (tip) height of the nearest turbine (`t_ttlh`) |
| `max_total_height_m_nearby` | Tallest turbine total height within the radius |
| `total_capacity_mw_nearby` | Sum of nameplate capacity within the radius (MW) |
| `turbines_present_flag` | `true` when ≥1 turbine falls within the radius |
| `error` | Null on success; message when a site can't be screened |
| `source_url` | USWTDB source used |
| `checked_at` | ISO run timestamp |

### Use as an MCP tool

This actor is a clean, chainable tool for AI agents (Claude, Cursor, etc.) via **mcp.apify.com**. Each output field has a description in the schema, so an agent can call it with a coordinate and reason directly over `turbine_count_within_radius`, `nearest_distance_miles`, and `total_capacity_mw_nearby` — e.g. as one step in an obstruction- or siting-analysis pipeline.

### FAQ

**Is there a wind turbine near this coordinate?** Yes — pass the lat/lon and read `nearest_distance_miles` and `turbines_present_flag`.

**How current is the data?** USWTDB is **quarterly-updated** by USGS/LBNL/ACP and lags new installations by roughly one quarter. Turbine points are visually verified from aerial imagery to ~10 m; some specs carry make/model uncertainty.

**Do I need an API key?** No. USWTDB is public-domain and keyless.

**What radius should I use?** Default is 10 miles. Use a smaller radius for tight obstruction/setback checks or a larger one for regional density screening (max 100 mi).

**Why do I still get a `nearest_*` value when the count is 0?** The count only includes turbines inside your radius, but the single nearest turbine in the state is always reported so you know how far the closest one is.

**Is this an official FAA/obstruction determination?** No. This is a screening aid over USWTDB data, not an FAA obstruction evaluation, a radar-interference study, or a legal setback ruling. Verify against authoritative sources.

### Data source & citation

U.S. Wind Turbine Database (USWTDB) — USGS, LBNL, and the American Clean Power Association. https://eerscmap.usgs.gov/uswtdb/ · DOI: 10.5066/F7TX3DN0

# Actor input Schema

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

List of sites to screen against US wind turbines. Each entry is an object {"lat": number, "lon": number, "label": string, "state": optional 2-letter code}. One output row is produced per asset summarizing nearby USWTDB turbines. Supplying "state" (e.g. "IA", "TX") is recommended for speed and accuracy; if omitted it is inferred from the coordinate by state bounding box (approximate near state borders).

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

Proximity radius (miles) around each asset within which turbines are counted and aggregated. Turbines outside the radius are excluded from the counts, but the single nearest turbine in the asset's state is always reported.

## `maxAssets` (type: `integer`):

Maximum number of asset rows to emit (one billable Result per asset). Extra assets beyond this cap are skipped.

## Actor input object example

```json
{
  "assets": [
    {
      "lat": 42.03,
      "lon": -95.02,
      "label": "Storm Lake wind area, IA",
      "state": "IA"
    },
    {
      "lat": 40.7128,
      "lon": -74.006,
      "label": "Lower Manhattan, NY (no-turbine control)",
      "state": "NY"
    }
  ],
  "radiusMiles": 10,
  "maxAssets": 500
}
```

# 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": 42.03,
            "lon": -95.02,
            "label": "Storm Lake wind area, IA",
            "state": "IA"
        },
        {
            "lat": 40.7128,
            "lon": -74.006,
            "label": "Lower Manhattan, NY (no-turbine control)",
            "state": "NY"
        }
    ],
    "radiusMiles": 10,
    "maxAssets": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("malonestar/uswtdb-turbine-proximity-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": 42.03,
            "lon": -95.02,
            "label": "Storm Lake wind area, IA",
            "state": "IA",
        },
        {
            "lat": 40.7128,
            "lon": -74.006,
            "label": "Lower Manhattan, NY (no-turbine control)",
            "state": "NY",
        },
    ],
    "radiusMiles": 10,
    "maxAssets": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("malonestar/uswtdb-turbine-proximity-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": 42.03,
      "lon": -95.02,
      "label": "Storm Lake wind area, IA",
      "state": "IA"
    },
    {
      "lat": 40.7128,
      "lon": -74.006,
      "label": "Lower Manhattan, NY (no-turbine control)",
      "state": "NY"
    }
  ],
  "radiusMiles": 10,
  "maxAssets": 500
}' |
apify call malonestar/uswtdb-turbine-proximity-screener --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "USWTDB Wind Turbine Proximity Screener — Nearest by Coordinate",
        "description": "Wind turbine proximity by coordinate from the US Wind Turbine Database (USWTDB): nearest wind turbine distance, count within a radius, tallest turbine, and total nearby capacity (MW) for each lat/lon. Keyless USGS/LBNL data for aviation, radar, setback and repowering screening.",
        "version": "1.0",
        "x-build-id": "FGkdF7dzx5bvHKzIv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/malonestar~uswtdb-turbine-proximity-screener/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-malonestar-uswtdb-turbine-proximity-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~uswtdb-turbine-proximity-screener/runs": {
            "post": {
                "operationId": "runs-sync-malonestar-uswtdb-turbine-proximity-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~uswtdb-turbine-proximity-screener/run-sync": {
            "post": {
                "operationId": "run-sync-malonestar-uswtdb-turbine-proximity-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 US wind turbines. Each entry is an object {\"lat\": number, \"lon\": number, \"label\": string, \"state\": optional 2-letter code}. One output row is produced per asset summarizing nearby USWTDB turbines. Supplying \"state\" (e.g. \"IA\", \"TX\") is recommended for speed and accuracy; if omitted it is inferred from the coordinate by state bounding box (approximate near state borders)."
                    },
                    "radiusMiles": {
                        "title": "Radius (miles)",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Proximity radius (miles) around each asset within which turbines are counted and aggregated. Turbines outside the radius are excluded from the counts, but the single nearest turbine in the asset's state is always reported.",
                        "default": 10
                    },
                    "maxAssets": {
                        "title": "Max assets",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of asset rows to emit (one billable Result per asset). Extra assets beyond this cap are skipped.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
