# Federal Register API — Rules, Notices & Public Inspection (`insight.solutions/federal-register-api`) Actor

Search the US Federal Register: final and proposed rules, notices and presidential documents, plus the Public Inspection desk before publication. One row per document with agencies, dates, comment deadline, docket, RIN, CFR parts, regulations.gov comment count and PDF links. No API key.

- **URL**: https://apify.com/insight.solutions/federal-register-api.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** News, Business, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.24 / 1,000 federal register documents

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 API — Rules, Notices & Public Inspection

Search the **US Federal Register** — final rules, proposed rules, notices and
presidential documents — and its **Public Inspection desk**, where documents sit
for a day or so before they are published. One row per document: title, type,
abstract, agencies, publication date, effective date, comment deadline, docket
and RIN identifiers, CFR parts affected, page citation, the significance flag,
the regulations.gov comment count, and links to the HTML, PDF, full-text and JSON
versions.

Filter by search term, agency, document type, publication or effective date,
docket, CFR title and part, significant-only, and "comments still open". Watch a
regulator, track a rulemaking from proposal to final rule, or read tomorrow's
Federal Register today.

No API key, no login, no browser. US Government public-domain data, read through
the Office of the Federal Register's own public API.

### At a glance

**Input** — this is the Store prefill; paste it and run:

```json
{ "terms": ["artificial intelligence"], "types": [], "sortBy": "newest", "maxResults": 20,
  "includeAbstract": true, "publicInspection": false, "maxConcurrency": 3, "maxRunSecs": 240,
  "proxyConfiguration": { "useApifyProxy": true } }
```

**Output** — one row per document. The fields you will use most are `title`,
`type`, `agencies`, `publishedAt`, `commentsCloseOn`, `docketIds`, `url` and
`pdfUrl` (full list under *Output reference*). Anything that could not be fetched
or used comes back as a free diagnostic row (`ok: false`, `errorType`, `error`)
instead of a charge.

**Price** — $0.40 per 1,000 documents (+ $0.001 per run); diagnostics and empty
runs free; no API key, no browser, limited permissions, works over the Apify MCP
server and with x402.

**From code** —
`client.actor("insight.solutions/federal-register-api").call(run_input={…})`
with `apify-client`, or
`POST https://api.apify.com/v2/acts/insight.solutions~federal-register-api/run-sync-get-dataset-items`.

***

### What you get

This is the first row the prefill returns — a real capture, trimmed to the
columns that carry something:

```json
{
  "ok": true,
  "rowType": "document",
  "input": "artificial intelligence",
  "source": "federalregister.gov",
  "documentNumber": "2026-19535",
  "title": "Request for Information; Medicare Part D Reasonable and Relevant Pharmacy Contracting Standards",
  "type": "proposed-rule",
  "typeRaw": "Proposed Rule",
  "action": "Request for information.",
  "abstract": "This request for information (RFI) solicits input from interested parties for purposes of establishing standards for reasonable and relevant pharmacy contract terms and conditions under the Medicare prescription drug benefit. …",
  "excerpt": "more transparent to pharmacies; • The use of “lesser of” pricing methodologies, … • Opportunities for the use of artificial intelligence (AI) with respect to Part D pharmacy reimbursement; …",
  "agencies": [
    { "slug": "health-and-human-services-department", "name": "Health and Human Services Department", "id": 221, "parentId": null },
    { "slug": "centers-for-medicare-medicaid-services", "name": "Centers for Medicare & Medicaid Services", "id": 45, "parentId": 221 }
  ],
  "agencyNames": ["Health and Human Services Department", "Centers for Medicare & Medicaid Services"],
  "primaryAgency": "Health and Human Services Department",
  "publishedAt": "2026-09-24",
  "commentsCloseOn": "2026-11-23",
  "commentsOpen": true,
  "docketIds": ["CMS-4217-NC"],
  "rins": ["0938-AW08"],
  "cfrReferences": [{ "title": 42, "part": "423", "chapter": null }],
  "cfrCitations": ["42 CFR 423"],
  "citation": "91 FR 60568",
  "volume": 91,
  "startPage": 60568,
  "endPage": 60572,
  "pageLength": 5,
  "datesText": "To be assured consideration, comments must be received at one of the addresses provided below, by November 23, 2026.",
  "regulationsGovDocketId": "CMS-2026-3037",
  "regulationsGovDocumentId": "CMS-2026-3037-0001",
  "regulationsGovCommentsCount": 6,
  "regulationsGovCommentsUrl": "https://www.regulations.gov/docketBrowser?rpp=50&so=DESC&sb=postedDate&po=0&dct=PS&D=CMS-2026-3037",
  "regulationsGovCheckedAt": "2026-09-28T15:55:04.000Z",
  "url": "https://www.federalregister.gov/documents/2026/09/24/2026-19535/request-for-information-medicare-part-d-reasonable-and-relevant-pharmacy-contracting-standards",
  "pdfUrl": "https://www.govinfo.gov/content/pkg/FR-2026-09-24/pdf/2026-19535.pdf",
  "jsonUrl": "https://www.federalregister.gov/api/v1/documents/2026-19535?publication_date=2026-09-24",
  "publicInspectionPdfUrl": "https://public-inspection.federalregister.gov/2026-19535.pdf?1790167517",
  "tocDoc": "Medicare Part D Reasonable and Relevant Pharmacy Contracting Standards",
  "query": "term \"artificial intelligence\"; order newest",
  "rank": 1,
  "scrapedAt": "2026-09-28T16:54:07.000Z",
  "sourceUrl": "https://www.federalregister.gov/documents/2026/09/24/2026-19535/request-for-information-medicare-part-d-reasonable-and-relevant-pharmacy-contracting-standards"
}
```

A Public Inspection row fills the filing half of the same schema instead —
`filedAt`, `filingType` (`regular` or `special`), `scheduledPublicationDate`,
`numPages`, `pdfFileSize`, `pdfUpdatedAt`, `subjects[]` — and leaves
`publishedAt` null, because it is not published yet.

Four dataset views ship with it: **Documents**, **Open for comment**, **Public
inspection** and **Diagnostics**.

***

### Quick start

**1. A term search** — the prefill. Newest first, twenty documents, one request:

```json
{ "terms": ["artificial intelligence"], "maxResults": 20 }
```

**2. An agency, a type and a date window** — every final rule EPA published
since the first of September (agencies take a slug, a name or a short name):

```json
{ "agencies": ["EPA"], "types": ["RULE"], "publishedFrom": "2026-09-01", "maxResults": 200 }
```

**3. An open-for-comment watch** — proposed rules from two agencies whose comment
period is still open today. Closed ones are read and dropped before anything is
charged; schedule it daily:

```json
{ "agencies": ["Securities and Exchange Commission", "Federal Communications Commission"],
  "types": ["PRORULE"], "publishedFrom": "2026-06-01", "commentsOpen": true, "maxResults": 500 }
```

**4. The Public Inspection desk** — everything filed for the next issues, before
it is published. With no terms you get the whole desk; add `terms` to search it,
`agencies` or `types` to narrow it:

```json
{ "publicInspection": true }
```

Looking for one document? `{ "documentNumbers": ["2026-18723"] }` — a
federalregister.gov link works too.

