# Regulations.gov Scraper (`parseforge/regulations-gov-scraper`) Actor

Collect federal regulatory documents, public comments, and dockets from Regulations.gov. Search by keyword, filter by agency (EPA, FDA, FCC, DOT), document type, and date range. Get titles, posting dates, comment periods, docket IDs, and links for rules, notices, and supporting materials.

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

## Pricing

from $6.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://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 📜 Regulations.gov Scraper

Whether you're a lobbyist tracking regulatory changes, a compliance officer monitoring agency rules, or a researcher analyzing public comments, this tool makes it easy to collect structured data from the federal government's regulatory portal.

> **The Regulations.gov Scraper collects federal regulatory documents, public comments, and dockets. Search by keyword, filter by agency, document type, and date range. Get titles, agencies, posting dates, comment periods, docket IDs, and direct links for rules, proposed rules, notices, and supporting materials.**

### ✨ What Does It Do

- 📄 **Regulatory documents** - collect rules, proposed rules, notices, and supporting materials with full metadata
- 💬 **Public comments** - gather public comments submitted on proposed regulations
- 📁 **Dockets** - retrieve docket records that group related documents and comments
- 🏛️ **Agency filtering** - filter by any federal agency (EPA, FDA, FCC, DOT, HHS, and more)
- 🔍 **Keyword search** - find documents matching specific terms like "climate change" or "net neutrality"
- 📅 **Date range filtering** - narrow results to documents posted within a specific date window
- 📋 **Docket lookup** - retrieve all documents and comments for a specific docket ID

### 🔧 Input

- **Search Term** - full text search query (e.g., 'climate change', 'net neutrality')
- **Document Type** - choose between Documents, Comments, or Dockets
- **Max Items** - how many records to collect (free users get 10, paid users up to 1,000,000)
- **API Key** - your free api.data.gov key (DEMO_KEY included for testing)
- **Agency ID** - filter by agency acronym (e.g., EPA, FDA, FCC)
- **Filter by Document Subtype** - narrow documents by Rule, Proposed Rule, Notice, etc.
- **Posted Date Start/End** - filter by posting date range (YYYY-MM-DD)
- **Docket ID** - look up a specific docket (overrides keyword search)

