# 📜 Federal Register Scraper (`skootle/federal-rulemaking-monitor`) Actor

Stop checking Federal Register and Regulations.gov separately. Get rules, docket IDs, public-comment counts, agency IDs, CFR parts, and days-to-close fields in one row. Add a free Regulations.gov key for comment enrichment. Export, run via API, schedule, or integrate with other tools.

- **URL**: https://apify.com/skootle/federal-rulemaking-monitor.md
- **Developed by:** [Skootle](https://apify.com/skootle) (community)
- **Categories:** Developer tools, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 rulemaking records

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

<!-- skootle:growth-loop-hook -->
### Stop checking two government systems for every rule

Never miss a federal comment deadline because Federal Register rules and Regulations.gov dockets live in separate systems. One run searches the rules, normalizes agency and CFR data, and, with a free API key, joins docket and public-comment context.

- Catch proposed rules before comment windows close.
- See official rule links, agency IDs, CFR references, docket IDs, and comment activity together.
- Schedule agency or topic searches and send results to alerts, spreadsheets, databases, or client briefings.

![Federal Rulemaking Monitor hero](https://raw.githubusercontent.com/kesjam/skootle-actors-assets/main/heroes/federal-rulemaking-monitor-v2.png)

### TL;DR

Search Federal Register rules, proposed rules, notices, and presidential documents by agency, keyword, CFR title or part, document type, and publication date. With a free Regulations.gov API key, matching rows also include docket IDs, public-comment counts, and recent comment excerpts. Every record includes official links, normalized agency and CFR fields, `isOpenForComment`, and ready-to-filter deadline countdowns when the source publishes those dates.

**Verified cloud proof:** a July 17 standard run returned 5 proposed-rule records with 0 recorded errors. A separate Regulations.gov-enabled run returned 10 rules, matched 9 dockets, and attached recent public comments to 8 rows with 0 recorded errors. [Inspect the public enriched sample dataset.](https://api.apify.com/v2/datasets/90Tu7A33askeIiHVs/items?clean=true)

<!-- skootle:review-cta -->
> Try it on a small dataset, then let us know what you think in a [review](https://apify.com/skootle/federal-rulemaking-monitor/reviews).

---

### What does Federal Rulemaking Monitor do?

The **Federal Register** publishes every U.S. federal rulemaking action - proposed rules, final rules, notices, and presidential documents - at `federalregister.gov` under a public API. **Regulations.gov** publishes the matching docket for each rulemaking, including all public comments filed during the comment period, at `api.regulations.gov`. The two systems are designed to be cross-referenced, but the cross-reference requires a separate API call per document, and most existing scrapers stop at one source.

This Actor always searches the Federal Register. When `enrichWithRegulationsGov` is enabled with a valid API key, it also looks up a matching Regulations.gov document by FR document number. If a match exists, the row gains its docket ID, comment count, and up to the requested number of recent comments; otherwise those fields remain null or empty.

The Actor adds three monitor-ready enrichments:

1. **Canonical agency IDs.** "Environmental Protection Agency", "Defense Department", and `defense-department` all map to short canonical IDs like `EPA`, `DOD`. Buyers filtering "all EPA rulemakings" don't have to enumerate every name variation.
2. **`daysUntilCommentClose` and `daysUntilEffective` countdowns** derived from the rule's comment-end and effective dates, computed against the run time. Monitor workflows ("alert me if any EPA rule has a comment period closing in the next 7 days") become one filter expression.
3. **`isOpenForComment` boolean** so binary filters work out of the box.

### Why scrape federal rulemaking?

Federal rulemaking affects compliance, product, legal, and policy decisions across industries. Lobbyists, regulatory-affairs teams, trade associations, and researchers monitor it continuously. The official APIs are free, but the buyer workflow often requires three integration steps:

1. **Cross-reference FR ↔ Regulations.gov.** Many proposed rules have a public-comment docket on Regulations.gov. Matching by `frDocNum` requires a second API workflow, and unmatched rows must remain valid without enrichment.
2. **Agency taxonomy.** FR returns the agency name as a free-text string and the slug in one of two competing formats (`department-of-x` and `x-department`). Without canonicalization, agency-level analytics fragment across both forms.
3. **Date arithmetic.** Comment-period close dates and effective dates live in the document, but the *days remaining* is what monitor pipelines actually need - and they recompute it every time the document is read. Bake it in once at scrape time.

This actor handles all three. The output is a daily-monitor-ready dataset where the only thing your downstream system has to do is filter.

### Who needs this?

- **In-house regulatory-affairs teams** at Fortune 500s (healthcare, energy, finance, telecom) monitoring proposed rules affecting their industry.
- **Lobbyists and government-affairs agencies** preparing comment-letter campaigns. The recent-comments field surfaces what other organizations have already filed.
- **Trade associations** running weekly digests of rulemakings affecting their member companies.
- **AI-policy and tech-policy think tanks** tracking proposed rules across multiple agencies on a single topic ("AI safety", "biometric data").
- **Public-affairs and ESG analysts** at PE / VC firms doing diligence on regulatory exposure of portfolio companies.
- **Law firms** building regulatory-compliance update services for clients.
- **AI agents and automation pipelines** that need a daily / weekly digest of new rulemakings piped into Slack, an LLM context, or a structured DB.

### How to use Federal Rulemaking Monitor

1. Open the actor in the Apify Console.
2. Set at least one filter: `searchTerm`, `agencyKeywords`, `cfrTitle`, `documentTypes`, or a `publicationDate` range.
3. (Optional) Set `regulationsGovApiKey` to enable comment-data enrichment. The actor still works without it but skips comment fields. Free key at `https://open.gsa.gov/api/regulationsgov/` (5-minute signup).
4. (Optional) Tune `recentCommentsPerDoc` (default 5).
5. Set `maxItems` (default 10 for trial; production typically 100-1000).
6. Click **Start**.

### How much will scraping federal rulemaking cost?

Pricing is per-result (per Federal Register document written to the dataset). Regulations.gov enrichment calls do not incur a separate event charge - they piggyback on the document event.

| Plan tier | Per-result price |
|---|---|
| FREE | $0.008 |
| BRONZE | $0.006 |
| SILVER | $0.005 |
| GOLD | $0.004 |
| PLATINUM | $0.004 |
| DIAMOND | $0.004 |

A 10-row trial costs $0.08 on the FREE tier or $0.04 on GOLD. The final cost depends only on the number of Federal Register records saved; use `maxItems` to set a predictable ceiling.

### Is it legal to scrape the Federal Register and Regulations.gov?

Yes. Both are official U.S. government publication systems explicitly released for public reuse. The Federal Register is published under 44 U.S.C. § 1505. Regulations.gov is operated by GSA and the official API is documented at `https://open.gsa.gov/api/regulationsgov/`. No authentication is needed for Federal Register; Regulations.gov uses an API-key system designed for third-party developers (free tier, 1000 requests/hour). This actor honors rate limits on both sources.

The data describes named individuals only in the case of public comments submitted by named individuals (who self-disclosed). Downstream use is bound by general privacy law in your jurisdiction; consult your own counsel for customer-facing products.

### Examples

**Daily climate rulemaking monitor.**

```json
{
  "searchTerm": "climate",
  "documentTypes": ["RULE", "PRORULE"],
  "publicationDateFrom": "2026-07-01",
  "maxItems": 100
}
````

**EPA proposed rules with open comment periods.**

```json
{
  "agencyKeywords": ["environmental-protection-agency"],
  "documentTypes": ["PRORULE"],
  "maxItems": 50
}
```

**All rules referencing 17 CFR (Securities and Commodities).**

```json
{
  "cfrTitle": 17,
  "documentTypes": ["RULE", "PRORULE"],
  "publicationDateFrom": "2026-07-01",
  "maxItems": 200
}
```

**Track CMS healthcare rulemaking.**

```json
{
  "agencyKeywords": ["centers-for-medicare-medicaid-services"],
  "documentTypes": ["RULE", "PRORULE", "NOTICE"],
  "maxItems": 50,
  "enrichWithRegulationsGov": true,
  "regulationsGovApiKey": "PASTE-YOUR-KEY"
}
```

**AI-policy comprehensive sweep across agencies.**

```json
{
  "searchTerm": "artificial intelligence",
  "documentTypes": ["RULE", "PRORULE", "NOTICE"],
  "publicationDateFrom": "2026-07-01",
  "maxItems": 200
}
```

**Watch for new PFAS rules.**

```json
{
  "searchTerm": "PFAS",
  "documentTypes": ["RULE", "PRORULE"],
  "publicationDateFrom": "2026-07-01",
  "maxItems": 100
}
```

### Input parameters

| Field | Type | Description |
|---|---|---|
| `searchTerm` | string | Free-text search across titles, abstracts, full text. |
| `documentTypes` | string\[] | `RULE`, `PRORULE`, `NOTICE`, `PRESDOCU`. |
| `agencyKeywords` | string\[] | Federal Register agency slugs. |
| `cfrTitle` | integer | Restrict to rules referencing a CFR title. |
| `cfrPart` | integer | Use with `cfrTitle` for a specific part. |
| `publicationDateFrom` | string | ISO date inclusive. |
| `publicationDateTo` | string | ISO date inclusive. |
| `enrichWithRegulationsGov` | boolean | Join to Regulations.gov dockets (default true). |
| `regulationsGovApiKey` | string | Free key - required for enrichment. |
| `recentCommentsPerDoc` | integer | 0-25 comments per doc (default 5). |
| `maxItems` | integer | Upper bound on rows. Default 10 (trial); production 100-1000. |

### Output format

| Field | Type | Notes |
|---|---|---|
| `recordType` | string | Always `"rulemaking"`. |
| `outputSchemaVersion` | string | `"2026-05-12"` until breaking change. |
| `documentNumber` | string | FR document number. |
| `title` | string | Rule title as published. |
| `abstract` | string | Plain-text summary. |
| `documentType` | string | Proposed Rule / Rule / Notice / Presidential Document. |
| `agencyCanonicalIds` | string\[] | Short canonical IDs (EPA, CMS, SEC, etc.). |
| `agencyNames` | string\[] | Full agency names. |
| `cfrReferences` | object\[] | `{title, part, chapter}` typed numerics. |
| `topics` | string\[] | FR taxonomy terms. |
| `publicationDate` | string | ISO date. |
| `effectiveDate` | string | ISO date or null. |
| `commentEndDate` | string | ISO date or null. |
| `daysUntilCommentClose` | integer | Computed at scrape time; negative means closed. |
| `daysUntilEffective` | integer | Computed at scrape time. |
| `isOpenForComment` | boolean | True iff `commentEndDate` is in the future. |
| `htmlUrl`, `pdfUrl`, `publicInspectionPdfUrl` | string | Source URLs. |
| `regulationsGovDocketId` | string | E.g. "EPA-HQ-OAR-2026-1234". |
| `regulationsGovDocketUrl` | string | Public docket page. |
| `totalCommentCount` | integer | Total comments on the docket. |
| `recentComments` | object\[] | Most recent N with `{id, postedDate, title, excerpt, submitterName, organization, documentType}`. |
| `fieldCompletenessScore` | integer | 0-100. |
| `agentMarkdown` | string | Drop-into-LLM card. |

The record below came from the verified Regulations.gov-enabled cloud run:

```json
{
  "recordType": "rulemaking",
  "outputSchemaVersion": "2026-05-12",
  "documentNumber": "2026-04388",
  "title": "Clean Water Act Hazardous Substance Facility Response Plans: Compliance Date Delay and Changes To Reflect Administration Policy",
  "agencyCanonicalIds": ["EPA"],
  "publicationDate": "2026-03-05",
  "regulationsGovDocketId": "EPA-HQ-OLEM-2021-0585",
  "totalCommentCount": 251,
  "recentComments": [{
    "id": "EPA-HQ-OLEM-2021-0585-0431",
    "postedDate": "2026-04-13",
    "title": "Comment submitted by Native Village of Dot Lake",
    "documentType": "Public Submission"
  }],
  "htmlUrl": "https://www.federalregister.gov/documents/2026/03/05/2026-04388/clean-water-act-hazardous-substance-facility-response-plans-compliance-date-delay-and-changes-to"
}
```

### During the Actor run

The actor queries the Federal Register `/api/v1/documents` endpoint, paging 100 rows at a time. For each document, if Regulations.gov enrichment is enabled, it issues two follow-up calls (1) to find the matching docket by `frDocNum`, (2) to pull recent comments on that docket. Records push to the default dataset as they're normalized.

KV store artifacts:

- `OUTPUT`: counts, agencies covered, by-type breakdown, API call counts, errors.
- `AGENT_BRIEFING`: markdown digest highlighting comment periods closing in the next 30 days.

### FAQ

#### How is this different from a free Federal Register scraper?

The value here is the verified workflow: Federal Register search, optional Regulations.gov docket and comment enrichment, normalized agency and CFR fields, date arithmetic, direct source links, and agent-ready output in one run.

#### Can I monitor only new rules since my last run?

Yes - schedule the actor to run daily with the same input parameters and a `publicationDateFrom` set to "yesterday". The actor will emit only rules published in that window. Dedupe downstream on `documentNumber` for safety.

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

Only if you want comment data attached. The actor works without it but skips the docket join + comment fields. The free key is straightforward - visit `https://open.gsa.gov/api/regulationsgov/`, click "Get a key", fill the form, key arrives by email within minutes. Free tier is 1000 requests/hour.

#### Can I use this with Python / Make / Zapier / n8n / Slack?

Yes. The Apify Python client and all four integrations are first-class. The `agentMarkdown` field is designed for direct posting into a Slack channel.

#### What about FR documents that don't have a Regulations.gov docket?

Some FR documents (presidential documents, certain notices) have no matching docket. The actor leaves `regulationsGovDocketId`, `totalCommentCount`, and `recentComments` null on those rows. The rule data itself is still complete.

#### How fresh is the Federal Register data?

Federal Register publishes on weekdays. For monitoring, schedule recurring runs with an overlapping publication-date window and deduplicate on `documentNumber`.

#### Can I filter to one agency without listing every variation?

The actor canonicalizes agencies into short IDs like `EPA`, but filtering at the Federal Register query layer requires their slug format. Use `agencyKeywords: ["environmental-protection-agency"]`. The output field `agencyCanonicalIds` is the post-processing convenience.

#### Why are comments truncated?

Comments are truncated to 400 chars in the `excerpt` field to keep dataset rows manageable. The full text is available at `https://www.regulations.gov/comment/{id}`. Most LLM use cases need only the excerpt to classify support/oppose/neutral.

#### Your feedback

Hit a bug or want a feature? Open an issue on the [Issues tab](https://apify.com/skootle/federal-rulemaking-monitor/issues/open) rather than the reviews page, and we'll fix it fast (typically within 48 hours).

### Why choose Federal Rulemaking Monitor

- **Joined FR + Regulations.gov fields** in a single dataset row when a matching public docket is available.
- **Canonical agency IDs** that collapse both slug variants and full agency names into a single short ID. Filter `EPA` once, not three ways.
- **Date countdowns baked in.** `daysUntilCommentClose` and `daysUntilEffective` are computed at scrape time. No client-side date math.
- **`isOpenForComment` boolean** for one-filter monitor pipelines.
- **Recent-comments excerpts** attached to each docket, ready for LLM classification (support / oppose / neutral / data-quality).
- **Versioned schema** (`outputSchemaVersion: "2026-05-12"`). Breaking changes bump the version.
- **`fieldCompletenessScore`** per record for self-filtering of sparse rows.
- **`agentMarkdown`** per record + **`AGENT_BRIEFING.md`** per run for direct LLM / Slack consumption.

### Other Skootle actors you might want to check

- [SAM.gov + USAspending Federal Contracts](https://apify.com/skootle/sam-gov-federal-contracts) - federal contract opportunities joined to USAspending awards.
- [SEC EDGAR Filings](https://apify.com/skootle/sec-edgar-filings) - full-text SEC filing search.
- [CMS Open Payments](https://apify.com/skootle/cms-open-payments) - pharma payments to physicians, NPI-joined.

### Support and contact

Open an issue at the [Issues tab](https://apify.com/skootle/federal-rulemaking-monitor/issues/open) for bugs, schema requests, or new filter ideas. Typical response time 48 hours.

# Actor input Schema

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

Free-text search across rule titles, abstracts, and full text (e.g. 'climate', 'PFAS', 'student loan').

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

Which Federal Register document categories to include. Default is rules + proposed rules.

## `agencyKeywords` (type: `array`):

Filter by Federal Register agency slug, e.g. \['environmental-protection-agency', 'securities-and-exchange-commission'].

## `cfrTitle` (type: `integer`):

Restrict to rules referencing this CFR title number (e.g. 17 for Securities and Commodities).

## `cfrPart` (type: `integer`):

Restrict to rules referencing this CFR part. Use with cfrTitle.

## `publicationDateFrom` (type: `string`):

ISO date (YYYY-MM-DD) for the earliest publication date to include.

## `publicationDateTo` (type: `string`):

ISO date (YYYY-MM-DD) for the latest publication date to include.

## `enrichWithRegulationsGov` (type: `boolean`):

Look up the matching Regulations.gov docket for every Federal Register document and attach total comment count + recent comments. Requires a free Regulations.gov API key (set regulationsGovApiKey).

## `regulationsGovApiKey` (type: `string`):

Required to enable Regulations.gov enrichment. Get a free key in 1 minute: (1) Visit https://open.gsa.gov/api/regulationsgov/. (2) Click 'Get a key'. (3) Fill the form. (4) Check your email and copy the key here. Stored encrypted. Free tier is 1000 requests/hour.

## `recentCommentsPerDoc` (type: `integer`):

How many of the most recent comments to attach per docket. Set 0 to skip comment scraping (still pulls total count).

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

Upper bound on Federal Register documents returned. Default 10 keeps trial runs under the 5-minute auto-test budget; production runs typically set 100-1000.

## Actor input object example

```json
{
  "documentTypes": [
    "RULE",
    "PRORULE"
  ],
  "agencyKeywords": [],
  "enrichWithRegulationsGov": true,
  "recentCommentsPerDoc": 5,
  "maxItems": 10
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Per-document records with agency canonical IDs, CFR refs, comment countdowns, recent comments.

## `runSummary` (type: `string`):

Compact OUTPUT object with counts and API call metrics.

## `agentBriefing` (type: `string`):

Markdown digest highlighting comment periods closing in the next 30 days.

# 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 = {
    "documentTypes": [
        "RULE",
        "PRORULE"
    ],
    "agencyKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("skootle/federal-rulemaking-monitor").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 = {
    "documentTypes": [
        "RULE",
        "PRORULE",
    ],
    "agencyKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("skootle/federal-rulemaking-monitor").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 '{
  "documentTypes": [
    "RULE",
    "PRORULE"
  ],
  "agencyKeywords": []
}' |
apify call skootle/federal-rulemaking-monitor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "📜 Federal Register Scraper",
        "description": "Stop checking Federal Register and Regulations.gov separately. Get rules, docket IDs, public-comment counts, agency IDs, CFR parts, and days-to-close fields in one row. Add a free Regulations.gov key for comment enrichment. Export, run via API, schedule, or integrate with other tools.",
        "version": "0.1",
        "x-build-id": "AnQs2Y4fHbKbCWhxo"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/skootle~federal-rulemaking-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-skootle-federal-rulemaking-monitor",
                "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/skootle~federal-rulemaking-monitor/runs": {
            "post": {
                "operationId": "runs-sync-skootle-federal-rulemaking-monitor",
                "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/skootle~federal-rulemaking-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-skootle-federal-rulemaking-monitor",
                "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": "Free-text search across rule titles, abstracts, and full text (e.g. 'climate', 'PFAS', 'student loan')."
                    },
                    "documentTypes": {
                        "title": "Document types",
                        "type": "array",
                        "description": "Which Federal Register document categories to include. Default is rules + proposed rules.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RULE",
                                "PRORULE",
                                "NOTICE",
                                "PRESDOCU"
                            ],
                            "enumTitles": [
                                "Final Rules (RULE)",
                                "Proposed Rules (PRORULE)",
                                "Notices (NOTICE)",
                                "Presidential Documents (PRESDOCU)"
                            ]
                        }
                    },
                    "agencyKeywords": {
                        "title": "Agency keywords",
                        "type": "array",
                        "description": "Filter by Federal Register agency slug, e.g. ['environmental-protection-agency', 'securities-and-exchange-commission'].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "cfrTitle": {
                        "title": "CFR title",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Restrict to rules referencing this CFR title number (e.g. 17 for Securities and Commodities)."
                    },
                    "cfrPart": {
                        "title": "CFR part",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Restrict to rules referencing this CFR part. Use with cfrTitle."
                    },
                    "publicationDateFrom": {
                        "title": "Publication date from",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD) for the earliest publication date to include."
                    },
                    "publicationDateTo": {
                        "title": "Publication date to",
                        "type": "string",
                        "description": "ISO date (YYYY-MM-DD) for the latest publication date to include."
                    },
                    "enrichWithRegulationsGov": {
                        "title": "Enrich with Regulations.gov docket data",
                        "type": "boolean",
                        "description": "Look up the matching Regulations.gov docket for every Federal Register document and attach total comment count + recent comments. Requires a free Regulations.gov API key (set regulationsGovApiKey).",
                        "default": true
                    },
                    "regulationsGovApiKey": {
                        "title": "Regulations.gov API key",
                        "type": "string",
                        "description": "Required to enable Regulations.gov enrichment. Get a free key in 1 minute: (1) Visit https://open.gsa.gov/api/regulationsgov/. (2) Click 'Get a key'. (3) Fill the form. (4) Check your email and copy the key here. Stored encrypted. Free tier is 1000 requests/hour."
                    },
                    "recentCommentsPerDoc": {
                        "title": "Recent comments per document",
                        "minimum": 0,
                        "maximum": 25,
                        "type": "integer",
                        "description": "How many of the most recent comments to attach per docket. Set 0 to skip comment scraping (still pulls total count).",
                        "default": 5
                    },
                    "maxItems": {
                        "title": "Max documents",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Upper bound on Federal Register documents returned. Default 10 keeps trial runs under the 5-minute auto-test budget; production runs typically set 100-1000.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
