# US Federal Rules API: CFR text as of a date + Federal Register (`bosco_labs/us-federal-rules`) Actor

The text of a CFR section as in force today or on any date, its amendment history and the Federal Register rules that changed it; what changed in a CFR part since a date; Federal Register documents by number or search. Official eCFR and FederalRegister.gov data, a source link per row.

- **URL**: https://apify.com/bosco_labs/us-federal-rules.md
- **Developed by:** [Bosco Labs](https://apify.com/bosco_labs) (community)
- **Categories:** Business, AI, Developer tools
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 cfr sections

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

## US Federal Rules API: CFR text as of a date + Federal Register

**One call answers "what does 21 CFR 101.9 say today, when did it last change, and which
Federal Register rule changed it?"**: the section as plain text from the eCFR (as in force today
or on any date since 2017), its amendment history, and the final rules behind each change. It
also lists what changed in a CFR part since a date ("15 CFR 744 this week") and returns Federal
Register documents by number or search. Built for **AI agents** doing regulatory, compliance and
export-control work, and for people who want a sourced answer without learning two APIs.

**Pricing (pay per event):** $0.005 per CFR section returned (`section`), $0.002 per Federal
Register document returned (`document`). A citation that can't be read, a section that doesn't
exist or an empty result fails or ends in seconds and costs nothing.

### What you get

Real output for `{"citation": "21 CFR 101.9"}`, run on 2026-11-06 (text and amendment list
shortened here; the full row is 22 KB):

```json
{
  "schema_version": "1",
  "record_type": "cfr_section",
  "query": "21 CFR 101.9",
  "citation": "21 CFR 101.9",
  "cfr_title": 21,
  "cfr_title_name": "Food and Drugs",
  "part": "101",
  "subpart": "A",
  "section": "101.9",
  "unit_type": "section",
  "heading": "§ 101.9 Nutrition labeling of food.",
  "as_of": "2026-11-04",
  "text": "(a) Nutrition information relating to food shall be provided for all products intended for human consumption and offered for sale unless an exemption is provided for the product in paragraph (j) of this section.\n(1) When food is in package form, the required nutrition labeling information shall appear on the label in the format specified in this section.\n(2) When food is not in package form, the required nutrition la ...",
  "text_chars": 19521,
  "text_truncated": true,
  "source_note": "[58 FR 2175, Jan. 6, 1993]",
  "removed": false,
  "latest_change_date": "2023-05-24",
  "changed_since": null,
  "amendments": [
    {
      "date": "2023-05-24",
      "substantive": true,
      "removed": false,
      "fr_documents": [
        {
          "document_number": "2023-10602",
          "citation": "88 FR 33550",
          "title": "Food Labeling, Infant Formula Requirements, Food Additives and Generally Recognized as Safe Substances, New Dietary Ingredient Notification; Technical Amendments; Correction",
          "type": "Rule",
          "publication_date": "2023-05-24",
          "effective_on": "2023-05-24",
          "url": "https://www.federalregister.gov/documents/2023/05/24/2023-10602/food-labeling-infant-formula-requirements-food-additives-and-generally-recognized-as-safe-substances"
        }
      ]
    },
    {
      "date": "2023-03-24",
      "substantive": true,
      "removed": false,
      "fr_documents": [
        {
          "document_number": "2023-05418",
          "citation": "88 FR 17710",
          "title": "Food Labeling, Infant Formula Requirements, Food Additives and Generally Recognized as Safe Substances, New Dietary Ingredient Notification; Technical Amendments",
          "type": "Rule",
          "publication_date": "2023-03-24",
          "effective_on": "2023-03-24",
          "url": "https://www.federalregister.gov/documents/2023/03/24/2023-05418/food-labeling-infant-formula-requirements-food-additives-and-generally-recognized-as-safe-substances"
        }
      ]
    },
    { "date": "2016-12-19", "substantive": true, "removed": false, "fr_documents": null }
  ],
  "ecfr_up_to_date_as_of": "2026-11-04",
  "source_url": "https://www.ecfr.gov/on/2026-11-04/title-21/section-101.9",
  "provided_by": "Bosco Labs (boscolabs.dev)",
  "api_url": "https://www.ecfr.gov/api/versioner/v1/full/2026-11-04/title-21.xml?section=101.9",
  "warnings": ["text cut at 20000 characters (of 121140); raise maxTextChars or read source_url."],
  "retrieved_at": "2026-11-06T08:37:27+00:00",
  "duration_seconds": 1.62
}
```

- **text**: plain text as in force on `as_of`, one line per paragraph (`(a)`, `(1)`, `(i)`),
  tables as `cell | cell` rows. Long sections are cut at `maxTextChars` (default 20,000) and
  flagged.
- **amendments**: every amendment date in the eCFR's history (newest first), with
  **fr_documents**: the final rules affecting that CFR part that took effect (or were published)
  on that date. `null` means not looked up (only the 5 newest dates are), `[]` means none found.
- **source_note**: the CFR source note with the Federal Register citation that created the
  section.
- **source_url** is the eCFR page for people (cite it). Programs should fetch **api_url**:
  ecfr.gov web pages send automated clients to a CAPTCHA, the API does not.

