# Federal Register Scraper — US Regulations & Notices (`hipersoft/federal-register-scraper`) Actor

Search and export US Federal Register documents in bulk: final rules, proposed rules, agency notices and White House executive documents. Filter by term, document type, agency and publication date. One clean row per document with citation, dockets and links.

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

## Pricing

from $0.0005 / document scraped

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?

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 — US Regulations & Notices

Search and export the **US Federal Register** into clean **JSON, CSV, Excel or XML**. Pull **final rules**, **proposed rules**, **notices** and **presidential documents** in bulk — filtered by search term, document type, issuing agency and publication date — and get one structured row per document with its title, abstract, citation, docket numbers and direct links to the official HTML and PDF.

Built for compliance teams, legal researchers, policy analysts and data pipelines that need the daily journal of the US federal government as a structured dataset instead of clicking through the Federal Register website page by page.

### What does the Federal Register Scraper do?

Enter a **search term**, optionally narrow by **document type**, **agencies** and a **publication date range**, and the actor paginates through the Federal Register and returns one clean row per document:

- **Rules & proposed rules** — track regulations as they are proposed and finalized.
- **Notices** — meetings, hearings, information collections and agency announcements.
- **Presidential documents** — executive orders, proclamations and determinations, with the signing president.

Every row includes the official `htmlUrl` and `pdfUrl`, the Federal Register `citation`, and any associated `docketIds`.

### What data can you get?

| Field | Type | Description |
| --- | --- | --- |
| `documentNumber` | string | Unique Federal Register document number (e.g. `2026-17843`). |
| `title` | string | Document title. |
| `type` | string | Document type: `Rule`, `Proposed Rule`, `Notice` or `Presidential Document`. |
| `abstract` | string | Short summary of the document, where published. |
| `agencies` | array | Issuing agency name(s). |
| `publicationDate` | string | Date the document was published (YYYY-MM-DD). |
| `effectiveOn` | string | Date the document takes effect, where applicable. |
| `htmlUrl` | string (URL) | Link to the official document page on the Federal Register. |
| `pdfUrl` | string (URL) | Link to the official PDF. |
| `citation` | string | Federal Register citation (e.g. `91 FR 55995`). |
| `docketIds` | array | Associated docket identifiers, where present. |
| `president` | string | Signing president (presidential documents only). |

### Use cases

- **Regulatory monitoring** — watch a term or an agency and capture every new rule and notice on a schedule.
- **Compliance & legal research** — assemble a dated, citable record of rules affecting an industry.
- **Policy analysis** — build datasets of proposed vs. final rules across agencies and time.
- **Executive action tracking** — collect presidential documents with their citations and PDFs.
- **Alerting & dashboards** — feed structured document records into your own tools and reports.

### How to use it

1. Add the Federal Register Scraper to your Apify account and open the input form.
2. Enter a **Search term** (e.g. `artificial intelligence`).
3. Optionally pick a **Document type**, add **agency slugs**, and set a **publication date range**.
4. Set **Max items** to cap the export, then **Run**.
5. **Export** the dataset as JSON, CSV, Excel or XML, or pull it through the Apify API.

### Input

```json
{
  "term": "artificial intelligence",
  "documentType": "RULE",
  "agencies": ["environmental-protection-agency"],
  "publicationDateGte": "2026-01-01",
  "publicationDateLte": "2026-08-31",
  "maxItems": 200
}
```

| Field | Type | Description |
| --- | --- | --- |
| `term` | string | Full-text search query. Empty = browse all documents by date. |
| `documentType` | string | One of `RULE`, `PRORULE`, `NOTICE`, `PRESDOCU`. Empty = all types. |
| `agencies` | array | Federal Register agency slugs (e.g. `securities-and-exchange-commission`). Empty = all. |
| `publicationDateGte` | string | Only documents published on or after this date (YYYY-MM-DD). |
| `publicationDateLte` | string | Only documents published on or before this date (YYYY-MM-DD). |
| `maxItems` | integer | Maximum documents to return, newest first (default 100). |

### Output

```json
{
  "documentNumber": "2026-17843",
  "title": "Declaring a National Emergency To Secure the United States Bulk-Power System",
  "type": "Presidential Document",
  "abstract": null,
  "agencies": ["Executive Office of the President"],
  "publicationDate": "2026-08-31",
  "effectiveOn": null,
  "htmlUrl": "https://www.federalregister.gov/documents/2026/08/31/2026-17843/declaring-a-national-emergency-to-secure-the-united-states-bulk-power-system",
  "pdfUrl": "https://www.govinfo.gov/content/pkg/FR-2026-08-31/pdf/2026-17843.pdf",
  "citation": "91 FR 55995",
  "docketIds": [],
  "president": "Donald Trump"
}
```

### FAQ

**What is the Federal Register?**
The Federal Register is the official daily journal of the US federal government. It publishes proposed and final regulations, agency notices, and presidential documents such as executive orders and proclamations.

**How do I find an agency slug?**
Use the agency's slug as it appears in Federal Register URLs — for example `environmental-protection-agency` or `securities-and-exchange-commission`. Leave the field empty to include every agency.

**How many documents can I get?**
As many as your search returns. Use **Max items** to cap a run and keep it cheap; results come back newest first.

**How does billing work?**
You pay only per document you get, so small, tightly filtered runs stay inexpensive.

**What export formats are supported?**
JSON, CSV, Excel and XML, plus direct access via the Apify API.

**Can I use this with n8n?**
Yes. Run the Federal Register Scraper from n8n with the [Apify node](https://n8n.io/integrations/apify/) — trigger a run, wait for it to finish, and read the dataset items straight into your workflow to drive compliance alerts, enrich records or update a database. It also works with [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier) and the [Apify API](https://docs.apify.com/api/v2).

**Can I connect this to other tools?**
The Federal Register Scraper connects with almost any cloud service or web app through [integrations on the Apify platform](https://apify.com/integrations) — [Make](https://apify.com/integrations/make), [Zapier](https://apify.com/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), [Google Drive](https://docs.apify.com/platform/integrations/drive) and [many more](https://apify.com/integrations), plus [webhooks](https://docs.apify.com/platform/integrations/webhooks) to trigger an action whenever a run finishes.

**Is this only public data?**
Yes. It returns only openly published US government documents from the Federal Register. You are responsible for compliant use.

### Notes

Original clean-room implementation. Not affiliated with the Office of the Federal Register, the National Archives and Records Administration, or the US government. All document data is public record.

# Actor input Schema

## `term` (type: `string`):

Full-text query to search Federal Register documents (e.g. "artificial intelligence", "clean water"). Leave empty to browse all documents by date.

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

Restrict to a single document type. RULE = final rule, PRORULE = proposed rule, NOTICE = notice, PRESDOCU = presidential document. Leave empty for all types.

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

Only include documents from these agencies, given as Federal Register agency slugs (e.g. "environmental-protection-agency", "securities-and-exchange-commission"), one per line. Empty = all agencies.

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

Only include documents published on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

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

Only include documents published on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

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

Maximum number of documents to return, newest first.

## Actor input object example

```json
{
  "term": "artificial intelligence",
  "documentType": "",
  "agencies": [],
  "maxItems": 100
}
```

# Actor output Schema

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

The scraped documents as dataset items.

# 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 = {
    "term": "artificial intelligence",
    "agencies": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("hipersoft/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 = {
    "term": "artificial intelligence",
    "agencies": [],
}

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

```

## MCP server setup

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