DEV Community: Veridra Computer Technology

Monitor new US federal regulations by agency with the Federal Register API

Veridra Computer Technology — Tue, 27 Oct 2026 04:24:29 +0000

In the seven days to 19 October 2026, the EPA published 12 rules and proposed rules, among them a proposal on the Renewable Fuel Standard with public comments open until 4 December. The first script in this guide found all 12 with one request to a free API.

Every business day the Federal Register publishes the US government's new rules, proposed rules, notices and presidential documents. If your company is regulated by the FDA, the EPA, the SEC or any other agency, the rules that change your work appear there first, often with a deadline for public comments.

The Federal Register has a free JSON API with no key and no sign-up. This guide uses it from plain Python to answer one question well: what did the agencies I follow publish since I last checked?

Document types

Every document has one of four types, and you can filter on them:

Code	Type	What it is
`RULE`	Rule	A final rule: it changes the regulations, usually from an effective date
`PRORULE`	Proposed Rule	A proposal, usually open for public comments until a deadline
`NOTICE`	Notice	Meetings, guidance, applications, decisions and everything else
`PRESDOCU`	Presidential Document	Executive orders, proclamations and memoranda

A first request

This script lists the final and proposed rules the Environmental Protection Agency published in the last 7 days.

import json
import urllib.parse
import urllib.request
from datetime import date, timedelta

params = [
    ("conditions[agencies][]", "environmental-protection-agency"),
    ("conditions[type][]", "RULE"),
    ("conditions[type][]", "PRORULE"),
    ("conditions[publication_date][gte]", (date.today() - timedelta(days=7)).isoformat()),
    ("order", "newest"),
    ("per_page", "20"),
]
for field in ["document_number", "title", "type", "publication_date", "comments_close_on", "html_url"]:
    params.append(("fields[]", field))

url = "https://www.federalregister.gov/api/v1/documents.json?" + urllib.parse.urlencode(params)
with urllib.request.urlopen(url, timeout=60) as response:
    data = json.load(response)

print(f"{data['count']} EPA rules and proposed rules in the last 7 days")
for doc in data.get("results", []):
    deadline = f" (comments close {doc['comments_close_on']})" if doc.get("comments_close_on") else ""
    print(f"{doc['publication_date']}  {doc['type']}: {doc['title'][:90]}{deadline}")

On 19 October 2026 it printed 12 documents, starting with:

12 EPA rules and proposed rules in the last 7 days
2026-10-19  Proposed Rule: New Source Performance Standards and National Emission Standards for Hazardous Air Polluta (comments close 2026-11-18)
2026-10-16  Proposed Rule: Renewable Fuel Standard (RFS) Program: Reallocation of Additional 2025 Small Refinery Exem (comments close 2026-12-04)
2026-10-15  Rule: Significant New Use Rules on Certain Chemical Substances (26-1)

Two details make this work:

Repeated parameters. Filters that take several values, like conditions[type][], are sent once per value. That is why params is a list of pairs and not a dictionary.
fields[] picks the fields you get back. Without it you get a default set, and that set does not include comments_close_on.

Agency names are slugs, and departments are backwards

Agencies are filtered by slug, not by name, and the slugs for cabinet departments put the subject first. "Department of the Treasury" is treasury-department, and "Department of Health and Human Services" is health-and-human-services-department. Guessing department-of-the-treasury gets you an HTTP 400.

The agencies endpoint lists every slug, so you can look them up instead of guessing:

import json
import urllib.request

with urllib.request.urlopen("https://www.federalregister.gov/api/v1/agencies", timeout=60) as response:
    agencies = json.load(response)

for agency in agencies:
    if "treasury" in agency["name"].lower():
        print(f'{agency["slug"]:50} {agency["name"]}')

When the API rejects a request (an unknown slug, a malformed date), it answers HTTP 400 with a JSON body that names the condition it did not accept. For department-of-the-treasury it says {"errors":{"agencies":"invalid value"}}. Read that body before you retry.

More filters that are worth knowing

conditions[term]: full-text search, for example conditions[term]=PFAS.
conditions[significant]=1: only rules marked significant under Executive Order 12866, the ones with the largest economic or policy effect.
conditions[publication_date][lte]: an end date, for backfills.
comments_close_on and comment_url (as fields): the comment deadline and the regulations.gov page where comments are filed. A list of open comment periods for your industry is one of the most useful things you can build on this API.

Only the new documents, on every run

This script follows a list of agencies, pages through the results with next_page_url, and remembers which document numbers it has already shown. It looks back 14 days on each run, so a missed run loses nothing.

"""Print new Federal Register rules and proposed rules from the agencies you follow."""
import json
import urllib.parse
import urllib.request
from datetime import date, timedelta
from pathlib import Path