A Federal Register document row (`{"documentNumber": "2026-17231"}`) has `citation`
(`91 FR 54658`), `title`, `type`, `action`, `abstract`, `dates`, `agencies`,
`publication_date`, `effective_on`, `comments_close_on`, `cfr_references` (`["15 CFR 744"]`),
`docket_ids`, `regulation_id_numbers`, the FederalRegister.gov page as `source_url` and the
official govinfo.gov `pdf_url`.

### Input

```json
{ "citation": "21 CFR 101.9", "asOf": "2024-01-01" }
```

| Field | Meaning |
|---|---|
| `citation` | `21 CFR 101.9`, `17 CFR 240.10b-5`, `48 CFR 52.212-4`, an appendix (`15 CFR 744 Supplement No. 4`), a part (`15 CFR 744`) or an eCFR link |
| `asOf` | `YYYY-MM-DD`: the text in force on that date (history from about January 2017). Default today |
| `since` | Part citation: units changed since (default 30 days). Search: published since |
| `documentNumber` | One Federal Register document, e.g. `2026-17231` |
| `search`, `agency`, `documentType` | Federal Register search: words, agency (`BIS`, `FDA`, `Bureau of Industry and Security`), `RULE` / `PRORULE` / `NOTICE` / `PRESDOCU` |
| `maxResults` | Rows for a part (max 25) or a search (max 100), default 20 |
| `maxTextChars` | Text cap per section, default 20,000 |

**What changed in a part:** `{"citation": "15 CFR 744", "since": "2026-08-01"}` returns one row
per section or appendix of the part changed since that date (most recent first, up to 25), each
with its current text and the rules behind its newest change (the 5 newest change dates per run
are looked up). On 2026-11-06 that was Supplement No. 4 (the
Entity List, changed 2026-08-24 by documents 2026-17231 and 2026-17230) and Supplement No. 2
(2026-08-14, "Streamlining Export Controls for Drone Exports"). If nothing changed, the run says
so and when the part last changed.

**Federal Register search:** `{"search": "entity list", "agency": "BIS", "since": "2026-06-01"}`
returns matching documents, newest first. Add `citation` to keep only documents affecting that
CFR part.

### Use from an AI agent (MCP)

