# Federal Register Rule Effective-Date Radar (`lukehunter/federal-rule-effective-date-radar`) Actor

Track final U.S. federal rules from the Federal Register approaching their published effective date, filterable by agency, keyword, and planning horizon, for compliance teams.

- **URL**: https://apify.com/lukehunter/federal-rule-effective-date-radar.md
- **Developed by:** [Luke Hunter](https://apify.com/lukehunter) (community)
- **Categories:** News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$10.00 / 1,000 rules

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 Rule Effective-Date Radar — Upcoming US Compliance Deadlines

**For compliance teams, consultants, legal ops and vendors serving regulated industries who need a repeatable regulatory horizon-scanning feed.** One run returns final federal rules approaching their published effective date, with agency, citation, docket and a planning-urgency band.
Pay-per-result: **$0.01 per delivered rule — 100 rules = $1.00.** You pay only for results delivered, capped by `maxItems`.
Try it free with Apify's monthly platform credit.

Instead of dumping every notice and proposed rule, this Actor focuses on the operational question: **which final rules become effective soon, who issued them, and how much planning time remains?**

### Quick start (2 minutes)

1. Open the **Input** tab (no Federal Register account or key needed — the source is public).
2. Use this prefill for cybersecurity-related rules taking effect soon:

```json
{
  "horizonDays": 60,
  "minDaysUntilEffective": 7,
  "searchTerm": "cybersecurity",
  "significantOnly": false,
  "maxItems": 100
}
```

3. Click **Start**. Export the resulting rule list to CSV/JSON, or pull it via the API shown below into your compliance tracker.

### Use cases

- **Compliance teams** monitoring rules entering force in the next 30/60/90 days for their industry.
- **Consultants and legal ops** building client-specific regulatory digests without manually reading the Federal Register.
- **Regulatory software and GRC teams** using the output as structured source material for their own tooling.
- **Vendors serving regulated industries** treating upcoming rule effective dates as a business-development signal.

### Run it weekly

1. Set your `agencies`/`searchTerm`/`horizonDays` filters, then click **Schedule** on the run page (or create one under **Schedules** in the Apify Console).
2. A daily or weekly schedule turns this into a lightweight regulatory horizon feed.
3. Compare `documentNumber` across runs (it's stable) to route newly appearing rules into email, Slack, a GRC tool or an analyst queue, rather than re-reviewing the whole list each time.

### Why use this Actor?

- Focus on final rules with a real published `effective_on` date, not general regulatory news.
- Filter by planning horizon, agency, keyword, and the Federal Register's significant flag.
- Get export-friendly records with official document links, citations, RINs, docket IDs, and dates.
- Use derived `daysUntilEffective` and `derivedUrgency` fields for triage without pretending to provide legal advice or an impact assessment.
- Schedule daily or weekly runs to maintain a lightweight US regulatory horizon-scanning workflow.

### How it works

1. Queries the public FederalRegister.gov API for documents of type `RULE` in your effective-date window.
2. Applies optional agency, keyword, and significant-rule filters.
3. Validates the source shape and deduplicates by official document number.
4. Calculates days until the published effective date and a transparent planning band.
5. Pushes at most `maxItems` records to the default dataset.

### Input

| Field | Meaning | Default |
|---|---|---:|
| `horizonDays` | Latest effective date, days from run date | 90 |
| `minDaysUntilEffective` | Earliest effective date, days from run date | 0 |
| `agencies` | Optional Federal Register agency filters | all |
| `searchTerm` | Optional full-text keyword/phrase | none |
| `significantOnly` | Keep only source records marked significant | false |
| `maxItems` | Hard output and billing cap | 250 |

```json
{
  "horizonDays": 60,
  "minDaysUntilEffective": 7,
  "searchTerm": "cybersecurity",
  "significantOnly": false,
  "maxItems": 100
}
```

### Output

Each row represents one official Federal Register document. Important fields include `documentNumber`, `title`, `agencies`, `publicationDate`, `effectiveDate`, `daysUntilEffective`, `derivedUrgency`, `significant`, `abstract`, `citation`, `regulationIdNumbers`, `docketIds`, `htmlUrl`, and `pdfUrl`.

### Output example

Illustrative only — values below are not presented as a validated live record:

```json
{
  "documentNumber": "2026-12345",
  "title": "Illustrative Final Rule",
  "agencies": ["Example Agency"],
  "publicationDate": "2026-09-15",
  "effectiveDate": "2026-10-15",
  "daysUntilEffective": 23,
  "derivedUrgency": "near_term",
  "significant": false,
  "citation": "91 FR 12345",
  "regulationIdNumbers": ["1234-AA00"],
  "docketIds": ["EXAMPLE-2026-001"],
  "htmlUrl": "https://www.federalregister.gov/",
  "sourceType": "Federal Register final rule"
}
```

| Field | Value (illustrative) |
|---|---|
| `title` | `Illustrative Final Rule` |
| `agencies` | `Example Agency` |
| `publicationDate` / `effectiveDate` | `2026-09-15` / `2026-10-15` |
| `daysUntilEffective` | `23` |
| `derivedUrgency` | `near_term` |
| `citation` | `91 FR 12345` |
| `regulationIdNumbers` | `1234-AA00` |

### How the data is transformed

Source facts remain source facts. `effectiveDate`, title, agency, citation, significance, RINs, docket IDs, and URLs come from FederalRegister.gov. The Actor derives only two key planning fields: `daysUntilEffective`, calculated from the run date, and `derivedUrgency`, a deterministic band (`imminent` 0–7 days, `near_term` 8–30, `planning_window` 31–90, `longer_horizon` 91+). These are workflow aids, not legal conclusions about applicability, materiality, or required actions.

### API usage

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("YOUR_ACTOR_ID").call(run_input={
    "horizonDays": 90,
    "searchTerm": "Medicare",
    "maxItems": 100,
})
items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
```

### Data source and trust

The source is the public FederalRegister.gov API operated for the US Federal Register. No login, browser session, CAPTCHA bypass, or private data is required. The Actor links every record back to the official document page when the API supplies it.

### Reliability and data quality

Built-in quality checks detect malformed or degraded source responses and reject data that no longer resembles expected Federal Register records instead of quietly treating it as valid. Requests use timeouts plus bounded retry/backoff for transient failures, pagination is bounded, document numbers are deduplicated, and `maxItems` is a hard delivery cap.

Individual records can still have fields the source does not provide. Missing values are returned as `null` (or an empty identifier list) rather than guessed.

### Pricing and cost control

**$0.01 per delivered rule** (100 rules = $1.00); the billable event is one **delivered rule**. `maxItems` caps both output and potential billable events. Failed requests, retries, malformed/rejected records, and empty results are not billable. A run-state ledger prevents the same delivered count from being charged twice after an Actor restart/migration.

### Important limitations

This is regulatory-intelligence infrastructure, not legal advice. A published effective date does not prove a rule applies to a particular organization, and some rules may later be amended, delayed, stayed, corrected, or superseded. Users should review the official document and subsequent Federal Register activity before making compliance decisions. Agency filter semantics depend on values accepted by the Federal Register API.

### FAQ

**Does this include proposed rules and notices?** No. The product intentionally focuses on final-rule documents (`RULE`) with effective dates.

**Does it tell me what my company must do?** No. It supplies structured official rule metadata and transparent timing fields; applicability and obligations require appropriate subject-matter/legal review.

**Can I monitor one topic?** Yes. Use `searchTerm`, and optionally agency filters, then schedule repeat runs.

**Is this affiliated with the Federal Register or US government?** No. This independent Actor uses the public FederalRegister.gov API and links to official source records.

### Related Actors

Other data tools from the same developer, built to the same standard: official or public sources, hard cost caps, and honest documentation of limits.

- **[Chicago Contract Recompete & Extension Radar](https://apify.com/lukehunter/chicago-contract-expiration-radar)**: expiring City of Chicago contracts with extension history, for recompete prospecting.
- **[Bank Branch Closings & Merger Radar (FDIC)](https://apify.com/lukehunter/bank-branch-merger-radar)**: new US bank branch closings, openings and mergers from the FDIC.
- **[Chicago New Business License Radar](https://apify.com/lukehunter/chicago-new-business-license-radar)**: newly licensed Chicago businesses as opening leads, grouped by category.
- **[NYC FDNY Contractor Leads & Hearing Radar](https://apify.com/lukehunter/fdny-violation-radar)**: fresh NYC fire-code summonses routed by remediation trade, with hearing dates.
- **[RCRA Enforcement Response Leads](https://apify.com/lukehunter/rcra-enforcement-radar)**: new EPA hazardous-waste (RCRA) enforcement actions and penalties, by state.
- **[Emerging Federal Contractor Radar](https://apify.com/lukehunter/emerging-federal-contractor-radar)**: companies that just won their first federal contracts, from USAspending.gov.
- **[Hospital Price Transparency Enforcement Leads](https://apify.com/lukehunter/hospital-price-transparency-enforcement-leads)**: hospitals with recent CMS price transparency warning notices, CAP requests and CMP notices.
- **[Hospital Ownership Change Radar](https://apify.com/lukehunter/hospital-chow-radar)**: hospitals that just changed owner, with buyer, seller and effective date from CMS filings.
- **[New Healthcare Organization NPI Radar](https://apify.com/lukehunter/new-healthcare-organization-npi-radar)**: newly registered healthcare organizations from CMS's weekly NPI file, by provider type.
- **[County Multifamily Building Permits Surge Radar](https://apify.com/lukehunter/county-multifamily-permit-surge-radar)**: U.S. counties where 5+ unit apartment permits are surging year over year.
- **[Zillow ZIP Code Property Search Scraper](https://apify.com/lukehunter/zillow-zip-scraper)**: for-sale listings by ZIP code with prices, price cuts and days on Zillow.
- **[Walmart Category Scraper](https://apify.com/lukehunter/walmart-category-scraper)**: product names, prices, was-prices and ratings from Walmart category pages.

# Actor input Schema

## `horizonDays` (type: `integer`):

Return final rules whose published effective date is no more than this many days away, 1-365, default 90.

## `minDaysUntilEffective` (type: `integer`):

Skip rules taking effect sooner than this many days from the run date, 0-365, default 0.

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

Optional Federal Register agency slugs/names accepted by the API, up to 20. Leave empty for all agencies.

## `searchTerm` (type: `string`):

Optional Federal Register full-text search term, such as cybersecurity, Medicare, or emissions. Up to 120 characters.

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

When enabled, keep only records the Federal Register API marks significant=true.

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

Hard cap on delivered records and therefore on billable rule events, 1-2000, default 250.

## Actor input object example

```json
{
  "horizonDays": 90,
  "minDaysUntilEffective": 0,
  "agencies": [],
  "significantOnly": false,
  "maxItems": 250
}
```

# Actor output Schema

## `rules` (type: `string`):

No description

# 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 = {
    "horizonDays": 90,
    "minDaysUntilEffective": 0,
    "significantOnly": false,
    "maxItems": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("lukehunter/federal-rule-effective-date-radar").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 = {
    "horizonDays": 90,
    "minDaysUntilEffective": 0,
    "significantOnly": False,
    "maxItems": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("lukehunter/federal-rule-effective-date-radar").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 '{
  "horizonDays": 90,
  "minDaysUntilEffective": 0,
  "significantOnly": false,
  "maxItems": 250
}' |
apify call lukehunter/federal-rule-effective-date-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lukehunter/federal-rule-effective-date-radar"
        }
    }
}
```

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/gCfF3Zr17Kx7jok3T/builds/6fveVbSSY1pWpYXbM/openapi.json