# Federal Register Scraper - Archived Original (`reapx/federal-register-archive`) Actor

Scrape rules, proposed rules, notices and presidential documents from the Federal Register API. Filter by agency, type, date, docket, RIN, CFR part or comment deadline. No key, no browser.

- **URL**: https://apify.com/reapx/federal-register-archive.md
- **Developed by:** [Tarek Etman](https://apify.com/reapx) (community)
- **Categories:** Developer tools, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 1,000 document returneds

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/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

## Federal Register Scraper — Rules, Notices & Agency Documents

Scrape the **Federal Register** — every final rule, proposed rule, notice and presidential
document published by US federal agencies — straight from the official Federal Register API.
No API key, no login, no headless browser. Run it empty and you get the newest documents;
add filters and you get exactly the slice of the regulatory record you care about.

Coverage runs back to **1994**, across **472 agencies**, with every document addressed by its
permanent Federal Register document number.

### Quick Start: Run in 1 Line

#### Python (using `reapx` SDK)

```python
import os, reapx
os.environ["APIFY_TOKEN"] = "usr_your_apify_token" # Free $5 monthly credit included
results = reapx.live("federal-register-scraper", {"searchTerm": "artificial intelligence"})
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/reapx~federal-register-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
     -H "Content-Type: application/json" \
     -d '{"searchTerm": "artificial intelligence", "maxDocuments": 20}'
```

### What this Federal Register scraper returns

One row per document:

| Field | What it gives you |
| --- | --- |
| `documentNumber`, `title`, `htmlUrl`, `pdfUrl` | The document and permanent links to it |
| `documentTypeLabel`, `subtype` | Final rule, proposed rule, notice or presidential document |
| `agencyNames`, `agencySlugs`, `topics` | Who issued it and what it is about |
| `publicationDate`, `effectiveOn`, `signingDate` | When it published, takes effect, was signed |
| `commentsCloseOn`, `commentsOpen`, `daysUntilCommentsClose`, `commentUrl` | The comment window and where to file |
| `significant` | Flagged under Executive Order 12866 as economically material |
| `docketIds`, `regulationIdNumbers`, `cfrReferences` | Docket, RIN and the CFR parts it touches |
| `citation`, `volume`, `startPage`, `endPage`, `pageLength` | Formal citation and how long it runs |
| `abstract`, `action`, `fullText` | The summary, the action line, and optionally the whole body |

Five named dataset views ship with it: **Documents**, **Open rulemaking**, **Effective dates**,
**Presidential documents** and **Citations & pages**.

### How to scrape the Federal Register

1. Run it with **no input at all** — you get the 100 newest documents.
2. Narrow by **agency** (`environmental-protection-agency`), **document type**, or a **search term**.
3. Add a **date window**, a **CFR part**, a **docket ID** or a **RIN** to target one rulemaking.
4. Set **Max documents**. You are charged once per document returned, so that is your cost cap.

### Filters

- **Search term** — full text across title, abstract and body
- **Document types** — final rule, proposed rule, notice, presidential document
- **Agencies** — any of the 472 agency slugs, several at once
- **Subject sections** — money, business and industry, environment, health and public welfare, science and technology, world
- **Published / effective date windows**, or a rolling "last N days"
- **Open for public comment only** and **comments close before** — the actionable docket
- **Significant regulatory actions only** — EO 12866
- **CFR title and part**, **docket ID**, **regulation ID number (RIN)**
- **Presidential document types** and **presidents** — executive orders, proclamations, memoranda

### What you can build with it

- **Regulatory monitoring** — run daily filtered to your agencies and diff by `documentNumber`.
- **Comment-deadline tracking** — `openForCommentOnly` plus `daysUntilCommentsClose` is a live docket calendar.
- **Compliance calendars** — `effectiveFrom` gives you every rule coming into force in a window.
- **Rulemaking histories** — one RIN returns every document in that rulemaking, in order.
- **Executive order archives** — all presidential documents by president or by type.
- **Policy datasets for LLMs and RAG** — `includeFullText` gives clean plain text with a citation.

### Pricing

Pay per event: **$0.002 per document returned**, with automatic discounts on every Apify plan
tier (Bronze through Diamond). Nothing else is billed to you — no separate platform-usage line.

You are charged **only** for complete document rows written to the dataset. A filter combination
the API rejects, an unreachable API, and a query that matches nothing all cost **zero**. Set
**Max total charge** on the run to cap spend; the actor checks that cap before it starts and
stops cleanly the moment it is reached.

### Input example

```json
{
  "documentTypes": ["PRORULE"],
  "agencies": ["environmental-protection-agency"],
  "openForCommentOnly": true,
  "maxDocuments": 200
}
```

### Output example

```json
{
  "documentNumber": "2026-15372",
  "title": "Air Plan Approval; Pennsylvania; Redesignation of the Warren Area",
  "documentType": "Proposed Rule",
  "documentTypeLabel": "Proposed rule",
  "abstract": "EPA is approving a state implementation plan revision submitted by Pennsylvania.",
  "action": "Proposed rule.",
  "agencyNames": ["Environmental Protection Agency"],
  "agencySlugs": ["environmental-protection-agency"],
  "topics": ["Air pollution control", "Ozone"],
  "publicationDate": "2026-08-03",
  "effectiveOn": null,
  "commentsCloseOn": "2026-08-31",
  "commentsOpen": true,
  "daysUntilCommentsClose": 28,
  "significant": false,
  "citation": "91 FR 37155",
  "docketIds": ["EPA-R03-OAR-2025-0321"],
  "regulationIdNumbers": [],
  "cfrReferences": ["40 CFR 52"],
  "htmlUrl": "https://www.federalregister.gov/documents/2026/08/03/2026-15372/air-plan-approval-pennsylvania",
  "daysSincePublication": 0,
  "scrapedAt": "2026-08-03T09:15:00Z"
}
```

### FAQ

#### How do I scrape the Federal Register?

Run this actor with no input and it returns the newest documents. Everything comes from the
official Federal Register API at `federalregister.gov/api/v1`, which is public and needs no key.

#### Do I need an API key or an account?

No. The Federal Register API is open. There is no authentication step and no private data
involved.

#### How do I find all documents from one agency?

Put the agency slug into **Agencies** — `environmental-protection-agency`,
`food-and-drug-administration`, `securities-and-exchange-commission`. The full list of 472 slugs
is at `federalregister.gov/api/v1/agencies.json`, and every row this actor returns carries
`agencySlugs` you can feed straight back in.

#### How do I track public comment deadlines?

Turn on **Open for public comment only**. Every row then carries `commentsCloseOn`,
`daysUntilCommentsClose` and, where the agency published one, a `commentUrl` for filing.

#### How far back does the data go?

To 1994. Set **Published from** to any date in that range, or sort **oldest first** to walk
forward from the beginning.

#### How do I follow a single rulemaking from proposal to final rule?

Use the **Regulation ID number (RIN)**. One RIN returns every document in that rulemaking across
its whole life. A **Docket ID** does the same for the agency's own docket numbering.

#### What is a "significant" regulatory action?

A document flagged under Executive Order 12866, broadly the economically material ones. Turn on
**Significant regulatory actions only** to keep just those.

#### Can I get the full text of each document, not just the abstract?

Yes — turn on **Include the full document text**. It adds a `fullText` column with the complete
plain-text body up to 40,000 characters. It costs one extra request per document, so large runs
take longer, but the price per document does not change.

#### How many documents can one run return?

Up to 10,000 per query, which is the API's own ceiling for a single filter set. Narrow the date
window and run again to walk past it.

#### Can an AI agent call this actor?

Yes. Every input and output field carries a title, description and example, and every row is
addressed by its `documentNumber`, so an agent can fill the input and chain the output without
extra prompting.

***

Unofficial - not affiliated with the Federal Register. Collects public data only. reapx.
Contact reapxdev@proton.me.

# Actor input Schema

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

Full-text search across the document title, abstract and body. Leave empty to match every document.

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

Limit to certain kinds of document. Leave empty for all four.

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

Agency slugs as the Federal Register spells them, e.g. environmental-protection-agency, food-and-drug-administration, securities-and-exchange-commission. The full list is at federalregister.gov/api/v1/agencies.json.

## `sections` (type: `array`):

The Federal Register's own top-level subject grouping.

## `maxDocuments` (type: `integer`):

Hard cap on how many documents the run returns. This is also your cost cap: you are charged once per document returned.

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

Which documents you get when the cap is smaller than the match count.

## `publishedLastDays` (type: `integer`):

Rolling publication window. Ignored if you set an explicit "Published from" date.

## `publishedFrom` (type: `string`):

Earliest publication date, YYYY-MM-DD.

## `publishedTo` (type: `string`):

Latest publication date, YYYY-MM-DD.

## `effectiveFrom` (type: `string`):

Earliest date a rule takes effect, YYYY-MM-DD. Use it to find regulation coming into force.

## `effectiveTo` (type: `string`):

Latest date a rule takes effect, YYYY-MM-DD.

## `effectiveNextDays` (type: `integer`):

Rolling forward window on the effective date — rules coming into force between today and N days from now. Stays correct as time passes, unlike a fixed date.

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

Keep only documents whose comment period has not closed yet — the actionable rulemaking docket.

## `commentsCloseBefore` (type: `string`):

Latest comment deadline, YYYY-MM-DD. Combine with "Open for public comment only" to get deadlines inside a window.

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

Keep only documents flagged significant under Executive Order 12866 — the economically material ones.

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

Code of Federal Regulations title number, e.g. 40 for Protection of Environment, 21 for Food and Drugs.

## `cfrPart` (type: `integer`):

Part number inside that CFR title. Requires a CFR title to be set.

## `docketId` (type: `string`):

Agency docket identifier exactly as the agency writes it, e.g. FDA-2026-N-2886.

## `regulationIdNumber` (type: `string`):

Unified Agenda RIN, which tracks one rulemaking across all its documents.

## `presidentialDocumentTypes` (type: `array`):

Only meaningful together with the Presidential document type.

## `presidents` (type: `array`):

President slugs, e.g. donald-trump, joe-biden, barack-obama, william-j-clinton, george-w-bush.

## `includeFullText` (type: `boolean`):

Fetch the complete plain-text body of every document, capped at 40,000 characters. Costs one extra request per document, so a large run takes noticeably longer.

## Actor input object example

```json
{
  "searchTerm": "artificial intelligence",
  "documentTypes": [
    "RULE",
    "PRORULE"
  ],
  "agencies": [
    "environmental-protection-agency",
    "food-and-drug-administration"
  ],
  "sections": [
    "environment"
  ],
  "maxDocuments": 100,
  "sortBy": "newest",
  "publishedLastDays": 7,
  "publishedFrom": "2026-01-01",
  "publishedTo": "2026-12-31",
  "effectiveFrom": "2026-09-01",
  "effectiveTo": "2026-12-31",
  "effectiveNextDays": 90,
  "openForCommentOnly": true,
  "commentsCloseBefore": "2026-09-30",
  "significantOnly": true,
  "cfrTitle": 40,
  "cfrPart": 60,
  "docketId": "FDA-2026-N-2886",
  "regulationIdNumber": "2060-AV50",
  "presidentialDocumentTypes": [
    "executive_order"
  ],
  "presidents": [
    "donald-trump"
  ],
  "includeFullText": true
}
```

# Actor output Schema

## `items` (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 = {
    "maxDocuments": 100,
    "sortBy": "newest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("reapx/federal-register-archive").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 = {
    "maxDocuments": 100,
    "sortBy": "newest",
}

# Run the Actor and wait for it to finish
run = client.actor("reapx/federal-register-archive").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 '{
  "maxDocuments": 100,
  "sortBy": "newest"
}' |
apify call reapx/federal-register-archive --silent --output-dataset

```

## MCP server setup

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

```

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/ZmVJiWQ6HGNQkNkhd/builds/Sd1UspgriNI6Xexaw/openapi.json