How a Federal Rule Is Made: Tracing the Rulemaking Lifecycle Across Federal Data

A federal regulation is not a single document. It is a chain. Congress passes a law that tells an agency to write rules; the agency publishes a proposal in the Federal Register and asks the public what it thinks; the public files comments in a docket on Regulations.gov; and the agency issues a final rule that has to answer the serious objections. Each stage lives in a different federal dataset, and the work of tracing a rule from an act of Congress to an enforceable regulation is the work of threading a handful of identifiers—a RIN, a docket ID, a document number—across three of them so the whole lifecycle finally sits in one connected view.

This article covers how the notice-and-comment process of the Administrative Procedure Act maps onto three federal datasets; the statute that starts a rulemaking and the delegation of authority it carries; the Notice of Proposed Rulemaking and the comment period that follows; the public-comment docket on Regulations.gov and the agency's obligation to respond; the final rule and how it must engage the significant comments; the three join keys—the Regulatory Identification Number, the Regulations.gov docket ID, and the Federal Register citation and document number—that thread the stages together; the questions the assembled data answers, from proposal-to-final timelines to which statutes spawn the most rulemaking; a Python workflow that takes a rule by RIN, pulls its proposed and final Federal Register documents, counts the comments in its docket, and measures the timeline; and the caveats—missing identifiers, mass-comment campaigns, and the gap between a published rule and the litigation that may follow—that every analyst must hold in mind before drawing conclusions.

The lifecycle and the three datasets

The reason a single regulation is spread across several datasets is that American rulemaking is a sequence of legally distinct steps, and each step produces a different kind of public record kept by a different system. At the top is the public law: an act of Congress, recorded in the statutes, that authorizes an agency to regulate in some domain. From that authority flows everything else. The agency drafts a regulation and publishes it first as a proposal and later, after public input, as a binding rule—both in the Federal Register, the federal government's official daily journal of agency actions. In between the proposal and the final rule sits the public's turn: the comments the public files are collected in a docket on Regulations.gov, the governmentwide portal for participating in rulemaking. Three records, three systems, one rule.

In our database these map onto three tables that an analyst joins rather than parses anew. The statute lives in a public_laws record. The proposed and final rules—both of them Federal Register documents—live in federal_register_rules. The comment docket and the comments themselves live in regulations_dockets. The whole exercise of tracing the lifecycle is the exercise of carrying the right identifiers across these three federal rulemaking datasets, so that the analyst can follow a single rule from the law that authorized it, to the proposal, to the comments, to the final rule, without re-parsing each source from scratch. The identifiers that make the thread tractable are the payload of this article; the columns that carry them look like this:

-- public_laws (the authorizing statute)
public_law_number      -- e.g. "117-58", the Pub. L. citation
statute_title          -- short title of the act
enacted_date           -- date the President signed it
us_code_citations      -- the U.S. Code sections it created/amended

-- federal_register_rules (proposed AND final, one row per FR document)
document_number        -- the FR document number (anchors the published action)
fr_citation            -- the "90 FR 12345" Federal Register citation
type                   -- "Proposed Rule" (NPRM) or "Rule" (final)
rin                    -- Regulation Identification Number (ties NPRM to final)
docket_ids             -- the Regulations.gov docket(s) for this action
agency                 -- the issuing agency
cfr_references         -- the CFR title/part the rule amends
publication_date       -- date published in the Federal Register
comment_close_date     -- end of the comment period (proposed rules)

-- regulations_dockets (the comment docket and its filings)
docket_id              -- groups the proposal with its comments + materials
document_id            -- a single docket item (rule, comment, or attachment)
document_type          -- "Proposed Rule", "Rule", "Public Submission", ...
rin                    -- the same RIN, where the agency supplied it
comment_count          -- number of public comments on the docket
posted_date            -- date the item was posted to the docket

Read the three blocks together and the architecture of a rulemaking is visible at a glance. The public_law_number names the authority. The rin appears in both the Federal Register rules and the docket, tying a proposal to its final rule and to the comments filed against it. The docket_id groups everything the public sees about one rulemaking. And the document_number and fr_citation anchor each published action to a specific, citable place in the official record. Nothing in this article is harder than learning which identifier carries which relationship; the rest is mechanics.

