# Federal Register Watch — New Rules, Proposed Rules & Notices (`oneshotventure/fedreg-watch`) Actor

Scheduled change feed of newly published Federal Register documents.

- **URL**: https://apify.com/oneshotventure/fedreg-watch.md
- **Developed by:** [Nick](https://apify.com/oneshotventure) (community)
- **Categories:** Agents, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.50 / 1,000 results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Federal Register Monitor — New Rules, Proposed Rules & Notices

Track **newly published Federal Register documents** by full-text keyword, agency and document type —
final rules, proposed rules, notices and presidential documents. Official Federal Register API, with a
change feed that remembers document numbers so nothing is missed or repeated.

### What does this Actor do?

You give it keywords, agency slugs and document types. It queries the Federal Register's official API
for each keyword separately, merges and de-duplicates the results by document number, sorts them
newest-first, and emits them with a link to both the HTML and the PDF.

The interesting problem here is that **Federal Register documents can appear before their publication
date.** A rule scheduled for Friday's issue is often available on Wednesday. Any monitor that tracks
"what has been published since date X" will therefore either re-send those documents once their
publication date arrives, or miss them entirely depending on which side of the comparison it lands.

This Actor keeps a **list of document numbers it has already seen**, alongside the run watermark, and
uses that list — not the publication date alone — to decide what is new. Documents that surfaced early
are flagged as new exactly once, on the run that first saw them.

### Who is it for?

- **Regulatory affairs and compliance teams** who must know when a rule affecting their industry
  moves.
- **Government affairs and policy analysts** tracking a specific agency's rulemaking.
- **Legal teams** watching comment periods open on proposed rules.
- **Trade associations and consultancies** monitoring a sector across many agencies at once.
- **AI agent builders** who want a regulatory tool with a stable output schema.

### Use cases

- Watch every SEC proposed rule mentioning a term and route it to a policy-review workflow.
- Monitor a set of agencies for any notice, as an early signal before formal rulemaking.
- Track a topic — `artificial intelligence`, `PFAS`, `tariff` — across all agencies at once.
- Feed newly published final rules into a compliance-obligations register.
- Give an agent a tool that answers "what has this agency published on this topic recently?"

### What you get

One row per document. Any value the source does not publish is `null` — the field is always present,
and the untouched source record stays in `raw`.

| Field | Type | Description |
|---|---|---|
| `documentNumber` | string | Federal Register document number — the unique ID, and what the seen-list tracks |
| `title` | string | Document title |
| `abstract` | string | Federal Register abstract, where published |
| `type` | string | Document type as the source labels it, e.g. `Rule`, `Proposed Rule`, `Notice` |
| `publicationDate` | string | Publication date (`YYYY-MM-DD`) |
| `agencies` | array | Names of the issuing agencies |
| `htmlUrl` | string | Link to the document on federalregister.gov |
| `pdfUrl` | string | Link to the official PDF |
| `commentsCloseOn` | string | null | Public-comment deadline (`YYYY-MM-DD`), where published |
| `docketIds` | array | null | Federal Register docket IDs, where published |
| `regulationIdNumbers` | array | null | Regulation Identifier Numbers (RINs), where published |
| `cfrReferences` | array | null | CFR references formatted as `title CFR part`, where published |
| `daysUntilCommentsClose` | integer | null | Days until the public-comment deadline, calculated when the record is retrieved |
| `raw` | object | The complete original record from the API, unmodified |
| `newSinceLastRun` | boolean | `true` if this document number had not been seen on an earlier successful run |
| `retrievedAt` | string | ISO 8601 timestamp of when this row was fetched |

#### Sample output record

```json
{
  "documentNumber": "2026-17342",
  "title": "Safeguards for Automated Decision Systems in Consumer Finance",
  "abstract": "The Bureau proposes to amend Regulation B to address the use of automated decision systems…",
  "type": "Proposed Rule",
  "publicationDate": "2026-08-21",
  "agencies": ["Consumer Financial Protection Bureau"],
  "htmlUrl": "https://www.federalregister.gov/documents/2026/08/21/2026-17342/safeguards-for-automated-decision-systems",
  "pdfUrl": "https://www.govinfo.gov/content/pkg/FR-2026-08-21/pdf/2026-17342.pdf",
  "commentsCloseOn": "2026-10-20",
  "docketIds": ["CFPB-2026-0012"],
  "regulationIdNumbers": ["3170-AA99"],
  "cfrReferences": ["12 CFR 1002"],
  "daysUntilCommentsClose": 58,
  "raw": { "document_number": "2026-17342", "…": "…" },
  "newSinceLastRun": true,
  "retrievedAt": "2026-08-23T09:30:12.004Z"
}
```

### How to use it

#### Watch one agency for rulemaking on a topic

```json
{
  "keywords": ["artificial intelligence"],
  "agencies": ["securities-and-exchange-commission"],
  "documentTypes": ["RULE", "PRORULE"],
  "maxResults": 25
}
```

#### Everything from a set of agencies

Leave `keywords` empty to search the window without a term.

```json
{
  "agencies": ["environmental-protection-agency", "food-and-drug-administration"],
  "maxResults": 200
}
```

Agency values are Federal Register **slugs**, not display names — the full list is at
[federalregister.gov/agencies](https://www.federalregister.gov/agencies).

### Input parameters

| Input | Type | Description |
|---|---|---|
| `keywords` | array | Full-text terms, each queried separately. Empty searches the window without a term |
| `agencies` | array | Federal Register agency slugs. Empty includes all agencies |
| `documentTypes` | array | `RULE`, `PRORULE`, `NOTICE` or `PRESDOCU`. Empty includes all types |
| `publishedSince` | string | `YYYY-MM-DD` start date. Overrides the previous successful run's watermark |
| `maxResults` | integer | Maximum records per run (1–1000). Default: `100` |
| `closingWithinDays` | integer | Only emit documents whose public-comment deadline is from now through this many days away; documents without a deadline are excluded |

Passing a document type outside the four allowed values fails the run with a clear error rather than
silently returning nothing.

### How monitoring works (first run and scheduling)

The first run returns documents from the **last seven days** unless `publishedSince` is supplied. To
keep the watermark and the seen-document list across runs, **schedule this Actor as a saved Task** so
runs share the same storage. A fresh unsaved run starts a fresh baseline.

**The dataset contains the whole window, not only the new documents.** Every run returns the
documents matching your query in the window, and `newSinceLastRun` marks the ones this Actor had not
seen before. Filter on that flag downstream if you only want to alert on genuinely new items.

### Honest limitations

- **Each run emits the window, not a strict delta.** As above — use `newSinceLastRun` to separate new
  documents from ones you have already seen.
- **Agencies must be given as slugs.** `securities-and-exchange-commission`, not `SEC` and not
  `Securities and Exchange Commission`. An unrecognized slug simply returns nothing for that agency.
- **Keywords are queried separately, then merged.** Two keywords means two queries and a union of the
  results, not an AND across both terms.
- **`maxResults` applies after the merge**, so with several keywords the newest documents across all
  of them win and older matches on a single keyword may be cut.
- **Full document text is not returned.** You get the title, abstract and links; fetching and parsing
  the rule itself is a separate job.
- **Some documents have no public-comment deadline or regulatory references.** Their corresponding
  nullable fields are `null`; `closingWithinDays` excludes them.

### Agent example

Ask an agent to run this Actor with `keywords: ["artificial intelligence"]` and send each resulting
Rule or Proposed Rule to your policy-review workflow.

### Reliability

Diagnostics are written to the `RUN_SUMMARY` key-value record — never into the dataset. A failed
upstream request leaves the watermark and the seen-document list unchanged, so a transient outage
cannot silently skip a window.

Every record carries `retrievedAt` and both `htmlUrl` and `pdfUrl` back to the official source, so you
can check any row against the publisher yourself.

Maintained against the upstream API. If the Federal Register changes its schema or an endpoint moves,
report it through the Issues tab and it gets fixed.

### Integrations

Connect this Actor to Make, Zapier, n8n, Slack, Google Sheets, Airtable or any HTTP endpoint through
Apify integrations. A daily Task can post new proposed rules into a policy channel, or fire a webhook
so a summarization job starts the moment a rule publishes. Datasets export as JSON, CSV, Excel, XML,
RSS or HTML.

### API usage

```bash
curl -X POST "https://api.apify.com/v2/acts/oneshotventure~fedreg-watch/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["artificial intelligence"], "documentTypes": ["RULE", "PRORULE"], "maxResults": 25}'
```

Python, JavaScript, PHP and CLI clients are documented under
[Apify API clients](https://docs.apify.com/api/client).

### Use with AI agents (MCP)

This Actor is callable from any MCP-compatible client — Claude, Cursor, VS Code or your own agent —
through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp). The input schema is
fully described and every record uses one stable, flat JSON shape, so an agent can call it and read
the result without a parsing step. Because it reads the official Federal Register API rather than a
rendered page, the answer an agent gets is the same one the source publishes — and `htmlUrl` gives the
agent a document to fetch and summarize.

### Frequently asked questions

#### Is there a free Federal Register API?

Yes — the Office of the Federal Register publishes an open API with no key required. This Actor is the
scheduling, multi-keyword and change-feed layer over it, including the seen-document tracking that
handles early-published documents.

#### How do I track new federal regulations by agency?

Put the agency's slug in `agencies`, save the Actor as a Task, and schedule it. Slugs are listed at
federalregister.gov/agencies.

#### How do I monitor proposed rules in my industry?

Set `documentTypes` to `["PRORULE"]` and add your industry terms to `keywords`. Add agency slugs to
narrow further.

#### What is the difference between a rule and a proposed rule?

A proposed rule (`PRORULE`) is an agency's draft, published to invite public comment. A final rule
(`RULE`) is the binding version published after that process. `NOTICE` covers announcements that are
not rulemaking, and `PRESDOCU` covers presidential documents.

#### Why am I seeing documents I already received?

Each run returns the whole window, not only the delta. Filter on `newSinceLastRun` to get just the
documents this Actor had not seen before.

#### Does it return the full text of the rule?

No. You get the title, abstract, type, agencies and links to the HTML and PDF. Retrieving and parsing
the document itself is a separate step.

#### How far back can I go?

Set `publishedSince` to any date you like. Without it, the first run covers the last seven days and
later scheduled runs continue from the watermark.

### Related actors

- [SAM.gov Contract Opportunities & Awards Feed](https://apify.com/oneshotventure/sam-feed) — federal
  contract opportunities and awards.
- [Grants.gov Monitor](https://apify.com/oneshotventure/grants-feed) — new federal grant
  opportunities.
- [US Product Recalls Monitor](https://apify.com/oneshotventure/recalls-monitor) — CPSC and FDA
  enforcement actions.
- [SEC EDGAR Filings Monitor](https://apify.com/oneshotventure/sec-filings) — new company filings
  from EDGAR.

### Disclaimer

This independent tool uses public U.S. government data and is not affiliated with the Office of the
Federal Register.

# Actor input Schema

## `keywords` (type: `array`):

Full-text terms to search separately. Empty searches the selected date window without a term.

## `agencies` (type: `array`):

Federal Register agency slugs. See https://www.federalregister.gov/agencies. Empty includes all agencies.

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

Federal Register type codes: RULE, PRORULE, NOTICE, or PRESDOCU. Empty includes all document types.

## `publishedSince` (type: `string`):

YYYY-MM-DD start date. Overrides the previous successful-run watermark.

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

Maximum records per run (1-1000).

## `closingWithinDays` (type: `integer`):

Only emit documents with a comment deadline from now through this many days away. Documents without a comment deadline are excluded.

## Actor input object example

```json
{
  "keywords": [
    "artificial intelligence"
  ],
  "agencies": [],
  "documentTypes": [],
  "maxResults": 25
}
```

# Actor output Schema

## `records` (type: `string`):

New Federal Register documents in the default dataset.

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

Run diagnostics stored as RUN\_SUMMARY in the key-value store.

# 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 = {
    "keywords": [
        "artificial intelligence"
    ],
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("oneshotventure/fedreg-watch").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 = {
    "keywords": ["artificial intelligence"],
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("oneshotventure/fedreg-watch").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 '{
  "keywords": [
    "artificial intelligence"
  ],
  "maxResults": 25
}' |
apify call oneshotventure/fedreg-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,oneshotventure/fedreg-watch"
        }
    }
}

```

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/Qzgz7EriFr8Egry3n/builds/FOcUI6WBVwmGeuiVG/openapi.json