# Federal Register Scraper - Comment Deadlines (`dataio/federal-register-comment-deadlines`) Actor

Scrape the US Federal Register: proposed and final rules with the days remaining until the comment period closes or the rule takes effect, the countdown the Federal Register never publishes. Filter by agency, CFR title, keyword and date, sorted by urgency.

- **URL**: https://apify.com/dataio/federal-register-comment-deadlines.md
- **Developed by:** [Tom Awake](https://apify.com/dataio) (community)
- **Categories:** News, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 regulatory documents

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

### What does Federal Register Scraper do?

US regulations with **the days remaining** until the comment period closes
or the rule takes effect — sorted by urgency.

**No login. No API key. No proxies.**

### The countdown the source never prints

The Federal Register publishes two dates that bind a company: when the
comment period on a proposed rule **closes**, and when a final rule
**takes effect**. It never publishes the number of days left.

That is the only number a regulatory affairs team actually works from.
*Which proposals affecting us are still open, and how long have we got?*

This Actor does the subtraction on every row, flags what is still open, and
sorts so the tightest deadline is first. A real run, 13 September 2026:

| Document | Agency | Days left |
|---|---|---|
| Request for Information; Clinical Laboratory Improvement | HHS | **1** |
| Medicare and Medicaid Programs; CY 2027 Payment Policies | HHS | **1** |
| Accreditation, Innovation and Modernization | Education | 8 |

Three comment periods closing within eight days, two of them tomorrow —
visible in one column instead of thirty PDF pages.

### Output

| Field | Example |
|---|---|
| `title`, `type`, `action` | Proposed Rule; request for comments |
| `agencies` | Health and Human Services, Food and Drug Administration |
| `commentsCloseOn` | 2026-09-14 |
| **`daysUntilCommentClose`** | **1** |
| `effectiveOn`, **`daysUntilEffective`** | 2026-11-01, 49 |
| `commentPeriodOpen`, `alreadyEffective` | true / false |
| `significant` | flagged under Executive Order 12866 |
| `cfrReferences` | 21 CFR 101 |
| `docketIds`, `regulationIdNumbers` | FDA-2026-N-1234, RIN 0910-AI43 |
| `documentNumber`, `citation`, `startPage`, `pageLength` | |
| `abstract`, `topics` | |
| `htmlUrl`, `pdfUrl` | the document itself |

A negative `daysUntilEffective` means the rule is already in force. A null
means no date was set — not that there is no deadline, so check the
document.

### Input

```json
{
  "documentType": "proposed-rules",
  "openForCommentOnly": true,
  "searchTerm": "artificial intelligence",
  "maxItems": 300
}
```

| Field | Default | Notes |
|---|---|---|
| `documentType` | `proposed-rules` | Proposed, final, notices, presidential |
| `openForCommentOnly` | `true` | Only what you can still influence |
| `searchTerm` | — (every document) | Full text, e.g. `artificial intelligence` |
| `maxItems` | `300` | Sorted by nearest deadline |
| `agencies` | — | Slugs, e.g. `food-and-drug-administration` |
| `cfrTitle` | — | 21 food and drugs, 40 environment, 47 telecoms |
| `publishedAfter` | — | YYYY-MM-DD |
| `significantOnly` | `false` | Economically significant rules |

**Proposed rules are the ones you can change.** Final rules are the ones you
must comply with. Pick the type that matches the job.

### Use cases

- **Regulatory affairs** — every open consultation touching your CFR title,
  ranked by how soon it closes.
- **Public affairs and lobbying** — where comment windows are still open, and
  how much time is left to file.
- **Compliance planning** — final rules and their effective dates, so
  deadlines reach the calendar before they reach you.
- **Competitive and policy monitoring** — what a given agency is proposing,
  continuously.
- **Legal research** — docket numbers, RINs and CFR references for follow-up
  on Regulations.gov.

### Running this as a scheduled watch

Comment periods are short and they do not reopen. This is the Actor
where a weekly schedule matters most: missing the window means losing
the right to respond at all.

```json
{
  "documentType": "proposed-rules",
  "openForCommentOnly": true,
  "publishedWithinDays": 7,
  "maxItems": 200
}
```

**Why not a fixed `publishedAfter` date?** A schedule replays the same
input every time, so a fixed date returns — and re-charges — the same
documents at every run. `publishedWithinDays` moves the window on its
own.

***

### Limits, honestly

- **Deadlines come from the source.** Agencies extend and reopen comment
  periods; a date read today can move tomorrow. Re-run before relying on it.
- `daysUntilCommentClose` is calculated against the run date, so a stored
  export ages. The dates themselves do not.
- Not every document carries a comment or effective date — notices often
  carry neither. Those sort last rather than being dropped.
- The API stops paginating deep result sets. Narrow by agency, CFR title or
  date rather than sweeping everything.
- Agency filters use the Federal Register's own slugs, which are not always
  the agency's common name.
- Requests are paced out of courtesy to a free public service.
- Not affiliated with the Office of the Federal Register.

### How much does it cost?

You pay per regulatory document returned: **$0.003 each**, that is $3.00 per 1,000. There is no start fee, and subscription plans pay less per regulatory document.

The example input below asks for up to 300 regulatory documents, so it costs **$0.90 at most**.

If a run reaches the spending limit you set, the output stops at that limit and never goes past it. You are never charged for rows that were not delivered.

### Use Federal Register Scraper as an API

Call it from your own code with the Apify client, here in Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("DataIO/federal-register-comment-deadlines").call(run_input={
    'documentType': 'proposed-rules',
    'openForCommentOnly': True,
    'searchTerm': 'artificial intelligence',
    'maxItems': 300,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

It also works from JavaScript, Make, Zapier, n8n, and from AI agents through the Apify MCP server.

### Other actors you might like

- [UK Contracts Finder Scraper](https://apify.com/DataIO/uk-public-contract-awards): Tenders & Awards
- [TED Tenders Scraper](https://apify.com/DataIO/ted-eu-tenders-procurement): EU Public Procurement
- [USAspending Scraper](https://apify.com/DataIO/usaspending-federal-awards): Federal Contract Awards

### FAQ

#### Is it legal to use this data?

The actor reads public data from its official source, without logging in and without bypassing any access control. What you do with the data, for example contacting people listed in it, is your responsibility under the laws that apply to you, such as GDPR in Europe.

#### Can I run it on a schedule?

Yes. See *Running this as a scheduled watch* above: use the rolling-window setting so each run returns only what is new.

#### Can AI agents use it?

Yes. It is available through the Apify MCP server, and every input field is described in its input schema, so an agent can call it directly.

# Actor input Schema

## `documentType` (type: `string`):

Proposed rules are the ones you can still influence. Final rules carry an effective date you must comply with.

## `openForCommentOnly` (type: `boolean`):

Keeps documents whose comment period has not closed. This is the actionable set — everything else is history.

## `searchTerm` (type: `string`):

Full-text search, for example "artificial intelligence", "medical device", "emissions". Leave empty for every document of the chosen type.

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

One row per document, sorted by how soon the deadline falls.

## `agencies` (type: `array`):

Agency slugs as the Federal Register spells them, for example \["food-and-drug-administration", "environmental-protection-agency"].

## `cfrTitle` (type: `string`):

Code of Federal Regulations title number, for example 21 for food and drugs, 40 for environment, 47 for telecommunications.

## `publishedWithinDays` (type: `integer`):

Rolling window, for a scheduled watch: 7 returns documents published in the last seven days. Comment periods are short, so a weekly schedule is the point of this Actor. Overrides Published after.

## `publishedAfter` (type: `string`):

YYYY-MM-DD.

## `significantOnly` (type: `boolean`):

Rules flagged as significant under Executive Order 12866 — the ones with real economic impact.

## Actor input object example

```json
{
  "documentType": "proposed-rules",
  "openForCommentOnly": true,
  "maxItems": 100,
  "publishedWithinDays": 30,
  "significantOnly": false
}
```

# Actor output Schema

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

Every row produced by the run, in JSON.

# 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": 100,
    "publishedWithinDays": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataio/federal-register-comment-deadlines").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": 100,
    "publishedWithinDays": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("dataio/federal-register-comment-deadlines").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": 100,
  "publishedWithinDays": 30
}' |
apify call dataio/federal-register-comment-deadlines --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataio/federal-register-comment-deadlines"
        }
    }
}
```

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/vV55LCZDAZG8EPUOS/builds/CNx03nhEkaVpUXfAf/openapi.json