The statute that starts a rulemaking

Every legitimate federal regulation rests on a grant of authority from Congress. Agencies are creatures of statute; they have no inherent power to make binding rules. When Congress wants a subject regulated—workplace safety, vehicle emissions, drug approvals, financial disclosure—it passes a law that, among other things, delegates rulemaking authority to a named agency, directing it (or permitting it) to issue regulations to carry the statute into effect. That delegation is the seed of every rule the agency later writes. A rule that exceeds the authority the statute confers is, in the language of administrative law, ultra vires—beyond the agency's power—and can be struck down on that ground alone. The statute is therefore not background; it is the legal source and the outer boundary of the entire rulemaking.

The public law also fixes the terms the rule must honor. A statute may set a deadline by which the agency must act, prescribe factors the agency must weigh, require a particular kind of analysis, or specify the standard the rule must meet—feasible, cost-justified, necessary to protect health, and so on. Those statutory instructions become the criteria against which a reviewing court later measures the final rule. This is why the lifecycle begins with the public_laws record and not with the Federal Register: the proposed rule will cite the statute as its authority, the final rule will defend itself as a reasonable exercise of that authority, and any challenge to the rule will argue that it strays from what the statute allows. Linking a Federal Register rule back to the public law that authorized it—through the statutory citations the agency lists as its legal basis—is what closes the loop from an act of Congress to the regulation it ultimately produced, and it is what lets an analyst ask which statutes generate the most regulatory activity downstream.

The proposed rule and the comment period

With authority in hand, the agency does not simply decree a rule. The Administrative Procedure Act (APA) of 1946 requires, for most substantive rules, a process of notice-and-comment rulemaking, and the first public act of that process is the Notice of Proposed Rulemaking (NPRM). The agency publishes the proposed rule in the Federal Register, where it must give the public genuine notice: a statement of the legal authority under which the rule is proposed, the substance of the proposed regulation or a description of the subjects and issues involved, and an explanation of the agency's reasoning. The NPRM is the moment the rulemaking becomes visible and participatory—the point at which a draft policy is opened to the people it will bind.

The NPRM opens the comment period, a defined window—commonly thirty, sixty, or ninety days, longer for complex or consequential rules—during which anyone may submit written comments on the proposal. This is not a formality. The APA entitles interested persons to participate, and the comments they file become part of the rulemaking record the agency must consider. Industry, advocacy groups, state and local governments, academics, and individual members of the public all use the comment period to argue that the proposal is too strict or too lax, that the agency has misjudged the costs or the benefits, that it has overlooked an alternative, or that it lacks the authority to do what it proposes. In the data, the NPRM is a Federal Register document of type “Proposed Rule,” carrying a publication_date, a comment_close_date that marks the end of the window, and—crucially—the RIN and docket ID that will tie it to the comments and to the final rule that follow.

The docket and the public comments

The comments do not pile up loose; they are collected in a docket, and the central public home for federal rulemaking dockets is Regulations.gov, the governmentwide portal where the public reads proposals, downloads supporting materials, and files comments. A docket is the folder for one rulemaking. It holds the proposed rule, the supporting and analytical documents the agency relied on, and the public comments submitted in response—and, when the rulemaking concludes, the final rule too. Everything about one rule that the public is meant to see is grouped under a single docket_id, which is precisely what makes that identifier the natural key for assembling a rulemaking's public record in one place.

What the agency does with the comments is the legal heart of the process. The APA requires the agency, after considering the comments, to incorporate in the final rule a concise general statement of the rule's basis and purpose—and the courts have read that requirement to mean that the agency must respond to the significant commentsit received. It need not answer every comment, but it cannot ignore the serious ones: it must show that it considered the important objections and alternatives raised, and explain why it adopted the course it did. A final rule that fails to engage a significant comment—or that adopts a position the record cannot support—is vulnerable to being set aside on judicial review as arbitrary and capricious. This is the mechanism that gives the comment period its teeth, and it is why counting comments is only the beginning: the analytically interesting question is whether the comments changed the rule, which one tests by comparing the proposal to the final and reading the agency's response in the preamble.

