# Regulation Change Monitor (`arched_friend/regulation-change-monitor`) Actor

Watch the US Federal Register for rules, proposed rules and notices affecting your business. Returns the agency, the action, the CFR parts touched, when comments close and how many days are left, with new documents and moved deadlines flagged each run.

- **URL**: https://apify.com/arched\_friend/regulation-change-monitor.md
- **Developed by:** [Peach O](https://apify.com/arched_friend) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 document returneds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

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

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

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

# README

## Regulation Change Monitor: Never Miss a Comment Deadline

Watch the US Federal Register for rules, proposed rules and notices on any subject. You get the agency, what the document does, the CFR parts it touches, when the comment period closes and **how many days are left** — with new documents and moved deadlines flagged on every run after the first.

Built for teams who have to file a comment, brief an executive, or change a process before a rule bites.

### How it works

```mermaid
flowchart LR
    A["Subjects or agencies"] --> B["Federal Register API"]
    B --> C["Rules, proposed rules,<br/>notices"]
    C --> D["Comment deadline<br/>+ days left"]
    D --> E{"Since last run?"}
    E -->|not seen| F["new-document"]
    E -->|deadline moved| G["comment-deadline-changed"]
    F --> H[("Regulatory feed")]
    G --> H
```

No scraping and no API key. This reads the Federal Register's own public API, so it does not break when the site is restyled and it needs no proxy or browser.

### Built for

- **Compliance and regulatory affairs** tracking what is coming
- **Public affairs and government relations** who need to file before the window shuts
- **Trade associations** briefing members on proposed rules
- **In-house legal** watching the CFR parts that govern their products
- **Consultancies** selling regulatory intelligence to clients

### Input

```json
{
  "terms": ["data privacy", "biometric"],
  "documentTypes": ["PRORULE"],
  "commentsOpenOnly": true,
  "onlyChanged": true
}
```

| Setting | What it does |
| --- | --- |
| `terms` | Subjects to watch — multi-word entries stay a phrase |
| `agencySlugs` | Limit to agencies, e.g. `food-and-drug-administration` |
| `documentTypes` | `PRORULE` is where you can still change the outcome |
| `lastDays` | How far back to search |
| `commentsOpenOnly` | Only what you can still comment on |
| `significantOnly` | Only documents flagged a significant regulatory action |
| `onlyChanged` | Return nothing on a quiet run |
| `timeBudgetSecs` | How long a run may spend paging before returning what it has |

### Output

```json
{
  "documentNumber": "2026-19290",
  "title": "Privacy Act Regulations",
  "type": "Proposed Rule",
  "agency": "Commodity Futures Trading Commission",
  "action": "Reopening of comment period.",
  "abstract": "The Commission is reopening the comment period for this NPRM for an additional ten days.",
  "publicationDate": "2026-09-21",
  "commentsCloseOn": "2026-10-01",
  "daysToComment": 10,
  "commentPeriodOpen": true,
  "effectiveOn": "2026-05-06",
  "cfrReferences": ["17 CFR 146"],
  "regulationIdNumbers": ["3038-AF26"],
  "citation": "91 FR 59711",
  "url": "https://www.federalregister.gov/documents/2026/09/21/2026-19290/privacy-act-regulations",
  "changeType": "comment-deadline-changed",
  "previousCommentsCloseOn": "2026-06-05",
  "checkedAt": "2026-09-21T19:01:18.204Z"
}
```

`daysToComment` is the field to alert on. It is the whole point: a proposed rule you find with 40 days left is an opportunity, and the same rule found with 2 days left is a fire drill.

**Comment deadlines move.** Agencies extend and reopen comment periods all the time — the example above is exactly that. A monitor that only reported documents it had never seen before would tell you nothing when the deadline you had diarised quietly shifted. That comes back as `comment-deadline-changed` with the old date.

`cfrReferences` is what to match against your own compliance register: `21 CFR 101` means your food labelling obligations just moved.

### Turn it into a filing alert

```json
{
  "agencySlugs": ["environmental-protection-agency"],
  "terms": ["emissions"],
  "documentTypes": ["PRORULE"],
  "commentsOpenOnly": true,
  "onlyChanged": true
}
```

Schedule it daily. The first run records what is already open without alerting; every run after returns only new documents and shifted deadlines.

### Run it as an API

```bash
curl -X POST "https://api.apify.com/v2/acts/arched_friend~regulation-change-monitor/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "terms": ["artificial intelligence"],
    "documentTypes": ["PRORULE"],
    "commentsOpenOnly": true
  }'
```

### Pricing

You pay $0.002 for each document returned. A run that finds nothing new costs nothing.

| Watching a subject daily | Monthly cost |
| --- | --- |
| Reading the Federal Register by hand | it publishes hundreds of pages a day |
| Regulatory intelligence platforms | $5,000 to $50,000 per year |
| This Actor | around $1.20 per month at 20 new documents a day |

### Common questions

**Why is `significant` usually null?** Because the Federal Register only carries the flag on some documents. It stays null rather than defaulting to `false`, since "not flagged" and "not significant" are different claims. `significantOnly` therefore keeps only what was explicitly flagged, and is a deliberately narrow filter.

**Why do some documents have no comment deadline?** Final rules and many notices have no comment period. Those come back with `commentPeriodOpen: null` rather than `false` — there is no window, as opposed to a window that has closed.

**How far back can it search?** The Federal Register API covers 1994 onward, but a result set is capped at 10,000 documents across 50 pages. Narrow by agency or type for a historical pull.

**Does this cover state regulations?** No. The Federal Register is US federal only.

**Do I need an API key?** No. The Federal Register API is open and keyless.

### Related products

- **FDA Recall Monitor** for enforcement once the rules are in force
- **Clinical Trial Monitor** for the studies those rules govern
- **Federal Contract Finder** for the spending a new rule creates
- **EU Tender Monitor** for the European public-sector side

# Actor input Schema

## `terms` (type: `array`):

What you need to hear about, one per line, for example data privacy or food labeling. Multi-word entries are kept together as a phrase.

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

Optional. Agency slugs as federalregister.gov spells them, one per line, for example food-and-drug-administration or environmental-protection-agency.

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

Proposed rules are where you can still influence the outcome. Rules are final. Leave empty for everything.

## `lastDays` (type: `integer`):

How far back to search. Keep this short for a scheduled run.

## `commentsOpenOnly` (type: `boolean`):

Keep only documents you can still file a comment on. Documents with no comment period at all are dropped by this.

## `significantOnly` (type: `boolean`):

Keep only documents the Federal Register explicitly flagged as significant. Most documents carry no flag either way, so this is a narrow filter.

## `agencyExcludes` (type: `array`):

Drop documents from agencies whose name contains any of these, one per line.

## `titleExcludes` (type: `array`):

Drop documents whose title or abstract contains any of these, one per line.

## `onlyChanged` (type: `boolean`):

Return nothing on a quiet run. Turn this on for a scheduled search so you only hear about new documents and comment deadlines that shifted.

## `maxResults` (type: `integer`):

The most documents to pull in one run, newest first.

## `requestTimeoutSecs` (type: `integer`):

How long to wait for a single page of results before giving up on it.

## `timeBudgetSecs` (type: `integer`):

How long the run may spend paging before it returns what it has. Keeps a scheduled run predictable.

## Actor input object example

```json
{
  "terms": [
    "data privacy"
  ],
  "documentTypes": [],
  "lastDays": 30,
  "commentsOpenOnly": false,
  "significantOnly": false,
  "onlyChanged": false,
  "maxResults": 200,
  "requestTimeoutSecs": 45,
  "timeBudgetSecs": 180
}
```

# Actor output Schema

## `documents` (type: `string`):

One row per Federal Register document with its agency, type, abstract, CFR references, comment deadline and days left, plus what changed since the last run.

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

Counts of rules, proposed rules and notices, how many comment periods are open, how many close within a fortnight, and a breakdown by agency.

# 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 = {
    "terms": [
        "data privacy"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arched_friend/regulation-change-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 = { "terms": ["data privacy"] }

# Run the Actor and wait for it to finish
run = client.actor("arched_friend/regulation-change-monitor").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "terms": [
    "data privacy"
  ]
}' |
apify call arched_friend/regulation-change-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arched_friend/regulation-change-monitor"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/PYYJB5cxqgl5dfvou/builds/M1U7IrQxYYCeLs4eP/openapi.json