***

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `terms` | string\[] | `[]` | Full-text searches. Each term is its own search with its own `maxResults`. Empty is fine when another filter is set. |
| `agencies` | string\[] | `[]` | Agency slugs (`environmental-protection-agency`), names (`Department of Energy`) or short names (`EPA`), resolved against the Federal Register's own list of 473 agencies. An unknown one gets a free `unknown-agency` row with suggestions and the run continues without it. |
| `types` | select | all | `RULE`, `PRORULE`, `NOTICE`, `PRESDOCU`. Validated before sending: the API answers an unknown type with an empty result rather than an error. |
| `publishedFrom` / `publishedTo` | date | — | Publication date window, `YYYY-MM-DD`. |
| `effectiveFrom` / `effectiveTo` | date | — | Effective date window. |
| `commentsOpen` | boolean | `false` | Keep only documents whose comment period closes today or later (Washington time). Applied before the charge. |
| `significantOnly` | boolean | `false` | Only documents marked significant under Executive Order 12866. |
| `docketIds` | string\[] | `[]` | Agency docket numbers; each is its own search. |
| `cfrTitle` / `cfrPart` | integer | — | Only documents affecting this CFR title (and part). `cfrPart` needs `cfrTitle`. |
| `presidentialDocumentTypes` | select | `[]` | `executive_order`, `proclamation`, `memorandum`, `notice`, `determination`, `other`. On its own it searches presidential documents. |
| `documentNumbers` | string\[] | `[]` | Fetch these documents directly, one request each. Filters do not apply to them. |
| `sortBy` | select | `newest` | `newest`, `oldest`, `relevance`, `executive_order_number`. Also the order `maxResults` cuts in. |
| `publicInspection` | boolean | `false` | Also read the Public Inspection desk: each term searches it; with no terms, everything on file today. `agencies` and `types` apply to it; dates, dockets and CFR do not. |
| `includeAbstract` | boolean | `true` | Keep `abstract` and `excerpt`. |
| `includeFacets` | boolean | `false` | One free `facet` row per search: its matches counted by agency. |
| `maxResults` | integer | `200` | Per search. Pages of up to 100. `0` = as many as the API serves within the time budget. |
| `maxConcurrency` | integer | `3` | Searches in flight. Pages of one search are read one at a time, 300 ms apart. |
| `maxRunSecs` | integer | `240` | 30–3600. Everything already returned is kept when it runs out. |
| `proxyConfiguration` | object | datacenter | The API answered from the datacenter proxy and with no proxy at all. |

A run with nothing to search — no term, agency, type, docket, date, CFR title or
document number, and the desk off — stops before any request, finishes FAILED
and says what to set. `commentsOpen` and `significantOnly` narrow a search; they
are not one on their own.

***

### Output reference

Every row has every column, null where it does not apply, so the dataset exports
as one table.

| Column | Meaning |
|---|---|
| `ok`, `rowType` | `rowType` is `document`, `public-inspection`, `facet` or `diagnostic`; `ok` is false only on a diagnostic |
| `input` | The term, docket ID or document number behind the row; `browse` for a filters-only search; `public-inspection` for the whole desk |
| `error`, `errorType` | On a diagnostic row: what went wrong and what to do |
| `scrapedAt`, `source`, `sourceUrl` | When, `federalregister.gov`, and the page the row describes |
| `documentNumber` | The FR document number, e.g. `2026-19535` |
| `title`, `action`, `abstract`, `excerpt` | As published; `excerpt` is the search-hit passages as plain text |
| `type`, `typeRaw`, `subtype` | `rule` / `proposed-rule` / `notice` / `presidential-document`, the label as published, and e.g. "Executive Order" |
| `agencies[]`, `agencyNames[]`, `primaryAgency` | `{slug, name, id, parentId}`, parent first |
| `publishedAt`, `effectiveOn`, `commentsCloseOn`, `signingDate` | `YYYY-MM-DD` |
| `commentsOpen` | True while comments are open today (Washington time), false after, null with no comment period |
| `docketIds[]`, `rins[]` | Agency dockets and Regulation Identifier Numbers |
| `cfrReferences[]`, `cfrCitations[]` | `{title, part, chapter}` and "42 CFR 423" |
| `topics[]`, `significant` | CFR indexing terms; the EO 12866 flag (null when not stated) |
| `citation`, `volume`, `startPage`, `endPage`, `pageLength` | "91 FR 60568" and its pages |
| `datesText` | The DATES paragraph verbatim |
| `executiveOrderNumber`, `proclamationNumber`, `presidentialDocumentNumber` | For presidential documents |
| `regulationsGovDocketId`, `regulationsGovDocumentId`, `regulationsGovCommentsCount`, `regulationsGovCommentsUrl`, `regulationsGovCheckedAt` | The comment docket on regulations.gov, as the Federal Register last read it |
| `url`, `pdfUrl`, `fullTextHtmlUrl`, `fullTextXmlUrl`, `rawTextUrl`, `jsonUrl`, `publicInspectionPdfUrl` | Every published version |
| `tocSubject`, `tocDoc` | The issue's table-of-contents entry |
| `query`, `rank` | The search spelled out, and the row's position in its results |
| `filedAt`, `filingType`, `scheduledPublicationDate`, `numPages`, `pdfFileSize`, `pdfUpdatedAt`, `subjects[]`, `docketNumbers[]` | Public Inspection rows only |
| `facetAgencies[]` | Facet rows only: `{slug, name, count}`, largest first |

