DEV Community: Veridra Computer Technology

Get newly registered Norwegian companies from the Brreg open API with Python

Veridra Computer Technology — Tue, 10 Nov 2026 04:24:11 +0000

In the 14 days to 20 October 2026, Norway registered 1,336 new limited companies (AS) and branches of foreign companies (NUF), not counting shelf and holding companies. 269 of them are in Oslo. The register behind those numbers is open and free, and this guide reads it with plain Python.

Norway registers every company in one public register, Enhetsregisteret, run by the Brønnøysund Register Centre (Brreg). Its data is open, free and served by a JSON API with no key. Every new limited company, foreign branch and partnership shows up there as soon as it is registered, with its industry code, address and, often, a website.

A list of companies registered this week is useful to anyone who sells to new businesses: accountants, banks, insurers, office suppliers, software companies. It is also a clean data set for market research. This guide pulls it with plain Python.

A first request

The enheter (entities) endpoint filters by registration date and organisation form. This asks for limited companies (AS) registered in the last 7 days:

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

params = {
    "organisasjonsform": "AS",
    "fraRegistreringsdatoEnhetsregisteret": (date.today() - timedelta(days=7)).isoformat(),
    "tilRegistreringsdatoEnhetsregisteret": date.today().isoformat(),
    "size": 20,
}
url = "https://data.brreg.no/enhetsregisteret/api/enheter?" + urllib.parse.urlencode(params)
request = urllib.request.Request(url, headers={"Accept": "application/json"})
with urllib.request.urlopen(request, timeout=60) as response:
    data = json.load(response)

print(f"{data['page']['totalElements']} new AS companies in the last 7 days")
for company in data.get("_embedded", {}).get("enheter", []):
    industry = company.get("naeringskode1", {}).get("beskrivelse", "no industry code yet")
    city = company.get("forretningsadresse", {}).get("poststed", "")
    print(company["organisasjonsnummer"], company["navn"], "|", industry, "|", city)

The results sit under _embedded.enheter, and page tells you the total count and the number of pages. On 19 October 2026 it printed lines like these:

755 new AS companies in the last 7 days
938564000 AB CONSULT AS | Annen teknisk konsulentvirksomhet | STAVANGER
938456968 ACCOUNTONME AS | Regnskapsføring og bokføring | OSLO
938676852 AFAS 011026-01 AS | Uoppgitt | NARVIK
938676860 AFAS 011026-02 AS | Uoppgitt | NARVIK

Industry descriptions are in Norwegian: "Regnskapsføring og bokføring" is accounting and bookkeeping, and "Uoppgitt" means not stated. The AFAS lines are explained under the gotchas below.

The fields you will use most