Agents can call this Actor as a tool through the
[Apify MCP server](https://github.com/apify/apify-mcp-server). Add this server URL to your MCP
client (Claude, Cursor, VS Code, ...):

```text
https://mcp.apify.com?tools=bosco_labs/us-federal-rules
```

It loads this Actor as a tool, plus the tools that read its results (`get-actor-run`,
`get-dataset-items`). The hosted server signs you in with OAuth, or accepts your Apify token as
`Authorization: Bearer <APIFY_TOKEN>`.

Example prompt: *"What changed in the Export Administration Regulations part 744 since August,
and which Federal Register notices did it? Link the sources."* The agent passes:

```json
{ "citation": "15 CFR 744", "since": "2026-08-01" }
```

**Output for agents:** small JSON rows (a section is typically 5-25 KB with the default text
cap), stable `snake_case` fields, ISO dates, `null` for unknown, a source link per row and per
linked rule. A unit whose text eCFR fails to send in a part listing comes back with
`text: null`, a warning and no charge. `warnings` says in plain words when text was cut, a date was capped at the eCFR's
latest data, or more results matched than were returned. A section lookup takes 1-2 seconds
after start-up (measured 1.6 s for 21 CFR 101.9); a part with changes 2-7 seconds for a few
units (the Entity List alone is 1.4 million characters of XML), up to about a minute for 25
units, which are downloaded two at a time to stay within eCFR's limits.

**Cost:** $0.005 per section, $0.002 per document, billed to the Apify account the MCP server is
signed in with. Nothing is charged for a failed or empty lookup, or for a section row without
text.

### FAQ

**Where does the data come from?** Only from the two official APIs of the Office of the Federal
Register (National Archives) and the Government Publishing Office: the eCFR versioner API
(point-in-time CFR text and version history) and the FederalRegister.gov API (documents since
1994\). Both are keyless. The text is converted from XML to plain text and nothing else is
changed.

**May you resell this?** Yes. FederalRegister.gov and eCFR.gov state: "Any person may reproduce
or republish any material appearing in any regular or special edition of the Federal Register
(1 CFR 2.6). There are no restrictions regarding what is reproduced, who can reproduce it, or
where it can be reproduced." Works of the US Government have no copyright (17 U.S.C. 105), and
GPO's e-CFR guide says "there are no restrictions on re-use of information in the e-CFR
documents". We don't use NARA or OFR seals or CFR logos and don't claim to be an official
edition. Sources: [About this site](https://www.ecfr.gov/reader-aids/government-policy-and-ofr-procedures/about-this-site),
[govinfo policies](https://www.govinfo.gov/about/policies),
[e-CFR XML guide](https://github.com/usgpo/bulk-data/blob/main/ECFR-XML-User-Guide.md).

**Is the eCFR text the law?** It is, in the OFR's words, "authoritative but unofficial". The
official CFR is the annual print edition on govinfo.gov, kept current by the daily Federal
Register. For legal research, verify against the official editions; each document row links
the official govinfo PDF (`pdf_url`). This is not legal advice.

**How exact is the link between a change and a Federal Register rule?** The Federal Register
indexes documents by CFR part, not section. For each amendment date we list the final rules that
affect the same part and took effect (or were published) that day: in practice that is the rule
that made the change, but on a busy day it can include a rule that changed a neighbouring
section. Each comes with its title and link so an agent can check. Only the 5 newest amendment
dates per run are looked up (older ones show `fr_documents: null`); in a part listing that is
each unit's newest change, for the 5 most recent dates. If the Federal Register lookup fails,
the row is kept with `fr_documents: null` and a warning.

**How current is it?** Live. The eCFR is updated daily and is usually 1-2 days behind the
Federal Register (`ecfr_up_to_date_as_of`); an `asOf` later than that returns the latest text
with a warning. The point-in-time history starts around January 2017; earlier dates fail with
the first available date.

**Can it diff two versions or return one paragraph?** Not yet. A section is returned whole (a
citation like `21 CFR 101.9(c)(8)` returns all of 101.9 with a warning), and "what changed" is
answered by dates and the rules that made the change, not a text diff. Huge appendices such as
the Entity List are cut at `maxTextChars` (raise it up to 500,000).

**Which CFR units work?** All 50 titles: sections, and appendices or supplements (`15 CFR 744
Supplement No. 4`, `40 CFR part 60 appendix A-1`). Reserved titles fail with a clear message.

**Personal data?** None is requested. Federal Register documents and CFR appendices can name
people or companies (e.g. the Entity List); they are returned only as published.

Content: Office of the Federal Register (National Archives) and US Government Publishing Office,
via ecfr.gov and federalregister.gov. Not an official legal edition.

# Actor input Schema

## `citation` (type: `string`):

A CFR section, part or appendix: "21 CFR 101.9", "17 CFR 240.10b-5", "48 CFR 52.212-4", "15 CFR 744 Supplement No. 4", or an eCFR link ("https://www.ecfr.gov/current/title-21/section-101.9"). A section or appendix returns one row: its text as in force on asOf, its amendment history and the Federal Register rules behind each change. A part ("15 CFR 744") returns its sections and appendices changed since the since date. Together with search, agency or documentType it instead limits Federal Register documents to that CFR part. Empty = no CFR lookup. An unreadable citation fails in seconds with examples, at no charge.

## `asOf` (type: `string`):

YYYY-MM-DD, e.g. "2024-01-01": the CFR text in force on that date (eCFR history begins around January 2017). Empty = today (the eCFR's latest data, usually 1-2 days old).

## `since` (type: `string`):

YYYY-MM-DD, e.g. "2026-11-01". With a part citation: list sections changed on or after this date (empty = the last 30 days). With a search: only documents published on or after this date (empty = any date). Ignored for a single section or a document number.

## `documentNumber` (type: `string`):

One Federal Register document by its number, e.g. "2026-17231" (corrections look like "C1-2026-16628"). Returns its citation, type, agencies, dates, the CFR parts it affects and links. Empty = no document lookup. Takes precedence over every other field.

## `search` (type: `string`):

Full-text search of Federal Register documents since 1994, newest first, e.g. "entity list". Combine with agency, documentType, since and citation. Empty = no word filter (agency or documentType alone also search).

## `agency` (type: `string`):

Federal Register search by issuing agency: an acronym ("BIS", "FDA", "EPA", "SEC", "OFAC"), a name ("Bureau of Industry and Security") or a FederalRegister.gov slug ("industry-and-security-bureau"). Empty = all agencies. An unknown name fails with suggestions, at no charge.

## `documentType` (type: `string`):

Federal Register search by type: RULE (final rules), PRORULE (proposed rules), NOTICE or PRESDOCU (presidential documents). Empty = all types. E.g. "RULE".

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

Most rows to return: for a part citation the most recently changed units (max 25 per run, each with its text), for a search the newest documents (max 100). Default 20. One charge per row returned with an answer. E.g. 10.

## `maxTextChars` (type: `integer`):

Cap on each section's text in characters, e.g. 20000 (default). Longer text is cut at a line end and flagged with text_truncated and a warning; source_url has the whole text.

## Actor input object example

```json
{
  "citation": "21 CFR 101.9",
  "maxResults": 20,
  "maxTextChars": 20000
}
```

# Actor output Schema

## `results` (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 = {
    "citation": "21 CFR 101.9"
};

// Run the Actor and wait for it to finish
const run = await client.actor("bosco_labs/us-federal-rules").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 = { "citation": "21 CFR 101.9" }

# Run the Actor and wait for it to finish
run = client.actor("bosco_labs/us-federal-rules").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 '{
  "citation": "21 CFR 101.9"
}' |
apify call bosco_labs/us-federal-rules --silent --output-dataset

```

## MCP server setup

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

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/VQGpM0F1Tx7TB1M6E/builds/M4TgWVY79o76VIG1e/openapi.json
