# FCC ASR Towers Scraper (`automation-lab/fcc-asr-towers-scraper`) Actor

🗼 Export official FCC tower registrations with coordinates, heights, FAA studies, lighting, status, and owner contacts for telecom and GIS workflows.

- **URL**: https://apify.com/automation-lab/fcc-asr-towers-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## FCC ASR Towers Scraper

Export the official US Federal Communications Commission Antenna Structure Registration inventory as clean, joined, analysis-ready records.

FCC ASR Towers Scraper downloads the FCC complete archive—or a dated verified snapshot when the live archive is unavailable—and combines registration, coordinate, and owner tables for you.

Filter tower records by state, exact ASR number, status, owner, height, issue date, or geographic bounding box.

Get JSON, CSV, Excel, XML, RSS, or Parquet through Apify datasets without maintaining a 166 MB data-processing pipeline.

### What does FCC ASR Towers Scraper do?

The Actor turns the FCC's pipe-delimited ASR bulk files into one record per antenna structure registration.

Each result can include:

- 🗼 FCC ASR registration and application identifiers
- 📍 address, state, county FIPS, latitude, and longitude
- 📏 structure, ground elevation, and overall height values
- ✈️ FAA determination date, study number, and circular
- 💡 structure type plus painting and lighting codes
- 🏢 registered owner name, contact details, and mailing address
- 🕒 FCC archive and scrape provenance

The source is official FCC registration data, either from the live weekly complete archive or the dated verified fallback described below—not a reseller or crowdsourced tower map.

### Who is this FCC tower data for?

**Telecom engineers** can create inventories for network planning, co-location analysis, and field validation.

**Site-acquisition teams** can identify registered structures in target states or map extents before outreach.

**Tower owners and brokers** can monitor portfolios, research competing sites, and export owner-focused lists.

**FCC and aviation consultants** can review status, dimensions, FAA studies, and lighting metadata together.

**Infrastructure investors** can compare geographic concentrations and ownership patterns.

**GIS analysts** receive decimal coordinates and flattened fields ready for spatial tools.

### Why use this Actor?

The FCC archive is free, but using it directly requires a weekly ZIP download, multiple table parsers, joins, field normalization, output limits, and export plumbing.

This Actor provides:

- ✅ a repeatable cloud workflow
- ✅ joined RA, EN, and CO records
- ✅ filters applied before dataset output
- ✅ bounded `maxItems` costs
- ✅ typed numbers and ISO dates
- ✅ direct API and scheduler access
- ✅ no browser, proxy, account, or API key requirement

### What FCC tower data can I extract?

| Group | Example fields |
|---|---|
| Identity | `registrationNumber`, `fileNumber`, `uniqueSystemIdentifier` |
| Status | `statusCode`, `statusLabel`, application purpose |
| Dates | entered, received, issued, constructed, dismantled, action |
| Site | street, city, state, county FIPS, ZIP |
| Geography | latitude, longitude, coordinate type |
| Dimensions | structure height, ground elevation, AGL and AMSL height |
| FAA | determination date, study number, circular number |
| Marking | structure type, painting and lighting codes |
| Owner | name, phone, email, address, city, state, ZIP, attention |
| Provenance | source URL, archive date, scrape timestamp |

Optional source values are omitted when the FCC row does not provide them.

### How to scrape FCC antenna tower registrations

1. Open the Actor input page.
2. Enter one or more two-letter tower state codes, or remove the default for nationwide results.
3. Add optional owner, status, height, date, registration, or map-boundary filters.
4. Set a practical maximum number of tower records.
5. Click **Start**.
6. Review results in the Dataset tab.
7. Export JSON, CSV, Excel, XML, RSS, or Parquet.

A first run with `TX` and 25 records is intentionally small and useful.

### Input parameters

#### Tower location filters

`states` accepts two-letter US state and territory codes such as `TX`, `CA`, `AK`, or `PR`.

`registrationNumbers` accepts exact FCC ASR registration numbers for targeted lookup workflows.

`boundingBox` accepts decimal-degree minimum and maximum latitude and longitude values.

#### Registration filters

`statusCodes` accepts one-letter FCC status codes. Common values include `A` for Active, `C` for Cancelled, `D` for Dismantled, and `T` for Terminated.

