# US Rule Watchlist Monitor (`enfex/federal-register-rule-watchlist`) Actor

Monitor explicit Federal Register agency watchlists for new or changed published rules and proposed rules with bounded public API queries and change-only output.

- **URL**: https://apify.com/enfex/federal-register-rule-watchlist.md
- **Developed by:** [Marcel K](https://apify.com/enfex) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 checked rule watchlist agencies

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

## US Rule Watchlist Monitor

Monitor an explicit FederalRegister.gov agency watchlist for newly published or changed rules and proposed rules. The Actor uses one bounded public API request per agency, stores a compact baseline, and returns only changed agency snapshots by default.

### What it does

- Accepts explicit Federal Register agency slugs only; it does not crawl arbitrary URLs, PDF files, private portals, or user accounts.
- Queries only published `RULE` and `PRORULE` source documents through the public FederalRegister.gov API.
- Retains a bounded newest-document snapshot per agency, including document number, title, document type, publication date, source URLs, optional source abstract, and effective date when supplied.
- Persists normalized snapshots by `baselineKey` to detect availability and document-metadata changes.
- Returns structured per-agency errors instead of terminating a whole watchlist run.
- Omits unchanged agency snapshots by default, keeping scheduled datasets compact.

### Good use cases

- Compliance teams tracking a narrow agency rulemaking watchlist.
- Policy analysts collecting a machine-readable review queue for specific federal agencies.
- Legal operations teams that need source metadata before their own legal review workflow.

### Input

- `agencySlugs`: required FederalRegister.gov agency slugs, such as `environmental-protection-agency`.
- `documentTypes`: optional `RULE` and/or `PRORULE`; both are queried by default.
- `maxAgencies`: run cap from 1 to 25; v1 defaults to 10.
- `maxDocumentsPerAgency`: bounded newest source documents from 1 to 10; v1 defaults to 3.
- `includeUnchanged`: include unchanged source snapshots after an initial baseline.
- `baselineKey`: separate stored baselines for environments, clients, or schedules.

Example:

```json
{
  "agencySlugs": ["environmental-protection-agency"],
  "documentTypes": ["RULE"],
  "maxAgencies": 1,
  "maxDocumentsPerAgency": 1,
  "includeUnchanged": false,
  "baselineKey": "production"
}
````

### Output

Each dataset row represents one agency snapshot that changed, was explicitly requested as unchanged, or could not be checked.

```json
{
  "agencySlug": "environmental-protection-agency",
  "checkedAt": "2026-07-10T01:00:00.000Z",
  "status": "ok",
  "changed": true,
  "changeTypes": ["documents"],
  "documents": [{
    "documentNumber": "2026-13843",
    "title": "Air Plan Approval; Michigan; Redesignation and Maintenance Plan",
    "type": "Rule",
    "publicationDate": "2026-07-09",
    "htmlUrl": "https://www.federalregister.gov/documents/..."
  }],
  "previousDocuments": [],
  "sourceUrl": "https://www.federalregister.gov/api/v1/documents.json?...",
  "snapshotHash": "...",
  "warnings": []
}
```

`status` values:

- `ok`: the source returned usable document records.
- `not_found`: no matching public document records were returned.
- `partial`: usable records were returned but malformed source rows were omitted.
- `error`: invalid agency input or a source failure; inspect `warnings` for a machine-readable code.

### Pricing status

Pay Per Event is enabled at **$0.002 per checked agency** using the `checked-rule-watchlist-agency` event. Input is capped at 25 agencies, so a full run costs at most **$0.05** in event charges. Charging happens before each FederalRegister.gov source request and stops before the next source request when the Apify event-charge limit is reached.

### Source, terms, and limitations

- Source: FederalRegister.gov public API: <https://www.federalregister.gov/developers/documentation/api/v1>.
- The source documentation says its APIs are public and require no API keys. This Actor uses one fixed-host HTTPS JSON query per explicit agency with a 8-second timeout, two redirect maximum, 256 KiB response cap, and no browser or proxy.
- The source site says its XML renditions are an unofficial informational resource; buyers must verify legal research against an official edition or the linked official PDF/GPO source.
- This Actor is not legal advice, does not determine applicability, deadlines, or compliance obligations, and must not be the sole basis for legal or regulatory decisions.
- This is an unofficial independent tool and is not affiliated with, endorsed by, or sponsored by the Office of the Federal Register, NARA, GPO, or FederalRegister.gov. No government seal, logo, or third-party branded asset is used.

### Recommended workflow

1. Run once with a stable `baselineKey` to establish an agency snapshot.
2. Schedule later checks with the same key.
3. Keep `includeUnchanged=false` for a compact review queue.
4. Open the source URLs and verify against official sources before acting on any result.

# Actor input Schema

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

Explicit FederalRegister.gov agency slugs to check, for example environmental-protection-agency. This Actor does not crawl arbitrary URLs or search private sources.

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

Published rule types to query. Defaults to both RULE and PRORULE.

## `maxAgencies` (type: `integer`):

Maximum unique agency slugs processed in a run. Hard-capped at 25.

## `maxDocumentsPerAgency` (type: `integer`):

Maximum newest source documents retained in each agency snapshot. Hard-capped at 10.

## `includeUnchanged` (type: `boolean`):

When false, only changed agency snapshots and structured errors are pushed after a baseline exists.

## `baselineKey` (type: `string`):

Namespace for stored watchlist snapshots, for example production, client-a, or weekly.

## Actor input object example

```json
{
  "agencySlugs": [
    "environmental-protection-agency"
  ],
  "documentTypes": [
    "RULE",
    "PRORULE"
  ],
  "maxAgencies": 10,
  "maxDocumentsPerAgency": 3,
  "includeUnchanged": false
}
```

# Actor output Schema

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

Default dataset items. Each item contains one agency snapshot and its public FederalRegister.gov source metadata.

# 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 = {
    "agencySlugs": [
        "environmental-protection-agency"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("enfex/federal-register-rule-watchlist").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 = { "agencySlugs": ["environmental-protection-agency"] }

# Run the Actor and wait for it to finish
run = client.actor("enfex/federal-register-rule-watchlist").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 '{
  "agencySlugs": [
    "environmental-protection-agency"
  ]
}' |
apify call enfex/federal-register-rule-watchlist --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Rule Watchlist Monitor",
        "description": "Monitor explicit Federal Register agency watchlists for new or changed published rules and proposed rules with bounded public API queries and change-only output.",
        "version": "0.1",
        "x-build-id": "CmqBZfoSvGebSoeO0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/enfex~federal-register-rule-watchlist/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-enfex-federal-register-rule-watchlist",
                "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/enfex~federal-register-rule-watchlist/runs": {
            "post": {
                "operationId": "runs-sync-enfex-federal-register-rule-watchlist",
                "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/enfex~federal-register-rule-watchlist/run-sync": {
            "post": {
                "operationId": "run-sync-enfex-federal-register-rule-watchlist",
                "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": [
                    "agencySlugs"
                ],
                "properties": {
                    "agencySlugs": {
                        "title": "Federal Register agency slugs",
                        "minItems": 1,
                        "maxItems": 25,
                        "type": "array",
                        "description": "Explicit FederalRegister.gov agency slugs to check, for example environmental-protection-agency. This Actor does not crawl arbitrary URLs or search private sources.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "documentTypes": {
                        "title": "Document types",
                        "type": "array",
                        "description": "Published rule types to query. Defaults to both RULE and PRORULE.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "RULE",
                                "PRORULE"
                            ]
                        },
                        "default": [
                            "RULE",
                            "PRORULE"
                        ]
                    },
                    "maxAgencies": {
                        "title": "Max agencies",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum unique agency slugs processed in a run. Hard-capped at 25.",
                        "default": 10
                    },
                    "maxDocumentsPerAgency": {
                        "title": "Latest documents per agency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum newest source documents retained in each agency snapshot. Hard-capped at 10.",
                        "default": 3
                    },
                    "includeUnchanged": {
                        "title": "Include unchanged agencies",
                        "type": "boolean",
                        "description": "When false, only changed agency snapshots and structured errors are pushed after a baseline exists.",
                        "default": false
                    },
                    "baselineKey": {
                        "title": "Baseline key",
                        "type": "string",
                        "description": "Namespace for stored watchlist snapshots, for example production, client-a, or weekly."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
