# Federal Register Scraper (`automation-lab/federal-register-rules-notices`) Actor

Search official Federal Register rules, proposed rules, notices, and presidential documents with agency, docket, date, CFR, RIN, abstract, and source-link metadata.

- **URL**: https://apify.com/automation-lab/federal-register-rules-notices.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.53 / 1,000 federal register document extracteds

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

Search and export official **Federal Register** rules, proposed rules, notices, and presidential documents as clean dataset records. Filter documents by keyword, agency, type, publication date, comment deadline, or exact document number, then collect abstracts, docket references, RINs, CFR citations, important dates, and official source links.

The Actor uses the anonymous FederalRegister.gov API. It adds validated inputs, pagination, detail enrichment, deduplication, Apify scheduling, exports, webhooks, API access, and MCP access without requiring a browser, proxy, or source account.

### What can this Federal Register scraper do?

- Search rules, proposed rules, notices, and presidential documents by topic.
- Limit results to one or more FederalRegister.gov agency slugs.
- Filter publication dates and public-comment closing dates.
- Retrieve exact Federal Register document numbers.
- Sort search results by newest, oldest, or relevance.
- Enrich each result with docket IDs, Regulation Identifier Numbers, CFR references, topics, actions, dates, and official text links.
- Save an exact maximum number of unique documents.
- Export JSON, CSV, Excel, XML, RSS, or JSONL from the default dataset.
- Run on a schedule for regulatory monitoring workflows.

### Who is it for?

**Regulatory affairs teams** can collect new rules and proposed rules by agency or subject.

**Legal and compliance researchers** can create source-backed datasets with citations, dockets, effective dates, and comment deadlines.

**Policy analysts and journalists** can search abstracts and official metadata without maintaining Federal Register API pagination code.

**Government-relations teams** can schedule recurring searches and compare stable document numbers between runs.

**Developers and data teams** can feed normalized records into databases, dashboards, spreadsheets, LLM workflows, or alerting systems.

### Why use this Actor instead of calling the Federal Register API directly?

FederalRegister.gov already provides an excellent public API. This Actor packages that source into a reusable product with an input form, strict validation, bounded retries, pagination, optional detail requests, normalized output, usage-based charging, datasets, schedules, webhooks, and integrations.

Every result keeps official identifiers and URLs. The Actor does not scrape visual page markup or hide the data source.

### What Federal Register data is extracted?

| Field | Description |
| --- | --- |
| `title`, `abstract`, `action` | Official title, abstract, and action statement |
| `documentNumber` | Stable Federal Register document number |
| `documentType`, `subtype` | Rule, proposed rule, notice, or presidential document classification |
| `publicationDate` | Date published in the Federal Register |
| `effectiveDate` | Effective date when supplied |
| `commentsCloseDate` | Public-comment deadline when supplied |
| `datesText`, `signingDate` | Official dates narrative and signing date |
| `agencies`, `agencyNames` | Structured issuing-agency metadata |
| `topics` | FederalRegister.gov indexed topics |
| `docketIds`, `dockets` | Docket references and structured docket metadata |
| `regulationIds` | Regulation Identifier Numbers (RINs) |
| `cfrReferences`, `citation` | CFR references and Federal Register citation |
| `executiveOrderNumber` | Executive order number when applicable |
| `htmlUrl`, `pdfUrl` | Official HTML and PDF links |
| `jsonUrl`, `rawTextUrl`, `fullTextXmlUrl` | Official machine-readable source links |
| `regulationsGovUrl`, `commentUrl` | Related Regulations.gov and comment links when available |
| `sourceUrl`, `scrapedAt` | API provenance and collection timestamp |

Fields are omitted when the official source does not provide them. Arrays remain empty when no agency, topic, docket, RIN, or CFR reference is present.

### How to search Federal Register rules and notices

1. Open the Actor input page.
2. Enter a topic such as `artificial intelligence`.
3. Select the document types you need.
4. Add agency slugs or date bounds if required.
5. Keep **Fetch full metadata** enabled for docket, RIN, CFR, topic, and official-text details.
6. Set a small `maxItems` value for your first run.
7. Start the run and open the default dataset.

Example input:

```json
{
  "searchTerm": "artificial intelligence",
  "documentTypes": ["RULE", "PRORULE", "NOTICE"],
  "sortBy": "newest",
  "includeDetails": true,
  "maxItems": 25
}
```

