US Public Laws: The Federal Record of Every Law Congress Has Enacted

A bill becomes a law in a single, datable instant—a signature, or the lapse of ten days, or a two-thirds override—and at that instant it is handed a number that will outlive the Congress that passed it: Public Law 117-58, Public Law 111-148, Public Law 101-336. That number is the spine of the federal statute book. Behind it sits the chronological record of every law Congress has actually enacted—the Americans with Disabilities Act, HIPAA, Sarbanes-Oxley, Dodd-Frank, the Affordable Care Act, the CARES Act, the Infrastructure Investment and Jobs Act—several thousand of them from 1989 forward, one row per law, published by the Government Publishing Office through GovInfo.

This article covers what the public-laws dataset is and how a bill becomes a numbered public law; the anatomy of the public-law number and what its two parts mean; the three-stage publication pipeline that takes a new statute from slip law to the Statutes at Large to the United States Code, and why those three forms are not the same thing; the difference between a public law and a private law; the originating bill and how a public law links back to the measure that became it; the Government Publishing Office and GovInfo as the source of record; the landmark statutes that anchor the coverage window and what the chronological record is good for; how the table joins to congressional roll-call votes and to the rulemaking the laws authorize; a Python workflow that pulls public laws from the GovInfo API, tallies enactments by Congress, and searches titles by keyword; and the caveats—codification lag, the gap between a law's number and its substance, and the difference between enactment and effect—that every analyst should hold in mind.

What the dataset is

A public law is a bill or joint resolution that has completed the full constitutional path to enactment: it has passed both the House of Representatives and the Senate in identical text, and it has been signed by the President—or it has become law without a signature, or over a veto by a two-thirds vote of both chambers. At that moment the measure ceases to be pending legislation and becomes binding federal law. Most of what is colloquially called “an act of Congress” is a public law. The dataset is the chronological record of those enacted laws themselves—not the bills that died in committee, not the thousands of measures introduced and never passed, but the comparatively small set that ran the full gauntlet and emerged as law.

In our database this record is stored as the table public_laws, with the grain of one row per enacted public law from the 101st Congress (1989) to the present—several thousand laws in all. It is keyed by the public-law number, the persistent identifier every enacted law receives. The columns capture the law's number, the bill that became it, the title, the date it was enacted, the Congress and session in which it passed, and a link to the full text:

public_law_number    -- e.g. "117-58" (Congress + sequential law within it)
congress             -- the numbered Congress that enacted it (e.g. 117)
session              -- the session within that Congress (1 or 2)
bill_number          -- the originating measure (e.g. "H.R. 3684", "S. 1605")
law_title            -- the short or popular title of the act
date_approved        -- date of enactment / approval (signature or override)
statutes_at_large    -- Statutes at Large citation (e.g. "135 Stat. 429")
package_id           -- GovInfo PLAW package ID (e.g. "PLAW-117publ58")
text_url             -- link to the full slip-law text on GovInfo

The public_law_number is the load-bearing column. It is the citation by which a statute is referenced in the years before—and often long after—it is codified, and it is the key that ties an enacted law to the congressional action that produced it and to the executive action it sets in motion. The bill_number records the measure as it was introduced (an H.R. bill originating in the House, an S. bill in the Senate, or a joint resolution), which is the join back to the legislative-history record—the committee reports, the floor debate, and the roll-call votes. The date_approved is the moment of enactment, the single datable instant that turns a bill into law. And the statutes_at_large citation is the law's permanent address in the bound, chronological compilation of federal statutes—the form the law takes the moment after it is a slip law and before it is woven into the Code.

How a bill becomes a public law

The enactment path is the one set out in Article I of the Constitution, and it is more selective than its familiar description suggests. A measure is introduced in one chamber, is usually referred to a committee, may be amended and reported, and must be passed by that chamber. It then goes to the other chamber, which may pass it as received, amend it, or ignore it; if the two chambers pass different versions, the differences must be reconciled (historically through a conference committee, increasingly through amendments traded between the chambers) so that identical text passes both. Only then does the measure go to the President. The President may sign it, in which case it becomes law on the date of signature; may take no action for ten days (excluding Sundays) while Congress is in session, in which case it becomes law without a signature; may veto it, returning it with objections; or, if Congress has adjourned within that ten-day window, may decline to act and let it die in a “pocket veto.” A vetoed bill becomes law only if both chambers override the veto by a two-thirds vote.

