# FCC Broadcast Station & Owner Leads Scraper (`scrapesage/fcc-broadcast-scraper`) Actor

Scrape the official FCC AM, FM & TV broadcast database: call sign, frequency, service, class, market, licensee (station owner), facility ID, power, GPS, license status & construction permits. Station + owner-portfolio B2B leads with filters, lead scoring & monitoring. No browser, no API key.

- **URL**: https://apify.com/scrapesage/fcc-broadcast-scraper.md
- **Developed by:** [Scrape Sage](https://apify.com/scrapesage) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 broadcast station records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are 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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Broadcast Station Scraper — AM, FM & TV Stations + Owner Leads

Extract the **complete U.S. broadcast station universe** straight from the **official FCC AM, FM, and TV databases** — every **AM/FM radio and TV station** with its **call sign, frequency/channel, service & class, community of license (market), licensee (station owner), facility ID, license status, construction permits, power (ERP), antenna height and GPS coordinates**. Group the data into **station-owner portfolios** to see who owns what, where.

No login, no cookies, no browser, no API key — fast, reliable extraction direct from the FCC's public broadcast query feeds.

### Why this FCC broadcast scraper?

Other "FCC" tools on the market are single-state radio lookups or thin MCP wrappers. This actor pulls **AM, FM, and TV nationwide** into **one clean, richest-in-category dataset**, adds a **station-owner grouping mode** (portfolios by licensee), a **lead score**, and a **monitor mode** that surfaces only new stations, fresh construction permits, and ownership changes.

| Data | Generic FCC lookups | This actor |
|---|---|---|
| AM, FM **and** TV in one run | ❌ (single band/state) | ✅ |
| Call sign, frequency/channel, service, class | partial | ✅ |
| Community of license (market) + state | ✅ | ✅ |
| **Licensee (station owner)** | partial | ✅ AM ~98% / FM ~99% / TV (licensed) |
| Facility ID, file number, license status | ❌ | ✅ |
| **Construction permits & applications** (build/upgrade intent) | ❌ | ✅ |
| Power (ERP), HAAT, GPS coordinates | partial | ✅ |
| **Owner-portfolio grouping** (station count, AM/FM/TV, markets) | ❌ | ✅ |
| Lead score + lead signals | ❌ | ✅ |
| **Monitor mode** (only new/changed) | ❌ | ✅ |
| Nationwide (50 states + DC + territories) | ❌ | ✅ |

### Use cases

- **Advertising & media buying** — build station target lists by market, band, format, and power for radio/TV ad campaigns, including the 2026 political ad cycle.
- **Broadcast equipment & software sales** — transmitters, antennas, automation, playout, EAS, and streaming vendors: target station owners, and catch **construction permits** the moment a new build or upgrade is authorized.
- **Station brokerage & M\&A** — use **owner-portfolio mode** to see consolidation: who owns how many AM/FM/TV stations, across which markets and states.
- **Program syndication & content distribution** — find stations by band, market, and class to pitch shows, networks, and syndicated content.
- **RF / engineering & tower services** — coordinates, ERP, HAAT, and antenna mode for coverage studies and site work.
- **PR & media outreach** — identify stations by market and owner to build broadcast media lists.
- **Market & competitive research** — map station counts and ownership by geography and band.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **FCC Broadcast Station & Owner Leads Scraper**, choose your **bands** (AM/FM/TV) and **states** (leave empty for all of the U.S.), and pick an **output mode** — `stations` (one row per station) or `owners` (grouped portfolios).
3. Click **Start** and watch results stream into the dataset table.
4. **Export** as JSON, CSV, Excel, XML, or RSS — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "outputMode": "stations",
    "bands": ["AM", "FM", "TV"],
    "states": ["CA", "TX"],
    "activeOnly": false,
    "sortBy": "leadScore",
    "maxResults": 1000,
    "monitorMode": false
}
```

- **outputMode** *(default `stations`)* — `stations` returns one record per AM/FM/TV station; `owners` aggregates stations by licensee into owner/group portfolios.
- **bands** *(default all)* — `AM`, `FM` (incl. LPFM, translators, boosters), `TV` (incl. full-power, Class A, LPTV, translators).
- **states** *(default all)* — two-letter state/territory codes; empty scans all 50 states + DC + PR/VI/GU/AS/MP.
- **activeOnly** *(default false)* — `true` returns only LICENSED stations; leave off to also capture **construction permits**, applications, and STAs (highest-intent leads).
- **licenseStatuses / serviceCodes / stationClasses / communities** — optional fine-grained filters (e.g. `["CP","NCECP"]`, `["FM","FL"]`, `["A","C"]`).
- **callSignQuery / licenseeQuery / nameQuery** — substring search by call sign, owner name, or keyword.
- **minErpKw** — minimum power (kW) to target larger stations.
- **authorizedAfter** *(YYYY-MM-DD)* — only authorizations on/after this date (great for fresh CPs and new applications).
- **minLeadScore / sortBy / maxResults** — filter, order (`leadScore`, `powerHigh`, `newest`, `callSign`), and cap.
- **includeRawFields** *(default false)* — attach the complete raw FCC field array so no source data is ever lost.
- **monitorMode / monitorKey** — return only new/changed records across runs (see below).
- **proxyConfiguration** — optional; the FCC feeds work with no proxy.

### Output

By default you get **one clean table of broadcast stations** — every column applies to every row. Set `outputMode` to `owners` for grouped owner portfolios.

A station record (`recordType: "broadcastStation"`):

```json
{
    "recordType": "broadcastStation",
    "callSign": "WHJY",
    "facilityId": "25444",
    "band": "FM",
    "serviceCode": "FM",
    "serviceLabel": "FM Radio (Full Power)",
    "frequency": 94.1,
    "frequencyUnit": "MHz",
    "frequencyDisplay": "94.1  MHz",
    "channel": "231",
    "stationClass": "B",
    "antennaMode": "Non-Directional",
    "licenseStatus": "LIC",
    "licenseStatusLabel": "Licensed",
    "isLicensed": true,
    "isConstructionPermit": false,
    "community": "Providence",
    "state": "RI",
    "market": "Providence, RI",
    "fileNumber": "BLH-20120118ABC",
    "authDate": "2012-01-18",
    "erpKw": 50,
    "haatMeters": 199,
    "latitude": 41.83,
    "longitude": -71.47,
    "licenseeName": "Ihm Licenses, LLC",
    "sourceUrl": "https://enterpriseefiling.fcc.gov/dataentry/public/tv/publicFacilityDetails.html?facilityId=25444",
    "leadScore": 72,
    "leadSignals": ["Active licensed station", "Full-power station", "High-power transmitter (≥50 kW)", "Licensee: Ihm Licenses, LLC"]
}
```

A station-owner record (`recordType: "stationOwnerProfile"`) carries `licenseeName`, `stationCount`, `amStations` / `fmStations` / `tvStations`, `fullPowerStations`, `constructionPermits`, `stateCount`, `states`, `markets`, `callSigns`, `maxErpKw`, and a `leadScore`.

#### What to expect (field coverage)

This is official FCC engineering data, so contact fields beyond the licensee name aren't part of the public feed, and a few records (notably new TV construction permits) leave the applicant name blank at the source.

| Field | Coverage |
|---|---|
| Call sign, band, service, community, state, facility ID, status | ~100% |
| Frequency / channel, power (ERP), coordinates | ~100% (engineering data) |
| **Licensee (owner) name** | AM ~98%, FM ~99%, TV ~80% (licensed TV; many new-CP rows are blank at source) |
| Station class | AM/FM ~100%; TV conveyed via service (Class A / full power / LPTV) |
| `authDate` | radio file numbers carry a date; some TV LMS file numbers do not |

A blank field means the FCC didn't publish it for that record — nothing is dropped, so you always get the richest dataset available. Turn on `includeRawFields` to keep every raw source value.

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily/weekly with **monitor mode on** to capture new stations, fresh construction permits, and ownership changes automatically.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

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

const client = new ApifyClient({ token: 'MY_APIFY_TOKEN' });

const run = await client.actor('scrapesage/fcc-broadcast-scraper').call({
    bands: ['FM', 'TV'],
    states: ['CA'],
    outputMode: 'stations',
    monitorMode: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} broadcast records`);
