# Federal Register Scraper — Rules, Notices & Regulations (`logiover/federal-register-scraper`) Actor

Scrape US Federal Register by keyword or agency. Extract document number, title, type, abstract, agencies, dates, URLs, and citation. No API key, no login.

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

## Pricing

from $1.50 / 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 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 & Regulations

Extract documents from the US Federal Register — the official journal of the US federal government — by keyword, agency, document type, or date range. No API key required. Powered by the official, keyless Federal Register public API.

### What You Can Do

- Search the full text of Federal Register documents by keyword or phrase
- Filter by agency (EPA, FDA, DOT, OSHA, and 400+ more)
- Filter by document type: Final Rules, Proposed Rules, Notices, Presidential Documents
- Filter by publication date range
- Retrieve thousands of documents per run (up to 10,000)
- Export to JSON, CSV, or Excel for compliance monitoring, legal research, and regulatory intelligence

### Why Federal Register Data?

The Federal Register publishes over 80,000 documents per year. Every federal agency rulemaking, public notice, executive order, and regulatory proposal must be published here before it takes effect. This makes it the most authoritative source for:

- **Compliance teams** tracking rule changes that affect their industry
- **Legal and policy researchers** monitoring regulatory activity
- **Lobbyists and advocacy groups** watching proposed rules during the comment period
- **Journalists** covering federal policy
- **Data scientists** building regulatory datasets for NLP and ML pipelines
- **Government contractors** staying ahead of procurement-related notices

The official Federal Register website offers search but no bulk export. This actor bridges that gap.

### Input Configuration

| Field | Type | Default | Description |
|---|---|---|---|
| `query` | String | — | Keyword or phrase to search |
| `agencies` | Array | \[] | Agency slugs, e.g. `["epa", "fda", "dot"]` |
| `types` | Array | \[] | Document types: `RULE`, `PRORULE`, `NOTICE`, `PRESDOCU` |
| `dateFrom` | String | — | Start date `YYYY-MM-DD` |
| `dateTo` | String | — | End date `YYYY-MM-DD` |
| `maxResults` | Integer | 200 | Max documents to return (1–10,000) |
| `mode` | String | `search` | `search` or `agencyDocs` |

#### Mode: `search`

Searches the Federal Register by keyword. You can combine this with agency, type, and date filters.

```json
{
  "query": "artificial intelligence",
  "maxResults": 500
}
```

#### Mode: `agencyDocs`

Returns all recent documents from one or more agencies, without a keyword filter. Useful for monitoring everything an agency publishes.

```json
{
  "mode": "agencyDocs",
  "agencies": ["epa"],
  "maxResults": 1000
}
```

#### Combining Filters

All filters stack. You can combine keyword search with agency, type, and date filters:

```json
{
  "query": "clean air",
  "agencies": ["epa"],
  "types": ["RULE", "PRORULE"],
  "dateFrom": "2024-01-01",
  "dateTo": "2024-12-31",
  "maxResults": 500
}
```

### Output Fields

Each document record contains:

| Field | Type | Description |
|---|---|---|
| `documentNumber` | String | Official FR document number, e.g. `2024-12345` |
| `title` | String | Full document title |
| `type` | String | `RULE`, `PRORULE`, `NOTICE`, or `PRESDOCU` |
| `abstract` | String | Brief summary of the document |
| `agencies` | String | Comma-separated list of issuing agencies |
| `publicationDate` | String | Publication date `YYYY-MM-DD` |
| `effectiveDate` | String | Effective date `YYYY-MM-DD` (if applicable) |
| `htmlUrl` | String | Full document URL on federalregister.gov |
| `pdfUrl` | String | Direct PDF download URL |
| `citation` | String | Official citation, e.g. `89 FR 12345` |

#### Sample Output

```json
{
  "documentNumber": "2024-28147",
  "title": "Artificial Intelligence Risk Management Framework for Federal Agencies",
  "type": "NOTICE",
  "abstract": "This notice announces the availability of an updated risk management framework for artificial intelligence systems used in federal decision-making processes.",
  "agencies": "Office of Science and Technology Policy",
  "publicationDate": "2024-11-15",
  "effectiveDate": "",
  "htmlUrl": "https://www.federalregister.gov/documents/2024/11/15/2024-28147/artificial-intelligence-risk-management-framework",
  "pdfUrl": "https://www.gpo.gov/fdsys/pkg/FR-2024-11-15/pdf/2024-28147.pdf",
  "citation": "89 FR 90512"
}
```

### How It Works

This actor calls the official Federal Register API at `https://www.federalregister.gov/api/v1/documents.json`. This is a completely public, keyless API — no authentication, no rate limits for reasonable usage. The API is maintained by the US Government Publishing Office (GPO) and is designed for programmatic access.

The actor paginates through results (up to 1,000 documents per page) until it hits your `maxResults` limit or exhausts all matching documents. For large queries like `"regulation"` or agency-wide pulls, this can return thousands of documents in a single run.

#### Agency Slugs

Agency slugs are lowercase, hyphenated identifiers used by the Federal Register API. Examples:

| Agency | Slug |
|---|---|
| Environmental Protection Agency | `epa` |
| Food and Drug Administration | `food-and-drug-administration` |
| Department of Transportation | `transportation-department` |
| Occupational Safety and Health Administration | `occupational-safety-and-health-administration` |
| Securities and Exchange Commission | `securities-and-exchange-commission` |
| Federal Communications Commission | `federal-communications-commission` |
| Federal Trade Commission | `federal-trade-commission` |
| Department of Homeland Security | `homeland-security-department` |
| Treasury Department | `treasury-department` |
| Department of Justice | `justice-department` |