The decisive analytic fact is how few measures complete this path. In a typical two-year Congress, thousands upon thousands of bills and joint resolutions are introduced; only a few hundred become public laws. The overwhelming majority never receive a committee vote, let alone a floor vote in both chambers. The public-laws dataset is therefore the record of the survivors—the thin top layer of the legislative funnel. This is why the dataset is far smaller than a dataset of introduced bills, and why each row represents not a proposal but a completed exercise of legislative power. It is also why studying what gets enacted, rather than what gets introduced, is a different and in some ways more revealing question: the introduced-bill record measures what members want; the public-laws record measures what the institution as a whole was actually able to agree on and the President was willing to sign.

Anatomy of the public-law number

Every public law is assigned a number in the form Public Law NNN-NNN—commonly abbreviated P.L. NNN-NNN or Pub. L. No. NNN-NNN—and the two parts of that number carry distinct meaning. The first number is the Congress in which the law was enacted. Congresses are numbered consecutively and run for two years; the 1st Congress convened in 1789, and the numbering has advanced by one every two years since. The second number is the law's sequence within that Congress: public laws are numbered consecutively in the order they are enacted, starting fresh at 1 for each new Congress. Thus Public Law 117-58 is the fifty-eighth public law enacted by the 117th Congress, and Public Law 101-336 is the three hundred thirty-sixth law of the 101st Congress.

Two consequences of this scheme matter for analysis. First, the number is chronological within a Congress but not across Congresses: P.L. 117-2 came before P.L. 116-260 by Congress number but after it in real time, because the 116th Congress preceded the 117th. To order laws by date one must use the date_approved field, not the law number. Second, the number is assigned at enactment and never changes. A statute may be amended, repealed, renumbered within the Code, or superseded, but its public-law number is a fixed historical fact—the permanent identifier of a specific act of a specific Congress on a specific date. That permanence is exactly what makes the public-law number a reliable primary key for a chronological dataset of enacted laws, and a stable citation that legal and policy documents can rely on across decades.

Slip law, Statutes at Large, and the US Code

A newly enacted public law passes through three published forms, and conflating them is one of the most common mistakes made about federal statutes. This dataset is fundamentally about the first two forms—the chronological record of laws as enacted—and it is important to understand how that differs from the third.

The first form is the slip law. The moment a bill is enacted, GPO prints it as an individual pamphlet—the official first publication of the new law as a standalone document, bearing its public-law number and the text exactly as passed. The slip law is the authoritative text of the act in the period immediately after enactment. The second form is the United States Statutes at Large. At the end of each session, GPO compiles all the slip laws of that session in chronological order—by date of enactment, exactly as they were passed—into the bound volumes of the Statutes at Large. The Statutes at Large is the permanent, official, chronological record of all the laws enacted by Congress, and it is legal evidence of the law: a Statutes at Large citation (for example, “135 Stat. 429”) points to the precise page where the law as enacted appears. The public-laws dataset corresponds to this chronological-record conception—it is, in effect, a queryable index of the slip laws and the Statutes at Large from 1989 forward.

The third form is the United States Code, and it is a different animal entirely. The Code is not chronological but topical: it is a consolidation and codification of the general and permanent laws of the United States, arranged by subject into roughly fifty titles (Title 26 is the Internal Revenue Code, Title 42 is The Public Health and Welfare, and so on). Codification is the work of the Office of the Law Revision Counsel (OLRC) of the House of Representatives, which takes each new public law and distributes its provisions into the appropriate places in the Code—some sections amending existing Code sections, some adding new ones, some appearing only as statutory notes. A single public law can scatter across a dozen titles of the Code; conversely, a single Code section can be the accreted product of provisions from many different public laws enacted across decades. This is why the public-laws dataset and a dataset of the US Code are complementary rather than redundant: the public-laws record tells you what Congress did and when; the Code tells you what the law currently says on a given subject. The bridge between them is the codification process, and the lag in that process is one of the caveats below.

Public laws versus private laws

