# Federal Register Scraper — US Rules, Notices & Executive Orders (`themineworks/federal-register-scraper`) Actor

Search the US Federal Register for rules, proposed rules, notices and presidential documents as clean structured JSON. Filter by term, type, agency and date. Zero charge on empty runs.

- **URL**: https://apify.com/themineworks/federal-register-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## Federal Register Scraper — US Rules, Notices & Executive Orders

Search the **US Federal Register** — the official daily journal of the federal government — and get clean, structured JSON back. Pull **final rules, proposed rules, notices and presidential documents** filtered by search term, document type, agency and date. Built for **regulatory and compliance monitoring**, **policy and legal research**, **govtech**, and **AI/RAG pipelines** that need authoritative regulatory text. You only pay for documents actually delivered.

**Keywords:** Federal Register API, regulations scraper, rulemaking data, compliance monitoring, executive orders, proposed rules, federal notices, regulatory intelligence, policy tracking.

---

### Why this actor

Every new federal regulation, proposed rule, agency notice and presidential document is published in the Federal Register. The official API is open and excellent, but driving it well means handling bracketed condition parameters, field selection and pagination. This actor wraps all of that and returns **one clean record per document**:

- **Full-text search** across the entire Federal Register.
- **Type filtering** — final rules, proposed rules, notices, presidential documents.
- **Agency and date filtering** — narrow to a regulator and a publication window.
- **Clean, flat output** — document number, type, title, abstract, action, agencies, publication and effective dates, docket IDs, citation, and direct HTML + PDF links.
- **Fully open, no API key** — official Federal Register API v1. No key, no login.

---

### What you can build with it

- **Compliance monitoring** — track new and proposed rules from the agencies that regulate your industry, the day they publish.
- **Regulatory intelligence** — feed a watchlist of terms and agencies into a daily run and never miss a rulemaking.
- **Legal & policy research** — assemble the complete documentary trail on a topic, with links to the official text.
- **AI / RAG pipelines** — ingest authoritative regulatory text and abstracts for grounded question-answering.
- **Lobbying & public affairs** — monitor dockets and comment periods as they open.

---

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `searchTerm` | string | `artificial intelligence` | Full-text search. Empty = all. |
| `documentTypes` | string[] | `["RULE","PRORULE"]` | `RULE`, `PRORULE` (proposed), `NOTICE`, `PRESDOCU`. Empty = all. |
| `agencySlugs` | string[] | — | Agency slugs (e.g. `environmental-protection-agency`). |
| `dateFrom` / `dateTo` | string | — | Publication-date window `YYYY-MM-DD`. |
| `maxResults` | integer | 100 | Max documents, newest first. |

#### Example input

```json
{
  "searchTerm": "cryptocurrency",
  "documentTypes": ["RULE", "PRORULE"],
  "agencySlugs": ["securities-and-exchange-commission"],
  "dateFrom": "2025-01-01",
  "maxResults": 200
}
````

***

### Output

Each document is one dataset record:

```json
{
  "document_number": "2026-11436",
  "type": "Proposed Rule",
  "title": "Approval and Promulgation of Air Quality Implementation Plans",
  "abstract": "The EPA is proposing to approve...",
  "action": "Proposed rule.",
  "agencies": ["Environmental Protection Agency"],
  "publication_date": "2026-06-08",
  "effective_on": null,
  "docket_ids": ["EPA-R05-OAR-2025-0123"],
  "citation": "91 FR 12345",
  "president": null,
  "html_url": "https://www.federalregister.gov/documents/2026/06/08/2026-11436/...",
  "pdf_url": "https://www.govinfo.gov/content/pkg/FR-2026-06-08/pdf/2026-11436.pdf",
  "scraped_at": "2026-06-10T15:00:00.000Z"
}
```

A final `{"_type": "summary"}` record reports how many documents were returned and how many matched in total.

***

### Pricing

**Your first 25 documents are free — every Apify account, no card, no trial clock.** After that it is a flat **$0.003 per document delivered**.

- First 25 documents free per account (lifetime), then $0.003/document
- **Zero charge on empty runs** — a search that matches nothing costs you nothing
- No monthly minimum, no rental
- A run pulling 1,000 documents costs $3.00

***

### FAQ

**Do I need an API key?** No. The Federal Register API is fully open.

**How current is it?** Real-time — new documents appear as soon as they are published, every business day.

**Can I monitor a regulator?** Yes — set `agencySlugs` (and/or a search term), save it as a task, and schedule a daily run.

**What document types are covered?** Final rules, proposed rules, notices, and presidential documents (executive orders, proclamations, etc.).

# Actor input Schema

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

Full-text search across Federal Register documents (e.g. artificial intelligence, clean water, tariffs). Leave empty to match all documents in your other filters.

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

Which document types to return. Leave empty for all.

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

Filter by agency slug as used by federalregister.gov (e.g. environmental-protection-agency, securities-and-exchange-commission). Leave empty for all agencies.

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

Earliest publication date. Leave empty for no lower bound.

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

Latest publication date. Leave empty for no upper bound.

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

Maximum number of documents to return, newest first.

## Actor input object example

```json
{
  "searchTerm": "artificial intelligence",
  "documentTypes": [
    "RULE",
    "PRORULE"
  ],
  "maxResults": 25
}
```

# 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",
    "documentTypes": [
        "RULE",
        "PRORULE"
    ],
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/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 = {
    "searchTerm": "artificial intelligence",
    "documentTypes": [
        "RULE",
        "PRORULE",
    ],
    "maxResults": 25,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Federal Register Scraper — US Rules, Notices & Executive Orders",
        "description": "Search the US Federal Register for rules, proposed rules, notices and presidential documents as clean structured JSON. Filter by term, type, agency and date. Zero charge on empty runs.",
        "version": "0.1",
        "x-build-id": "yZGVhGJZUQnptjdgB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/themineworks~federal-register-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-themineworks-federal-register-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/themineworks~federal-register-scraper/runs": {
            "post": {
                "operationId": "runs-sync-themineworks-federal-register-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/themineworks~federal-register-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-themineworks-federal-register-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": "Full-text search across Federal Register documents (e.g. artificial intelligence, clean water, tariffs). Leave empty to match all documents in your other filters."
                    },
                    "documentTypes": {
                        "title": "Document types",
                        "type": "array",
                        "description": "Which document types to return. Leave empty for all.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RULE",
                                "PRORULE",
                                "NOTICE",
                                "PRESDOCU"
                            ]
                        }
                    },
                    "agencySlugs": {
                        "title": "Agency slugs",
                        "type": "array",
                        "description": "Filter by agency slug as used by federalregister.gov (e.g. environmental-protection-agency, securities-and-exchange-commission). Leave empty for all agencies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateFrom": {
                        "title": "Published on or after (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Earliest publication date. Leave empty for no lower bound."
                    },
                    "dateTo": {
                        "title": "Published on or before (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Latest publication date. Leave empty for no upper bound."
                    },
                    "maxResults": {
                        "title": "Max documents to return",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of documents to return, newest first.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