The final rule

The rulemaking culminates in the final rule, published—like the proposal—in the Federal Register, and it is here that the chain becomes binding law. The final rule sets out the regulatory text in its adopted form, almost always preceded by a lengthy preamble that recounts the proposal, summarizes the comments received, gives the agency's reasoned response to the significant ones, explains any changes made between the proposal and the final version, and sets the effective date. When the final rule takes effect, its text is codified into the Code of Federal Regulations (CFR), the topical compilation of the government's standing regulations, where it lives as enforceable law until amended or repealed. The Federal Register publishes the action; the CFR holds the result.

For consequential rules the path also runs through review outside the issuing agency. Significant rules are reviewed by the Office of Information and Regulatory Affairs (OIRA) within the Office of Management and Budget before publication, both at the proposed and the final stage, a step that adds time to the timeline and that is itself partially documented in the public record. Major rules are also subject to the Congressional Review Act, which gives Congress a window to disapprove a rule before it takes effect. In the data, the final rule is a Federal Register document of type “Rule” that carries the same RIN as the proposal that preceded it— that shared RIN is what lets an analyst pair a proposal with its final and measure how long the journey took. The fr_citation and document_numberanchor the final rule to its citable place in the official journal, and the cfr_references point to where its text now lives in the standing regulations.

The join keys: RIN, docket ID, and FR document number

The entire enterprise of tracing a rule rests on three identifiers that the federal system threads through the stages, and understanding exactly what each one ties together is what separates a clean lifecycle reconstruction from a tangle of mismatched records.

The Regulation Identification Number (RIN) is the spine. The RIN is a code—an agency prefix followed by a four-character suffix—assigned to a rulemaking when the agency first lists it in the Unified Agenda of regulatory actions, and it stays attached to that rulemaking across all its Federal Register documents. The proposed rule and the final rule that grew out of it carry the same RIN. That is the single most useful fact in this article: because the RIN is stable across the proposed-to-final pairing, an analyst can collect every Federal Register document bearing a given RIN, sort them by date and type, and reconstruct the rulemaking's arc—proposal, any supplemental or interim actions, and final rule—without guessing which documents belong together. The RIN is what makes the proposal-to-final timeline computable at scale.

The Regulations.gov docket ID is the grouping key for the public side. Where the RIN ties the agency's published documents together, the docket ID groups a proposal with the comments and supporting materials filed against it. A Federal Register document records which docket it belongs to (the docket_ids field), and Regulations.gov uses the same docket ID to gather the comments. Joining the Federal Register rule to the Regulations.gov docket on that shared docket ID is what carries the analyst from “what the agency proposed” to “what the public said about it.” The relationship is not always one-to-one—a single docket can host more than one Federal Register action, and an agency can occasionally split a rulemaking across dockets—but the docket ID is the canonical link between the published rule and its public participation record.

The Federal Register citation and document numberare the anchors. Every published action—every proposed rule, every final rule—has a Federal Register document number that uniquely identifies it within the Federal Register's own system, and a citation of the familiar form “volume FR page” (for example, 90 FR 12345) that locates it in the official journal. These are what make a rule citable and what let any record—a court opinion, a later rule, a comment—point unambiguously to a specific published action. Together the three identifiers form a small but complete graph: the RIN binds an agency's documents across time, the docket ID binds an action to its public comments, and the document number and citation anchor each action to its exact place in the record. Thread all three and the rulemaking lifecycle assembles itself.

What the assembled data answers

Once the three datasets are joined, the connected view answers questions that no single source can—the questions that actually drive regulatory analysis.

How long the path from proposed to final rule takes.Pairing a proposal with its final rule by RIN and differencing the two publication dates yields the rulemaking's duration—the time the agency took to digest the comments, clear interagency review, and issue the binding rule. Aggregated across many rules, these durations reveal how long rulemaking really takes, how it varies by agency and by subject, and which proposals stall for years or never reach a final rule at all. The proposal-to-final timeline is the single most requested metric in rulemaking analysis, and the shared RIN is what makes it computable.

