# Federal Register Scraper | Daily US Rulemaking Notices (`parseforge/federalregister-scraper`) Actor

Extract structured data from the US Federal Register: rules, proposed rules, notices, and presidential documents. Filter by agency, document type, and publication date. Ideal for compliance teams, policy analysts, and legal researchers tracking US regulations.

- **URL**: https://apify.com/parseforge/federalregister-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** News, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📜 Federal Register Scraper

> 🚀 **Export every Federal Register document in seconds.** Final rules, proposed rules, notices, and presidential documents from the daily journal of the United States government.

> 🕒 **Last updated:** 2026-05-25 · **📊 10 fields** per record · **Full archive coverage** · **All federal agencies**

The Federal Register is the official daily publication for rules, proposed rules, and notices of federal agencies and organizations, as well as executive orders and other presidential documents. This scraper turns that firehose into structured data you can filter by agency, document type, search term, and publication date range.

Coverage includes every document published since 1994 across 400+ executive branch agencies and sub-agencies, including the EPA, FDA, FAA, SEC, Treasury, and the Executive Office of the President. Each record returns the document number, title, type, publication date, abstract, agency list, and direct links to the official HTML page and PDF.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Compliance teams, regulatory analysts, lobbyists, journalists, policy researchers, law firms | Tracking new rules, monitoring agency activity, building regulatory alerts, historical research, training LLMs on US regulations |

### 📋 What the Federal Register Scraper does

- Pulls daily and historical Federal Register documents via the official API
- Filters by document type (Final Rule, Proposed Rule, Notice, Presidential Document)
- Filters by agency slug, search term, and publication date range
- Returns abstract, agency list, publication date, and official PDF links
- Paginates automatically up to your requested maxItems

> 💡 **Why it matters:** Federal Register rules govern trillions of dollars of regulated activity. Catching a new proposed rule the day it drops is the difference between shaping policy and reacting to it.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Description</th></tr>
<tr><td>searchTerm</td><td>string</td><td>Free-text search across document content</td></tr>
<tr><td>maxItems</td><td>integer</td><td>How many records to return (free=10, paid up to 1M)</td></tr>
<tr><td>documentType</td><td>array</td><td>RULE / PRORULE / NOTICE / PRESDOCU</td></tr>
<tr><td>publicationDateGte</td><td>string</td><td>Earliest date YYYY-MM-DD</td></tr>
<tr><td>publicationDateLte</td><td>string</td><td>Latest date YYYY-MM-DD</td></tr>
<tr><td>agencySlugs</td><td>array</td><td>Agency slugs e.g. environmental-protection-agency</td></tr>
</table>