Not every law Congress enacts is a public law. The Constitution does not distinguish between them, but long practice does: enacted measures are classified at publication as either public laws or private laws, and they are numbered in separate sequences. A public law is one of general applicability—it affects the public at large, a class of persons, or the nation as a whole, and it is the kind of law this dataset records. A private lawaffects only a specific, named individual or entity: historically these have addressed matters such as an individual's immigration or naturalization status, a particular claim against the United States, or a specific land conveyance. Private laws are numbered “Private Law NNN-NNN” in their own parallel series.

The practical distinction is volume and significance. Private laws were once a meaningful share of congressional output, particularly in eras before general statutes governed immigration relief and claims; today they are rare, and the great mass of enacted legislation is public. For an analyst the takeaway is simply definitional: this dataset is the public-law series, the laws of general effect, and it does not include the private-law series. When the count of “laws enacted by a Congress” is cited from this dataset, it is the count of public laws—the figure that virtually everyone means by the phrase, but worth stating precisely.

The originating bill and the GovInfo source of record

Every public law began life as a bill or joint resolution, and the bill_numberfield preserves that origin—the link from the finished law back to the legislative measure that became it. A measure beginning “H.R.” originated in the House; one beginning “S.” in the Senate; a joint resolution (H.J.Res. or S.J.Res.) is the other vehicle that can become law, used for purposes such as continuing appropriations, single-subject enactments, and the congressional step in proposing constitutional amendments. This origin matters because it is the hinge between the public-laws dataset and the much larger record of congressional process: the same bill number, scoped to its Congress, identifies the committee that reported the measure, the reports and hearings, the amendments, and—most useful for analysis—the recorded roll-call votes by which each chamber passed it.

The authoritative publisher of this record is the Government Publishing Office (GPO), the agency responsible for producing and distributing the official publications of the federal government, and its modern delivery system is GovInfo(govinfo.gov). GovInfo hosts the official digital collections of all three branches, and the public-laws collection—identified internally as the PLAWcollection—provides the enacted public laws as individual packages, each with its public-law number, originating bill, title, dates, Statutes at Large citation, and the full text in multiple formats. GovInfo exposes this through a public API at api.govinfo.gov and through bulk downloads, with no key required for basic access (a free API key raises rate limits). One coverage detail is worth stating precisely: GovInfo's online PLAW collection begins with the 104th Congress (1995); the laws in this table from the 101st through 103rd Congresses (1989–1994) are drawn from the chronological Statutes at Large record, which GPO also publishes through GovInfo. Because GovInfo is the official source—the same digital backbone GPO uses to publish the slip laws and the Statutes at Large—the public-laws dataset built on it inherits the authority of the government's own record rather than a third-party reconstruction of it.

Landmark statutes and the coverage window

The dataset's coverage runs from the 101st Congress (1989)to the present, and that window happens to contain a remarkable share of the statutes that have most shaped modern American life. Reading the public-law series across these decades is, in effect, a chronological tour of recent legislative history.

The 101st Congress enacted the Americans with Disabilities Act(Public Law 101-336), the landmark civil-rights statute barring discrimination on the basis of disability. The 104th Congress passed the Health Insurance Portability and Accountability Act (HIPAA), which reshaped health-coverage portability and, through its administrative-simplification provisions, the privacy and security of health information. In the wake of the Enron and WorldCom collapses, Congress enacted Sarbanes-Oxley, overhauling corporate financial reporting and auditor oversight. After the 2008 financial crisis came the Dodd-Frank Wall Street Reform and Consumer Protection Act, the most sweeping financial-regulatory statute in generations. The 111th Congress enacted the Affordable Care Act(Public Law 111-148), restructuring health insurance markets. In the COVID-19 emergency the 116th Congress passed the CARES Act, an extraordinary fiscal-relief statute. And the 117th Congress enacted the Infrastructure Investment and Jobs Act (Public Law 117-58), a multi-hundred-billion-dollar public-works law. Each of these is one row in the public_laws table—a single number, bill, title, and date—and the dataset's value is precisely that it places these famous statutes in a uniform, machine-readable, date-stamped series alongside the thousands of less famous laws enacted in the same decades, so that the celebrated and the routine can be analyzed together.

Joining to roll-call votes and downstream rulemaking

