# Regulations.gov Crawler - Rules, Dockets, Public Comments (`jungle_synthesizer/regulations-gov-crawler`) Actor

Query the official regulations.gov v4 API for federal rules, proposed rules, notices, dockets, and public comments. Filter by agency, document type, docket, date range, and keywords. Requires a free API key.

- **URL**: https://apify.com/jungle\_synthesizer/regulations-gov-crawler.md
- **Developed by:** [BowTiedRaccoon](https://apify.com/jungle_synthesizer) (community)
- **Categories:** Business, Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Regulations.gov Crawler - Rules, Dockets, Public Comments

Query the official [regulations.gov](https://www.regulations.gov) v4 API for federal rulemaking. Returns rules, proposed rules, notices, dockets, and public comments — all three endpoints from one actor, covering 2M+ documents, 400K+ dockets, and 20M+ comments submitted to the federal government.

---

### Regulations.gov Crawler Features

- Covers three endpoints from a single actor — documents, dockets, and public comments
- Filters by agency, document type, docket ID, date range, and full-text keyword
- Returns clean JSON with consistent field names across all three record types
- Pure JSON API — no browser, no proxies, no anti-bot theater
- Rate-limit aware — a 4-second courtesy delay keeps runs well under the api.data.gov quota
- Handles your own api.data.gov key if you have one, so you can crank through 1,000 requests per hour

---

### Who Uses Regulations.gov Data?

- **Compliance teams** — Track new rules affecting their industry without paying SaaS rent to Bloomberg Government
- **Law firms** — Monitor rulemaking dockets in their practice areas and stay ahead of client questions
- **Policy researchers** — Analyze public comments on proposed rules to understand stakeholder positions
- **Trade associations** — Watch agency activity and flag anything that could rearrange their members' Monday
- **Regulatory intelligence products** — Feed structured federal rulemaking data into internal dashboards and client alerts

---

### How Regulations.gov Crawler Works

1. Pick a data type — documents, dockets, or comments.
2. Narrow the query with optional filters: agency acronym, document type, docket ID, date range, search term.
3. The actor hits the regulations.gov v4 API, paginates up to the API's 20-page hard cap (5,000 records per query), and writes each record to your dataset.
4. Get a free api.data.gov key if you plan to run this more than a couple times an hour. It takes a minute and doubles your effective throughput.

---

### Input

```json
{
  "apiKey": "your-free-api-data-gov-key",
  "dataType": "documents",
  "searchTerm": "climate",
  "agencyId": "EPA",
  "documentType": "Rule",
  "postedDateFrom": "2025-01-01",
  "postedDateTo": "2026-04-01",
  "sortBy": "-lastModifiedDate",
  "maxItems": 500
}
````

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `apiKey` | string | (empty) | Your free api.data.gov key. Get one at [open.gsa.gov/api/regulationsgov](https://open.gsa.gov/api/regulationsgov/). Optional but strongly recommended — without it you share a global DEMO\_KEY quota. |
| `dataType` | string | `documents` | Which endpoint to hit: `documents`, `dockets`, or `comments`. |
| `searchTerm` | string | (empty) | Full-text search across titles and abstracts. |
| `documentType` | string | (empty) | Documents-only filter: `Rule`, `Proposed Rule`, `Notice`, `Supporting & Related Material`, `Other`. |
| `docketType` | string | (empty) | Dockets-only filter: `Rulemaking` or `Nonrulemaking`. |
| `agencyId` | string | (empty) | Agency acronym: `EPA`, `FAA`, `SEC`, `DOT`, `FDA`, `FCC`, `NRC`, etc. |
| `docketId` | string | (empty) | Filter to a specific docket (e.g., `EPA-HQ-OAR-2023-0234`). Documents and comments only. |
| `postedDateFrom` | string | (empty) | Return records posted on or after this date (YYYY-MM-DD). |
| `postedDateTo` | string | (empty) | Return records posted on or before this date (YYYY-MM-DD). |
| `sortBy` | string | `-lastModifiedDate` | Sort order: `-lastModifiedDate`, `lastModifiedDate`, `-postedDate`, `postedDate`, `title`. |
| `maxItems` | integer | `100` | Max records to return. API hard cap is 5,000 per query — narrow filters for larger datasets. |

#### Example: All EPA Final Rules Posted in the Last Month

```json
{
  "dataType": "documents",
  "agencyId": "EPA",
  "documentType": "Rule",
  "postedDateFrom": "2026-03-19",
  "maxItems": 500
}
```

#### Example: Public Comments on a Specific Docket

```json
{
  "dataType": "comments",
  "docketId": "EPA-HQ-OAR-2023-0234",
  "sortBy": "-postedDate",
  "maxItems": 1000
}
```

#### Example: Rulemaking Dockets From the FAA

```json
{
  "dataType": "dockets",
  "agencyId": "FAA",
  "docketType": "Rulemaking",
  "maxItems": 200
}
```

***

### Regulations.gov Crawler Output Fields

All three endpoints share a consistent schema. Fields that do not apply to a given record type are returned as empty strings.

#### Document Record

```json
{
  "recordType": "document",
  "id": "FAA-2026-3471-0001",
  "objectId": "09000064b925548c",
  "title": "Airworthiness Directives: The Boeing Company Airplanes",
  "documentType": "Proposed Rule",
  "subtype": "Request for Comment",
  "agencyId": "FAA",
  "docketId": "FAA-2026-3471",
  "docketType": "",
  "frDocNum": "2026-06691",
  "commentStartDate": "2026-04-07T04:00:00Z",
  "commentEndDate": "2026-05-23T03:59:59Z",
  "postedDate": "2026-04-07T04:00:00Z",
  "lastModifiedDate": "2026-04-19T09:00:22Z",
  "withinCommentPeriod": true,
  "openForComment": true,
  "withdrawn": false,
  "allowLateComments": false,
  "commentOnId": "",
  "commentOnDocumentId": "",
  "url": "https://www.regulations.gov/document/FAA-2026-3471-0001",
  "apiUrl": "https://api.regulations.gov/v4/documents/FAA-2026-3471-0001"
}
```

#### Docket Record

```json
{
  "recordType": "docket",
  "id": "USCG-2019-0806",
  "objectId": "0b00006483f8d57e",
  "title": "Allegheny River mm 0-0.25, Pittsburgh, PA",
  "documentType": "Rulemaking",
  "agencyId": "USCG",
  "docketType": "Rulemaking",
  "lastModifiedDate": "2019-10-25T12:02:53Z",
  "url": "https://www.regulations.gov/docket/USCG-2019-0806",
  "apiUrl": "https://api.regulations.gov/v4/dockets/USCG-2019-0806"
}
```

#### Comment Record

```json
{
  "recordType": "comment",
  "id": "EPA-R10-OW-2017-0369-1246",
  "objectId": "0900006482ba59a6",
  "title": "Comment submitted by J. Grimble",
  "documentType": "Public Submission",
  "agencyId": "EPA",
  "docketId": "EPA-R10-OW-2017-0369",
  "postedDate": "2017-10-11T04:00:00Z",
  "lastModifiedDate": "2017-10-12T01:52:49Z",
  "withdrawn": false,
  "url": "https://www.regulations.gov/comment/EPA-R10-OW-2017-0369-1246",
  "apiUrl": "https://api.regulations.gov/v4/comments/EPA-R10-OW-2017-0369-1246"
}
```

#### Field Reference

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Which endpoint produced the record: `document`, `docket`, or `comment`. |
| `id` | string | Regulations.gov ID (e.g., `EPA-HQ-OAR-2023-0234-0005`). |
| `objectId` | string | Internal regulations.gov object identifier — useful for cross-referencing and for filtering comments by parent document. |
| `title` | string | Record title. |
| `documentType` | string | Document type or (for dockets) the docket type. |
| `subtype` | string | Document subtype (e.g., `Final Rule`, `Interim Final Rule`). |
| `agencyId` | string | Agency acronym (e.g., `EPA`, `FAA`, `SEC`). |
| `docketId` | string | Parent docket ID (documents and comments). |
| `docketType` | string | `Rulemaking` or `Nonrulemaking` (dockets only). |
| `frDocNum` | string | Federal Register document number (documents only). |
| `commentStartDate` | string | Start of comment period (ISO 8601). |
| `commentEndDate` | string | End of comment period (ISO 8601). |
| `postedDate` | string | Date the record was posted. |
| `lastModifiedDate` | string | Last modification timestamp. |
| `withinCommentPeriod` | boolean | Whether the comment period is currently open. |
| `openForComment` | boolean | Whether the record is currently accepting comments. |
| `withdrawn` | boolean | Whether the record has been withdrawn. |
| `allowLateComments` | boolean | Whether late comments are permitted. |
| `commentOnId` | string | Object ID of the parent document (comments only). |
| `commentOnDocumentId` | string | Document ID the comment is on (comments only). |
| `url` | string | Public regulations.gov URL for the record. |
| `apiUrl` | string | API URL for fetching the full detail record (including attachments, CFR parts, effective dates, topics, etc.). |

For document-level details like CFR part, effective date, topics, page count, and attached file URLs, call `apiUrl` directly with the same API key. The list endpoint used here returns the summary fields; the detail endpoint returns everything.

***

### FAQ

#### How do I scrape regulations.gov?

Regulations.gov Crawler hits the official v4 REST API. Pick a `dataType` (`documents`, `dockets`, or `comments`), add filters, and run it. No browser, no HTML parsing, no proxy.

#### Do I need an API key?

Regulations.gov Crawler works without one, but not very well. The shared DEMO\_KEY is rate-limited to 10 requests per hour across all users of the API. Get a free key at [open.gsa.gov/api/regulationsgov](https://open.gsa.gov/api/regulationsgov/) — it takes about a minute and bumps your quota to 1,000 requests per hour.

#### How much data can I pull in one run?

Regulations.gov Crawler is capped at 5,000 records per query by the API itself (20 pages × 250 records). For larger datasets, narrow your filters — by agency, date range, or docket — and run the actor multiple times. The date range filters are especially useful for slicing large agencies into monthly windows.

#### Can I get the full text of public comments?

Regulations.gov Crawler returns comment metadata and titles in the list response. Full comment text lives on the per-comment detail endpoint, which is linked as `apiUrl` on each record. The list endpoint would otherwise slow to a crawl under the API's strict rate limits.

#### Does this actor need proxies?

Regulations.gov Crawler is a public U.S. government API with no anti-bot measures. No proxy needed. The only throttling is the api.data.gov hourly quota, which a real API key solves.

#### How much does it cost to run?

Regulations.gov Crawler uses the standard PPE pricing model: $0.10 per run start plus $0.001 per record. A 500-record pull costs about $0.60. A full 5,000-record run is $5.10.

***

### Need More Features?

Need detail-level fields (CFR parts, effective dates, attachments), a different endpoint, or bulk comment-text extraction? [File an issue](https://console.apify.com/actors/issues) or get in touch.

### Why Use Regulations.gov Crawler?

- **Covers all three endpoints** — Documents, dockets, and comments in one actor. Other regulations.gov scrapers on the Apify store pick one and stop there.
- **Uses the official API** — Structured JSON, stable schemas, no HTML parsing brittleness, no surprise 500s from the rendered site.
- **Bring your own key** — The actor supports your own api.data.gov key so you can run it at full throughput without sharing a quota with strangers.

# Actor input Schema

## `sp_intended_usage` (type: `string`):

Please describe how you plan to use the data extracted by this crawler.

## `sp_improvement_suggestions` (type: `string`):

Provide any feedback or suggestions for improvements.

## `sp_contact` (type: `string`):

Provide your email address so we can get in touch with you.

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

Your free api.data.gov key. Sign up at https://open.gsa.gov/api/regulationsgov/ (takes ~1 minute). Optional but strongly recommended -- free tier is 1000 requests/hour. Without your own key the actor may hit rate limits quickly.

## `dataType` (type: `string`):

Which regulations.gov endpoint to query. Documents = rules and notices. Dockets = the folders grouping related documents. Comments = public submissions on documents.

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

Full-text search across titles and abstracts. E.g., 'tariff', 'artificial intelligence', 'climate'. Leave empty for no keyword filter.

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

Filter documents by type. Ignored for dockets and comments.

## `docketType` (type: `string`):

Filter dockets by type. Ignored for documents and comments.

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

Agency acronym (e.g., EPA, FAA, SEC, DOT, FDA, FCC, NRC). Leave empty for all agencies.

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

Filter to a specific docket (e.g., 'EPA-HQ-OAR-2023-0234'). Returns all documents or comments within that docket. Ignored when data type is dockets.

## `postedDateFrom` (type: `string`):

Return records posted on or after this date (YYYY-MM-DD).

## `postedDateTo` (type: `string`):

Return records posted on or before this date (YYYY-MM-DD).

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

How to sort results.

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

Maximum records to return. The regulations.gov API caps results at 5,000 per query (20 pages x 250 records). For more, narrow filters and run multiple invocations.

## `proxyConfiguration` (type: `object`):

Select proxies. Regulations.gov is a government API and does not require proxies.

## Actor input object example

```json
{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "dataType": "documents",
  "sortBy": "-lastModifiedDate",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "apiKey": "",
    "dataType": "documents",
    "searchTerm": "",
    "documentType": "",
    "docketType": "",
    "agencyId": "",
    "docketId": "",
    "postedDateFrom": "",
    "postedDateTo": "",
    "sortBy": "-lastModifiedDate",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("jungle_synthesizer/regulations-gov-crawler").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 = {
    "sp_intended_usage": "Describe your intended use...",
    "sp_improvement_suggestions": "Share your suggestions here...",
    "sp_contact": "Share your email here...",
    "apiKey": "",
    "dataType": "documents",
    "searchTerm": "",
    "documentType": "",
    "docketType": "",
    "agencyId": "",
    "docketId": "",
    "postedDateFrom": "",
    "postedDateTo": "",
    "sortBy": "-lastModifiedDate",
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("jungle_synthesizer/regulations-gov-crawler").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 '{
  "sp_intended_usage": "Describe your intended use...",
  "sp_improvement_suggestions": "Share your suggestions here...",
  "sp_contact": "Share your email here...",
  "apiKey": "",
  "dataType": "documents",
  "searchTerm": "",
  "documentType": "",
  "docketType": "",
  "agencyId": "",
  "docketId": "",
  "postedDateFrom": "",
  "postedDateTo": "",
  "sortBy": "-lastModifiedDate",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call jungle_synthesizer/regulations-gov-crawler --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Regulations.gov Crawler - Rules, Dockets, Public Comments",
        "description": "Query the official regulations.gov v4 API for federal rules, proposed rules, notices, dockets, and public comments. Filter by agency, document type, docket, date range, and keywords. Requires a free API key.",
        "version": "1.0",
        "x-build-id": "C3EqIyR30iGRPSUIa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jungle_synthesizer~regulations-gov-crawler/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jungle_synthesizer-regulations-gov-crawler",
                "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/jungle_synthesizer~regulations-gov-crawler/runs": {
            "post": {
                "operationId": "runs-sync-jungle_synthesizer-regulations-gov-crawler",
                "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/jungle_synthesizer~regulations-gov-crawler/run-sync": {
            "post": {
                "operationId": "run-sync-jungle_synthesizer-regulations-gov-crawler",
                "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",
                "required": [
                    "sp_intended_usage",
                    "sp_improvement_suggestions"
                ],
                "properties": {
                    "sp_intended_usage": {
                        "title": "What is the intended usage of this data?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Please describe how you plan to use the data extracted by this crawler."
                    },
                    "sp_improvement_suggestions": {
                        "title": "How can we improve this crawler for you?",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide any feedback or suggestions for improvements."
                    },
                    "sp_contact": {
                        "title": "Contact Email",
                        "minLength": 1,
                        "type": "string",
                        "description": "Provide your email address so we can get in touch with you."
                    },
                    "apiKey": {
                        "title": "Regulations.gov API Key",
                        "type": "string",
                        "description": "Your free api.data.gov key. Sign up at https://open.gsa.gov/api/regulationsgov/ (takes ~1 minute). Optional but strongly recommended -- free tier is 1000 requests/hour. Without your own key the actor may hit rate limits quickly."
                    },
                    "dataType": {
                        "title": "Data Type",
                        "enum": [
                            "documents",
                            "dockets",
                            "comments"
                        ],
                        "type": "string",
                        "description": "Which regulations.gov endpoint to query. Documents = rules and notices. Dockets = the folders grouping related documents. Comments = public submissions on documents.",
                        "default": "documents"
                    },
                    "searchTerm": {
                        "title": "Search Term",
                        "type": "string",
                        "description": "Full-text search across titles and abstracts. E.g., 'tariff', 'artificial intelligence', 'climate'. Leave empty for no keyword filter."
                    },
                    "documentType": {
                        "title": "Document Type (documents only)",
                        "enum": [
                            "",
                            "Rule",
                            "Proposed Rule",
                            "Notice",
                            "Supporting & Related Material",
                            "Other"
                        ],
                        "type": "string",
                        "description": "Filter documents by type. Ignored for dockets and comments."
                    },
                    "docketType": {
                        "title": "Docket Type (dockets only)",
                        "enum": [
                            "",
                            "Rulemaking",
                            "Nonrulemaking"
                        ],
                        "type": "string",
                        "description": "Filter dockets by type. Ignored for documents and comments."
                    },
                    "agencyId": {
                        "title": "Agency",
                        "type": "string",
                        "description": "Agency acronym (e.g., EPA, FAA, SEC, DOT, FDA, FCC, NRC). Leave empty for all agencies."
                    },
                    "docketId": {
                        "title": "Docket ID (documents & comments only)",
                        "type": "string",
                        "description": "Filter to a specific docket (e.g., 'EPA-HQ-OAR-2023-0234'). Returns all documents or comments within that docket. Ignored when data type is dockets."
                    },
                    "postedDateFrom": {
                        "title": "Posted On Or After",
                        "type": "string",
                        "description": "Return records posted on or after this date (YYYY-MM-DD)."
                    },
                    "postedDateTo": {
                        "title": "Posted On Or Before",
                        "type": "string",
                        "description": "Return records posted on or before this date (YYYY-MM-DD)."
                    },
                    "sortBy": {
                        "title": "Sort By",
                        "enum": [
                            "-lastModifiedDate",
                            "lastModifiedDate",
                            "-postedDate",
                            "postedDate",
                            "title"
                        ],
                        "type": "string",
                        "description": "How to sort results.",
                        "default": "-lastModifiedDate"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum records to return. The regulations.gov API caps results at 5,000 per query (20 pages x 250 records). For more, narrow filters and run multiple invocations.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies. Regulations.gov is a government API and does not require proxies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
