# Federal Register Scraper — New Rules & Comment Deadlines (`northbell/federal-register-scraper`) Actor

US Federal Register documents from the official API: rules, proposed rules, notices and presidential documents with agency, dates, comment deadline, docket, RIN and CFR references. Filter by keyword, agency or CFR part and flag what is new since your last run.

- **URL**: https://apify.com/northbell/federal-register-scraper.md
- **Developed by:** [Northbell](https://apify.com/northbell) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 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

## Federal Register Scraper — New Rules & Comment Deadlines

Search the **US Federal Register** by keyword, agency, document type, CFR title and part or topic and get one clean row per document: **title, type, abstract, agencies, publication date, effective date, comment deadline, docket IDs, RINs, CFR references, page range, significant flag**, plus the link to the document, its PDF and the **regulations.gov comment link**. Final rules, proposed rules, notices and presidential documents, back to 1994. **$2.00 per 1,000 documents**, no login, no API key.

Run it again — or put it on a daily schedule — and every row also tells you **whether the document is new since the last run** (`isNew`). Set *What to return* to *Only new* and you pay only for documents you have not seen before. Switch on *Comment period still open* and you get the open dockets with their deadlines.

### What you get

| Field | What it is |
|---|---|
| `documentNumber`, `url`, `pdfUrl` | the Federal Register document number (for example `2026-21155`), the link to its page on federalregister.gov and to the PDF of the printed edition on govinfo.gov |
| `title`, `abstract` | the title as published, and the abstract cut at a word near 500 characters (`null` when the document has none) |
| `documentType`, `subtype`, `action` | `Rule`, `Proposed Rule`, `Notice` or `Presidential Document`; for presidential documents the kind (`Proclamation`, `Memorandum`…); the action line the agency printed (`Final rule.`, `Notice of proposed rulemaking.`, `60-Day notice.`) |
| `agencies`, `agencySlugs` | the agencies as federalregister.gov names them (a department and its sub-agency appear as two entries) and their slugs, which you can pass back in *Agencies* |
| `publicationDate`, `effectiveDate` | when the Federal Register published it and, where the document states one, when it takes effect |
| `commentsCloseDate`, `commentPeriodOpen`, `commentUrl` | the date comments are due; `true` / `false` whether that date is today or later in US Eastern time on the day of the run (`null` when there is no deadline); the regulations.gov link for commenting, where there is one |
| `docketIds`, `regulationIdNumbers` | the docket numbers and the RINs (Regulation Identifier Numbers), each as the agency printed them |
| `cfrReferences`, `topics` | the CFR parts the document affects (`40 CFR 80`, or `5 CFR Chapter XIV` when only a chapter is given) and its CFR indexing topics |
| `citation`, `startPage`, `endPage`, `pageCount` | the Federal Register citation (`91 FR 65699`) and the page range in the printed edition |
| `significant` | `true` / `false` whether the Federal Register marks the rulemaking as significant under Executive Order 12866; `null` when it has no flag |
| `isNew`, `previousRunAt` | `true` / `false` whether you had not seen this document in your previous run of the same search, and when that run was (`null` on the first run) |
| `observedAt` | when the row was collected |

### Run it again and again

- **On a schedule** — save your input as a task and add a **Schedule**: the same search every morning. Send each run to Google Sheets, Slack or email with an integration on the task.
- **Watch for changes** — Set **What to return** to *Only documents that are new since the last run*.
- **In bulk** — Combine **Keywords**, **Agencies**, **Document types** and a CFR title in one run; each keyword line is its own search and the results come back as one list, newest first.

### Use it for

- **Regulatory monitoring** — a daily schedule with your keywords or agencies, *Only new*, sent to Slack, email or your compliance tool
- **Comment deadlines** — *Comment period still open* with your agencies or CFR part: every open docket, its deadline and the regulations.gov link, soonest to act on
- **Policy and lobbying research** — *Proposed rules* and *Significant rules only* for a sector, with RINs and dockets to follow a rule from proposal to final
- **Compliance and legal teams** — everything that touches `40 CFR 60` or `21 CFR` since a date, with CFR references and effective dates

### Input

```json
{
  "keywords": ["cybersecurity", "\"data breach\""],
  "agencies": ["Securities and Exchange Commission", "EPA"],
  "documentTypes": ["rule", "proposed-rule"],
  "commentPeriodOpen": true,
  "maxResults": 200,
  "output": "new"
}
```

- All filters are combined with AND; the entries inside one list are combined with OR.
- **keywords** — searched in the full text of the document. Several words on one line must all appear; put a phrase in quotes. Every line is a separate search (up to 10) and the results are merged without duplicates.
- **agencies** — the agency's name, abbreviation or slug (`Environmental Protection Agency`, `EPA`, `environmental-protection-agency`). The Actor looks the name up in the Federal Register's agency list and stops before charging anything if it finds no match or an abbreviation that fits two agencies (it then lists their slugs).
- **documentTypes** — `rule`, `proposed-rule`, `notice`, `presidential-document`. Empty means all four.
- **significantOnly** — only rulemakings marked significant under Executive Order 12866.
- **cfrTitle**, **cfrPart** — documents that affect that CFR title (1–50) and, if given, part (`60`) or part range (`50-99`). A part needs its title.
- **topics** — CFR indexing topic slugs as listed at federalregister.gov/topics, such as `air-pollution-control`.
- **commentPeriodOpen** — only documents whose comment deadline is today or later (US Eastern date). When you give neither *Published since* nor *Published within*, it looks back 730 days.
- **publishedSince** (`YYYY-MM-DD`) or **publishedWithinDays** (default 7) — the publication period, up to today.
- Results are always sorted newest first, and **maxResults** (default 200, up to 5,000) cuts the list from the old end. With *Only new* it is the number of new documents to return: the Actor reads down the list, past the documents you have already seen (up to 5,000 deep), until it has found that many. Documents below the cut-off are not marked as seen, so they come back as new in your next run.

"Is it new" is remembered per search — the same keywords, agencies, document types, significant flag, CFR title and part, topics and comment-period setting — in a named key-value store in your Apify account, so the second run of the same search already shows `isNew`. Changing *Published within*, *Published since* or *Maximum documents* keeps the same history.

### Pricing

**$2.00 per 1,000 documents**, plus $0.01 per run. Error rows (a search the API rejects, the API not answering) are free. With *Only new*, documents you have already seen are skipped and not charged. The $0.01 run-start fee is the one charge every run pays, even one that returns nothing.

### Notes

- Source: the public Federal Register API (`federalregister.gov/api/v1`) run by the Office of the Federal Register (National Archives) and the Government Publishing Office. Anonymous access, no key, nothing from behind a login. The site's robots.txt disallows only a few web pages (its search pages, `/my/`, `/auth/`), not `/api/`, and its About page says any person may reproduce or republish material from the Federal Register (1 CFR 2.6). Republishers may not use the official NARA or OFR logos or seals; this Actor uses none.
- **Not an official legal edition.** FederalRegister.gov is an unofficial informational resource: it does not provide legal notice to the public or judicial notice to the courts. Anyone relying on this data for legal research should check it against an official edition of the Federal Register (the PDF on govinfo.gov, linked in `pdfUrl`). This Actor is not affiliated with or endorsed by the Office of the Federal Register, the National Archives or the Government Publishing Office.
- **How deep a search can go.** The API documents that you can page through the first 2,000 results of a search and that you should use date ranges to get more. The Actor stays inside that: when you ask for more than 2,000 documents (*Maximum documents* above 2,000, or *Only new*, which reads up to 5,000 deep) it first counts the matches and halves the publication period until each part holds at most 2,000 documents, then reads the newest part first. A single day with more than 2,000 matching documents cannot be split further; you get 2,000 of them and a free error row saying the list may be incomplete. For scale: 436 documents were published on the four publication days 13–16 Oct 2026. Reading 2,500 documents from a 40-day period took 7 seconds in 7 requests on 16 Oct 2026.
- The API has no OR between search words (a check on 16 Oct 2026 gave the same count for `A OR B` as for `A B`), which is why each keyword line is run as its own search.
- `abstract` is empty on many notices: 103 of those 436 documents had none (meeting notices and filings mostly). Abstracts are cut at a word near 500 characters; the cut is marked with `…` (134 of the 333 abstracts in that read). A sentence of an abstract that carries an e-mail address, a phone number or a "please contact / directed to" line is dropped (2 of 333).
- **No person fields.** The Actor never asks for signers, authors or contact points, and `agencies` are organisations. Titles are passed on exactly as the Federal Register publishes them, and titles and abstracts can mention people or companies by name when the document does.
- `commentsCloseDate` was filled on 133 of those 436 documents, `commentUrl` on 96. 92 had both, 41 had a deadline without a regulations.gov link (27 of them information-collection, Paperwork Reduction Act or Privacy Act notices) and 4 had a link without a deadline. `commentPeriodOpen` is calculated at the time of the run from `commentsCloseDate`, so it is `null` when there is no deadline. A few documents carry deadlines years ahead (one final rule in that read: 25 Nov 2028); they are passed on as published.
- `significant` comes from the rulemaking's entry in the Unified Agenda: 5 documents were `true`, 29 `false` and 402 `null` in that read, and 34 of the 84 rules and proposed rules had a flag. *Significant rules only* therefore returns the flagged rules and leaves out the documents without a flag.
- `docketIds` are the agency's own labels and the format varies (`Docket No. FDA-2022-N-2226`, `OMB Number 1105-0103`, `Release No. IC-36358`). 312 of the 436 documents had at least one, and 53 had a RIN. `cfrReferences` was filled on 84 (up to 16 parts on one document). `commentUrl` is the regulations.gov link exactly as the API returns it (`http://`).
- A few agency entries on federalregister.gov have no slug (for example "Office of the Secretary" under a department); they appear in `agencies` but not in `agencySlugs`.
- If the API is rate limiting, the Actor waits and retries twice. Requests are spaced 0.7 seconds apart. If it still gets no answer it adds a free error row, and the run is marked failed when nothing at all could be read. A topic slug the API does not know is answered with an error row that names the field.

If you also watch public procurement, see [EU Tenders Scraper (TED)](https://apify.com/northbell/eu-tenders-ted-search); for US vehicle safety recalls, see [NHTSA Vehicle Recalls](https://apify.com/northbell/nhtsa-vehicle-recalls).

### For AI agents

`{"documentTypes": ["proposed-rule"], "commentPeriodOpen": true, "agencies": ["EPA"], "maxResults": 5}` returns up to 5 open-for-comment EPA proposed rules, newest first, each with title, abstract, comment deadline, docket and the regulations.gov link. Rows have `type`: `document` or `error`. Fields that do not apply to a document are `null` (or an empty list), never missing. Schedule the same input daily with `"output": "new"` to get only what was published since the previous run.

# Actor input Schema

## `keywords` (type: `array`):

Words or phrases to find in the full text of the document. One per line; a document that matches any line is returned. Several words on one line must all appear, and a phrase in quotes is matched as written, e.g. "data breach". Each line is a separate search, so use up to 10 lines. Leave empty to skip.

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

Only documents from these agencies. One per line, as the agency's name, its abbreviation or its slug on federalregister.gov, e.g. Environmental Protection Agency, EPA or environmental-protection-agency. A document matches if it comes from any of them. Leave empty for every agency.

## `documentTypes` (type: `array`):

Only these kinds of documents. Leave empty for all four.

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

Only documents whose rulemaking the Federal Register marks as significant under Executive Order 12866. The flag comes from the regulation's entry in the Unified Agenda, so most notices have none and are left out when this is on.

## `cfrTitle` (type: `integer`):

Only documents that affect this title of the Code of Federal Regulations, e.g. 40 for environmental protection or 21 for food and drugs. Combine with the CFR part below to narrow it down.

## `cfrPart` (type: `string`):

A part of the CFR title above, e.g. 60, or a range such as 50-99. Needs the CFR title to be set.

## `topics` (type: `array`):

Topic slugs (the CFR indexing terms listed at federalregister.gov/topics), one per line, e.g. air-pollution-control or water-pollution-control. A document matches if it has any of them. A slug the Federal Register does not know ends the run with an error row that says so.

## `commentPeriodOpen` (type: `boolean`):

Only documents that invite comments and whose comment period has not closed yet (comment deadline today or later, by US Eastern date). When this is on and you set neither "Published since" nor "Published within", the Actor looks back 730 days, which covers open comment periods.

## `publishedSince` (type: `string`):

Only documents published on or after this date, written YYYY-MM-DD, e.g. 2026-10-01. Takes the place of "Published within". The Federal Register API starts in 1994.

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

Only documents published in the last N days, counting back from today. Leave empty for 7 days (730 days when "Comment period still open" is on). Ignored when "Published since" is set. Run it daily with 7 and "Only new" for a feed of fresh documents.

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

How many documents to return, newest first. You pay per document returned. With "Only new" the Actor reads past the documents you have already seen until it has found this many new ones. Narrow the search with the filters above rather than raising this.

## `output` (type: `string`):

With "Only new", documents you already got in an earlier run of the same search are skipped and not charged. The first run returns everything, because there is nothing to compare with yet.

## Actor input object example

```json
{
  "keywords": [
    "cybersecurity"
  ],
  "significantOnly": false,
  "commentPeriodOpen": false,
  "maxResults": 200,
  "output": "all"
}
```

# Actor output Schema

## `documents` (type: `string`):

Title, type, agencies, publication, effective and comment-close dates, docket, RIN and CFR references for each document.

# 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 = {
    "keywords": [
        "cybersecurity"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("northbell/federal-register-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 = { "keywords": ["cybersecurity"] }

# Run the Actor and wait for it to finish
run = client.actor("northbell/federal-register-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 '{
  "keywords": [
    "cybersecurity"
  ]
}' |
apify call northbell/federal-register-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,northbell/federal-register-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/kHIVUQ3MbXHgfEmUQ/builds/AyqXtM6i9ylj37ip8/openapi.json