Example A. Newest 25 documents:
```json
{ "maxItems": 25 }
````

Example B. EPA proposed rules in 2025:

```json
{
  "documentType": ["PRORULE"],
  "agencySlugs": ["environmental-protection-agency"],
  "publicationDateGte": "2025-01-01",
  "publicationDateLte": "2025-12-31",
  "maxItems": 500
}
```

> ⚠️ **Good to Know:** The Federal Register API returns up to 10,000 documents per query. For larger date ranges, split into multiple runs by year or quarter.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 📄 documentNumber | string | Official Federal Register document number |
| 📌 title | string | Document title |
| 📑 type | string | Rule / Proposed Rule / Notice / Presidential Document |
| 🔗 url | string | Official federalregister.gov HTML page |
| 📅 publicationDate | string | Publication date |
| 🏛️ agencies | string | Semicolon-separated list of issuing agencies |
| 📝 abstract | string | Document abstract |
| 📕 pdfUrl | string | Official PDF on govinfo.gov |
| 🔍 publicInspectionPdfUrl | string | Public inspection PDF |
| 🕒 scrapedAt | string | ISO timestamp of collection |

Sample record:

```json
{
  "documentNumber": "2026-10400",
  "title": "Restoring Integrity to America's Financial System",
  "type": "Presidential Document",
  "url": "https://www.federalregister.gov/documents/2026/05/22/2026-10400/restoring-integrity-to-americas-financial-system",
  "publicationDate": "2026-05-22",
  "agencies": "Executive Office of the President",
  "abstract": null,
  "pdfUrl": "https://www.govinfo.gov/content/pkg/FR-2026-05-22/pdf/2026-10400.pdf"
}
```

### ✨ Why choose this Actor

- 🇺🇸 Official Federal Register API source, full coverage 1994 to present
- 🎯 Filter by agency, type, date, and free-text in one call
- 📦 Export to CSV, Excel, JSON, or XML
- 🔄 Cloud-based, schedule daily for new rule alerts

### 📈 How it compares to alternatives

| Approach | Result |
|---|---|
| Manual federalregister.gov browsing | Slow, no bulk export |
| Email alerts | One agency at a time, no structured data |
| Building your own API client | Days of work plus pagination, rate limit, error handling |
| This Actor | One-click structured export with filters |

### 🚀 How to use

1. [Create a free Apify account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. Open this Actor
3. Set your filters and maxItems
4. Click Start
5. Download CSV, Excel, JSON, or XML from the dataset

### 💼 Business use cases

**Compliance and legal**: monitor proposed rules in your industry before they take effect.
**Government affairs**: feed new agency notices into your tracking dashboards.
**Journalism**: catch federal actions on the day they publish.
**LLM training**: build a clean corpus of US regulatory text.

### 🔌 Automating Federal Register Scraper

Connect to Make, Zapier, Slack, Airbyte, GitHub Actions, Google Drive, or any tool via the Apify API and webhooks. Schedule daily runs to be notified of every new Federal Register document.

### 🌟 Beyond business use cases

**Research**: longitudinal studies of US regulatory activity.
**Personal**: track rules affecting your hobby or trade.
**Non-profit**: monitor agency notices relevant to your mission.
**Experimentation**: train classifiers on regulatory text.

### 🤖 Ask an AI assistant about this scraper

Paste this README into ChatGPT, Claude, Perplexity, or Copilot and ask how to use the scraper for your specific workflow.

### ❓ Frequently Asked Questions

**Q: 📅 How current is the data?**
A: New documents appear in the API the morning of publication.

**Q: 📦 What formats can I export?**
A: CSV, Excel, JSON, XML directly from the Apify dataset UI.

**Q: 🔍 Can I search inside document text?**
A: Yes, the searchTerm field runs a full-text search on the Federal Register index.

**Q: 🏛️ Can I filter by multiple agencies?**
A: Yes, pass an array of agency slugs.

**Q: 📅 How far back does it go?**
A: All Federal Register documents published since 1994.

**Q: 🆔 What is a document number?**
A: The unique identifier assigned by the Office of the Federal Register, e.g. 2026-10400.

**Q: 📕 Are PDFs included?**
A: Direct PDF links are included. The PDFs themselves are hosted on govinfo.gov.

**Q: 🔒 Is the data official?**
A: Yes, every record comes from the official Federal Register API.

**Q: 💰 What does it cost?**
A: Free users get 10 items. Paid users get up to 1,000,000 per run.

**Q: ⏰ Can I schedule daily runs?**
A: Yes, use Apify scheduling for daily, weekly, or hourly runs.

### 🔌 Integrate with any app

Make, Zapier, n8n, Slack, Airbyte, GitHub Actions, Google Drive, Google Sheets, BigQuery, S3, webhooks, REST API.

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| Congress.gov Bills Scraper | US legislative bills, votes, sponsors |
| GAO Reports Scraper | Government Accountability Office reports |
| DOJ Press Releases Scraper | Department of Justice press releases |
| FCC Broadband Map Scraper | FCC broadband coverage by address |
| SAM.gov Entities Scraper | Federal contractor registry |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more government data scrapers.

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** Independent tool, not affiliated with the Office of the Federal Register or any US federal agency. Only publicly available data is collected.

# Actor input Schema

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

Free-text search across Federal Register documents. Leave empty to return newest documents.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

## `documentType` (type: `array`):

Filter by document type. Leave empty for all types.

## `publicationDateGte` (type: `string`):

Earliest publication date (YYYY-MM-DD). Leave empty for no lower bound.

## `publicationDateLte` (type: `string`):

Latest publication date (YYYY-MM-DD). Leave empty for today.

## `agencySlugs` (type: `array`):

Filter by agency slugs (e.g. environmental-protection-agency, federal-aviation-administration). See federalregister.gov/agencies.

## Actor input object example

```json
{
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/federalregister-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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/federalregister-scraper").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 '{
  "maxItems": 10
}' |
apify call parseforge/federalregister-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Federal Register Scraper | Daily US Rulemaking Notices",
        "description": "Extract structured data from the US Federal Register: rules, proposed rules, notices, and presidential documents. Filter by agency, document type, and publication date. Ideal for compliance teams, policy analysts, and legal researchers tracking US regulations.",
        "version": "0.1",
        "x-build-id": "8X6W9Ag14wRBdalds"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~federalregister-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-federalregister-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~federalregister-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-federalregister-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~federalregister-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-federalregister-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Free-text search across Federal Register documents. Leave empty to return newest documents."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "documentType": {
                        "title": "Document Type",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by document type. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RULE",
                                "PRORULE",
                                "NOTICE",
                                "PRESDOCU"
                            ],
                            "enumTitles": [
                                "Final Rule",
                                "Proposed Rule",
                                "Notice",
                                "Presidential Document"
                            ]
                        }
                    },
                    "publicationDateGte": {
                        "title": "Published On or After",
                        "type": "string",
                        "description": "Earliest publication date (YYYY-MM-DD). Leave empty for no lower bound."
                    },
                    "publicationDateLte": {
                        "title": "Published On or Before",
                        "type": "string",
                        "description": "Latest publication date (YYYY-MM-DD). Leave empty for today."
                    },
                    "agencySlugs": {
                        "title": "Agency Slugs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter by agency slugs (e.g. environmental-protection-agency, federal-aviation-administration). See federalregister.gov/agencies.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```