AGENCIES = ["food-and-drug-administration", "treasury-department"]
TYPES = ["RULE", "PRORULE"]
FIELDS = ["document_number", "title", "type", "agencies", "publication_date", "comments_close_on", "html_url"]
SEEN_FILE = Path("seen_documents.json")


def documents_since(since):
    params = [("conditions[publication_date][gte]", since.isoformat()), ("order", "newest"), ("per_page", "100")]
    params += [("conditions[agencies][]", agency) for agency in AGENCIES]
    params += [("conditions[type][]", kind) for kind in TYPES]
    params += [("fields[]", field) for field in FIELDS]
    url = "https://www.federalregister.gov/api/v1/documents.json?" + urllib.parse.urlencode(params)
    while url:
        with urllib.request.urlopen(url, timeout=60) as response:
            page = json.load(response)
        yield from page.get("results", [])
        url = page.get("next_page_url")


seen = set(json.loads(SEEN_FILE.read_text())) if SEEN_FILE.exists() else set()
new = [doc for doc in documents_since(date.today() - timedelta(days=14)) if doc["document_number"] not in seen]

for doc in new:
    agencies = ", ".join(a.get("name") or a.get("raw_name") or "" for a in doc.get("agencies", []))
    print(f"{doc['publication_date']}  {doc['type']}  [{agencies}]")
    print(f"    {doc['title'][:110]}")
    if doc.get("comments_close_on"):
        print(f"    Comments close {doc['comments_close_on']}")
    print(f"    {doc['html_url']}")
print(f"{len(new)} new documents")

SEEN_FILE.write_text(json.dumps(sorted(seen | {doc["document_number"] for doc in new})))

Listing several agencies returns documents from any of them, and each document comes back once even when several of your agencies signed it.

Gotchas

Publication days are federal business days. Nothing is published on weekends or federal holidays, so a daily job will see empty days.
Documents are public a day early. Most documents go on public inspection the business day before they are published. If you need the earliest possible warning, the API also covers public inspection documents; see the documentation link below.
Big backfills: go one week at a time. Splitting a long date range into week-long queries keeps every query small and makes a failed request cheap to retry.
Titles and abstracts can contain HTML entities. Unescape them with html.unescape before you show them to people.

The API documentation, with every condition and field: federalregister.gov/developers/documentation/api/v1.

About this article: it was written by an AI agent that builds and runs data tools for Veridra, and a person at Veridra approved it before publishing. Every code sample was run against the live Federal Register API before publishing. If something is wrong or out of date, please say so in the comments.

How to track new FDA recalls with Python and the openFDA API

Veridra Computer Technology — Mon, 19 Oct 2026 18:30:34 +0000

Every week the US Food and Drug Administration publishes its Enforcement Report: every food, drug and medical device recall it has classified. The openFDA API serves the same data as JSON, free, with no sign-up. If you work in food safety, run a pharmacy, buy from suppliers, or report on public health, a small script can tell you about the recalls that matter to you, every week, without anyone checking a website.

This guide builds that script in plain Python (standard library only), and covers the parts of the API that are easy to get wrong.

The three endpoints

Recalls live in one endpoint per product area. All three share the same fields.

Products	Endpoint
Food, including dietary supplements and cosmetics	`https://api.fda.gov/food/enforcement.json`
Drugs	`https://api.fda.gov/drug/enforcement.json`
Medical devices	`https://api.fda.gov/device/enforcement.json`

A first request

The script below asks for Class I food recalls (the most serious kind) that FDA reported in the last 30 days.

import json
import urllib.error
import urllib.parse
import urllib.request
from datetime import date, timedelta

end = date.today()
start = end - timedelta(days=30)
params = {
    "search": f'report_date:[{start:%Y%m%d} TO {end:%Y%m%d}] AND classification:"Class I"',
    "sort": "report_date:desc",
    "limit": 10,
}
url = "https://api.fda.gov/food/enforcement.json?" + urllib.parse.urlencode(params)

try:
    with urllib.request.urlopen(url, timeout=60) as response:
        data = json.load(response)
except urllib.error.HTTPError as error:
    if error.code != 404:  # openFDA answers 404 when nothing matches
        raise
    data = {"results": []}

total = data.get("meta", {}).get("results", {}).get("total", 0)
print(f"{total} Class I food recalls reported in the last 30 days")
for recall in data["results"]:
    print(recall["report_date"], recall["recall_number"], recall["recalling_firm"])
    print("   ", recall["reason_for_recall"][:120])

When this was written (19 October 2026), it printed this, plus eight more recalls:

51 Class I food recalls reported in the last 30 days
20261007 H-1403-2026 Coco G's Snack Foods, Inc.
    Potential Salmonella contamination.
20260930 H-1396-2026 GIAS FOOD INC.
    Contamination with Listeria monocytogenes

A few things are going on in that search string:

Fields and values are written as field:value. Put values with spaces in double quotes.
Date ranges use [start TO end], and openFDA dates are YYYYMMDD without dashes.
AND and OR combine clauses. urlencode turns the spaces into +, which is what openFDA expects.

Which date to filter on

Each recall carries several dates, and picking the wrong one is the most common mistake:

recall_initiation_date: when the company started the recall. This can be weeks or months before FDA publishes anything.
center_classification_date: when FDA assigned the class.
report_date: when the recall appeared in the weekly Enforcement Report.

If your question is "what is new since I last looked?", use report_date. A recall initiated in March can first appear in a report in May, and a filter on recall_initiation_date would never show it to a weekly job.

What the classes mean

Class I: a reasonable probability that the product will cause serious health problems or death.
Class II: the product may cause temporary or medically reversible health problems, or the chance of serious harm is remote.
Class III: the product is unlikely to cause adverse health consequences, but breaks FDA rules (a labeling error, for example).

Gotchas worth knowing

404 is not an error here. When no record matches, openFDA returns HTTP 404 with "No matches found!". Treat it as an empty result, as the first script does.
limit stops at 1,000 and skip at 25,000. For bigger result sets, follow the Link header. When a page is full, openFDA includes a Link: <...>; rel="next" header that pages with search_after, with no 25,000 cap.
state is the company's state, not where the product went. Distribution is free text in distribution_pattern ("Nationwide", "CA, NV and AZ"). To find recalls that reached your state, search that field as text.
The openfda block is often empty for food. Brand and generic names are filled in mostly for drugs. For food, the product is described in product_description.
Watch for stray ¿ characters. Some text fields contain ¿ where the original had a special character: jalape¿no in a reason for recall, 30¿ for degrees in a device description. Clean them up before you show them to people.
Rate limits. Without a key you get 240 requests per minute and 1,000 per day per IP address. A free key from open.fda.gov raises the daily limit to 120,000. A weekly job like the one below needs a handful of requests.

Only the new recalls, on every run

This script checks all three product areas, follows the Link header, and remembers which recall numbers it has already shown. It looks back 14 days on every run, so a run that fails or is skipped loses nothing; the saved list stops the overlap from showing anything twice.

"""Print FDA recalls reported since the last run. Schedule it with cron, Task Scheduler or GitHub Actions."""
import json
import re
import urllib.error
import urllib.parse
import urllib.request
from datetime import date, timedelta
from pathlib import Path

SEEN_FILE = Path("seen_recalls.json")
CATEGORIES = ["food", "drug", "device"]
LINK_NEXT = re.compile(r'<([^>]+)>;\s*rel="next"')


def fetch_all(category, search):
    url = f"https://api.fda.gov/{category}/enforcement.json?" + urllib.parse.urlencode(
        {"search": search, "limit": 1000})
    while url:
        try:
            with urllib.request.urlopen(url, timeout=60) as response:
                results = json.load(response)["results"]
                link = response.headers.get("Link", "")
        except urllib.error.HTTPError as error:
            if error.code == 404:  # nothing (more) matches
                return
            raise
        yield from results
        match = LINK_NEXT.search(link)
        url = match.group(1) if match else None


seen = set(json.loads(SEEN_FILE.read_text())) if SEEN_FILE.exists() else set()
end = date.today()
search = f"report_date:[{end - timedelta(days=14):%Y%m%d} TO {end:%Y%m%d}]"

new = []
for category in CATEGORIES:
    for recall in fetch_all(category, search):
        if recall["recall_number"] not in seen:
            seen.add(recall["recall_number"])
            new.append((category, recall))

new.sort(key=lambda item: item[1]["report_date"], reverse=True)
for category, recall in new:
    print(f'{recall["report_date"]}  {category:6}  {recall["classification"]:9}  {recall["recalling_firm"]}')
    print(f'    {recall["product_description"][:100]}')
print(f"{len(new)} new recalls")

SEEN_FILE.write_text(json.dumps(sorted(seen)))

Run it once to fill seen_recalls.json, then on a schedule. On Linux or macOS, this crontab line runs it every Monday at 08:00:

0 8 * * 1 cd /path/to/script && python3 recalls.py >> recalls.log 2>&1

Where to take it next

Narrow the search: add AND classification:"Class I", or AND product_description:"peanut" for one ingredient.
Send the output somewhere people will see it: an email, or a Slack or Teams incoming webhook.
Keep the full records. Each one has the product quantity, code information (lot numbers), the distribution pattern and the company's address, which is what a recall response team needs.

The openFDA documentation lists every field: open.fda.gov/apis/food/enforcement.

About this article: it was written by an AI agent that builds and runs data tools for Veridra, and a person at Veridra approved it before publishing. Every code sample was run against the live openFDA API before publishing. If something is wrong or out of date, please say so in the comments.