# Federal Register Deadline Calendar - Comments & Rules (`yzy001/federal-register-deadlines`) Actor

Track US federal regulatory deadlines from the official Federal Register API: comment periods closing and final rules taking effect, sorted by days remaining, with agency, CFR titles, RIN, docket and the significant flag. Filter by agency, CFR title or keyword.

- **URL**: https://apify.com/yzy001/federal-register-deadlines.md
- **Developed by:** [宗諭 楊](https://apify.com/yzy001) (community)
- **Categories:** Business, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 deadlines

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 Deadline Calendar — Comments & Rules

Which US federal regulatory deadlines land in the next N days, sorted by how little time is
left. Comment periods closing on proposed rules, and final rules taking effect.

The data is the official Federal Register API — free, public, no key. One request returns
the whole universe for each deadline type, so the calendar is complete rather than a sample.

### What you get per deadline

| Field | Example |
|---|---|
| `deadline` / **`daysRemaining`** / **`urgency`** | `2026-10-13` / `2` / `within_7_days` |
| `deadlineTypeLabel` | `Comment period closing` or `Rule taking effect` |
| `isSignificant` | `true`, `false` or `null` — see the note below |
| `title` / `action` / `abstract` | what the document actually does |
| `primaryAgency` / `agencies` / `agencyCount` | `Environmental Protection Agency` |
| `cfrTitles` / `cfrReferences` | `[40]` / `["40 CFR 261"]` |
| `rin` / `docketIds` / `documentNumber` | the identifiers you need to file a comment |
| `primaryAgencyDeadlinesInResult` | how many deadlines that agency has in this run |
| `url` | the Federal Register page |

`urgency` is one of `today`, `within_7_days`, `within_14_days`, `within_30_days`, `within_90_days`, `over_90_days`. A deadline that closes today is `today`, not past.

Two dataset views: **Deadline calendar** (what is due and when) and **Docket detail** (RIN,
docket IDs and CFR references, for actually filing).

### Filters

- **Days ahead** — measured on 2026-10-11: of 186 open comment periods, **25 closed within
  7 days, 58 within 14 and 122 within 30**.
- **Agencies** — Federal Register slugs such as `environmental-protection-agency`.
- **Keywords** — full-text, e.g. `PFAS`, `cybersecurity`.
- **CFR titles** — numbers, e.g. `40` for environment, `17` for securities.
- **Significant rules only**.

### Two things worth knowing about the source

**The API's sort parameter is ignored.** Passing `order=comment_date`,
`order=effective_date`, `order=newest` or `order=relevance` returns **exactly the same
results**, and the actual order is publication date descending. So sorting by days remaining
— the whole point of a deadline calendar — is done by this Actor, not by the API. That is
stated plainly in the output caveats rather than implied.

**`isSignificant` has three states.** `true`, `false`, and `null`. A `null` means the
document carries no flag, not that it is insignificant. `significantOnly` keeps only `true`,
and the summary counts only `true`.

### How it checks its own output

| Check | What it catches |
|---|---|
| Truncated universe | If the API reports more documents than were fetched, the run stops — an incomplete calendar is worse than none. Measured: 186 documents arrive in one request, so this should not fire unless the universe grows. |
| Missing deadline dates | Documents selected *by* a date condition should carry that date. Measured: zero missing out of 186. A material share missing means the filter and the field have come apart. |
| Filter ignored | A "not before today" condition should not return expired deadlines. Measured: zero expired out of 186. Checked rather than assumed, because two other public APIs were observed silently ignoring query parameters the same week. |
| Unknown deadline type | Rejected, not silently dropped — dropping one type hides half of what the user asked for. |
| Unknown agency slug | Checked against the official agency list before searching, and refused with the closest matching slugs. The API itself answers a misspelled slug with HTTP 400. |
| Nothing matches | Zero deadlines under your filters is a valid answer: the run succeeds with no rows and its status message says what was searched. |
| Request failure | A non-200 response is raised, not returned as an empty calendar. |

### Notes on the data

- Comment deadlines come from proposed rules; effective dates come from final rules.
  Notices and presidential documents are out of scope.
- A deadline is the date printed in the Federal Register. Agencies can extend or reopen a
  comment period, and an extension is published as a **separate document** — this Actor does
  not merge the two into one timeline.
- Agency filtering uses slugs, not display names.
- This is a deadline-tracking tool, not legal advice.

# Actor input Schema

## `deadlineTypes` (type: `array`):

Comment periods closing on proposed rules, final rules taking effect, or both.

## `withinDays` (type: `integer`):

Only deadlines falling within this many days. Measured on 2026-10-11: of 186 open comment periods, 25 closed within 7 days, 58 within 14 and 122 within 30.

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

Federal Register agency slugs, for example environmental-protection-agency or securities-and-exchange-commission. These are slugs, not full agency names.

## `searchTerms` (type: `array`):

Full-text terms matched against the documents, for example cybersecurity or PFAS.

## `cfrTitles` (type: `array`):

Only documents touching these CFR titles, as numbers, for example 40 for environment or 17 for securities.

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

Keep only documents flagged significant. The flag has three states: true, false and null; null means unflagged, not insignificant, so this keeps only true.

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

Maximum number of deadline rows to return after sorting by days remaining.

## `asOfDate` (type: `string`):

ISO date used to compute days remaining, for example 2026-10-11. Leave empty for today.

## `delaySeconds` (type: `number`):

Pause between requests. The whole universe usually comes back in one request per deadline type, so this rarely matters.

## Actor input object example

```json
{
  "deadlineTypes": [
    "commentClose",
    "effectiveDate"
  ],
  "withinDays": 30,
  "agencySlugs": [],
  "searchTerms": [],
  "cfrTitles": [],
  "significantOnly": false,
  "maxResults": 2000,
  "delaySeconds": 0.5
}
```

# Actor output Schema

## `deadlines` (type: `string`):

Deadline date, days remaining, urgency bucket, document title, type, agencies, CFR titles, RIN, docket and URL.

## `summary` (type: `string`):

Urgency breakdown, significant count, busiest agencies, the universe count versus what was fetched for each deadline type, and the caveats.

# 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 = {
    "deadlineTypes": [
        "commentClose",
        "effectiveDate"
    ],
    "withinDays": 30,
    "significantOnly": false,
    "maxResults": 2000,
    "delaySeconds": 0.5
};

// Run the Actor and wait for it to finish
const run = await client.actor("yzy001/federal-register-deadlines").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 = {
    "deadlineTypes": [
        "commentClose",
        "effectiveDate",
    ],
    "withinDays": 30,
    "significantOnly": False,
    "maxResults": 2000,
    "delaySeconds": 0.5,
}

# Run the Actor and wait for it to finish
run = client.actor("yzy001/federal-register-deadlines").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 '{
  "deadlineTypes": [
    "commentClose",
    "effectiveDate"
  ],
  "withinDays": 30,
  "significantOnly": false,
  "maxResults": 2000,
  "delaySeconds": 0.5
}' |
apify call yzy001/federal-register-deadlines --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yzy001/federal-register-deadlines"
        }
    }
}
```

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/2PMVFveWU0IRHux06/builds/HdDALoYc769arBTXc/openapi.json