```json
{
    "searchTerm": "climate change",
    "documentType": "documents",
    "maxItems": 50,
    "apiKey": "DEMO_KEY",
    "agencyId": "EPA"
}
````

### 📊 Output

Each record includes different fields depending on the document type. Download as JSON, CSV, or Excel.

#### Documents

| Field | Description |
|-------|-------------|
| documentId | Unique document identifier |
| title | Document title |
| agencyId | Issuing agency acronym |
| documentType | Type (Rule, Proposed Rule, Notice, etc.) |
| postedDate | Date posted on Regulations.gov |
| modifyDate | Last modification date |
| docketId | Parent docket identifier |
| objectId | Internal object identifier |
| commentStartDate | When public comment period opens |
| commentEndDate | When public comment period closes |
| openForComment | Whether comments are currently accepted |
| withdrawn | Whether document has been withdrawn |
| url | Direct link to the document on Regulations.gov |
| scrapedAt | Timestamp when data was collected |

```json
{
    "documentId": null,
    "title": "EPA - Climate Change Impacts Midwest",
    "agencyId": "PHMSA",
    "documentType": "Supporting & Related Material",
    "postedDate": "2023-10-25T04:00:00Z",
    "docketId": "PHMSA-2021-0046",
    "objectId": "PHMSA-2021-0046-0078",
    "openForComment": false,
    "withdrawn": false,
    "url": "https://www.regulations.gov/document/PHMSA-2021-0046-0078",
    "scrapedAt": "2026-04-08T16:52:33.693Z"
}
```

### 💎 Why Choose the Regulations.gov Scraper?

| Feature | Our Tool | Manual Regulations.gov |
|---------|----------|----------------------|
| Batch collection | Up to 5,000 records | Browse 25 at a time |
| Multi-type search | Documents, comments, dockets | Switch between tabs |
| Agency filtering | Any federal agency | Limited dropdown |
| Date range | Precise YYYY-MM-DD filtering | Basic date picker |
| Structured output | JSON, CSV, Excel | HTML pages only |
| Automated scheduling | Daily/weekly monitoring | Manual visits |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Configure** - set your search term, document type, and filters
3. **Run It** - click "Start" and get structured regulatory data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- ⚖️ **Compliance officers** - monitor new rules and proposed regulations affecting your industry
- 🏛️ **Lobbyists** - track regulatory activity across multiple agencies and dockets
- 📰 **Journalists** - research public comments and agency actions on policy issues
- 🎓 **Researchers** - analyze patterns in regulatory activity, comment volumes, and agency behavior
- 🏢 **Law firms** - build databases of regulatory actions for client advisories
- 📊 **Policy analysts** - monitor rulemaking timelines and comment periods across agencies

### ❓ FAQ

📜 **What is Regulations.gov?**
Regulations.gov is the official U.S. government portal where federal agencies publish proposed rules, final rules, notices, and accept public comments on regulatory actions.

🔑 **Do I need an API key?**
The scraper works with the included DEMO\_KEY for testing (30 requests/minute, 50/hour). For production use, get a free key at api.data.gov/signup for higher limits.

📋 **What's the maximum number of results?**
The Regulations.gov API limits results to 5,000 per search (20 pages of 250). Use date ranges or agency filters to narrow large result sets.

⏱️ **How long does a run take?**
About 2-3 seconds per page of 250 results. A full 5,000-record fetch takes approximately 30 seconds.

🏛️ **What agency codes can I use?**
Common codes: EPA, FDA, FCC, DOT, HHS, NHTSA, OSHA, SEC, USDA, DOE, DOD, DOI, DOJ, DOL, ED, HUD, SBA, VA.

### 🔗 Integrate Regulations.gov Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate regulatory monitoring workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts when new rules are published
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified about comment period deadlines
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export regulatory data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more government data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| Federal Register Scraper | Collect regulatory notices and rules | [Link](https://apify.com/parseforge/federal-register-regulatory-notices-rules-scraper) |
| Grants.gov Scraper | Collect federal grant opportunities | [Link](https://apify.com/parseforge/grants-gov-scraper) |
| USASpending Scraper | Gather federal spending and award data | [Link](https://apify.com/parseforge/usaspending-scraper) |
| GSA eLibrary Scraper | Collect government contract data | [Link](https://apify.com/parseforge/gsa-elibrary-scraper) |
| FAA Aircraft Registry Scraper | Extract aircraft registration data | [Link](https://apify.com/parseforge/faa-aircraft-registry-scraper) |

**Pro Tip:** Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to Regulations.gov, the eRulemaking Program, or any federal agency. It accesses only publicly available data through the official Regulations.gov public API.

# Actor input Schema

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

Full text search query (e.g. 'climate change', 'net neutrality', 'clean water')

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

Type of records to retrieve from Regulations.gov

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

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

## `agencyId` (type: `string`):

Filter by federal agency acronym (e.g. EPA, NHTSA, FDA, FCC, DOT, HHS). Leave empty for all agencies.

## `filterDocumentType` (type: `string`):

Filter documents by subtype. Examples: Rule, Proposed Rule, Notice, Supporting & Related Material. Only applies when Document Type is 'documents'.

## `postedDateStart` (type: `string`):

Only return records posted on or after this date (format: YYYY-MM-DD)

## `postedDateEnd` (type: `string`):

Only return records posted on or before this date (format: YYYY-MM-DD)

## `docketId` (type: `string`):

Filter by a specific docket ID (e.g. EPA-HQ-OAR-2009-0171). Overrides search term when provided.

## Actor input object example

```json
{
  "searchTerm": "climate change",
  "documentType": "documents",
  "maxItems": 10
}
```

# Actor output Schema

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

Overview of scraped data

# 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": "climate change",
    "documentType": "documents",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/regulations-gov-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": "climate change",
    "documentType": "documents",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/regulations-gov-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": "climate change",
  "documentType": "documents",
  "maxItems": 10
}' |
apify call parseforge/regulations-gov-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Regulations.gov Scraper",
        "description": "Collect federal regulatory documents, public comments, and dockets from Regulations.gov. Search by keyword, filter by agency (EPA, FDA, FCC, DOT), document type, and date range. Get titles, posting dates, comment periods, docket IDs, and links for rules, notices, and supporting materials.",
        "version": "0.0",
        "x-build-id": "pA8jMVLGigQjKE5r2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~regulations-gov-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-regulations-gov-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~regulations-gov-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-regulations-gov-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~regulations-gov-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-regulations-gov-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 query (e.g. 'climate change', 'net neutrality', 'clean water')"
                    },
                    "documentType": {
                        "title": "Document Type",
                        "enum": [
                            "documents",
                            "comments",
                            "dockets"
                        ],
                        "type": "string",
                        "description": "Type of records to retrieve from Regulations.gov"
                    },
                    "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"
                    },
                    "agencyId": {
                        "title": "Agency ID",
                        "type": "string",
                        "description": "Filter by federal agency acronym (e.g. EPA, NHTSA, FDA, FCC, DOT, HHS). Leave empty for all agencies."
                    },
                    "filterDocumentType": {
                        "title": "Filter by Document Subtype",
                        "type": "string",
                        "description": "Filter documents by subtype. Examples: Rule, Proposed Rule, Notice, Supporting & Related Material. Only applies when Document Type is 'documents'."
                    },
                    "postedDateStart": {
                        "title": "Posted Date Start",
                        "type": "string",
                        "description": "Only return records posted on or after this date (format: YYYY-MM-DD)"
                    },
                    "postedDateEnd": {
                        "title": "Posted Date End",
                        "type": "string",
                        "description": "Only return records posted on or before this date (format: YYYY-MM-DD)"
                    },
                    "docketId": {
                        "title": "Docket ID",
                        "type": "string",
                        "description": "Filter by a specific docket ID (e.g. EPA-HQ-OAR-2009-0171). Overrides search term when provided."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
