# FCC ECFS Scraper: Filings by Docket & Filer (`thoob/fcc-ecfs-filings`) Actor

Clean, flat records of public FCC filings from the official ECFS API (Electronic Comment Filing System), searchable by docket/proceeding, filer, and text, with a what-changed-since-last-run mode. Billed only per delivered filing.

- **URL**: https://apify.com/thoob/fcc-ecfs-filings.md
- **Developed by:** [Pono Data](https://apify.com/thoob) (community)
- **Categories:** Developer tools, Lead generation, News
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$4.00 / 1,000 filing 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 Filings & Proceedings Lookup (ECFS)

Clean, flat records of public FCC filings from the official ECFS API (Electronic
Comment Filing System), the FCC's live, developer-facing JSON service. Search by
docket/proceeding, filer, or full text, and run it on a schedule in changes-only
mode to pull just the new filings since the last run.

### Note on scope

The FCC's older ULS license-view JSON API has been retired, so this actor targets
ECFS, the FCC's maintained public filings API. It covers proceedings, comments,
and filings (the high-demand, queryable surface), not ULS license records.

### Input

- **Proceeding / docket** (for example 17-59), **Full-text search**, **Filer name**,
  **Received on/after**, **Sort**, **Mode** (full / changes).
- **FCC API key**: optional free api.data.gov key; falls back to DEMO\_KEY (rate-limited)
  or an `FCC_API_KEY` actor secret.
- **Max delivered filings**, **API page size**.

### Output

One row per filing: `submissionId`, `submissionType`, `proceedings`, `filers`,
`authors`, `lawFirms`, `bureaus`, `dateReceived`, `dateDisseminated`,
`documentCount`, `documentUrls`, `pageCount`, `viewingStatus`, `changeType`, plus
provenance (`sourceUrl` is the ECFS filing page, `retrievedAt`, `confidence`, `dataSource`).

### How it works

Every value is copied from the ECFS record; nested fields (proceedings, filers,
documents) are flattened and joined, and absent fields are null, never invented.
A page that fails to fetch is logged to the free `rejected` dataset; a search that
matches nothing bills nothing.

### Billing

Pay per delivered filing. Empty result sets and fetch failures cost nothing.

### Sample output

A real run of public FCC filings from the official ECFS API:

| proceeding | type | filer | received |
| --- | --- | --- | --- |
| 11-42 | PUBLIC NOTICE | Wireline Competition Bure… | 2026-06-05 |
| 11-42 | REPLY TO COMMEN… | National Association of S… | 2026-06-02 |
| 11-42 | REPLY TO COMMEN… | National Lifeline Associa… | 2026-06-02 |
| 11-42 | REPLY | Summit Ridge Group, LLC | 2026-06-02 |

Every row carries a `sourceUrl` to the filing, for example `https://www.fcc.gov/ecfs/search/search-filings/filing/1060556591362`.

### Use cases

- Track a proceeding you care about: pull every filing in a docket (for example 17-59), or just the new ones since your last run in changes mode.
- Monitor a filer or law firm: search by filer name to see what an organization is submitting across proceedings.
- Build a regulatory-watch dashboard: a scheduled changes-mode run delivers only the new filings, each with its documents and a link to the ECFS page.
- Feed an analyst or a model clean filing records instead of scraping the ECFS web search.

### FAQ

- Is this the official source? Yes. It reads the FCC's maintained ECFS JSON API, not a scrape of the web search. The older ULS license-view API was retired, so this covers proceedings, comments, and filings.
- Does a docket search match exactly? Yes. A query for 11-42 returns filings in 11-42, not 11-420; the docket match is exact.
- Do I need an API key? No. It falls back to the public DEMO\_KEY; a free api.data.gov key (or an actor secret) raises the rate limit.
- How am I billed? Per delivered filing. Empty result sets and fetch failures cost nothing.

### See also

More clean, pay-only-for-results data tools from Pono Data:

- [Regulatory Change Monitor](https://apify.com/thoob/regulatory-change-monitor) - federal rulemaking from the Federal Register
- [FARA Foreign Agent Feed](https://apify.com/thoob/fara-foreign-agent-feed) - DOJ FARA registrant-to-principal records
- [FDA Food Recall & Enforcement Alerts](https://apify.com/thoob/fda-food-recall-feed) - US food recalls and enforcement reports

Full catalog: https://apify.com/thoob

# Actor input Schema

## `docket` (type: `string`):

Filter to a docket/proceeding number (for example 17-59, 21-450). The most common filter.

## `query` (type: `string`):

Optional free-text query across filing content.

## `filer` (type: `string`):

Optional. Keep only filings whose filer matches this name.

## `sinceDate` (type: `string`):

Optional. Keep only filings received on or after this date (filtered on the returned record).

## `sort` (type: `string`):

Result ordering.

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

full returns every matching filing. changes returns only filings not seen in this account's prior runs.

## `apiKey` (type: `string`):

Optional. A free api.data.gov key raises the rate limit. If empty, the actor uses the public DEMO\_KEY (heavily rate-limited) or an FCC\_API\_KEY actor secret.

## `maxRecords` (type: `integer`):

Cap on delivered, billed rows. 0 means no cap. The platform spend cap is honored regardless.

## `pageSize` (type: `integer`):

Filings per API page (1 to 250).

## Actor input object example

```json
{
  "sort": "date_disseminated,DESC",
  "mode": "full",
  "maxRecords": 500,
  "pageSize": 100
}
```

# Actor output Schema

## `filings` (type: `string`):

One row per matching filing.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("thoob/fcc-ecfs-filings").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("thoob/fcc-ecfs-filings").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 '{}' |
apify call thoob/fcc-ecfs-filings --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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