# FCC Licenses Scraper (`acquistion-automation/fcc-licenses-scraper`) Actor

Scrapes FCC licenses from the Universal Licensing System by state, call sign, licensee name, or application status. Returns each license as a flat row with call sign, licensee, radio service, and location.

- **URL**: https://apify.com/acquistion-automation/fcc-licenses-scraper.md
- **Developed by:** [Acquisition Automation Co.](https://apify.com/acquistion-automation) (community)
- **Categories:** Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

![Acquisition Automation Co. Search less. Close more.](https://api.apify.com/v2/key-value-stores/AOdPHdOpeDpzEPS5f/records/banner.jpg)

## 📡 FCC Licenses Scraper

> **Export FCC radio licenses from the Universal Licensing System as flat rows: call sign, licensee, FRN, status, expiry, site coordinates, frequency band, antenna and transmit power.** No API key, no registration, no login.

The FCC's Universal Licensing System is the public record of who is licensed to transmit in the United States, where, and on what frequencies. The search at `wireless2.fcc.gov` answers one query at a time, paginates a handful of results per page, and has no export. This Actor drives that search and writes every matching license into a dataset you can open in a spreadsheet.

| Who uses it | What they use ULS for |
|---|---|
| 💼 Buyers of wireless ISPs and tower businesses | Confirming the licenses on the asset schedule exist, are active, and are held by the entity being sold |
| 📋 Lenders and insurers | Checking call sign, FRN, status and expiry before writing a facility against licensed spectrum |
| 🎯 Sourcing and lead generation | Listing every licensee in a state, with their sites, to find operators that never appear on a broker site |
| 🗺 Network and RF planners | Mapping licensed sites, bands and transmit power around a coverage area |

### 📋 What it does

> 💡 **Why it matters:** when the asset being bought is spectrum, the licence record is the asset. Status, expiry and the FRN on the licence are what tell you whether the seller still holds what they are selling.

- 🔎 **Searches ULS four ways.** By state, by exact call sign, by licensee name substring, or by application status.
- 🏢 **Returns the licensee and its FRN**, the FCC Registration Number that ties licences to a single legal entity across the whole database.
- 📅 **Status and dates.** Application status, status date, application receipt date and expiry, so a dead licence is visible as dead.
- 📍 **Site detail.** Location name, city, county, state, latitude and longitude for the licensed site.
- 📶 **RF detail.** Lower and upper frequency, EIRP, emission designator, antenna make and model, and equipment designation type.
- 📦 **One flat row per licence**, the same 25 fields every run, so several searches append into a single clean dataset.
- 💾 **Exports to CSV, Excel, JSON or XML**, from the run page or the API.

### 📊 Output

Every licence is one flat row with 25 fields. A field is `null` where ULS publishes no value for that licence.

| Field | Type | Description |
|---|---|---|
| 📻 `callSign` | string | The licence call sign, for example `WQJW268` |
| 🆔 `licenseId` | string | FCC licence key, the id used in the ULS record URL |
| 🏢 `licenseName` | string | Licensee as recorded, the legal entity holding the licence |
| 🔢 `frns` | string | FCC Registration Number of the licensee |
| ✅ `applicationStatus` | string | Licence status, for example `Active`, `Deleted` or `Terminated` |
| 📅 `statusDate` | string | Date the current status took effect |
| 📄 `fileNumber` | string | FCC file number of the application behind the licence |
| 📥 `applicationReceiptDate` | string | Date the FCC received the application |
| ⏳ `expiredDate` | string | Licence expiry date |
| 🏷 `locationName` | string | Site name as the licensee registered it |
| 🏙 `locationCity` | string | City of the licensed site |
| 🗺 `locationState` | string | Two-letter state code of the site |
| 🧭 `locationCounty` | string | County of the site |
| 📍 `latitude` | number | Site latitude in decimal degrees |
| 📍 `longitude` | number | Site longitude in decimal degrees |
| 📉 `lowerFrequency` | string | Lower edge of the authorised band, with unit, for example `3650.00000000 MHz` |
| 📈 `upperFrequency` | string | Upper edge of the authorised band, with unit |
| ⚡ `eirp` | string | Effective isotropic radiated power as recorded |
| 🛰 `antennaMake` | string | Antenna manufacturer, for example `Ubiquiti` |
| 🔧 `antennaModel` | string | Antenna model as filed |
| 🧪 `emissionDesignator` | string | ITU emission designator, for example `17M8D7D` |
| 🏗 `fccEquipmentDesignationType` | string | Equipment role, for example `CPE` or `Dual Use/Pt-Pt` |
| 🔗 `url` | string | Direct link to the licence record in ULS |
| 🕒 `scrapedAt` | string | ISO timestamp of collection |
| ⚠️ `error` | string | `null` on a normal row |

#### Example rows

```json
{
  "callSign": "WQJW268",
  "licenseId": "3072529",
  "licenseName": "The Corporation",
  "frns": "18344861",
  "applicationStatus": "Deleted",
  "statusDate": "2018-12-14T00:00:00.000",
  "fileNumber": "6757878",
  "applicationReceiptDate": "2015-04-15T00:00:00.000",
  "expiredDate": "2019-01-21T00:00:00.000",
  "locationName": "Highland",
  "locationCity": "St. Maries",
  "locationState": "ID",
  "locationCounty": "BENEWAH",
  "latitude": 47.31152778,
  "longitude": -116.57072222,
  "lowerFrequency": "3650.00000000 MHz",
  "upperFrequency": "3675.00000000 Mhz",
  "eirp": "42",
  "antennaMake": "Ubiquiti",
  "antennaModel": "AMS 3G-120-18",
  "emissionDesignator": "17M8D7D",
  "fccEquipmentDesignationType": "Dual Use/Pt-Pt",
  "url": "https://wireless2.fcc.gov/UlsApp/UlsSearch/license.jsp?licKey=3072529",
  "scrapedAt": "2026-09-14T16:27:15.815Z",
  "error": null
}
```

```json
{
  "callSign": "WQJC938",
  "licenseId": "3032444",
  "licenseName": "Intelliwave LLC",
  "frns": "15876352",
  "applicationStatus": "Deleted",
  "statusDate": "2018-11-19T00:00:00.000",
  "fileNumber": "6762516",
  "applicationReceiptDate": "2015-04-16T00:00:00.000",
  "expiredDate": "2018-07-29T00:00:00.000",
  "locationName": "3560",
  "locationCity": "Circleville",
  "locationState": "OH",
  "locationCounty": "PICKAWAY",
  "latitude": 39.67138889,
  "longitude": -82.85611111,
  "lowerFrequency": "3650.00000000 MHz",
  "upperFrequency": "3675.00000000 Mhz",
  "eirp": "39",
  "antennaMake": "Motorola",
  "antennaModel": "Integrated",
  "emissionDesignator": "9M50W7D",
  "fccEquipmentDesignationType": "CPE",
  "url": "https://wireless2.fcc.gov/UlsApp/UlsSearch/license.jsp?licKey=3032444",
  "scrapedAt": "2026-09-14T16:27:15.815Z",
  "error": null
}
```

Unfiltered runs return licences of every status, including deleted and expired ones. Set `applicationStatus` to `Active` if you only want live licences.

### ✨ Why choose this Actor

| | What you get |
|---|---|
| **The official record** | Data comes from the FCC's own licensing database, not from a broker page or a coverage map. |
| **The entity, not the brand** | `licenseName` and `frns` identify who actually holds the licence, which is what a purchase agreement has to name. |
| **Bulk instead of one at a time** | ULS answers one search per page. Here you set a state and a cap and walk away. |
| **Site coordinates included** | Latitude and longitude come out per licence, so the dataset maps without geocoding. |
| **You pay per row** | No subscription. A search that returns nothing costs nothing. |

### 🚀 How to use it

1. [Create a free Apify account](https://console.apify.com/sign-up). New accounts start with $5 of credit.
2. Open the Actor and select **Try for free**.
3. Set any of `state`, `callSign`, `licenseName` or `applicationStatus`. Leave them blank for an unfiltered pull.
4. Set `maxItems` to cap the run.
5. Select **Start**, then export from the **Dataset** tab as CSV, Excel, JSON or XML.

A first run:

```json
{
  "maxItems": 10
}
```

Active licences in one state:

```json
{
  "maxItems": 2000,
  "state": "TX",
  "applicationStatus": "Active"
}
```

One licensee by name:

```json
{
  "maxItems": 200,
  "licenseName": "Intelliwave"
}
```

### ⚙️ Input

| Field | Required | Description |
|---|---|---|
| `maxItems` | No | Maximum licences to collect per run. Default 10 |
| `state` | No | Two-letter state code, for example `CA` or `NY`. Puerto Rico is `PR` |
| `applicationStatus` | No | One of Active, Pending, Deleted, Granted, Terminated |
| `callSign` | No | Exact call sign, for example `WQJW268` |
| `licenseName` | No | Licensee name substring |

### 💰 Pricing

Pay per result. No subscription, and no Apify platform usage on top.

| Apify plan | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Per licence row | $0.021 | $0.0203 | $0.0197 | $0.019 | $0.019 | $0.019 |

| Rows collected | Cost on the Free plan |
|---|---|
| 100 | $2.10 |
| 1,000 | $21.00 |
| 10,000 | $210.00 |

**Free plan runs** return up to 10 rows as a preview. Any paid Apify plan lifts that to 1,000,000 per run.

### 🔌 Integrate with any app

The dataset is available through the Apify API as soon as the run finishes. Use `run-sync-get-dataset-items` for a one-shot call, webhooks to trigger what happens next, or the Make, Zapier, Airbyte and LangChain integrations listed on the Actor page.

### 🤖 Use with an AI agent

Give an agent live access to the FCC licence database over the Model Context Protocol:

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

Then ask it in plain language who holds a call sign, or which licensees operate in a county, and have it read the result back.

### ❓ Frequently asked questions

**Which licences does this cover?**
Wireless licences in the FCC's Universal Licensing System, searched by state, call sign, licensee name or application status.

**Why are my rows marked `Deleted` or expired?**
ULS keeps historical licences. An unfiltered search returns them alongside live ones. Set `applicationStatus` to `Active` to see only current licences.

**What is the FRN for?**
The FCC Registration Number identifies the licensee as a legal entity. Two call signs sharing an FRN are held by the same company, which is how you find every licence a target owns.

**Can I search by frequency band?**
Not in the input. Export the dataset and filter on `lowerFrequency` and `upperFrequency` in a spreadsheet.

**Why do some rows have no antenna or power values?**
ULS does not publish every technical field for every licence type. Missing values come back as `null` rather than as a guess.

**Do I need a proxy?**
No. Requests and retries are handled inside the Actor and included in the price.

### 🔗 More from Acquisition Automation Co.

- [SAM.gov Contract Opportunities Scraper](https://apify.com/acquistion-automation/sam-gov-contracts-scraper)
- [USASpending Contracts Scraper](https://apify.com/acquistion-automation/usaspending-contracts-scraper)
- [USCG PSIX Vessel Registry Scraper](https://apify.com/acquistion-automation/uscg-psix-vessel-incidents-scraper)
- [IRS Exempt Organizations Scraper](https://apify.com/acquistion-automation/irs-eo-master-file-scraper)
- [BizBuySell Scraper](https://apify.com/acquistion-automation/bizbuysell-scraper)

### About Acquisition Automation Co.

We build automation for people buying businesses. The repetitive part of an acquisition search, checking listings, pulling public records, tracking owners and assets, is work a machine should do, so the buyer's time goes into judging deals instead of collecting them.

We add new Actors regularly. If there is a source you need and do not see here, tell us.

### 🆘 Support

Open an issue in the **Issues** tab of this Actor with your run ID, the input you used, and what you expected to get back.

### ⚠️ Disclaimer

This Actor is independent and is not affiliated with, endorsed by, or sponsored by the Federal Communications Commission or any government agency. It collects only publicly available data. You are responsible for using that data in compliance with the source's terms of service and applicable law.

# Actor input Schema

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

Maximum number of licenses to collect per run.

## `state` (type: `string`):

Two-letter state code (e.g. CA, NY)

## `applicationStatus` (type: `string`):

Filter by status

## `callSign` (type: `string`):

Exact call sign (e.g. WQJW268)

## `licenseName` (type: `string`):

Match licensee name (substring)

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("acquistion-automation/fcc-licenses-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("acquistion-automation/fcc-licenses-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call acquistion-automation/fcc-licenses-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,acquistion-automation/fcc-licenses-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/M5YZ9xKeHllR849dx/builds/PAXbQgkzVSwdAkCaZ/openapi.json