You can find any agency's slug by searching the Federal Register website and checking the URL parameter. The API accepts partial slug matching.

#### Document Types

| Type Code | Description |
|---|---|
| `RULE` | Final Rules — legally binding regulations |
| `PRORULE` | Proposed Rules — open for public comment |
| `NOTICE` | Notices — announcements, meetings, grant awards |
| `PRESDOCU` | Presidential Documents — executive orders, proclamations |

### Use Cases

#### Compliance Monitoring

Track all final rules published by the EPA or OSHA in the last 90 days:

```json
{
  "agencies": ["epa", "occupational-safety-and-health-administration"],
  "types": ["RULE"],
  "dateFrom": "2024-10-01",
  "maxResults": 500
}
```

#### Proposed Rule Comment Tracking

Find all proposed rules with an open comment period in your industry:

```json
{
  "query": "financial services",
  "types": ["PRORULE"],
  "dateFrom": "2024-01-01",
  "maxResults": 200
}
```

#### AI and Tech Policy Research

Monitor all AI-related regulatory activity across the federal government:

```json
{
  "query": "artificial intelligence",
  "maxResults": 1000
}
```

#### Agency Activity Audit

Get a complete picture of what the SEC published this year:

```json
{
  "mode": "agencyDocs",
  "agencies": ["securities-and-exchange-commission"],
  "dateFrom": "2024-01-01",
  "maxResults": 2000
}
```

#### Legal Citation Research

Search by a specific regulatory topic and export citations for legal briefs:

```json
{
  "query": "clean water act effluent limitations",
  "agencies": ["epa"],
  "types": ["RULE"],
  "maxResults": 100
}
```

### Performance and Limits

- **No API key required** — the Federal Register API is completely public
- **No login required** — no account, no OAuth, no credentials
- **Per-page limit**: 1,000 results per API call
- **Max results**: 10,000 per actor run
- **Speed**: Typically 1,000–5,000 documents per minute
- **Memory**: 512 MB (sufficient for any query size)
- **Datacenter proxy** used by default (the Federal Register API is not blocked)

The Federal Register API returns total\_pages in each response, so the actor knows exactly how many pages to fetch. Pagination is automatic — you only need to set `maxResults`.

### Frequently Asked Questions

#### Does this actor require an API key?

No. The Federal Register API (`federalregister.gov/api/v1`) is a completely free, public government API with no authentication required. You can verify this yourself by visiting `https://www.federalregister.gov/api/v1/documents.json?conditions[term]=test&per_page=5` in your browser.

#### How recent is the data?

Documents are typically available within 24 hours of publication. The Federal Register publishes on business days, and the API reflects the same-day publication.

#### Can I get the full text of documents?

The API returns the abstract and a URL to the full HTML document. You can use the `htmlUrl` field to access the complete document. For bulk full-text extraction, combine this actor with a web scraper pointed at those URLs.

#### How do I find the right agency slug?

Visit `https://www.federalregister.gov/api/v1/agencies.json` for a complete list of all agencies and their slugs. You can also search for an agency on federalregister.gov and check the URL — the slug appears after `/agencies/`.

#### What is the difference between RULE and PRORULE?

A `RULE` (Final Rule) is a legally binding regulation that has completed the rulemaking process. A `PRORULE` (Proposed Rule / NPRM) is a draft regulation open for public comment — it is not yet binding.

#### Can I filter by multiple agencies and types at once?

Yes. All filters stack. You can pass multiple agency slugs and multiple document types in the same run. The API treats multiple values of the same filter as OR (any match), while different filter types are AND (all must match).

#### How many results can I get per run?

Up to 10,000. The Federal Register API can return up to 1,000 results per page, and the actor will paginate automatically. For unrestricted keyword searches like `"regulation"`, there may be hundreds of thousands of matching documents — use `maxResults` to cap the output.

#### Is this legal to scrape?

Yes. All Federal Register content is in the public domain (US government works are not subject to copyright). The API is provided specifically for programmatic access and is documented at `https://www.federalregister.gov/developers/api/v1`.

### Data Source

All data is sourced from the official US Federal Register API:

- **Base URL**: `https://www.federalregister.gov/api/v1/`
- **Documentation**: https://www.federalregister.gov/developers/api/v1
- **Publisher**: US Government Publishing Office (GPO)
- **Coverage**: All Federal Register documents since 1994 (full-text since 2000)

The Federal Register has been published every federal business day since 1936. The API covers documents from 1994 onward, with full-text search available for documents from 2000 onward.

### 📝 Changelog

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.

# Actor input Schema

## `query` (type: `string`):

Keyword or phrase to search in the Federal Register. Leave empty to browse the most recent documents.

## `types` (type: `array`):

Filter by document type. Leave empty to include all types.

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

Filter by publishing agency. Leave empty to include all agencies.

## `order` (type: `string`):

How to order results.

## `dateFrom` (type: `string`):

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

## `dateTo` (type: `string`):

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

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

Maximum number of documents to return. Default 200. Raise it to pull more.

## `proxy` (type: `object`):

Apify proxy settings. Automatic (any group) is recommended for this public government API.

## Actor input object example

```json
{
  "query": "artificial intelligence",
  "types": [
    "RULE",
    "NOTICE"
  ],
  "agencies": [
    "environmental-protection-agency"
  ],
  "order": "newest",
  "dateFrom": "2024-01-01",
  "dateTo": "2024-12-31",
  "maxResults": 200,
  "proxy": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/5QfZKXiwRhyKR87EX/builds/YucjmY6E5qhLH3u1R/openapi.json