# FCC License Scraper - ULS Call Sign, FRN, Towers & ECFS (`scrapersdelight/fcc-license-scraper`) Actor

Search FCC ULS licences by call sign, FRN, licensee, service, state, status and dates: amateur, GMRS, land mobile, microwave, cellular, PCS/AWS, paging, marine. Licensee phone, email, address, contact. Tower registrations, new-grant monitor from FCC daily files, ECFS docket filings.

- **URL**: https://apify.com/scrapersdelight/fcc-license-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 fcc licence or tower 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/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

### What does FCC License Scraper do?

**FCC License Scraper** reads the Federal Communications Commission's Universal Licensing System (ULS) and returns one clean row per licence: call sign, licensee, FRN, radio service, status, grant / effective / expiration dates, mailing address, and - for business licences - the licensee's phone and email plus the licence contact person. It covers every ULS service file (amateur, GMRS, land mobile, microwave, cellular, PCS/AWS/700 MHz, paging, marine, aviation, commercial operators, BRS/EBS), FCC antenna structure registrations (towers), a new-licence feed from the FCC's daily files, and ECFS docket filings.

- 📡 **Every ULS service in one actor** - 14 FCC licence files, 129 radio service codes, 5.2 million licences, plus 197,769 tower registrations.
- ☎️ **Contacts, not just names** - licensee phone, email, fax and attention line, plus the licence contact (company, person, phone, email) the FCC keeps on file.
- 🔎 **Look up or search** - by call sign, FRN or licensee name, or filter by service, service code, status, state, city, ZIP, applicant type, operator class, grant / expiry / last-action dates, frequency range.
- 🆕 **New-licence feed** - grants, renewals, modifications and cancellations from the FCC's daily transaction files; schedule it daily with "only new rows".
- 🗼 **Towers** - owner, contact, coordinates, heights, structure type and FAA study number for every registered antenna structure.
- 🗂️ **ECFS filings** - comments, replies, ex partes and orders in any docket, with document links.
- 🔐 **No login, no API key** - the actor reads the FCC's public bulk files and the keyless ECFS API.

### What data can you get from the FCC ULS?

| | | |
|---|---|---|
| 📻 Call sign `callSign` | 🏢 Licensee `licenseeName` | 🆔 FRN `frn` |
| 📶 Radio service + code `radioService` | ✅ Status `licenseStatusLabel` | 📅 Grant, effective, expiration dates |
| ⏳ Days to expiry `daysToExpiry` | ☎️ Phone `phone` | 📧 Email `email` |
| 📠 Fax `fax` | 🏠 Address `fullAddress` | 👤 Attention line `attentionLine` |
| 🧑‍💼 Licence contact `contactName` | 🏛️ Contact company `contactOrganization` | 📞 Contact phone / email |
| 🏷️ Applicant type `applicantType` | 💼 Business flag `isBusiness` | ✍️ Certifier name + title |
| 🎓 Amateur class `operatorClass` | 🔁 Previous call sign, trustee | 🗺️ Market name, channel block |
| 🎚️ Frequencies (MHz) | 📍 Licensed locations + coordinates | 🕓 FCC action history |
| 🗼 Tower owner, contact, heights | 🧭 Tower latitude / longitude | ✈️ FAA study number |
| 🗂️ ECFS docket, filer, author, law firm | 📄 ECFS document links | 🔗 FCC licence / registration URL |

### How to scrape FCC licences with FCC License Scraper