The public-laws table is most powerful not in isolation but as the keystone of a chain that runs from a member's vote all the way to a regulation in the Code of Federal Regulations. Two joins, one upstream and one downstream, are especially valuable.

The upstream join is to congressional roll-call votes. Through the originating bill number, scoped to its Congress, a public law connects to the recorded votes by which the House and Senate passed it—who voted aye, who voted nay, who was absent. This is what lets an analyst move from “this law was enacted” to “here is the coalition that enacted it.” Joining public laws to roll-call data supports questions the law record alone cannot answer: how partisan was the vote that produced a given statute, which laws passed with broad bipartisan margins versus narrow party-line votes, and how a member's pattern of votes maps onto the body of law that actually resulted. The public-laws table supplies the outcome; the roll-call data supplies the politics that produced it.

The downstream join is to rulemaking. A statute is rarely self-executing; Congress typically directs an executive agency to write the regulations that implement it. A public law authorizing a new program is the legal origin of a cascade of agency action—proposed rules, final rules, and guidance—published in the Federal Register and codified in the Code of Federal Regulations, each of which cites the public law (and its Statutes at Large or US Code provisions) as its statutory authority. Tracing a public law forward into the rulemaking it authorizes is how one measures the administrative footprint of legislation: which statutes generated the most regulatory activity, how long the lag was between enactment and implementation, and where the substance of a law actually got written—not on the floor of Congress, but in the agency that Congress told to fill in the details. Holding the enacting vote on one side and the resulting rules on the other, the public-laws table is the fixed point that makes the full statute-to-regulation pipeline legible.

Python workflow: public laws from the GovInfo API

The script below works against the GovInfo PLAW collection and search service. It does two things. First, it tallies enactments by Congress—paging through the PLAW packages for each Congress in a range and counting the laws, which produces the legislative-output time series (how many public laws each Congress actually enacted). Second, it runs a keyword search over law titles, using the GovInfo search service scoped to the PLAW collection, so an analyst can pull, say, every public law in a given Congress whose title mentions a subject. A demo key works for light use; a free registered key raises the rate limits. Because GovInfo's API parameters and field names evolve, and because its online PLAW collection begins with the 104th Congress (1995), any production use should be validated against the current API documentation at api.govinfo.gov/docsand should page fully through large result sets.

import requests
import pandas as pd
from collections import Counter

# GovInfo public laws (PLAW collection).
#
# The Government Publishing Office publishes enacted public laws through
# GovInfo. Two interfaces are useful together:
#   1. The PLAW collection in the GovInfo API (paged package listings)
#   2. The search service for keyword queries over law titles/text
# A demo key (DEMO_KEY) works for light use; register a free key at
# https://api.govinfo.gov/docs/ for higher rate limits. No key is
# required to browse the bulk PLAW collection on govinfo.gov directly.
# Note: GovInfo's online PLAW collection begins with the 104th Congress
# (1995); earlier laws are found in the Statutes at Large collection.
API = "https://api.govinfo.gov"
KEY = "DEMO_KEY"


def plaw_packages(congress, page_size=1000):
    # List every PLAW package for one Congress. Package IDs look like
    # "PLAW-117publ58" -> Public Law 117-58. We page through results.
    out, offset_mark = [], "*"
    while True:
        url = f"{API}/collections/PLAW/2000-01-01T00:00:00Z"
        params = {
            "congress": congress,
            "pageSize": page_size,
            "offsetMark": offset_mark,
            "api_key": KEY,
        }
        r = requests.get(url, params=params, timeout=120)
        r.raise_for_status()
        body = r.json()
        out.extend(body.get("packages", []))
        offset_mark = body.get("nextPage")
        if not offset_mark or not body.get("packages"):
            break
    return out


def enactments_by_congress(first=104, last=118):
    # Tally how many public laws each Congress produced. GovInfo's PLAW
    # collection covers the 104th Congress (1995) onward, so we start there.
    counts = {}
    for c in range(first, last + 1):
        pkgs = plaw_packages(c)
        counts[c] = len(pkgs)
        print(f"Congress {c}: {len(pkgs):,} public laws")
    return counts