### Input parameters

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `searchTerm` | string | — | Topic or words searched in Federal Register documents. |
| `agencySlugs` | string\[] | `[]` | FederalRegister.gov slugs such as `environmental-protection-agency`. |
| `documentTypes` | string\[] | rules, proposed rules, notices | Any of `RULE`, `PRORULE`, `NOTICE`, or `PRESDOCU`. |
| `publicationDateFrom` | date | — | Earliest publication date in `YYYY-MM-DD` format. |
| `publicationDateTo` | date | — | Latest publication date in `YYYY-MM-DD` format. |
| `commentDateFrom` | date | — | Earliest public-comment closing date. |
| `commentDateTo` | date | — | Latest public-comment closing date. |
| `documentNumbers` | string\[] | `[]` | Exact source document numbers. Other supplied filters still apply. |
| `sortBy` | string | `newest` | `newest`, `oldest`, or `relevance`. |
| `includeDetails` | boolean | `true` | Request full document metadata for each search result. |
| `maxItems` | integer | `100` | Maximum unique saved records, from 1 to 10,000. |

When `documentNumbers` is supplied, the Actor retrieves those documents directly instead of running a search. All agency, type, topic, and date filters still apply to direct results.

### Output example

A real result has this shape (abbreviated):

```json
{
  "title": "Request for Information on the Development of an Artificial Intelligence Action Plan",
  "documentNumber": "2025-02305",
  "documentType": "Notice",
  "publicationDate": "2025-02-06",
  "agencies": [
    {
      "name": "Executive Office of the President",
      "slug": "executive-office-of-the-president"
    }
  ],
  "agencyNames": ["Executive Office of the President"],
  "topics": [],
  "docketIds": [],
  "regulationIds": [],
  "cfrReferences": [],
  "htmlUrl": "https://www.federalregister.gov/documents/2025/02/06/2025-02305/request-for-information-on-the-development-of-an-artificial-intelligence-action-plan",
  "jsonUrl": "https://www.federalregister.gov/api/v1/documents/2025-02305.json",
  "sourceUrl": "https://www.federalregister.gov/api/v1/documents/2025-02305.json",
  "scrapedAt": "2026-08-28T20:00:00.000Z"
}
```

The exact record content is controlled by the official source and can change when FederalRegister.gov updates metadata.

### How much does it cost to export Federal Register documents?

Pricing uses one small start event plus one `item` event for every accepted dataset record. Duplicate, rejected, empty, or failed records are not charged as items.

The exact tier applying to your account is shown by Apify before a run. At the current Bronze configuration, the start fee is **$0.005** and each accepted document is **$0.002544**. That makes 25 documents about **$0.0686**, 100 documents about **$0.2594**, and 1,000 documents about **$2.549** in Actor charges. Higher usage tiers have lower per-document prices.

Apify platform usage is included in pay-per-event pricing. The upstream Federal Register API does not require a paid key.

### Agency and document-type workflows

Use agency slugs exactly as FederalRegister.gov identifies them. For example:

```json
{
  "agencySlugs": ["environmental-protection-agency"],
  "documentTypes": ["RULE", "PRORULE"],
  "publicationDateFrom": "2025-01-01",
  "publicationDateTo": "2025-12-31",
  "maxItems": 100
}
```

For open-comment research, combine proposed rules or notices with `commentDateFrom` and `commentDateTo`. Some documents do not have a comment deadline; those records are correctly excluded when a comment-date filter is active.

### Exact document lookup

Use stable document numbers when another system already knows the records to retrieve:

```json
{
  "documentNumbers": ["2025-02305"],
  "includeDetails": true,
  "maxItems": 1
}
```

Exact lookup is useful for enrichment, verification, and repeatable source citations. A mismatching topic, agency, type, or date filter can intentionally produce an empty dataset.

### Scheduling and regulatory monitoring

Save a tested input as an Apify Task and schedule it daily, weekly, or monthly. Use `documentNumber` as the stable key when comparing datasets across runs. Send a webhook after successful runs to trigger a database load, spreadsheet update, Slack workflow, or internal alert.

The Actor exports snapshots. It does not itself calculate changes, continuously watch the source, or send legal alerts. Your downstream workflow should compare datasets and decide which changes matter.

### Use from the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~federal-register-rules-notices/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerm":"clean energy","documentTypes":["RULE","PRORULE"],"maxItems":25}'
```

Poll the returned run ID or configure a webhook before production use. Keep your Apify token in an environment variable or secret manager.

### Use from JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/federal-register-rules-notices').call({
  searchTerm: 'artificial intelligence',
  documentTypes: ['RULE', 'PRORULE', 'NOTICE'],
  includeDetails: true,
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use from Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/federal-register-rules-notices').call(run_input={
    'agencySlugs': ['environmental-protection-agency'],
    'documentTypes': ['RULE', 'PRORULE'],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with MCP and AI assistants

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/federal-register-rules-notices"
```