1. [Sign up for a free Apify account](https://console.apify.com/sign-up) - the free plan's credit covers thousands of rows.
2. Open **FCC License Scraper** and pick **What to scrape**: licences and towers, recent licence activity, or ECFS filings.
3. Choose the **Radio services** to read and add call signs, FRNs or names - or leave them empty and use the filters.
4. Click **Start**. A cellular search returns in seconds; the amateur file (1.7 million licences) takes 15-40 seconds.
5. Download the results as JSON, CSV, Excel or HTML, or read them through the Apify API.

### ⬇️ Input

#### Input parameters

| Parameter | Type | Description |
|---|---|---|
| `mode` | select | `licenses` (default), `recentActivity`, `ecfsFilings`. |
| `radioServices` | multi-select | FCC files to read. Default `cellular`. Also `amateur`, `gmrs`, `landMobilePrivate`, `landMobileCommercial`, `broadcastAuxiliary`, `microwave`, `marketBased`, `paging`, `coastGround`, `ship`, `aircraft`, `commercialOperators`, `brsEbs`, `antennaStructures`. |
| `callSigns` | list | Exact call signs, e.g. `W1AW`, `KNKA671`. |
| `frns` | list | FCC Registration Numbers - every licence held under each. |
| `licenseeNames` | list | Licensee (or tower owner) name contains, e.g. `verizon`, `county of`. |
| `statuses` | multi-select | A, E, C, T, L, P, X. Empty = Active only for a search, any status for recent activity. |
| `radioServiceCodes` | multi-select | Any of the 129 FCC codes (HA, ZA, IG, PW, CW, AW...). Alone, it picks the right file for you. |
| `states`, `cities`, `zipCodes` | lists | Licensee address (towers: where the structure stands). ZIP codes match as prefixes (`770`). |
| `applicantTypes` | multi-select | Individual, Corporation, LLC, Governmental Entity, Amateur Club... |
| `operatorClasses` | multi-select | Amateur class (Extra, General, Technician...) or commercial operator licence (GROL, MROP...). |
| `grantedFrom` / `grantedTo`, `expiresFrom` / `expiresTo`, `lastActionFrom` / `lastActionTo` | dates | Date windows. |
| `expiringWithinDays` | integer | Active licences expiring in the next N days. |
| `frequencyFromMhz` / `frequencyToMhz` | numbers | Licences with an assigned frequency or band in the range. |
| `towerStatuses`, `structureTypes`, `minHeightMeters`, `maxHeightMeters` | | Tower filters. Empty status = Constructed + Granted. |
| `businessOnly`, `requireEmail`, `requirePhone` | booleans | Keep business licensees / licences with an email / with a phone. |
| `recentDays` | integer | Recent activity: how many of the FCC's latest non-empty daily files to read (1-7, default 3). |
| `eventTypes` | multi-select | Recent activity: `newGrant` (default), `renewal`, `modification`, `cancellation`, `expiration`, `termination`, `assignment`, `transferOfControl`, `adminUpdate`, `lease`, `construction`, `dismantlement`, `otherUpdate`. |
| `ecfsProceedings`, `ecfsFiler`, `ecfsQuery` | | ECFS: docket numbers, filer name, full-text words (at least one). |
| `ecfsReceivedFrom` / `ecfsReceivedTo`, `ecfsSubmissionTypes`, `ecfsExcludeExpressComments`, `ecfsSort` | | ECFS date window, filing types, skip one-line express comments, order. |
| `includeFrequencies`, `includeLocations`, `includeHistory` | booleans | Add frequencies, licensed locations, FCC action history. |
| `monitorMode`, `monitorName`, `resetMonitor` | | Only rows earlier runs did not deliver. |
| `maxResults` | integer | Default 100; 0 = no limit. |
| `sortBy` | select | File order (fastest), newest grant, latest action, soonest expiry, tallest structure. |
| `includeRawRecord` | boolean | Attach the FCC's own columns. |
| `proxyConfiguration` | proxy | Not needed (see FAQ). |

#### Input JSON

```json
{
  "radioServices": ["landMobileCommercial", "landMobilePrivate"],
  "states": ["CA"],
  "businessOnly": true,
  "requireEmail": true,
  "maxResults": 500
}
```

#### Pick the radio service before anything else

Each FCC service family is a separate weekly file, and the actor reads only the files you pick. Business two-way radio users are in **land mobile private** (Industrial/Business pool, public safety); SMR and 220/900 MHz operators in **land mobile commercial**; carriers' PCS/AWS/700 MHz/CBRS licences in **market-based**; point-to-point links in **microwave**; hams in **amateur**. If you only know the service code (e.g. `IG`, `CW`), put it in `radioServiceCodes` and leave `radioServices` empty.

#### Use recent activity for new licensees, not a date window on the weekly file

`mode: recentActivity` reads the FCC's daily transaction files (a few KB to 3 MB each) - every licence granted, renewed or cancelled on each of the last days, with the FCC's own action codes. It is far faster and cheaper than searching a weekly file by grant date, and with `monitorMode` on a daily schedule it is a new-licensee feed.

### ⬆️ Output

A licence (land mobile commercial, real row from the 2026-10-11 file; trimmed):

```json
{
  "recordType": "license",
  "callSign": "KMJ431",
  "licenseeName": "GILCOMM LLC",
  "frn": "0005836275",
  "radioService": "800 MHz Trunked SMR (SMR, Site-specific)",
  "licenseStatusLabel": "Active",
  "grantDate": "2025-06-04",
  "expirationDate": "2035-05-16",
  "applicantType": "Limited Liability Company",
  "isBusiness": true,
  "phone": "6613228650",
  "email": "lbarnes@atginternet.com",
  "fullAddress": "4440 EASTON DRIVE, BAKERSFIELD, CA 93309",
  "contactName": "Lori Barnes",
  "contactOrganization": "Applied Technology Group, Inc.",
  "contactEmail": "lbarnes@atginternet.com",
  "certifierTitle": "owner",
  "uniqueSystemIdentifier": "1112431",
  "licenseUrl": "https://wireless2.fcc.gov/UlsApp/UlsSearch/license.jsp?licKey=1112431",
  "dataAsOf": "2026-10-11"
}
```

A new grant from the daily file (recent activity):

```json
{
  "callSign": "WSON839",
  "licenseeName": "WESTERN NEW MEXICO TELEPHONE COMPANY, INC.",
  "radioService": "Common Carrier Fixed Point to Point Microwave",
  "grantDate": "2026-10-13",
  "phone": "5753882546",
  "email": "wbaxter@wnmt.com",
  "contactOrganization": "Intelpath",
  "eventType": "newGrant",
  "eventDate": "2026-10-13",
  "eventCodes": [{ "code": "LIISS", "description": "License Issued" }]
}
```

A tower:

```json
{
  "recordType": "antennaStructure",
  "registrationNumber": "1000178",
  "ownerName": "Crown Castle GT Company, LLC",
  "structureTypeLabel": "Any type of Pole",
  "statusLabel": "Constructed",
  "structureCity": "HOUSTON",
  "structureState": "TX",
  "latitude": 29.782194,
  "longitude": -95.617194,
  "overallHeightAboveGroundM": 49.4,
  "faaStudyNumber": "2008-ASW-4448-OE",
  "ownerPhone": "7244162400",
  "ownerEmail": "Regulatory.Department@crowncastle.com",
  "contactName": "Tom Anderson",
  "contactEmail": "Tom.Anderson@crowncastle.com"
}
```

An ECFS filing:

```json
{
  "recordType": "ecfsFiling",
  "filingId": "26110080152",
  "submissionType": "NOTICE OF EXPARTE",
  "proceedings": ["25-180", "26-54", "14-177", "25-133"],
  "filers": ["GeoLinks", "JLC Infrastructure"],
  "authors": ["Andrew Magloughlin"],
  "lawFirms": ["Steptoe LLP"],
  "presentedTo": ["Office of Chairman Brendan Carr"],
  "dateReceived": "2026-10-08T21:59:08.320Z",
  "documentUrls": ["https://www.fcc.gov/ecfs/document/26110080152/1"],
  "filingUrl": "https://www.fcc.gov/ecfs/search/search-filings/filing/26110080152"
}
```

#### How complete is each field? (measured on real runs, 2026-10-14)

| Field | Land mobile private, TX (1,000) | Land mobile commercial, all active (8,097) | Cellular, all active (3,861) | Amateur, TX (1,000) | Towers, TX (1,000) |
|---|---|---|---|---|---|
| Licensee / owner name, FRN, address | 100% | 100% | 100% | 100% | 100% |
| Phone | 100% | 100% | 100% | 0% | 99.9% |
| Email | 99.6% | 92.8% | 99.7% | 0% | 95.1% |
| Licence contact (person or company) | 99.8% | 95.9% | 100% | 0% | 68.9% |
| Contact email | 98.5% | 93.9% | 99.9% | 0% | 93.5% |
| Fax | 75.2% | 44.8% | 21.2% | 0% | - |
| Certifier title | 4.5% | 61.7% | 94.2% | 1% | 99.9% (signer) |
| Operator class | - | - | - | 99% | - |

The FCC publishes no phone or email for individual amateur, GMRS, ship, aircraft and commercial-operator licensees - those rows carry name, FRN and mailing address. ECFS (1,000 filings in docket 25-133): filer and type 100%, document links 87.9%, authors 32.5%, law firms 13.7%.

### Use cases

- 📻 **Two-way radio and equipment dealers** - land mobile licensees by state with phone, email and the frequency coordinator who files for them.
- 🗼 **Tower and site services** - every registered structure with owner contact, coordinates and height.
- 🔁 **Renewal and compliance services** - `expiringWithinDays: 90` finds active licences up for renewal.
- 🆕 **New-licensee prospecting** - a daily recent-activity run with `monitorMode` delivers each day's new grants.
- 📶 **Spectrum and carrier research** - market-based licences by carrier FRN, market and channel block.
- 🎙️ **Ham radio clubs and apps** - call-sign verification, operator class, trustee.
- ⚖️ **Regulatory and policy teams** - every filing in a docket, with law firm, author and document links.

### How much does it cost to scrape the FCC ULS?

Pay per row, no start fee: **$0.0016 per licence or tower ($1.60 per 1,000)** and **$0.0032 per ECFS filing ($3.20 per 1,000)**. Rows your filters drop, call signs that are not found and rows a monitor already delivered are not charged.

| Rows | Licences / towers | ECFS filings |
|---|---|---|
| 10 | $0.016 | $0.032 |
| 100 | $0.16 | $0.32 |
| 1,000 | $1.60 | $3.20 |
| 10,000 | $16.00 | $32.00 |

Apify's free plan includes monthly credit that covers several thousand licences.

### Integrations, API, scheduling & MCP

- **Schedules** - run recent activity daily (the FCC posts daily files each morning, Eastern time) or a search weekly (weekly files are posted on Sundays).
- **Webhooks, Make, Zapier, n8n, Google Sheets, Slack** - send each run's rows to your CRM or sheet.
- **API** - start runs and read datasets with [apify-client for Python](https://apify.com/scrapersdelight/fcc-license-scraper/api/python) or [JavaScript](https://apify.com/scrapersdelight/fcc-license-scraper/api/javascript).
- **MCP** - call the actor from Claude, ChatGPT or any agent through the [Apify MCP server](https://apify.com/scrapersdelight/fcc-license-scraper/api/mcp).

### More government data scrapers

- ✈️ [FAA Aircraft Registry Scraper](https://apify.com/scrapersdelight/faa-aircraft-registry-scraper) - aircraft owners by N-number, make, model and state.
- 🚚 [FMCSA Carrier Scraper](https://apify.com/scrapersdelight/fmcsa-carrier-scraper) - trucking companies with USDOT, MC, phone and email.
- ☎️ [Phone Number Validator](https://apify.com/scrapersdelight/phone-number-validator-scraper) - check line type and carrier of the licensee phones you export.
- 🏛️ [GSA Auctions Scraper](https://apify.com/scrapersdelight/gsa-auctions-scraper) - federal surplus lots and bids.
- More on our [Apify profile](https://apify.com/scrapersdelight).

### Limits & empty runs

- **Freshness** - weekly licence files are the FCC's Sunday snapshot (`dataAsOf` on every row); recent activity covers the last 7 daily files the FCC keeps.
- **Speed** - small files answer in seconds; a search of the amateur file reads up to ~150 MB of the FCC's zip and takes 15-40 s. "File order" stops as soon as `maxResults` is filled; any other sort reads the whole file.
- **ECFS** - the API returns at most 10,000 filings per query; newest-received order reads further by date windows, other orders stop at 10,000. The public API no longer returns filer addresses, titles or text snippets.
- **Empty runs** - a run with no match ends successfully with 0 rows and costs nothing; the run summary (`RUN_SUMMARY`) lists call signs that were not found and why.
- **Integrity** - every FCC file member read to the end is checked against its CRC-32; a corrupted download fails the run instead of returning partial data.

### ❓ FAQ

#### How much does FCC License Scraper cost?

$0.0016 per licence or tower row and $0.0032 per ECFS filing, no start fee. 100 licences cost $0.16.

#### How many FCC licences can FCC License Scraper return?

All of them: 5.2 million licences across the 14 ULS files (1.7 million amateur, 860,739 land mobile private, 793,162 commercial operators, 615,496 GMRS...) and 197,769 tower registrations. Set `maxResults: 0` for no limit.

#### Can FCC License Scraper find new FCC licences every day?

Yes - `mode: recentActivity` with `eventTypes: ["newGrant"]` and `monitorMode: true` on a daily schedule returns each new grant once. Over three daily files the FCC issued 828 new licences across all services (measured 2026-10-14).

#### Do I need an FCC API key or login to use FCC License Scraper?

No. The licence and tower data come from the FCC's public bulk files and ECFS from the FCC's keyless public API host.

#### Why does FCC License Scraper return no phone or email for some licences?

The FCC does not publish phone or email for individual licensees (amateur, GMRS, ship, aircraft, commercial operators). Business licences in land mobile, microwave, cellular, market-based and paging carry them on 92-100% of rows.

#### Can I use FCC License Scraper with the Apify API or an MCP server?

Yes - every input above works through the API, and the actor is available to AI agents through the Apify MCP server.

#### Can FCC License Scraper search by frequency?

Yes - set `frequencyFromMhz` and `frequencyToMhz` (equal values for one exact frequency). The actor then also reads the FCC's frequency file for the services you picked.

#### Does FCC License Scraper need a proxy?

No. It downloads the FCC's files directly. If the FCC ever refuses the direct download, the actor switches to a residential proxy and then the Apify Unblocker by itself, within a small per-run budget.

#### Why did my FCC License Scraper run return nothing?

Check the radio service: a call sign is only found in the file of its service (a ham call sign in `amateur`, a business radio call sign in `landMobilePrivate`). The default status filter is Active - add E, C and T to find expired or canceled licences.

#### Your feedback

Missing a field or found a bug? Open an issue on the actor's [Issues tab](https://apify.com/scrapersdelight/fcc-license-scraper/issues/open) and we will look at it.

*FCC License Scraper is an independent tool and is not affiliated with or endorsed by the Federal Communications Commission.*

# Actor input Schema

## `mode` (type: `string`):

Licences = search the FCC's weekly ULS files (and tower registrations). Recent activity = licences granted, renewed, modified or cancelled in the FCC's last daily files. ECFS = comments and filings in FCC dockets.

## `radioServices` (type: `array`):

Which FCC files to read (licence counts from the 2026-10-11 files). Bigger files take longer: amateur reads ~150 MB. Not used by ECFS.

## `callSigns` (type: `array`):

Look up these call signs, e.g. W1AW, KNKA671, WSHM478. Exact match, case does not matter. Searches the radio services selected above.

## `frns` (type: `array`):

Every licence (or tower) held under these FRNs, e.g. 0003291341. Leading zeros optional.

## `licenseeNames` (type: `array`):

Licensee (or tower owner) name contains any of these, case-insensitive, e.g. verizon, county of, school district.

## `statuses` (type: `array`):

Keep licences with these FCC statuses. Empty = Active only for a licence search, any status for recent activity. Select all to include expired and cancelled licences.

## `radioServiceCodes` (type: `array`):

Narrow to these FCC service codes (e.g. HA amateur, IG industrial/business, PW public safety, CW PCS, AW AWS). With no radio service picked above, the file holding each code is read.

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

Two-letter state of the licensee's mailing address, e.g. TX, CA. For towers: the state the structure stands in.

## `cities` (type: `array`):

Exact city of the licensee's address (towers: structure city), e.g. HOUSTON. Combine with states to avoid same-name cities.

## `zipCodes` (type: `array`):

ZIP code or its start, e.g. 77002 or 770 (all of Houston).

## `applicantTypes` (type: `array`):

Licensee / owner legal form as filed with the FCC, e.g. Corporation, LLC, Individual, Governmental Entity.

## `operatorClasses` (type: `array`):

Amateur licence class (Extra, General, Technician...) or commercial operator licence (GROL, MROP, GMDSS...).

## `grantedFrom` (type: `string`):

Licences granted on or after this date (towers: registration issued).

## `grantedTo` (type: `string`):

Licences granted on or before this date.

## `expiresFrom` (type: `string`):

Licences expiring on or after this date.

## `expiresTo` (type: `string`):

Licences expiring on or before this date.

## `lastActionFrom` (type: `string`):

Last FCC action (grant, renewal, modification, cancellation) on or after this date.

## `lastActionTo` (type: `string`):

Last FCC action on or before this date.

## `expiringWithinDays` (type: `integer`):

Active licences whose expiration date falls in the next N days - renewal leads, e.g. 90.

## `frequencyFromMhz` (type: `number`):

Licences with an assigned frequency or band in this range (inclusive). Set both; equal values = one exact frequency, e.g. 462.5625. Reads the frequency file too.

## `frequencyToMhz` (type: `number`):

Upper end of the frequency range, e.g. 467.7125.

## `towerStatuses` (type: `array`):

ASR registration status. Empty = Constructed and Granted for a search, any status for recent activity.

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

Kind of structure as registered, e.g. Monopole, Lattice tower, Guyed tower, Building.

## `minHeightMeters` (type: `number`):

Overall height above ground of at least this many meters, e.g. 60.

## `maxHeightMeters` (type: `number`):

Overall height above ground of at most this many meters.

## `businessOnly` (type: `boolean`):

Keep licensees filed as a corporation, LLC, partnership, trust or association - drops individuals, governments and amateur clubs.

## `requireEmail` (type: `boolean`):

Keep licences that list an email (licensee or licence contact).

## `requirePhone` (type: `boolean`):

Keep licences that list a phone number (licensee or licence contact).

## `recentDays` (type: `integer`):

How many of the FCC's most recent non-empty daily files to read per service: 1 = the latest day of actions, 7 = the whole week.

## `eventTypes` (type: `array`):

Which FCC actions to return. Default: new grants only - the new-licensee feed.

## `ecfsProceedings` (type: `array`):

FCC proceeding / docket numbers, e.g. 23-320, 17-108, 25-133. Each is searched separately.

## `ecfsFiler` (type: `string`):

Only filings by this filer, e.g. Verizon, AT\&T Services Inc., NTCA.

## `ecfsQuery` (type: `string`):

Full-text search across filings, e.g. spectrum sharing, net neutrality.

## `ecfsReceivedFrom` (type: `string`):

Filings received on or after this date.

## `ecfsReceivedTo` (type: `string`):

Filings received on or before this date.

## `ecfsSubmissionTypes` (type: `array`):

Keep only these filing types as ECFS names them, e.g. COMMENT, REPLY TO COMMENTS, NOTICE OF EXPARTE, LETTER, PETITION FOR RECONSIDERATION.

## `ecfsExcludeExpressComments` (type: `boolean`):

Drop one-line public "express" comments (millions on some dockets) and keep formal filings.

## `ecfsSort` (type: `string`):

Newest received first reads past ECFS's 10,000-filings-per-query limit; the other orders stop there.

## `includeFrequencies` (type: `boolean`):

Add assigned frequencies and bands (MHz) to each licence.

## `includeLocations` (type: `boolean`):

Add licensed locations: address, county, latitude/longitude, structure height, tower registration number.

## `includeHistory` (type: `boolean`):

Add the FCC action history of each licence or tower (dates and actions).

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

Return only licences, actions or filings this monitor has not delivered in earlier runs. Rows already delivered are not charged again.

## `monitorName` (type: `string`):

Optional name to keep separate monitors apart, e.g. texas-new-gmrs. Empty = one monitor per set of filters.

## `resetMonitor` (type: `boolean`):

Forget what this monitor delivered and start over.

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

Stop after this many rows. 0 = no limit (amateur alone has 822,954 active licences).

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

File order is fastest (stops at Max results). Any other order reads the whole file first.

## `includeRawRecord` (type: `boolean`):

Attach the FCC's own columns (HD, EN, AM... rows) to each row.

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

Only used if the FCC refuses the direct download; the actor then tries a residential proxy and the Apify Unblocker on its own, within a small budget.

## Actor input object example

```json
{
  "mode": "licenses",
  "radioServices": [
    "cellular"
  ],
  "businessOnly": false,
  "requireEmail": false,
  "requirePhone": false,
  "recentDays": 3,
  "eventTypes": [
    "newGrant"
  ],
  "ecfsExcludeExpressComments": false,
  "ecfsSort": "newestReceived",
  "includeFrequencies": false,
  "includeLocations": false,
  "includeHistory": false,
  "monitorMode": false,
  "resetMonitor": false,
  "maxResults": 20,
  "sortBy": "fileOrder",
  "includeRawRecord": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `items` (type: `string`):

One row per FCC licence (call sign, licensee, FRN, service, status, dates, address, phone, email, licence contact), antenna structure registration, licence action from the daily files, or ECFS filing.

## `runSummary` (type: `string`):

RUN_SUMMARY: the FCC files read and their dates, bytes per route, CRC checks, rows read and matched, delivered and charged, call signs not delivered, monitor counts and the fill of every delivered field.

# 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 = {
    "radioServices": [
        "cellular"
    ],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/fcc-license-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 = {
    "radioServices": ["cellular"],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/fcc-license-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 '{
  "radioServices": [
    "cellular"
  ],
  "maxResults": 20
}' |
apify call scrapersdelight/fcc-license-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/fcc-license-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/aNbBcs5CioQaqohwM/builds/SablnMr7LYGCodpul/openapi.json