# Regulations.gov Rulemaking Dockets Scraper (`automation-lab/regulations-gov-rulemaking-dockets-comments`) Actor

Search official Regulations.gov dockets, documents, attachments, and public comments for regulatory monitoring.

- **URL**: https://apify.com/automation-lab/regulations-gov-rulemaking-dockets-comments.md
- **Developed by:** [Automation Lab](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.44 / 1,000 item 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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Regulations.gov Rulemaking Dockets Scraper

Search official **Regulations.gov rulemaking dockets** and export structured dockets, documents, comment periods, attachment links, and public comments with stable government IDs and source URLs.

Use the Actor for recurring regulatory monitoring, policy research, compliance review, government affairs, or a one-time docket export. It calls the official Regulations.gov v4 API directly without browser scraping. Requests are direct by default; the Actor can use US residential proxy transport after a direct HTTP 429 or when `proxyMode` is set to `always`.

### What does this Actor do?

The Actor supports four workflows:

- **Dockets** — find rulemaking and nonrulemaking dockets by keyword or agency.
- **Documents** — export notices, proposed rules, rules, and supporting material.
- **Comments** — collect public-submission metadata and, with detail enrichment, available comment text.
- **Complete docket bundle** — export one docket followed by its related documents and comments.

Every row includes a stable record ID, an official Regulations.gov page, an official API URL, and the extraction timestamp. Optional detail enrichment adds fields that are absent from lightweight search results, including file/download links.

### Who is it for?

- **Regulatory compliance teams** tracking agency proposals and deadlines.
- **Government affairs teams** monitoring dockets that affect clients or industries.
- **Policy researchers** building repeatable datasets across agencies.
- **Legal teams** collecting docket records with official provenance.
- **Journalists and civil-society analysts** reviewing public participation in rulemaking.
- **Data engineers** feeding federal regulatory records into warehouses or search indexes.

### Why use this Regulations.gov exporter?

- Uses the official public API instead of brittle page selectors.
- Covers dockets, documents, and comments through one consistent input.
- Preserves official identifiers for reliable deduplication between scheduled runs.
- Supports agency, document type, posted date, and comment-deadline filters.
- Exposes comment-period state on document rows.
- Can fetch available abstracts, public comment text, submitter fields, and file links.
- Stops at a clear `maxItems` limit and removes duplicates across multiple searches.
- Fails clearly when an API key is rejected or rate limits are exhausted.

This Actor is independent and is not affiliated with or endorsed by Regulations.gov or the U.S. government.

### Data you can extract

| Field | Meaning |
| --- | --- |
| `recordType` | `docket`, `document`, or `comment` |
| `recordId` | Stable Regulations.gov record ID |
| `agencyId` | Publishing federal agency acronym |
| `docketId` | Related docket ID, when supplied by the source |
| `title` | Official record title |
| `documentType` | Notice, Proposed Rule, Rule, Public Submission, or supporting type |
| `docketType` | Rulemaking/nonrulemaking classification on docket rows |
| `postedDate` | Official posting timestamp |
| `lastModifiedDate` | Latest source modification timestamp when available |
| `commentStartDate` / `commentEndDate` | Public-comment window |
| `openForComment` | Source-provided open/closed state |
| `withinCommentPeriod` | Whether the current date is inside the source period |
| `withdrawn` | Source-provided withdrawal state |
| `commentOnDocumentId` | Document targeted by a public comment |
| `federalRegisterDocumentNumber` | Linked Federal Register document number |
| `abstract` | Detailed document abstract when available |
| `commentText` | Public comment body when available |
| `organization` / `submitterName` | Public submitter fields when supplied |
| `files` | Official file URLs, format, and byte size from detailed records |
| `sourceUrl` | Human-readable official page |
| `apiUrl` | Official API provenance URL |
| `query` | Search term that found the row |
| `scrapedAt` | Actor extraction time |

Null fields mean Regulations.gov did not provide that value for the record or the run did not request detail enrichment.

### Getting started

1. Select **Documents**, **Dockets**, **Comments**, or **Complete docket bundle**.
2. Enter search terms or one or more official docket IDs.
3. Add an agency or date filter if needed.
4. Enable **Fetch full details and file links** only when you need enriched fields.
5. For scheduled or larger runs, add your free api.data.gov key.
6. Choose the maximum number of records and start the Actor.
7. Download the default dataset as JSON, CSV, Excel, XML, or RSS.

A no-key run uses the public shared `DEMO_KEY`. Its quota is outside this Actor's control and can be exhausted by unrelated API users.

### Input parameters

| Input | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `documents` | Record collection or complete docket bundle |
| `searchTerms` | string\[] | `artificial intelligence` | Terms sent to official full-text search |
| `docketIds` | string\[] | — | IDs used to filter documents/comments or build bundles |
| `agencyId` | string | — | Agency acronym such as `EPA`, `NIST`, or `FDA` |
| `documentType` | string | any | Regulations.gov document type |
| `postedAfter` | date | — | Inclusive `YYYY-MM-DD` posted-date lower bound |
| `postedBefore` | date | — | Inclusive `YYYY-MM-DD` posted-date upper bound |
| `commentEndAfter` | date | — | Inclusive comment-deadline lower bound for documents |
| `openForComment` | boolean | `false` | Keep only documents marked open for comment |
| `includeDetails` | boolean | `false` | Add one detail request per row for rich fields/files |
| `proxyMode` | string | `onRateLimit` | Use fresh US residential identities on 429, always, or never |
| `apiKey` | secret string | shared demo key | Free api.data.gov key, recommended for automation |
| `maxItems` | integer | `50` | Maximum unique rows, from 1 to 5,000 |

Filters are applied to official API requests. `openForComment` is additionally enforced on accepted document records.

### Example inputs

#### Search federal AI documents

```json
{
  "mode": "documents",
  "searchTerms": ["artificial intelligence"],
  "maxItems": 10
}
```

#### Monitor one agency's dockets

```json
{
  "mode": "dockets",
  "agencyId": "NIST",
  "searchTerms": ["artificial intelligence"],
  "maxItems": 25
}
```

#### Export a complete docket

```json
{
  "mode": "docketBundle",
  "docketIds": ["NIST-2026-0100"],
  "maxItems": 100,
  "apiKey": "YOUR_FREE_DATA_GOV_KEY"
}
```

### Example output

A current document search produces rows shaped like this:

```json
{
  "recordType": "document",
  "recordId": "SEC-2026-5815-0001",
  "agencyId": "SEC",
  "docketId": null,
  "title": "Self-Regulatory Organizations; Proposed Rule Changes: NYSE American LLC",
  "documentType": "Notice",
  "postedDate": "2026-09-18T04:00:00Z",
  "commentEndDate": null,
  "openForComment": false,
  "files": [],
  "sourceUrl": "https://www.regulations.gov/document/SEC-2026-5815-0001",
  "apiUrl": "https://api.regulations.gov/v4/documents/SEC-2026-5815-0001",
  "query": "artificial intelligence",
  "scrapedAt": "2026-09-19T00:00:00.000Z"
}
```

With `includeDetails: true`, `files`, `abstract`, `commentText`, and public submitter fields may contain additional source data.

### Pagination, limits, and deduplication

Regulations.gov requires API pages of at least five records. The Actor requests up to 25 rows per page but saves no more than `maxItems`. It deduplicates by record type plus official ID, so overlapping search terms do not create repeated dataset rows.

A complete docket bundle counts the docket, its documents, and its comments toward one shared `maxItems` limit. The order is docket first, then documents, then comments.

### Details and attachments

Summary searches are fast and economical. Enable `includeDetails` when you need full available metadata. Detailed document and comment responses can expose `fileFormats`; each entry becomes a `files` object with an official download URL, format, and byte size.

Not every source record has an attachment, abstract, comment body, or public submitter identity. The Actor never fabricates missing values.

### Rate limits and retries

The Actor retries network errors, HTTP 429, and temporary server errors up to three times with bounded backoff. With the default `proxyMode: "onRateLimit"`, a direct 429 switches subsequent attempts to fresh US residential proxy identities. Choose `always` only when a known network route requires it; choose `never` with a dependable personal API key to guarantee zero proxy use. It does not endlessly retry invalid input, rejected keys, or stable API errors.

For recurring schedules, enriched rows, or larger exports:

1. obtain a free key from [api.data.gov](https://api.data.gov/signup/);
2. store it in the secret `apiKey` input;
3. keep `maxItems` appropriate for your quota;
4. avoid detail enrichment unless downstream work needs it.

If all retries fail, the run fails rather than presenting an unexpected empty dataset as success.

### How much does it cost to export Regulations.gov records?

The Actor charges a **$0.003 start event** and one `item` event per unique saved row. BRONZE pricing is **$0.0024 per record**; spend-tier prices are shown before the run in Apify Console.

BRONZE examples use the same transparent formula:

| Useful records | Charged events |
| ---: | --- |
| 1 | one start + one item |
| 10 | one start + ten items |
| 100 | one start + one hundred items |
| 1,000 | one start + one thousand items |

Multiply the item count by the active per-record price and add the single active start price shown above.

The source API is public. A paid residential transport is used only after a direct HTTP 429 when the rate-limit fallback is enabled; a dependable personal API key can normally avoid that route. Billing uses only the listed `start` and `item` events. Actual platform billing can reflect refunds, fraud controls, disputes, taxes, corrections, or clawbacks. Check the run's charge events for the authoritative total.

### Schedule regulatory monitoring

Use an Apify Schedule to run a stable query daily or weekly. In your downstream database, upsert on `recordType` plus `recordId`, then compare `lastModifiedDate`, comment-period fields, or a row hash. This avoids treating repeated unchanged records as new regulatory actions.

Typical automation:

1. scheduled Actor run;
2. dataset export or webhook;
3. stable-ID upsert;
4. detect new or changed rows;
5. notify the responsible policy or compliance owner.

The Actor exports observations; it does not itself send alerts or preserve a historical change log.

### Integrations

- **Google Sheets** — maintain a review queue for proposed rules and deadlines.
- **Slack or Microsoft Teams** — notify a channel from a run-finished webhook.
- **Make or Zapier** — route new docket IDs into case-management workflows.
- **BigQuery, Snowflake, or PostgreSQL** — build a longitudinal regulatory dataset.
- **LLM pipelines** — summarize public documents after retaining the official source link.
- **Webhooks** — trigger internal compliance review when a scheduled run succeeds.

### Use through the Apify API

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/regulations-gov-rulemaking-dockets-comments').call({
  mode: 'documents',
  searchTerms: ['artificial intelligence'],
  agencyId: 'NIST',
  maxItems: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("automation-lab/regulations-gov-rulemaking-dockets-comments").call(run_input={
    "mode": "comments",
    "searchTerms": ["climate"],
    "maxItems": 25,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~regulations-gov-rulemaking-dockets-comments/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"dockets","agencyId":"EPA","maxItems":10}'
```

Do not embed long-lived tokens or api.data.gov keys in public source code.

### Use with AI agents through MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/regulations-gov-rulemaking-dockets-comments"
```

For Claude Desktop, Cursor, or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/regulations-gov-rulemaking-dockets-comments"
    }
  }
}
```

Example prompts:

- “Search Regulations.gov for NIST artificial-intelligence dockets and return official IDs.”
- “Export public comments for docket NIST-2026-0100.”
- “Find EPA documents with comment deadlines after this month.”

### Responsible use and legality

The Actor accesses the public official Regulations.gov API. Regulatory documents and displayed public comments are government records, but source records can still contain names, organizations, and contact details submitted by members of the public.

Use only the fields necessary for a legitimate research, compliance, journalism, or public-interest purpose. Respect applicable privacy, records, contractual, and data-protection rules. Do not use output to harass submitters, build sensitive personal profiles, or infer facts that the source does not state.

Regulations.gov controls availability, redactions, corrections, and API quotas. Always retain `sourceUrl` and verify consequential decisions against the current official record.

### Limitations

- The shared demo key can be rate limited; a personal free key is recommended.
- Search quality and record coverage are determined by Regulations.gov.
- Summary mode does not contain all fields available from detail endpoints.
- Some comments have no body text or public submitter details.
- Some records have no files, docket ID, or Federal Register number.
- `maxItems` is a record cap, not a promise that the source has that many matches.
- Complete bundles may reach the cap before comments are collected.
- This Actor does not download attachment bytes or extract PDF text.
- This Actor does not provide legal advice or determine regulatory applicability.

### Troubleshooting

#### The run reports HTTP 429

The source quota remained exhausted after bounded retries and any enabled residential fallback. Add your own free api.data.gov key, reduce `maxItems`, disable `includeDetails`, or run later.

#### I received zero matching records

Remove filters one at a time and verify the official agency/docket ID. A naturally empty official response is different from a failed API request; failed requests produce a failed Actor run.

#### Why are enriched fields null?

Confirm `includeDetails` is true. Even detailed source records can omit an abstract, comment body, attachment, or public identity.

#### Why does a docket bundle contain no comments?

The docket may have no public submissions, or documents may consume the run's `maxItems` before comment collection starts. Increase the cap if appropriate.

### FAQ

#### Do I need a Regulations.gov API key?

No for a small trial: the Actor falls back to `DEMO_KEY`. Yes in practice for dependable schedules or larger/detail-heavy runs. api.data.gov keys are free.

#### Can I search several terms?

Yes. Add multiple `searchTerms`. The cap applies across them and duplicate official IDs are saved once.

#### Can I export attachment contents?

The Actor exports official file URLs and metadata from detailed records. It intentionally does not download or parse file bytes.

#### Does it include agencies?

Every record includes the source's `agencyId` when available, and you can filter by that ID. It does not create a separate agency-directory dataset.

#### Can I track changes over time?

Yes. Schedule recurring runs and compare records by stable `recordType` + `recordId`. Historical storage/comparison belongs in your downstream dataset or database.

#### Are all comments public?

The Actor returns only what the official public API exposes. Regulations.gov controls redaction and field availability.

### Related Automation Lab Actors

- [Federal Register Rules & Notices Scraper](https://apify.com/automation-lab/federal-register-rules-notices) — monitor official publication notices and rules rather than docket submissions.
- [SEC Comment Letters Scraper](https://apify.com/automation-lab/sec-comment-letters-scraper) — collect SEC staff comment-letter correspondence.
- [Grants.gov Funding Opportunities Scraper](https://apify.com/automation-lab/grants-gov-funding-opportunities-scraper) — monitor federal funding opportunities.

These are separate official-source workflows; they do not replace Regulations.gov docket and public-comment records.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/regulations-gov-rulemaking-dockets-comments/changelog.md

# Actor input Schema

## `mode` (type: `string`):

Choose a searchable record collection, or export a docket bundle containing its docket, documents, and comments.

## `searchTerms` (type: `array`):

Keywords searched by Regulations.gov. Leave empty to retrieve the latest matching records.

## `docketIds` (type: `array`):

Official docket IDs, for example NIST-2023-0009. Documents/comments modes filter by these IDs; complete docket bundle requires them.

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

Optional official acronym such as EPA, FDA, NIST, FTC, or SEC.

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

Optional Regulations.gov document type filter. Applies only to documents.

## `postedAfter` (type: `string`):

Inclusive posted-date lower bound in YYYY-MM-DD format. Applies to documents and comments.

## `postedBefore` (type: `string`):

Inclusive posted-date upper bound in YYYY-MM-DD format. Applies to documents and comments.

## `commentEndAfter` (type: `string`):

Inclusive comment-end-date lower bound in YYYY-MM-DD format. Applies only to documents.

## `openForComment` (type: `boolean`):

Keep only document records that the official API marks open for comment.

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

Fetch each record detail to include available abstracts, comment text, submitter fields, and attachment/file URLs. Uses one extra API request per item.

## `proxyMode` (type: `string`):

On HTTP 429, optionally retry through fresh US residential proxy identities. Disable this only when using a dependable personal API key.

## `apiKey` (type: `string`):

Optional free Regulations.gov/API.data.gov key. Recommended for details, larger exports, and scheduled runs. If omitted, the shared DEMO\_KEY is used and may be rate limited.

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

Maximum unique records saved across all terms and docket IDs.

## Actor input object example

```json
{
  "mode": "documents",
  "searchTerms": [
    "artificial intelligence"
  ],
  "documentType": "",
  "openForComment": false,
  "includeDetails": false,
  "proxyMode": "onRateLimit",
  "maxItems": 10
}
```

# Actor output Schema

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

Open normalized Regulations.gov records in the overview table.

# 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 = {
    "mode": "documents",
    "searchTerms": [
        "artificial intelligence"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/regulations-gov-rulemaking-dockets-comments").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 = {
    "mode": "documents",
    "searchTerms": ["artificial intelligence"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/regulations-gov-rulemaking-dockets-comments").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 '{
  "mode": "documents",
  "searchTerms": [
    "artificial intelligence"
  ],
  "maxItems": 10
}' |
apify call automation-lab/regulations-gov-rulemaking-dockets-comments --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/regulations-gov-rulemaking-dockets-comments"
        }
    }
}
```

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/Llcr9lb3nZ7SZCo1S/builds/V8dD42pwJ6Rv0YTd7/openapi.json