For Claude Desktop, Cursor, or VS Code, use:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/federal-register-rules-notices"
    }
  }
}
```

Example prompts:

- “Search Federal Register proposed rules about artificial intelligence and summarize agency, docket, and comment deadlines.”
- “Export 2025 EPA final rules and return document numbers, effective dates, CFR references, and official URLs.”
- “Retrieve Federal Register document 2025-02305 and cite its official HTML and PDF sources.”

### Reliability, retries, and source limits

The Actor requests the official JSON API directly. HTTP 429 and 5xx responses are retried up to three times with bounded exponential backoff. Permanent API errors fail the run instead of silently producing incomplete output.

Search pages contain up to 100 records. Detail enrichment runs at bounded concurrency. `maxItems` stops accepted output at the requested count, up to 10,000.

FederalRegister.gov controls availability, coverage, indexing, field definitions, and freshness. A successful query with no matching documents produces an empty dataset. The Actor does not bypass source restrictions or enrich records from private systems.

Disable `includeDetails` only when faster list-level metadata is sufficient. Dockets, RINs, CFR references, topics, action text, and machine-readable links may require detail enrichment.

### Responsible use and legal considerations

Federal Register documents are official public U.S. government records. Use the data responsibly, retain source URLs for auditability, and verify consequential conclusions against the official document text.

This Actor is a retrieval and normalization tool, not legal advice. A missing or delayed source record does not prove that no regulatory action exists. Respect Apify terms, FederalRegister.gov policies, applicable laws, and your organization's retention and compliance requirements.

### Troubleshooting

**The dataset is empty.** Remove filters one at a time. Confirm agency slugs, date order, document types, and exact document numbers. Comment-date filters intentionally reject documents without a matching closing date.

**The run reports an invalid date.** Use complete dates in `YYYY-MM-DD` format and ensure each “from” date is not later than its “to” date.

**The run fails with 429 or 5xx.** The Actor retries transient failures. If the source remains unavailable, wait before rerunning rather than starting repeated parallel jobs.

**Some enriched fields are empty.** The official source does not provide every field for every document. Keep `includeDetails` enabled for the richest available metadata.

### Related Automation Lab actors

- [Grants.gov Funding Opportunities Scraper](https://apify.com/automation-lab/grants-gov-funding-opportunities-scraper) for federal grant opportunity monitoring.
- [NIST NVD CVE Vulnerability Records](https://apify.com/automation-lab/nist-nvd-cve-vulnerability-records) for official vulnerability-intelligence datasets.
- [Federal Audit Clearinghouse Scraper](https://apify.com/automation-lab/federal-audit-clearinghouse-scraper) for federal single-audit submissions and findings.

### FAQ

#### Does the Actor require a FederalRegister.gov API key?

No. It uses public anonymous FederalRegister.gov API endpoints.

#### Does it download full document text?

It exports official HTML, PDF, raw-text, and XML links when available. It does not download and embed entire PDF or XML bodies in each dataset row.

#### Can it monitor executive orders?

Yes. Include `PRESDOCU` in `documentTypes`, optionally add a keyword, and schedule the input. Presidential-document records can include `executiveOrderNumber` when the source provides it.

#### Can I filter by topic and agency together?

Yes. Search, agency, type, publication-date, and comment-date filters can be combined. Every accepted row must satisfy the supplied filters.

#### How do I avoid duplicate records?

The Actor deduplicates by `documentNumber` within each run. For recurring monitoring, compare that stable field across run datasets.

#### Is this an official Federal Register product?

No. This is an independent Apify Actor that retrieves public official data from FederalRegister.gov and preserves links back to the source.

# Actor input Schema

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

Words to find in Federal Register documents, such as artificial intelligence or clean energy.

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

FederalRegister.gov agency slugs, such as environmental-protection-agency.

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

Limit results to final rules, proposed rules, notices, or presidential documents.

## `publicationDateFrom` (type: `string`):

Earliest publication date in YYYY-MM-DD format.

## `publicationDateTo` (type: `string`):

Latest publication date in YYYY-MM-DD format.

## `commentDateFrom` (type: `string`):

Earliest public-comment closing date in YYYY-MM-DD format.

## `commentDateTo` (type: `string`):

Latest public-comment closing date in YYYY-MM-DD format.

## `documentNumbers` (type: `array`):

Optional Federal Register document numbers to retrieve directly. Other supplied filters still apply.

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

Order search results by newest, oldest, or relevance.

## `includeDetails` (type: `boolean`):

Fetch each document detail record to include docket IDs, RINs, CFR references, topics, action, and official text links.

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

Maximum number of matching documents to save.

## Actor input object example

```json
{
  "searchTerm": "artificial intelligence",
  "agencySlugs": [],
  "documentTypes": [
    "RULE",
    "PRORULE",
    "NOTICE"
  ],
  "documentNumbers": [],
  "sortBy": "newest",
  "includeDetails": true,
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Open the default dataset using the overview view.

# 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 = {
    "searchTerm": "artificial intelligence",
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/federal-register-rules-notices").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 = {
    "searchTerm": "artificial intelligence",
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/federal-register-rules-notices").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 '{
  "searchTerm": "artificial intelligence",
  "maxItems": 20
}' |
apify call automation-lab/federal-register-rules-notices --silent --output-dataset

```

## MCP server setup

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

```

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/KbvQQHb73pXp2QgFv/builds/k0b4sH29qgw5ijaWf/openapi.json