```

**Monitor mode vs. Apify Schedules** — they are independent and work together. *Monitor mode* remembers what previous runs returned (per `monitorKey`) and emits only new/changed records; *Schedules* decide when the actor runs. Combine them for a hands-off feed of new stations and construction permits.

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new station/owner leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored market adds a station or construction permit.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. Call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "list every FM station in Texas with its owner and power" and let it run the scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **government-data B2B lead-gen stack** from official, public registries:

- **[FCC License & Antenna Tower Leads Scraper](https://apify.com/scrapesage/fcc-license-scraper)** — wireless licensees and antenna-structure (tower) owners with phone, email, FRN, heights & GPS.
- **[FAA Aircraft Registry Scraper](https://apify.com/scrapesage/faa-aircraft-registry-scraper)** — registered aircraft and their owners.
- **[FMCSA Trucking Scraper](https://apify.com/scrapesage/fmcsa-trucking-scraper)** — motor carriers and freight brokers with contact and safety data.
- **[US Business Formation Scraper](https://apify.com/scrapesage/us-business-formation-scraper)** — newly registered companies as fresh-business intent.
- **[SBA Loan Leads Scraper](https://apify.com/scrapesage/sba-loan-leads-scraper)** — financed small businesses (7(a) & 504).
- **[USASpending Scraper](https://apify.com/scrapesage/usaspending-scraper)** — federal contract and grant recipients.
- **[GSA eLibrary Scraper](https://apify.com/scrapesage/gsa-elibrary-scraper)** — GSA Schedule contractors and their contacts.

### Tips

- **Pick a single output mode** (`stations` or `owners`) for a clean, fully-populated table that's perfect for direct export. Use the **Broadcast stations** / **Station owners** dataset views to switch focus.
- **Hunt new builds**: turn `activeOnly` **off** and filter `licenseStatuses` to `["CP","NCECP"]` (or sort by `newest`) to catch stations being built or upgraded — the best leads for equipment and engineering vendors.
- **Target big stations**: set `minErpKw` (e.g. 50) and `sortBy: "powerHigh"` for the largest, highest-budget signals.
- **Find a group's footprint**: use `outputMode: "owners"` with a `licenseeQuery` (e.g. "Townsquare") to see a broadcaster's full portfolio.
- **Recurring monitoring**: pair `monitorMode` with a daily/weekly [Schedule](https://docs.apify.com/platform/schedules) for an always-fresh feed of new stations, permits, and ownership changes.

### FAQ

**Where does the data come from?** The official FCC AM, FM, and TV query databases (the same public broadcast records the FCC publishes), normalized into one schema and enriched with a lead score and owner grouping.

**Does it need an FCC API or a key?** No. There's no login, key, or browser — the actor reads the FCC's public broadcast feeds directly.

**Does every station include the owner's phone or email?** No — the FCC broadcast feed publishes the licensee (owner) **name**, market, and facility ID, but not a phone/email per station. Each record links to the FCC facility page, and you can combine this with our other actors for outreach contacts.

**Can I get TV station owners?** Yes for licensed stations (~80%). Brand-new TV **construction permits** sometimes leave the applicant name blank at the FCC source; the record is still returned with its facility ID and FCC link.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically on every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor a market for new stations or permits?** Turn on `monitorMode`, set a `monitorKey`, and create a [Schedule](https://docs.apify.com/platform/schedules); optionally add a [webhook](https://docs.apify.com/platform/integrations/webhooks) or [Zapier zap](https://docs.apify.com/platform/integrations/zapier) to push new records into your CRM.

**Is scraping this data legal?** This actor collects publicly available U.S. government data only. You're responsible for using it in compliance with applicable laws and the FCC's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `outputMode` (type: `string`):

‘Broadcast stations’ returns one record per AM/FM/TV station (call sign + licensee). ‘Station owners (grouped)’ aggregates stations by licensee into owner/group portfolios (station count, bands, markets) — ideal for M\&A and group-owner targeting.

## `bands` (type: `array`):

Which broadcast bands to include. FM covers full-power FM, LPFM, FM translators & boosters; TV covers full-power, Class A, LPTV & TV translators.

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

Two-letter state/territory codes (e.g. CA, TX, NY, PR). Leave empty to scan all 50 states + DC + territories.

## `activeOnly` (type: `boolean`):

Only return stations with a current LICENSED authorization. Turn OFF to also include construction permits (CP), applications and special temporary authorities — the highest-intent leads for equipment & engineering vendors.

## `licenseStatuses` (type: `array`):

Filter by authorization status code: LIC (Licensed), CP (Construction Permit), NCECP (Noncommercial Educational CP), APP (Application), MOD (Modification), STA (Special Temporary Authority). Empty = all.

## `serviceCodes` (type: `array`):

Narrow to specific FCC service codes, e.g. FM (full-power FM), FL (LPFM), FX (FM translator), DT (full-power digital TV), DC (Class A TV), LD (low-power TV). Empty = all in the selected bands.

## `stationClasses` (type: `array`):

Filter by station class, e.g. A, B, B1, C, C0, C1, C2, C3, D (FM) or A, B, C, D (AM). Empty = all.

## `communities` (type: `array`):

Keep only stations whose community of license (city) contains one of these terms. Empty = all.

## `callSignQuery` (type: `string`):

Filter by call sign (substring match, e.g. KQ or WXYZ).

## `licenseeQuery` (type: `string`):

Filter by licensee (station owner) name — e.g. ‘iHeart’, ‘Townsquare’, ‘Cumulus’, ‘Educational’. Substring match.

## `nameQuery` (type: `string`):

Free-text keyword matched across licensee name, call sign and community of license.

## `minErpKw` (type: `integer`):

Only return stations with effective radiated power at or above this value (kW). Useful to target larger, higher-budget stations.

## `authorizedAfter` (type: `string`):

Only return authorizations whose file/action date is on or after this date (great for catching fresh construction permits & new applications). Note: TV LMS records may not carry a parseable date.

## `minLeadScore` (type: `integer`):

Only return records with a lead score (0–100) at or above this value.

## `sortBy` (type: `string`):

Order of results before the max-results cap is applied.

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

Maximum number of records to return (stations or owner profiles depending on output mode).

## `includeRawFields` (type: `boolean`):

Attach the complete raw pipe-delimited field array (rawFields) from the FCC feed to every station record, so no source data is ever lost.

## `monitorMode` (type: `boolean`):

Remember what was returned on previous runs (per monitor key) and emit only NEW stations (or owners whose station count changed). Perfect for a recurring Apify Schedule that feeds fresh construction permits, new stations and ownership changes into your CRM. Works alongside Apify scheduling — they are independent.

## `monitorKey` (type: `string`):

Names the saved monitor state, so different filter setups track new records independently. Use a distinct key per saved configuration.

## `proxyConfiguration` (type: `object`):

Optional. The FCC open data feeds work directly from Apify with no proxy; you can enable one if you prefer.

## Actor input object example

```json
{
  "outputMode": "stations",
  "bands": [
    "AM",
    "FM",
    "TV"
  ],
  "states": [
    "RI"
  ],
  "activeOnly": false,
  "licenseStatuses": [],
  "serviceCodes": [],
  "stationClasses": [],
  "communities": [],
  "sortBy": "leadScore",
  "maxResults": 1000,
  "includeRawFields": false,
  "monitorMode": false,
  "monitorKey": "default",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped FCC broadcast station or owner-profile records in 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 = {
    "states": [
        "RI"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/fcc-broadcast-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": ["RI"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/fcc-broadcast-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": [
    "RI"
  ]
}' |
apify call scrapesage/fcc-broadcast-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/IfHv32W7ARDvTeeK1/builds/LF9SVcJnpfdBrllKN/openapi.json