How many comments a controversial rule drew, and whether the agency changed it. Counting the comments in a docket measures public engagement; reading the final rule's preamble against the proposal measures response. Together they let an analyst ask whether the rules that drew the most comments were the ones the agency revised most—or whether heavy comment volume, often driven by organized mass-comment campaigns, moved the outcome at all. Which statutes spawn the most rulemaking follows from linking final rules back through their statutory authority to the public laws that authorized them, surfacing the acts of Congress that generate the heaviest downstream regulatory activity. And how regulatory output rises and falls across administrations emerges from counting proposed and final rules by publication date, exposing the surges, freezes, and end-of-term pushes that mark the regulatory calendar. Each of these is a join away once the RIN, the docket ID, and the statutory citation are in hand.

Python: tracing a single rule across all three sources

The script below takes a rule by its RIN, uses the Federal Register API (federalregister.gov/api, no key required) to pull every published document carrying that RIN, splits them into the proposed rule and the final rule, measures the proposal-to-final timeline, and then uses the Regulations.gov API (which uses a free api.data.gov key) to count the public comments in the matching docket. It is the lifecycle reconstruction in miniature: one identifier in, the arc of a rulemaking out. The Federal Register API exposes the RIN, the document type, the publication date, and the docket IDs directly, so the proposal-to-final pairing needs nothing more than a filter and a date difference; the comment tally comes from the totalElements count Regulations.gov returns in its page metadata, so a single small request yields the full count. Requirements: requests.

import requests, time
from datetime import date

# Trace one rule across the rulemaking lifecycle using three public sources.
#
#   1. Federal Register API  -- federalregister.gov/api/v1  (NO key needed)
#      Holds the proposed rule (NPRM) and the final rule as published
#      documents, each carrying the RIN, the docket_id, and a document_number.
#   2. Regulations.gov API   -- api.regulations.gov/v4       (free api.data.gov key)
#      Holds the docket and the public comments filed against it.
#
# Strategy: given a RIN, pull every Federal Register document that carries it,
# split them into proposed vs final, measure the proposed-to-final timeline,
# then count the comments in the matching Regulations.gov docket.
FR_API   = "https://www.federalregister.gov/api/v1"
REG_API  = "https://api.regulations.gov/v4"
REG_KEY  = "DEMO_KEY"   # replace with your free api.data.gov key for real volume


def fr_documents_for_rin(rin):
    # The Federal Register API filters documents by Regulation ID Number.
    # We ask only for the fields we need to keep the payload small.
    params = {
        "conditions[regulation_id_number]": rin,
        "fields[]": ["document_number", "type", "publication_date",
                     "docket_ids", "title", "regulation_id_numbers"],
        "per_page": 1000,
        "order": "oldest",
    }
    r = requests.get(f"{FR_API}/documents.json", params=params, timeout=60)
    r.raise_for_status()
    return r.json().get("results", [])


def comment_count(docket_id):
    # Regulations.gov returns a totalElements count in the page metadata,
    # so a single page-size-1 request yields the full comment tally.
    params = {
        "filter[docketId]": docket_id,
        "page[size]": 1,
        "api_key": REG_KEY,
    }
    r = requests.get(f"{REG_API}/comments", params=params, timeout=60)
    r.raise_for_status()
    return r.json().get("meta", {}).get("totalElements", 0)


def trace(rin):
    docs = fr_documents_for_rin(rin)
    if not docs:
        print(f"No Federal Register documents found for RIN {rin}")
        return
    proposed = [d for d in docs if d["type"] == "Proposed Rule"]
    final    = [d for d in docs if d["type"] == "Rule"]

    # --- Proposal-to-final timeline --------------------------------------
    if proposed and final:
        p0 = date.fromisoformat(proposed[0]["publication_date"])
        f0 = date.fromisoformat(final[0]["publication_date"])
        print(f"RIN {rin}: proposed {p0} -> final {f0} "
              f"({(f0 - p0).days} days)")
    else:
        print(f"RIN {rin}: {len(proposed)} proposed, {len(final)} final "
              "(incomplete lifecycle in the FR record)")

    # --- Comment volume in the matching docket ---------------------------
    dockets = {d for doc in docs for d in (doc.get("docket_ids") or [])}
    for dk in sorted(dockets):
        n = comment_count(dk)
        print(f"  docket {dk}: {n:,} public comments")
        time.sleep(1)   # be polite to the rate limit