Field	Meaning
`organisasjonsnummer`	The 9-digit organisation number, the company's permanent ID
`navn`	Registered name
`organisasjonsform.kode`	Organisation form: AS, ASA, NUF, ENK and so on
`registreringsdatoEnhetsregisteret`	Date it entered the register
`stiftelsesdato`	Date it was founded
`naeringskode1`	Main industry code and description (Norway's version of NACE)
`antallAnsatte`	Number of employees registered
`forretningsadresse`	Business address: street lines, postal code, city, municipality
`hjemmeside`	Website, when the company gave one
`registrertIMvaregisteret`	Whether it is registered for VAT
`konkurs`, `underAvvikling`	Bankruptcy and liquidation flags

Organisation forms

AS: private limited company, by far the most common form for new businesses.
ASA: public limited company.
NUF: Norwegian branch of a foreign company.
ENK: sole proprietorship. These are registered under the owner's own name, so treat them as personal data. If you plan to contact them, data protection law (GDPR) applies.

Gotchas

You cannot page past the first 10,000 results of a query. The API checks that size × (page + 1) is at most 10,000 and answers HTTP 400 otherwise. A month of all registrations can be more than that, so split long date ranges into week-long windows, as the script below does.
New companies are often empty shells for a while. Many have no employees, website or VAT registration yet, and many start with the industry "Uoppgitt" (not stated). Filter on what your use case needs.
Shelf and holding companies add noise. Law firms register ready-made "shelf" companies with numbered names (like ABCD 011026-01 AS), and many new companies are one person's holding company (industry code 64.2). If you are looking for operating businesses, drop both.

Only the new companies, on every run

This script collects new AS and NUF registrations from the last 14 days, in week-long windows, skips shelf and holding companies, and remembers which organisation numbers it has already shown:

"""Print Norwegian companies registered since the last run."""
import json
import re
import urllib.parse
import urllib.request
from collections import Counter
from datetime import date, timedelta
from pathlib import Path

API = "https://data.brreg.no/enhetsregisteret/api/enheter"
FORMS = ["AS", "NUF"]
PAGE_SIZE = 500
SEEN_FILE = Path("seen_companies.json")
SHELF_OR_HOLDING = re.compile(r"(?i)\bholding\b|^\S+ \d{6}-\d+\b")


def registered_between(form, first, last):
    page = 0
    while True:
        params = {"organisasjonsform": form, "fraRegistreringsdatoEnhetsregisteret": first.isoformat(),
                  "tilRegistreringsdatoEnhetsregisteret": last.isoformat(), "size": PAGE_SIZE, "page": page}
        request = urllib.request.Request(f"{API}?{urllib.parse.urlencode(params)}",
                                         headers={"Accept": "application/json"})
        with urllib.request.urlopen(request, timeout=60) as response:
            data = json.load(response)
        yield from data.get("_embedded", {}).get("enheter", [])
        page += 1
        if page >= data.get("page", {}).get("totalPages", 0) or (page + 1) * PAGE_SIZE > 10_000:
            break


def weeks(days_back):
    end = date.today()
    start = end - timedelta(days=days_back)
    while end >= start:
        first = max(start, end - timedelta(days=6))
        yield first, end
        end = first - timedelta(days=1)


seen = set(json.loads(SEEN_FILE.read_text())) if SEEN_FILE.exists() else set()
new = []
for first, last in weeks(days_back=14):
    for form in FORMS:
        for company in registered_between(form, first, last):
            number = company["organisasjonsnummer"]
            industry = company.get("naeringskode1", {}).get("kode", "").replace(".", "")
            if number in seen or SHELF_OR_HOLDING.search(company["navn"]) or industry.startswith("642"):
                continue
            seen.add(number)
            new.append(company)

new.sort(key=lambda c: c.get("registreringsdatoEnhetsregisteret", ""), reverse=True)
for company in new:
    address = company.get("forretningsadresse", {})
    print(f'{company.get("registreringsdatoEnhetsregisteret")}  {company["organisasjonsnummer"]}  {company["navn"]}')
    print(f'    {company.get("naeringskode1", {}).get("beskrivelse", "no industry code yet")}, '
          f'{address.get("poststed", "no address")}')
print(f"{len(new)} new companies")
top = Counter(c.get("forretningsadresse", {}).get("poststed", "no address") for c in new).most_common(8)
for city, count in top:
    print(f"{count:6}  {'█' * max(1, round(30 * count / top[0][1])):30}  {city}")

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

On 20 October 2026 its output ended like this, with a chart of the towns:

2026-10-06  938582327  VJ STUNDER OY NUF
    Annen teknisk konsulentvirksomhet, FI-28130 PORI
2026-10-06  938601593  ZWANNEHEIM NUF
    Utleie av egen eller leid fast eiendom, 2517 JL 'S-GRAVENHAGE
1336 new companies
   269  ██████████████████████████████  OSLO
    36  ████                            STAVANGER
    31  ███                             BERGEN
    24  ███                             TRONDHEIM
    21  ██                              SANDEFJORD
    19  ██                              KRISTIANSAND S
    16  ██                              HELLEVIK I FJALER
    13  █                               ASKER

To focus on one sector, keep only companies whose naeringskode1.kode starts with your industry's code (for example 62 for computer programming and consultancy). To focus on one region, filter on forretningsadresse.kommunenummer.

Licence

Brreg publishes this data under the Norwegian Licence for Open Government Data (NLOD), which allows commercial use with attribution. The API documentation is at data.brreg.no/enhetsregisteret/api/dokumentasjon/en.

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 Brreg API before publishing. If something is wrong or out of date, please say so in the comments.

Find companies that just raised money by reading SEC Form D filings with Python

Veridra Computer Technology — Tue, 03 Nov 2026 04:25:56 +0000

On Friday 16 October 2026, 137 Form D filings reached the SEC. One of them, from Ramp Business Corp, reported $1,585,000,000 sold of a $1,850,000,000 offering. Every one of those filings is public, and this guide reads them with plain Python.

When a US company sells securities in a private offering (a seed round, a Series A, a friends-and-family raise), it usually files a short notice with the SEC called a Form D. The filing is due within 15 days after the first sale, it is public, and it says which company raised money, how much, in what industry, and where the company is.

That makes Form D one of the earliest public signals that a company has fresh funding. Sales teams use it to find companies that just got a budget, investors use it to watch competitors' portfolios, and journalists use it to spot raises before they are announced.

This guide reads Form D filings straight from SEC EDGAR with plain Python.

Rules of the road

EDGAR is free, but the SEC sets two conditions for automated access:

Identify yourself. Send a User-Agent header with your name or company and an email address. Requests without one are refused with HTTP 403.
Stay under 10 requests per second. The scripts below pause between requests to keep well under that.

Step 1: the daily index

EDGAR publishes an index of every filing received each business day, at a predictable address:

https://www.sec.gov/Archives/edgar/daily-index/{year}/QTR{quarter}/master.{yyyymmdd}.idx

Each line is CIK|Company Name|Form Type|Date Filed|File Name, separated by pipes. Form D filings have the form type D, and amendments D/A. This script finds the most recent business day with an index and lists its Form D filings:

import os
import urllib.error
import urllib.request
from datetime import date, timedelta

# The SEC asks every script to say who is calling. Use your name or company and an email address.
USER_AGENT = os.environ.get("SEC_USER_AGENT", "Your Name your.email@example.com")


def daily_index(day):
    quarter = (day.month - 1) // 3 + 1
    url = f"https://www.sec.gov/Archives/edgar/daily-index/{day.year}/QTR{quarter}/master.{day:%Y%m%d}.idx"
    request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
    try:
        with urllib.request.urlopen(request, timeout=60) as response:
            return response.read().decode("latin-1")
    except urllib.error.HTTPError as error:
        if error.code in (403, 404):  # weekends, holidays, and an index that is not published yet
            return None
        raise


for back in range(1, 11):
    day = date.today() - timedelta(days=back)
    index = daily_index(day)
    if index is not None:
        break
else:
    raise SystemExit("No daily index in the last 10 days. Check your User-Agent.")

filings = [line.split("|") for line in index.splitlines()]
form_d = [row for row in filings if len(row) == 5 and row[2] == "D"]
print(f"{len(form_d)} new Form D filings on {day}")
for cik, company, form, filed, path in form_d[:10]:
    print(f"{cik:>10}  {company}")

Note the loop limit. EDGAR answers 403, not only 404, for a day that has no index. A script that keeps stepping back until it finds one would loop forever if the 403 really meant your User-Agent was refused, so it gives up after 10 days and says why.

Step 2: the filing itself

The index line ends with a path like edgar/data/1234567/0001234567-26-000001.txt. The structured Form D data sits next to it, in primary_doc.xml inside the filing's folder:

https://www.sec.gov/Archives/edgar/data/{cik}/{accession number without dashes}/primary_doc.xml

The XML has three parts you will want: primaryIssuer (name, address, phone, entity type), offeringData (industry, amounts, investors, exemptions) and relatedPersonsList (executive officers, directors and promoters, with their roles). The script below counts those roles and leaves people's names out; the last section explains why.

This script reads the filings from the most recent business day, skips investment funds, and prints the company, its state and industry, the amount sold, and how many people hold each listed role:

import os
import time
import urllib.error
import urllib.request
import xml.etree.ElementTree as ET
from datetime import date, timedelta

USER_AGENT = os.environ.get("SEC_USER_AGENT", "Your Name your.email@example.com")
ARCHIVES = "https://www.sec.gov/Archives/edgar"


def get(url):
    time.sleep(0.15)  # stays well under the SEC's limit of 10 requests per second
    request = urllib.request.Request(url, headers={"User-Agent": USER_AGENT})
    with urllib.request.urlopen(request, timeout=60) as response:
        return response.read()


def latest_form_d_filings(max_days_back=10):
    for back in range(1, max_days_back + 1):
        day = date.today() - timedelta(days=back)
        url = f"{ARCHIVES}/daily-index/{day.year}/QTR{(day.month - 1) // 3 + 1}/master.{day:%Y%m%d}.idx"
        try:
            index = get(url).decode("latin-1")
        except urllib.error.HTTPError as error:
            if error.code in (403, 404):
                continue
            raise
        rows = [line.split("|") for line in index.splitlines()]
        return day, [row for row in rows if len(row) == 5 and row[2] == "D"]
    raise SystemExit("No daily index in the last 10 days. Check your User-Agent.")


def text(node, path):
    found = node.find(path) if node is not None else None
    return found.text.strip() if found is not None and found.text else None


def money(value):
    try:
        return f"${float(value):,.0f}"
    except (TypeError, ValueError):
        return value or "not stated"  # "Indefinite" is allowed for the offering size


def parse(xml_bytes):
    root = ET.fromstring(xml_bytes)
    for element in root.iter():  # drop the XML namespaces so the paths below stay short
        element.tag = element.tag.rsplit("}", 1)[-1]
    issuer, offering = root.find("primaryIssuer"), root.find("offeringData")
    roles = {}  # how many listed people hold each role; names are left out
    for person in root.findall("relatedPersonsList/relatedPersonInfo"):
        for role in {r.text.strip() for r in person.findall("relatedPersonRelationshipList/relationship") if r.text}:
            roles[role] = roles.get(role, 0) + 1
    return {
        "company": text(issuer, "entityName"),
        "state": text(issuer, "issuerAddress/stateOrCountry"),
        "industry": text(offering, "industryGroup/industryGroupType"),
        "sold": text(offering, "offeringSalesAmounts/totalAmountSold"),
        "offered": text(offering, "offeringSalesAmounts/totalOfferingAmount"),
        "roles": ", ".join(f"{role} ({n})" for role, n in sorted(roles.items())),
    }


day, filings = latest_form_d_filings()
print(f"{len(filings)} Form D filings on {day}; reading the first 25")
for cik, company, form, filed, path in filings[:25]:
    accession = path.rsplit("/", 1)[-1].removesuffix(".txt")
    try:
        filing = parse(get(f"{ARCHIVES}/data/{int(cik)}/{accession.replace('-', '')}/primary_doc.xml"))
    except (urllib.error.HTTPError, ET.ParseError) as error:
        print(f"Skipped {company}: {error}")
        continue
    if filing["industry"] == "Pooled Investment Fund":
        continue  # private funds raising from their investors, not operating companies
    print(f"{filing['company']} ({filing['state']}), {filing['industry']}: "
          f"{money(filing['sold'])} sold of {money(filing['offered'])}")
    if filing["roles"]:
        print(f"    Roles listed: {filing['roles']}")

On 19 October 2026 it read the filings from Friday 16 October. A few of the lines it printed:

137 Form D filings on 2026-10-16; reading the first 25
J3 BIOSCIENCE, INC. (UT), Other Health Care: $50,000 sold of $50,000
    Roles listed: Director (9), Executive Officer (3)
Global Atomic Corp (A6), Other: $1,930,774 sold of $29,927,580
    Roles listed: Director (6), Executive Officer (2)
Ramp Business Corp (NY), Other Technology: $1,585,000,000 sold of $1,850,000,000
    Roles listed: Director (4), Executive Officer (2)
High Street Holdco, LLC (MI), Insurance: $4,500,000 sold of Indefinite
    Roles listed: Director (5), Executive Officer (6)

Gotchas

Many Form D filers are funds. Venture funds, hedge funds and real estate vehicles file Form D when they raise from their investors, under the industry group "Pooled Investment Fund". If you want operating companies, filter them out as the script does.
Namespaces change between schema versions. Matching on element names with the namespace stripped, as parse does, keeps one parser working across old and new filings.
Amounts are not always numbers. The total offering amount can be "Indefinite". Amount sold is a number, but it is the amount sold so far, often only part of the round.
Amendments. A D/A is a change to an earlier filing, often filed each year while an offering stays open, and there are about as many of them as new filings: 137 D and 126 D/A on 16 October 2026. If you only want new raises, keep D and skip D/A. One company can also file several new notices on the same day, so remove repeats by CIK if you want one line per company.
State codes are EDGAR's own. US states use the usual two letters, but Canadian provinces and other countries get codes such as A6 (Ontario) and A1 (British Columbia), as in the output above. The filing also has stateOrCountryDescription with the name spelled out.
Today's index comes late. The index for the current day appears in the evening, US Eastern time, so a morning job should read yesterday's.

Why the script leaves names out

Form D lists the names of a company's executives, directors and promoters. They are public, but once you collect people's names you take on duties under data protection laws (GDPR in Europe, and similar laws in many other places), and marketing rules such as CAN-SPAM apply if you contact them. Counting roles gives you most of the signal (whether there is a board, how many officers are named) without holding anyone's personal data. When you do need a name, open the filing on EDGAR.

The SEC explains its access rules on Accessing EDGAR Data.

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 live SEC EDGAR data before publishing. If something is wrong or out of date, please say so in the comments.

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.