**Diagnostic types** (all free): `bad-input` (an entry that could not be used),
`unknown-agency`, `not-found` (a document number the Register does not know),
`no-results`, `rate-limited` (HTTP 429 twice, from two proxy sessions),
`blocked` (HTTP 403 twice), `http` (any other failure), `timeout`, `deadline`
(the run's time budget ran out), `budget` (your maximum charge was reached) and
`upstream-format` (an answer that is not the documented JSON).

***

### Document types explained

- **Rule** (`RULE`) — a final rule: it amends the Code of Federal Regulations and
  usually carries an `effectiveOn` date. This is the law changing.
- **Proposed rule** (`PRORULE`) — a notice of proposed rulemaking, or an advance
  notice or request for information before one. Usually carries a
  `commentsCloseOn` date and a regulations.gov docket: this is the stage where
  anyone can comment.
- **Notice** (`NOTICE`) — everything that is neither: meetings, information
  collections, grant announcements, permits, orders, filings. The largest type by
  far.
- **Presidential document** (`PRESDOCU`) — executive orders, proclamations,
  memoranda and determinations signed by the President; `subtype` says which and
  `signingDate` when.

***

### What you are never charged for

- Every `diagnostic` row and every `facet` row.
- Documents read and then excluded by `commentsOpen`, and Public Inspection
  filings excluded by your agency or type filters — every filter runs **before**
  the row is written, so it is never billed.
- A document a second search in the same run found again: it is returned and
  charged once.
- A run that returns nothing. A run whose input was usable but produced nothing —
  no match, a filter that excluded every match, a document number that does not
  exist, an API that refused us or timed out — finishes **SUCCEEDED with zero
  results**, a status message that says "0 results. N diagnostic row(s) explain
  why … Nothing was charged.", and a free diagnostic row per cause; nothing is
  charged, start fee included. A run finishes **FAILED** only when there was
  nothing usable to attempt, or the Actor itself hit an error.

### Pricing

| Event | FREE | BRONZE | SILVER | GOLD |
|---|---|---|---|---|
| Run started | $0.001 | $0.001 | $0.001 | $0.001 |
| **Federal Register document** | **$0.0004** | $0.0004 | $0.00032 | $0.00024 |
| Public Inspection document | $0.0004 | $0.0004 | $0.00032 | $0.00024 |

**$0.40 per 1,000 documents** at the free tier; 500 documents cost
$0.001 + 500 × $0.0004 = **$0.201**. The run honours `ACTOR_MAX_TOTAL_CHARGE_USD`:
when the ceiling is reached it stops fetching, leaves a free `budget` row, keeps
everything already delivered and finishes successfully.

***

### Use it from an AI agent, or from code

One JSON object in, one flat array out. The Actor runs with **limited
permissions**, uses **pay-per-event** pricing and never enters Standby, so it
works over the Apify MCP server (`mcp.apify.com`) and with x402 agentic payments.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~federal-register-api/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"agencies":["EPA"],"types":["PRORULE"],"commentsOpen":true,"publishedFrom":"2026-06-01"}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/federal-register-api").call(run_input={
    "terms": ["artificial intelligence"],
    "types": ["RULE", "PRORULE"],
    "publishedFrom": "2026-01-01",
    "maxResults": 500,
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["rowType"] != "document":
        continue
    print(row["publishedAt"], row["type"], row["primaryAgency"], row["title"],
          row["commentsCloseOn"], row["url"], sep=" | ")