# Example RINs (replace with the rule you want to follow):
trace("2127-AL76")   # an NHTSA corporate average fuel economy (CAFE) rulemaking

Two refinements turn this sketch into production work. First, the script assumes a clean one-proposal-one-final arc, but real rulemakings are messier: a RIN can carry supplemental proposals, interim final rules, corrections, and withdrawals, so robust code should classify documents by type and date rather than taking the first proposed and first final and should handle the case where a proposal never produced a final rule. Second, the comment count is a volume measure, not a substance measure—to learn whether the comments changed the rule, the analyst must go further: fetch the final rule's full text from the Federal Register, locate the response-to-comments section of the preamble, and compare the adopted regulatory text against the proposal. For national-scale work—ranking agencies by rulemaking duration, or building the full statute-to-rule lineage—the Federal Register bulk data on GovInfo and the Regulations.gov bulk download are far more efficient than iterating the APIs rule by rule, and they ship the authoritative, version-stamped field definitions.

Limitations and analytical caveats

The joined rulemaking record is the most complete public account of how regulations are made, but it is assembled from three independently maintained systems, and the seams between them carry limitations an analyst must internalize before drawing conclusions.

The join keys are not always present or consistent.The whole method depends on the RIN and the docket ID appearing on the records that should carry them—but they do not always. Older Federal Register documents may lack a RIN; some actions are published without a populated docket ID; and a docket can occasionally host more than one rulemaking or be split across more than one docket, breaking the clean one-to-one mapping the simple join assumes. Where an identifier is missing, the lifecycle has to be reconstructed by other means—matching on agency, subject, and date, or following the citations the documents make to one another— which is slower and more error-prone. An analysis that silently drops the records without clean keys will understate exactly the older or irregular rulemakings that the keys fail to cover.

Comment counts are volume, not consensus. A docket's comment tally is one of the most misread numbers in regulatory data. Modern rulemakings frequently draw mass-comment campaigns in which advocacy organizations generate tens or hundreds of thousands of near-identical form submissions, so a rule with a million comments may reflect a handful of distinct positions amplified by mobilization rather than a million independent judgments. The APA, moreover, does not weigh comments by the count—an agency must respond to the significant comments, and a single well-argued comment from an expert can carry more legal weight than a hundred thousand identical form letters. Treating comment volume as a vote, or as a measure of how persuasive the public was, fundamentally misunderstands the process; volume measures engagement and mobilization, not the merits.

A published final rule is not the end of the story.The lifecycle this article traces ends at the final rule, but a regulation's real life often continues past publication. A final rule can be challenged in court and stayed, vacated, or remanded to the agency; it can be delayed or reconsidered by a new administration; it can be disapproved under the Congressional Review Act; and it can be superseded by a later rulemaking that carries a new RIN. The three datasets capture the making of the rule, not the subsequent litigation and political contestation that determine whether it survives. An analyst who treats the existence of a final rule as proof that the policy took effect and stuck will sometimes be wrong—the rule may have been enjoined before its effective date—so conclusions about regulatory outcomes should be cross-checked against the dockets of the courts and the record of any later amending actions.

There is reporting lag, and the systems are not in lockstep.A document appears in the Federal Register on its publication date, but the matching docket materials and comments propagate to Regulations.gov on their own schedule, and the linkage between a Federal Register rule and its statutory authority depends on how the agency cited that authority. Snapshots taken close to a comment deadline will undercount comments still being processed, and very recent rules may not yet show a settled docket. The joined record is authoritative for established, completed rulemakings and for multi-year trends; it is less reliable as a real-time monitor of a rulemaking still in motion.

Held with these caveats in mind, the joined rulemaking lifecycle is a uniquely powerful view of American governance in action: three federal datasets—the public law that grants the power, the Federal Register documents that propose and then impose the rule, and the Regulations.gov docket that records the public's say—threaded together by a RIN, a docket ID, and a document number into a single legible arc from an act of Congress to an enforceable regulation, the machinery by which a statute becomes law you can be held to.