`ownerName` performs a case-insensitive substring match against the joined owner name.

`minOverallHeightMeters` and `maxOverallHeightMeters` constrain overall height above ground.

`issuedFrom` and `issuedTo` are inclusive dates in `YYYY-MM-DD` format.

#### Output limit

`maxItems` controls how many matching tower records are saved, from 1 to 100,000.

The full FCC archive is still scanned so filters are accurate.

### Example input: state tower inventory

```json
{
  "states": ["TX"],
  "statusCodes": ["A"],
  "minOverallHeightMeters": 60,
  "maxItems": 250
}
````

This request exports up to 250 active Texas registrations at least 60 meters tall.

### Example input: geographic bounding box

```json
{
  "boundingBox": {
    "minLatitude": 32.5,
    "maxLatitude": 33.2,
    "minLongitude": -97.6,
    "maxLongitude": -96.5
  },
  "maxItems": 500
}
```

Coordinates missing from the FCC source fail the geographic filter closed.

### Example output

```json
{
  "registrationNumber": "1000019",
  "fileNumber": "A0000039",
  "uniqueSystemIdentifier": 96973,
  "statusCode": "T",
  "statusLabel": "Terminated",
  "structureAddress": "705 OAKWOOD",
  "structureCity": "RAVENNA",
  "structureState": "OH",
  "countyFips": "39133",
  "structureZipCode": "44266",
  "heightOfStructureMeters": 86.8,
  "overallHeightAboveGroundMeters": 91.1,
  "structureTypeCode": "TOWER",
  "faaStudyNumber": "96-AGL-1905-OE",
  "ownerName": "GTE MOBILNET OF OHIO LIMITED PARTNERSHIP",
  "sourceUrl": "https://data.fcc.gov/download/pub/uls/complete/r_tower.zip"
}
```

Actual optional fields vary by FCC registration.

### How much does it cost to scrape FCC tower data?

The Actor uses pay-per-event pricing: one small start charge for downloading and joining the weekly archive, plus a charge for each tower record saved.

The input limit makes the maximum output charge predictable.

Apify's Free plan includes monthly platform credits, so small lookup and sample runs may fit within those credits.

See the live pricing panel for current tier-specific prices before starting a large export.

### Data freshness and official source

The Actor first requests the live FCC complete archive:

`https://data.fcc.gov/download/pub/uls/complete/r_tower.zip`

The FCC normally refreshes this archive weekly. If the live archive is unavailable or blocked, the Actor can fall back to a verified Internet Archive snapshot dated **2025-09-25**. Results from that fallback are valid FCC records, but they are not current weekly data.

Always inspect each item's `sourceUrl` and `archiveDate` before using it for time-sensitive monitoring. `sourceUrl` identifies whether the run used the live FCC download or the dated snapshot, while `archiveDate` records the source timestamp when available.

`scrapedAt` only records when the Actor created the dataset item; it does not indicate source freshness.

The Actor does not claim that every physical communications tower must have an ASR registration; FCC registration requirements depend on aviation-notification rules.

### Working with coordinates and GIS

Latitude and longitude are converted from FCC degrees, minutes, and seconds to signed decimal degrees.

West longitudes and south latitudes are negative.

For GIS use:

1. Export CSV or Parquet.
2. Treat `longitude` as X and `latitude` as Y.
3. Use WGS84-style decimal coordinates for visualization.
4. Retain `registrationNumber` and `sourceUrl` for traceability.

Some FCC rows have no usable surface coordinate and therefore omit coordinate fields.

### Tips for reliable tower research

- 🎯 Start with a state or exact registration number.
- 📦 Increase `maxItems` only after checking a sample.
- 🧭 Use a bounding box for map-tile or market-area workflows.
- 🏢 Search a distinctive owner substring rather than a legal suffix.
- 📐 Remember that source height values are meters.
- 🕒 Schedule weekly runs after the FCC archive refresh.
- 🔗 Keep the FCC identifiers when joining to internal systems.

### Scheduling and monitoring

Use an Apify schedule to refresh an inventory every week.

For change monitoring, write each run to a named dataset or export it to your warehouse, then compare on `registrationNumber` and relevant status/date fields.

Useful monitoring events include:

- new registrations
- status changes
- owner-name changes
- newly constructed or dismantled dates
- FAA study changes

