# Federal Register Monitor — agency, term & date (`brightish_ascent/federal-register-monitor`) Actor

Track U.S. Federal Register documents (rules, proposed rules, notices, presidential docs) via the official public JSON API. Filter by agency, term, document type, significant-only, and publication date. One normalized dataset row per document.

- **URL**: https://apify.com/brightish\_ascent/federal-register-monitor.md
- **Developed by:** [Michael Rice](https://apify.com/brightish_ascent) (community)
- **Categories:** Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $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?

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

## Federal Register Monitor — agency, term & date

Query the official U.S. **Federal Register** [public JSON API](https://www.federalregister.gov/developers/documentation/api/v1) and get **one normalized dataset item per document**. Filter by agency slug, search term, document type (RULE / PRORULE / NOTICE / PRESDOCU), significant-only flag, and publication date — built for compliance, policy, and legal-ops monitoring.

> **Not affiliated with the U.S. Federal Register / NARA / OFR.** Public API data only. Verify every document on the official `htmlUrl` before taking action. Do not use official NARA or OFR logos when republishing.

### Features

- **Official `documents.json` API** — HTTP `GET` only; no browser, no HTML scraping
- **Filters** — term, agency slugs, document types, publication date range, significant-only (EO 12866)
- **Normalized output** — stable fields (`documentNumber`, `title`, `type`, `agencies`, `publicationDate`, `effectiveOn`, `commentsCloseOn`, `htmlUrl`, `pdfUrl`, `abstract`, `significant`, `cfrReferences`, …)
- **Safety by default** — empty input auto-applies a ~14-day publication window so Store Try / first runs stay bounded
- **Bounded & resilient** — `maxItems` (default 50, hard cap 1000), pagination with ~200 ms pacing, retry/backoff on HTTP 429 / 5xx, clear User-Agent
- **Optional raw payload** — attach the original Federal Register JSON under `raw` when `includeRaw` is true

### Who is it for

- **Compliance & regulatory-affairs** teams watching rules and notices by agency
- **Policy / government-affairs** shops tracking topics (e.g. cybersecurity, PFAS, tariffs)
- **Legal-ops and research** workflows that need machine-readable FR metadata + links
- **Developers** who want a ready-made Apify Actor instead of hand-rolling the Federal Register client

### How it works

1. Open this Actor on Apify and set filters (or leave empty for the ~14-day default window).
2. Optionally set `maxItems`, `significantOnly`, `includeRaw`, and `abstractMaxLength`.
3. Run the Actor. It calls\
   `GET https://www.federalregister.gov/api/v1/documents.json?…`\
   with only documented `conditions[...]` parameters and selected `fields[]`.
4. Read results from the default dataset — one row per document — or download via the dataset API URL in the run output.

**Tips:** Prefer filtered queries. Upstream pagination covers only the first ~2000 matches; use date bounds for large corpora. Agency slugs look like `environmental-protection-agency` (see [agencies](https://www.federalregister.gov/agencies)).

Official docs: [Federal Register API v1](https://www.federalregister.gov/developers/documentation/api/v1).

### Input

| Field | Maps to API | Notes |
| --- | --- | --- |
| `term` | `conditions[term]` | Full-text search |
| `agencies` | `conditions[agencies][]` | Agency ID slugs |
| `documentTypes` | `conditions[type][]` | `RULE`, `PRORULE`, `NOTICE`, `PRESDOCU` |
| `publicationDateStart` / `publicationDateEnd` | `conditions[publication_date][gte]` / `[lte]` | Prefer `YYYY-MM-DD` |
| `significantOnly` | `conditions[significant]=1` | EO 12866 significant docs only |
| `maxItems` | (client) | Default `50`, max `1000` |
| `includeRaw` | (client) | Attach original JSON under `raw` |
| `abstractMaxLength` | (client) | Default `500` |

#### Input example

```json
{
  "term": "cybersecurity",
  "agencies": [],
  "documentTypes": ["RULE", "PRORULE", "NOTICE"],
  "publicationDateStart": "2026-06-01",
  "publicationDateEnd": "2026-09-24",
  "significantOnly": false,
  "maxItems": 25,
  "includeRaw": false
}
```

Store **Try** / first-run uses a similar term + date window + modest `maxItems` so an unedited run succeeds. If you clear all filters, the Actor auto-applies a ~14-day publication window.

### Output example

```json
{
  "documentNumber": "2026-19584",
  "title": "Flight Operations: Pilot requirements; Use of oxygen",
  "type": "Proposed Rule",
  "agencies": ["Transportation Department", "Federal Aviation Administration"],
  "publicationDate": "2026-09-24",
  "effectiveOn": null,
  "commentsCloseOn": "2026-11-23",
  "htmlUrl": "https://www.federalregister.gov/documents/2026/09/24/2026-19584/…",
  "pdfUrl": "https://www.govinfo.gov/content/pkg/FR-2026-09-24/pdf/2026-19584.pdf",
  "publicInspectionPdfUrl": "https://public-inspection.federalregister.gov/2026-19584.pdf?…",
  "abstract": "FAA proposes to raise the altitudes at which a pilot is required to don an oxygen mask…",
  "significant": null,
  "topics": ["Air carriers", "Aircraft", "Aviation safety"],
  "cfrReferences": ["14 CFR part 91", "14 CFR part 135"],
  "source": "federalregister-gov"
}
```

More samples: `OUTPUT.example.json`.

### Pricing

Pay-per-event pricing:

| Event | Price (USD) | Notes |
| --- | --- | --- |
| Actor start (`apify-actor-start`) | **$0.00005** | Charged once per run |
| Dataset item (`apify-default-dataset-item`) | **$0.0025** | Per normalized document row (**$2.50 per 1,000 results**) |

You pay only for the documents the Actor returns. For example, a 50-document run costs about $0.125 in result charges plus the start fee.

See `PRICING.md` for the locked PPE record.

### Source, rate limits & ToS

- **Public API, no API key.** Docs explicitly invite HTTP clients: [API Documentation](https://www.federalregister.gov/developers/documentation/api/v1), [REST API overview](https://www.federalregister.gov/reader-aids/developer-resources/rest-api).
- FederalRegister.gov **restricts aggressive HTML scraping** and steers programmatic access to this API. This Actor uses **only** `/api/v1/…` endpoints.
- `robots.txt` disallows some HTML search paths (`/documents/search`, etc.); it does **not** disallow `/api/`. Prefer the API (as this Actor does).
- Usage note from official docs: republishers must **not** use official NARA or OFR logos/seals.
- Upstream pages only the first ~2000 matches; use date filters for larger pulls. This Actor paces ~200 ms between pages and retries with backoff on **429 / 5xx**.
- Always verify critical decisions against the official document page in `htmlUrl`.

### FAQ / disclaimer

**Is this official Federal Register / NARA software?** No. Not affiliated with, endorsed by, or operated by NARA, OFR, or FederalRegister.gov.

**What happens if I set no filters?** The Actor auto-applies a ~14-day `publicationDateStart` / `publicationDateEnd` window so Store Try / first runs succeed without dumping years of documents. Pass explicit filters for precision.

**Is the data complete?** Dataset items are convenience transforms of public API metadata and may be incomplete, delayed, or truncated (`abstract`). Full document body is **not** fetched by default (use `htmlUrl` / `pdfUrl`). **Verify every document on the official page** before compliance or legal action.

**What are valid agency IDs?** Use Federal Register agency **slugs** (e.g. `environmental-protection-agency`), not display names. See https://www.federalregister.gov/agencies.

**What does `significant` mean?** When present, it reflects documents associated with the Unified Agenda and deemed significant under EO 12866. Many records return `null`.

**Why might a hit's title or abstract not contain my `term`?** `term` is full-text search on the upstream Federal Register API (`conditions[term]`). Matches can come from body or other indexed fields, so the returned `title` / `abstract` may not literally include the keyword.

**Is this legal advice?** No.

### Limitations

- Metadata + links only; no full-text body download in this Actor
- Upstream pagination ceiling (~2000 matches) — partition by date/agency for large jobs
- `significant` is often `null` even for important rules
- Agency filter requires correct slugs
- Public government data may lag or change; not an official gazette substitute for citation

### Local development

```bash
npm install
## place input at storage/key_value_stores/default/INPUT.json
npm run dry-run
```

Requires Node.js 18+. Uses Apify SDK v3 (`apify` package).

### License

MIT (Actor scaffold). Upstream Federal Register content remains U.S. government public information; do not use official NARA/OFR logos when republishing.

# Actor input Schema

## `term` (type: `string`):

Full-text search term (official API `conditions[term]`). Example: cybersecurity, PFAS, tariff.

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

Federal Register agency ID slugs (`conditions[agencies][]`). Examples: environmental-protection-agency, securities-and-exchange-commission, food-and-drug-administration. Leave empty for all agencies. Browse agency slugs via https://www.federalregister.gov/agencies

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

Official type codes: RULE (Rule), PRORULE (Proposed Rule), NOTICE (Notice), PRESDOCU (Presidential Document). Leave empty for all.

## `publicationDateStart` (type: `string`):

Inclusive lower bound YYYY-MM-DD (`conditions[publication_date][gte]`). Empty input with no other filters auto-applies a ~14-day window.

## `publicationDateEnd` (type: `string`):

Inclusive upper bound YYYY-MM-DD (`conditions[publication_date][lte]`). Empty input with no other filters auto-applies a ~14-day window.

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

If true, restrict to documents deemed significant under EO 12866 (`conditions[significant]=1`).

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

Maximum documents to push. Default 50. Hard-capped at 1000. API paginates (per\_page up to 100; Actor uses 100) and only pages through the first ~2000 matches upstream.

## `includeRaw` (type: `boolean`):

If true, attach the original Federal Register JSON under `raw`.

## `abstractMaxLength` (type: `integer`):

Max characters for the `abstract` field. Default 500.

## Actor input object example

```json
{
  "term": "cybersecurity",
  "publicationDateStart": "2026-01-01",
  "publicationDateEnd": "2026-12-31",
  "significantOnly": false,
  "maxItems": 50,
  "includeRaw": false,
  "abstractMaxLength": 500
}
```

# Actor output Schema

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

Default dataset of normalized Federal Register items (documentNumber, title, type, agencies, publicationDate, effectiveOn, commentsCloseOn, htmlUrl, pdfUrl, abstract, significant, cfrReferences, and more).

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("brightish_ascent/federal-register-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("brightish_ascent/federal-register-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 '{}' |
apify call brightish_ascent/federal-register-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,brightish_ascent/federal-register-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/jBIdUHnBPQTDHtfeP/builds/k3CWNzARePahdvw4n/openapi.json