```

***

### FAQ

**What is Public Inspection?**
Documents are filed with the Office of the Federal Register and put on public
inspection before they are published — usually the business day before, earlier
for some. The desk is the first public sight of a rule. A filing can still be
withdrawn or corrected before publication, which is why it is its own row type
with a `filedAt` and a `scheduledPublicationDate` instead of a `publishedAt`.
With `publicInspection: true` and no terms you get everything on file right now;
the desk empties as documents are published, so schedule it for the morning.

**Why do counts stop at 10,000?**
The Federal Register API stops counting there: a broad query reports
`count: 10000` and at most fifty pages, however many documents really match. The
run notes this in its status message. To reach everything, split the query by
date — a month at a time is usually well under the ceiling.

**Where is the full text?**
Not in the rows — a final rule can be hundreds of pages. Each row links to it:
`fullTextHtmlUrl` and `rawTextUrl` (and `fullTextXmlUrl`, `pdfUrl`). The
single-document response behind `documentNumbers` carries all three full-text
links; on search results they are requested from the API too and filled when it
serves them — `pdfUrl` and `url` are there either way.

**Does it return anyone's contact details?**
No. The fields it reads name agencies, not people, and the contact block ("FOR
FURTHER INFORMATION CONTACT") lives in the full text, which it does not fetch.
The one place contact text can surface is the search-hit `excerpt`, so any
excerpt passage carrying an email address, a phone number or a contact or
mailing instruction is removed before the row is written. Titles are the
Register's own, verbatim.

**How do I watch for new rules every day?**
Save a task with an agency, a type and `publishedFrom` set to yesterday (or
`commentsOpen: true` for an open-for-comment list), and schedule it. `sortBy:
newest` with a modest `maxResults` keeps each run small.

***

### Limitations

- **No full text in rows** — links only (see the FAQ).
- **Counts stop at 10,000 and paging at fifty pages** per query; split by date.
- **Public Inspection filters**: `agencies` and `types` are applied to the rows;
  date, docket and CFR filters do not apply to the desk.
- **`commentsOpen` is applied to the rows**, so a watch over a wide window reads
  documents it will not return. They cost nothing, but they take time.
- **The upstream format may change.** The Federal Register API is stable and
  versioned, but every field is treated as optional: a shape the Actor does not
  recognise becomes a free `upstream-format` row rather than a wrong value.

***

### Source

US Government public-domain data, read from the Office of the Federal Register's
public API at `federalregister.gov/api/v1`. The PDFs link to the official
edition on govinfo.gov; comment counts come from regulations.gov as the Federal
Register last checked them (`regulationsGovCheckedAt`).

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript API](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments API](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel API](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [Discourse Forum API](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown — Content Extractor for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [Internet Archive API](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Toolkit](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Intelligence API](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Page Audit](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions API](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Releases API](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress & Insider Trades API](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [Y Combinator Companies, Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Career Site Jobs API](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [New Job Postings Monitor](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products API](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit & IRS 990 Lookup API](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews API](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews API](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.

# Actor input Schema

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

Full-text searches, e.g. `["artificial intelligence"]` or `["PFAS", "drinking water"]`. Each term is its own search with its own `maxResults`, and a document two terms both find is returned (and charged) once. Leave empty to browse by the filters below instead — an agency, a type, a date window, a docket or a CFR title is enough on its own.

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

Agency slugs as the Federal Register uses them (`environmental-protection-agency`, `securities-and-exchange-commission`), or their names (`Environmental Protection Agency`, `Department of Energy`) or short names (`EPA`, `SEC`). Names are resolved against the Federal Register's own list of 473 agencies; one that cannot be resolved gets a free `unknown-agency` row with suggestions, and the run continues without it. Several agencies mean any of them.

## `types` (type: `array`):

Which kinds of document to return. Leave empty for all four.

## `publishedFrom` (type: `string`):

Earliest publication date, `YYYY-MM-DD`.

## `publishedTo` (type: `string`):

Latest publication date, `YYYY-MM-DD`.

## `effectiveFrom` (type: `string`):

Earliest effective date, `YYYY-MM-DD` — the day a rule takes legal effect. Mostly useful with final rules.

## `effectiveTo` (type: `string`):

Latest effective date, `YYYY-MM-DD`. Set both ends to list the rules that take effect in a given month.

## `commentsOpen` (type: `boolean`):

Keep only documents whose comment period closes today or later (Washington time). Applied to the rows before anything is charged, so the closed ones are read but never billed. Documents looked up by number and Public Inspection filings are not affected.

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

Keep only documents the Federal Register marks as significant under Executive Order 12866.

## `docketIds` (type: `array`):

Agency docket numbers, e.g. `["EPA-HQ-OAR-2023-0401"]`. Each docket is its own search (combined with each term, if you set terms).

## `cfrTitle` (type: `integer`):

Only documents that affect this title of the Code of Federal Regulations, e.g. `40` (Protection of Environment) or `21` (Food and Drugs).

## `cfrPart` (type: `integer`):

Narrows `cfrTitle` to one part, e.g. title 40 part `52` (state implementation plans). Needs `cfrTitle`.

## `presidentialDocumentTypes` (type: `array`):

Narrow presidential documents to executive orders, proclamations and so on. Setting this with no `types` searches presidential documents only.

## `documentNumbers` (type: `array`):

Fetch these documents directly, e.g. `["2026-18723"]`. A federalregister.gov document link works too. One request each; the filters above do not apply to them. A number the Federal Register does not know gets a free `not-found` row.

## `sortBy` (type: `string`):

The order documents are read in, which is also the order `maxResults` cuts in.

## `publicInspection` (type: `boolean`):

Also return documents filed for the next issues of the Federal Register, before they are published. With terms, each term searches the desk; with no terms, you get everything on file today. The agency and type filters apply; the date, docket and CFR filters do not.

## `includeAbstract` (type: `boolean`):

Keep each document's abstract and its search-hit excerpt. Turn it off for narrower rows.

## `includeFacets` (type: `boolean`):

Add one free `facet` row per search: how many of its matches each agency published. One extra request per search; never charged.

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

How many documents each search (each term, docket or Public Inspection search) may return. `0` means as many as the Federal Register serves for the query within the time budget.

## `maxConcurrency` (type: `integer`):

How many searches run at once. Pages of one search are always read one after another, 300 ms apart.

## `maxRunSecs` (type: `integer`):

Stop fetching after this many seconds and keep everything already returned.

## `proxyConfiguration` (type: `object`):

The Federal Register API answered from Apify's datacenter proxy and from no proxy at all in testing, so the cheap datacenter pool is the default and a cleared field still works.

## Actor input object example

```json
{
  "terms": [
    "artificial intelligence"
  ],
  "agencies": [],
  "types": [],
  "commentsOpen": false,
  "significantOnly": false,
  "docketIds": [],
  "presidentialDocumentTypes": [],
  "documentNumbers": [],
  "sortBy": "newest",
  "publicInspection": false,
  "includeAbstract": true,
  "includeFacets": false,
  "maxResults": 20,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

One row per document or Public Inspection filing, plus free facet and diagnostic rows. Delivered as JSON items in the default dataset.

# 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": [
        "artificial intelligence"
    ],
    "types": [],
    "sortBy": "newest",
    "publicInspection": false,
    "includeAbstract": true,
    "maxResults": 20,
    "maxConcurrency": 3,
    "maxRunSecs": 240,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/federal-register-api").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": ["artificial intelligence"],
    "types": [],
    "sortBy": "newest",
    "publicInspection": False,
    "includeAbstract": True,
    "maxResults": 20,
    "maxConcurrency": 3,
    "maxRunSecs": 240,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/federal-register-api").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": [
    "artificial intelligence"
  ],
  "types": [],
  "sortBy": "newest",
  "publicInspection": false,
  "includeAbstract": true,
  "maxResults": 20,
  "maxConcurrency": 3,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/federal-register-api --silent --output-dataset

```

## MCP server setup

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

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/wdUqQMBFbvKDfdjgK/builds/Xe2yZcu2RC9oulfuw/openapi.json