The initial release exports current complete records; it does not emit a computed change log.

### Integrations

#### Google Sheets and Excel

Export CSV or XLSX for tower prospecting, audit lists, and owner research.

#### Webhooks

Trigger a webhook when scheduled runs finish, then pass the dataset ID to a downstream process.

#### Make and Zapier

Connect Apify run completion to CRM enrichment, notifications, or file delivery.

#### GIS and data warehouses

Load CSV or Parquet into QGIS, ArcGIS, BigQuery, Snowflake, Postgres, or DuckDB.

#### Python notebooks

Use the API client to fetch records into pandas or GeoPandas for spatial analysis.

### Use FCC ASR Towers Scraper with the Apify API

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/fcc-asr-towers-scraper').call({
  states: ['TX'],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/fcc-asr-towers-scraper").call(
    run_input={"states": ["TX"], "maxItems": 100}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~fcc-asr-towers-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"states":["TX"],"maxItems":100}'
```

### Use the FCC tower scraper through MCP

Apify MCP lets compatible AI assistants start the Actor and inspect its output.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/fcc-asr-towers-scraper"
```

#### Claude Desktop, Cursor, or VS Code

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/fcc-asr-towers-scraper"
    }
  }
}
```

Example prompts:

- “Export 50 active FCC antenna structures in Alaska.”
- “Look up these FCC ASR registration numbers and summarize their owners.”
- “Find structures over 150 meters in this bounding box and return CSV-ready fields.”

### Is it legal to scrape FCC ASR data?

The Actor downloads a public US government data archive made available by the FCC.

Government data may still contain contact details, so use results for legitimate, compliant purposes.

Follow applicable privacy, marketing, telecommunications, and data-retention rules.

Do not use the dataset to harass owners, compromise infrastructure, or misrepresent FCC status.

This documentation is not legal advice.

### Limitations

- The Actor reflects the source archive and does not independently verify physical towers.
- Not every antenna or communications site is subject to FCC ASR registration.
- Some registrations omit coordinates, contacts, dates, or other optional values.
- FCC structure and lighting codes are preserved as source codes.
- V1 does not include remarks, special conditions, or complete history rows.
- V1 processes the weekly complete archive rather than daily transaction deltas.

### Troubleshooting

#### Why did my bounding-box search omit a tower with a street address?

The FCC row may lack usable coordinates. Geographic filters require coordinates and fail closed; try state, city, or registration lookup instead.

#### Why did an owner search return no records?

Try a shorter distinctive substring and remove punctuation or corporate suffixes. The Actor matches the FCC owner/entity text, which may differ from a current brand name.

#### Why is the run not instant for a small `maxItems`?

The Actor still downloads and joins the complete weekly FCC archive so filters are applied correctly. `maxItems` limits saved records and output charges, not source archive size.

### Frequently asked questions

#### Can I export all US FCC tower registrations?

Yes. Remove location filters and set an appropriate `maxItems`, up to 100,000 per run. Split very large exports by state if you need more.

#### Can I search by FCC ASR number?

Yes. Add one or more exact values to `registrationNumbers`.

#### Are heights feet or meters?

All output height and elevation fields are in meters, matching the source measurements.

#### Does the Actor need a proxy?

No. It uses the FCC's anonymous public bulk-download endpoint directly.

#### Does it return cell tower tenants or antennas?

No. ASR records describe registered antenna structures and their owners; they are not a complete tenant, carrier, radio, or antenna inventory.

#### Can I run it every week?

Yes. Weekly scheduling is a strong fit for inventory refresh and monitoring workflows.

### Related FCC and telecom scrapers

Use [FCC ULS License Holder Scraper](https://apify.com/automation-lab/fcc-uls-license-holder-scraper) when you need radio-license holder and ULS authorization data rather than physical ASR tower registrations.

The two Actors cover different FCC entities and can be combined in a telecom data warehouse using FCC identifiers where applicable.

### Support

If a valid FCC archive record is parsed incorrectly, open an Actor issue with:

- the ASR registration number
- your exact input
- the expected source value
- the run ID

That evidence helps reproduce field-layout or source-data changes quickly.

# Actor input Schema

## `states` (type: `array`):

Two-letter state or territory codes, for example TX, CA, or PR.

## `registrationNumbers` (type: `array`):

Optional exact seven-digit registration numbers. Use this for tower lookups.

## `boundingBox` (type: `object`):

Optional decimal-degree limits: minLatitude, maxLatitude, minLongitude, and maxLongitude.

## `statusCodes` (type: `array`):

Optional one-letter FCC status codes, such as A (Active), C (Cancelled), D (Dismantled), or T (Terminated).

## `ownerName` (type: `string`):

Case-insensitive text matched against the joined FCC owner/entity name.

## `minOverallHeightMeters` (type: `number`):

Only return structures at least this tall, in meters.

## `maxOverallHeightMeters` (type: `number`):

Only return structures no taller than this value, in meters.

## `issuedFrom` (type: `string`):

Inclusive FCC issue date in YYYY-MM-DD format.

## `issuedTo` (type: `string`):

Inclusive FCC issue date in YYYY-MM-DD format.

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

Stop saving after this many matching FCC tower registrations.

## Actor input object example

```json
{
  "states": [
    "TX"
  ],
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "states": [
        "TX"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/fcc-asr-towers-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 = {
    "states": ["TX"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/fcc-asr-towers-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 '{
  "states": [
    "TX"
  ],
  "maxItems": 20
}' |
apify call automation-lab/fcc-asr-towers-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/fcc-asr-towers-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FCC ASR Towers Scraper",
        "description": "🗼 Export official FCC tower registrations with coordinates, heights, FAA studies, lighting, status, and owner contacts for telecom and GIS workflows.",
        "version": "0.1",
        "x-build-id": "9hzZp6Efk0dQ83lpv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~fcc-asr-towers-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-fcc-asr-towers-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/automation-lab~fcc-asr-towers-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-fcc-asr-towers-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/automation-lab~fcc-asr-towers-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-fcc-asr-towers-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": {
                    "states": {
                        "title": "Tower state codes",
                        "type": "array",
                        "description": "Two-letter state or territory codes, for example TX, CA, or PR.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "registrationNumbers": {
                        "title": "FCC ASR registration numbers",
                        "type": "array",
                        "description": "Optional exact seven-digit registration numbers. Use this for tower lookups.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "boundingBox": {
                        "title": "Geographic bounding box",
                        "required": [
                            "minLatitude",
                            "maxLatitude",
                            "minLongitude",
                            "maxLongitude"
                        ],
                        "type": "object",
                        "description": "Optional decimal-degree limits: minLatitude, maxLatitude, minLongitude, and maxLongitude.",
                        "properties": {
                            "minLatitude": {
                                "title": "Minimum latitude",
                                "description": "Southern latitude boundary.",
                                "type": "number"
                            },
                            "maxLatitude": {
                                "title": "Maximum latitude",
                                "description": "Northern latitude boundary.",
                                "type": "number"
                            },
                            "minLongitude": {
                                "title": "Minimum longitude",
                                "description": "Western longitude boundary.",
                                "type": "number"
                            },
                            "maxLongitude": {
                                "title": "Maximum longitude",
                                "description": "Eastern longitude boundary.",
                                "type": "number"
                            }
                        }
                    },
                    "statusCodes": {
                        "title": "FCC status codes",
                        "type": "array",
                        "description": "Optional one-letter FCC status codes, such as A (Active), C (Cancelled), D (Dismantled), or T (Terminated).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ownerName": {
                        "title": "Owner name contains",
                        "type": "string",
                        "description": "Case-insensitive text matched against the joined FCC owner/entity name."
                    },
                    "minOverallHeightMeters": {
                        "title": "Minimum overall height above ground (m)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only return structures at least this tall, in meters."
                    },
                    "maxOverallHeightMeters": {
                        "title": "Maximum overall height above ground (m)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only return structures no taller than this value, in meters."
                    },
                    "issuedFrom": {
                        "title": "Issued on or after",
                        "type": "string",
                        "description": "Inclusive FCC issue date in YYYY-MM-DD format."
                    },
                    "issuedTo": {
                        "title": "Issued on or before",
                        "type": "string",
                        "description": "Inclusive FCC issue date in YYYY-MM-DD format."
                    },
                    "maxItems": {
                        "title": "Maximum tower records",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop saving after this many matching FCC tower registrations.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