def search_titles(query, congress=None, page_size=100):
    # Full-text search over the PLAW collection. Returns matching laws,
    # newest first, so we can scan titles for a keyword such as "tax".
    url = f"{API}/search"
    q = f'collection:PLAW {query}'
    if congress:
        q += f" congress:{congress}"
    payload = {"query": q, "pageSize": page_size, "offsetMark": "*",
               "sorts": [{"field": "publishdate", "sortOrder": "DESC"}]}
    r = requests.post(url, params={"api_key": KEY}, json=payload, timeout=120)
    r.raise_for_status()
    results = r.json().get("results", [])
    return [{"id": x["packageId"], "title": x.get("title", "")} for x in results]


# 1. Enactments per Congress -- the legislative-output time series.
counts = enactments_by_congress(115, 117)
total = sum(counts.values())
print(f"Total over the window: {total:,} public laws")

# 2. Keyword scan of titles -- e.g. every public law mentioning "veterans".
hits = search_titles("veterans", congress=117)
print(f"117th Congress laws matching 'veterans': {len(hits)}")
for h in hits[:5]:
    print(" ", h["id"], "--", h["title"][:70])

Two practical notes apply. First, the keyword search in the script matches against the law's indexed text, which includes the title but is not limited to it; for a strict title-only filter an analyst should post-filter the returned title field rather than rely on the full-text match alone, since a law can mention a term in its body without being about it. Second, for systematic work—reconstructing the complete enacted-law series, or joining every law to its originating bill and roll-call votes—GovInfo's bulk PLAW downloads and the associated package metadata files are far more efficient than paging the API package by package, and they ship the authoritative Statutes at Large citations and bill references for each law. The API is the right tool for targeted queries; the bulk collection is the right tool for building the whole table.

Limitations and analytical caveats

The public-laws dataset is an authoritative record of what Congress enacted, but it answers a narrower question than it can appear to, and a few distinctions are essential before drawing conclusions from it.

A law's number is not its substance. The dataset is a record of enactments—number, bill, title, date—not a record of what each law does or how much it matters. Counting public laws is a famously misleading measure of legislative productivity: a single omnibus statute can carry the weight of dozens of ordinary bills folded into one number, while another public law may do nothing more than rename a federal building. Treating each row as one unit of equal legislative significance—ranking Congresses purely by how many laws they passed—will mislead, because the laws are radically unequal in scope. The count is a real figure, but it is a count of acts, not of importance.

Enactment is not the same as effect. The date_approved field records when a law was enacted, but many statutes specify a later effective date, phase provisions in over years, or condition them on subsequent agency action. A law can be on the books for some time before any of its provisions bind anyone. The public-laws record is precise about the moment of enactment and silent about the moment of effect; reconstructing when a law actually took hold requires reading the statute itself and, usually, the implementing regulations. The dataset answers “when did this become law,” not “when did this start to matter.”

Codification lags, and the Code can diverge from the enacted text.Because the chronological public-laws record and the topical United States Code are produced by different processes, there is a lag between enactment and codification: a new public law appears in the slip-law and Statutes at Large record immediately, but it takes time for the Office of the Law Revision Counsel to distribute its provisions through the Code. Moreover, not all of the Code has been enacted into “positive law”—for titles that have not, the Statutes at Large remains the legal evidence of the law and the Code is prima facie evidence, so in the event of a conflict the enacted text in this dataset's lineage controls. An analyst who wants the current operative law on a subject must consult the Code; one who wants the authoritative text of what Congress actually passed, as passed, belongs in the public-laws and Statutes at Large record.

A title is a label, not a summary. The law_title field carries the short or popular title of an act, which is chosen for recognizability and political resonance, not for descriptive completeness—and many of the most consequential provisions in federal law ride inside omnibus and appropriations acts whose titles reveal nothing about the substance buried in their later divisions. Searching titles by keyword will reliably find the laws named for a subject and reliably miss the provisions on that subject tucked into a law named for something else. The keyword scan in the workflow is a starting point, not a census of everything Congress did on a topic.

Held with these caveats in mind, the public_laws table is a foundational resource: a uniform, date-stamped, machine-readable record of every law of general effect that Congress has enacted since 1989, keyed by the permanent public-law number, anchored to the originating bill, and joinable both backward to the votes that produced each law and forward to the rules it set in motion—the fixed center of the long arc that runs from a member's aye on the floor to a regulation that governs the country.