SEC Litigation Releases: The Federal Record of Securities Cases Filed in Court

When the SEC decides that a securities-law violation belongs in front of a federal judge—an accounting fraud that wiped out shareholders, an insider-trading ring, a Ponzi scheme dressed up as a hedge fund, a pump-and-dump, a foreign-bribery scheme—it sues in United States district court and, the same day, issues a Litigation Release: a plain public summary of who was charged, with what, and why. Then it keeps issuing them, release after release, as the case moves to judgment, settlement, disgorgement, and bars. Our table holds roughly 11,800 of these releases, the running narrative of the agency's court enforcement going back decades.

This article covers what a Litigation Release is and how it differs from the administrative proceedings the SEC adjudicates in-house; the structure of the Division of Enforcement and why it chooses one forum over the other; the 2024 Supreme Court decision in SEC v. Jarkesy and how it pushed penalty-seeking fraud cases back into the courts; the anatomy of a release and the categories of case it announces—accounting fraud, insider trading, Ponzi and offering frauds, market manipulation, and Foreign Corrupt Practices Act bribery; the structure of our sec_litigation_releases table and its columns; the join by defendant to the EDGAR company registry and to the compliance screening lists; a Python workflow that pulls releases from the public sec.gov listing, tallies them by year, and searches the text for a company or individual; and the caveats—the announcement-not-adjudication nature of the record, the forum-selection distortion, name-matching ambiguity, and survivorship of charges that are later dropped—that every analyst must internalize before drawing conclusions.

What the dataset is

The SEC enforces the federal securities laws along two tracks. It can file a civil action in United States district court, asking a federal judge to enjoin the conduct, order disgorgement of ill-gotten gains, impose civil money penalties, and bar individuals from serving as officers or directors of public companies or from the securities industry. Or it can institute an administrative proceeding, adjudicated inside the agency before its own administrative law judges and, on appeal, the Commission itself. The Litigation Release is the agency's public announcement of the first track: the press item it publishes whenever it files—or reports a development in—a case in federal court. Administrative proceedings are announced separately, through the parallel stream of administrative-proceeding releases and orders. Together the two streams cover the full output of the SEC's enforcement program; this dataset is the court half of it.

In our database this record is stored as the table sec_litigation_releases, with the grain of one row per release—roughly 11,800 of them. The unit of identity is the litigation-release number, the sequential “LR-” identifier the SEC assigns to every release (LR-26107, LR-26569, and so on), which increments over time and is the closest thing the corpus has to a primary key. A single court case typically generates several releases—one announcing the filed complaint, then later ones reporting the asset freeze, the settlement, the final judgment, the bar—each with its own number, so the release count is larger than the count of distinct cases. The columns capture the number, the date, the parties named, the charges, and the document links:

release_number   -- the "LR-NNNNN" litigation-release identifier (key)
release_date     -- the date the SEC issued the release
title            -- the release headline (usually the case caption)
defendants       -- the parties named (firms and/or individuals)
summary_text     -- the release body: charges, facts, relief sought
court            -- the US district court where the action was filed
charges          -- the statutes/rules alleged (e.g. Securities Act 17(a),
                 --   Exchange Act 10(b) and Rule 10b-5, FCPA provisions)
release_url      -- canonical sec.gov page for the release
document_links   -- linked PDFs: complaint, judgment, injunction order

Two columns do the heaviest analytic lifting. The release_number is the identity and the chronology: because the numbers increment monotonically, they double as a rough time index and let an analyst stitch the releases of a single case together in sequence. The defendants field is the join key to the rest of the world—it names the companies and individuals the SEC sued, and it is what ties a release to the same entity's EDGAR registration, its other filings, and its appearance on the compliance screening lists. The summary_text is the substance: a few paragraphs describing the alleged scheme, the statutory provisions charged, and the relief the SEC seeks or obtained. Because that text is unstructured prose rather than a coded field, much of the analytic work on this dataset—classifying cases by fraud type, extracting dollar amounts, identifying repeat defendants—is text mining over the summary, which is both the corpus's richness and its principal limitation.

District court versus the administrative forum

The single most important thing to understand about this dataset is what it is not: it is not the whole of SEC enforcement. The agency adjudicates a large share of its cases administratively, in-house, before its own administrative law judges rather than in an Article III court. Those administrative proceedings—cease-and-desist orders, registration revocations, industry bars, follow-on actions against regulated entities—are announced through a separate release series and are not Litigation Releases. The Litigation Releases capture only the cases the Division of Enforcement chose to bring as civil injunctive actions in federal district court. Any count, trend, or ranking drawn from this dataset is therefore a count of court cases, not of all enforcement, and the share of enforcement that runs through the courts versus the administrative forum has itself shifted over time for reasons of law and policy.

The choice between forums is consequential and deliberate. District court offers the full apparatus of federal civil litigation—broad discovery, a jury, and the credibility that comes from an independent judge—and it is where the SEC has historically brought its largest, most contested fraud cases and the ones where it seeks the strongest remedies against individuals. The administrative forum is faster, governed by the agency's own rules of practice, decided by adjudicators steeped in securities law, and well suited to technical regulatory matters and actions against registered firms and professionals over whom the Commission has direct authority. For years the SEC expanded its use of the administrative forum, including for some fraud cases, because the Dodd-Frank Act broadened the penalties it could impose there. That expansion drew constitutional objections that culminated in the Supreme Court's 2024 decision—the development that gives this dataset renewed weight.

What SEC v. Jarkesy changed

In SEC v. Jarkesy (2024), the Supreme Court held that when the SEC seeks civil penalties for securities fraud, the Seventh Amendment guarantees the defendant a jury trial, which the in-house administrative forum cannot provide. The practical effect is that the SEC can no longer route fraud cases seeking civil penalties through its own administrative law judges—those cases must be filed in federal district court, where a jury is available. The decision did not abolish the administrative forum; the Commission retains it for many kinds of action, particularly against registered entities and for equitable remedies. But for the heartland of securities-fraud enforcement against individuals and companies—the very cases that generate the most consequential penalties—the courthouse is now the required venue.

For the Litigation Releases this is structurally important. The decision channels a category of enforcement that the agency had sometimes kept in-house back into the federal courts, which means more of the SEC's most significant fraud cases will surface as Litigation Releases rather than as administrative orders. An analyst who treated the release stream as a stable, constant-share sample of enforcement over the decades would be misled: the mix of what appears in this dataset versus the administrative stream is not fixed, and Jarkesy marks a discontinuity that tilts it toward the courts. The upside is that the litigation-release record now captures an even larger fraction of the agency's headline enforcement than before, making it the single most representative public window onto serious securities-fraud prosecution—provided the analyst reads year-over-year changes against the legal backdrop rather than as pure shifts in enforcement intensity.

The categories of case the releases announce

The court-enforcement docket is dominated by a handful of recurring case types, and learning them is what lets an analyst read the corpus as a structured record rather than a wall of prose. Accounting and disclosure fraud cases allege that a public company and its executives misstated financial results—inflated revenue, hidden losses, fictitious transactions—in violation of the antifraud and reporting provisions of the Securities Act and the Securities Exchange Act. The post-Enron era of the early 2000s, and the Sarbanes-Oxley reforms that followed, made these among the most prominent cases in the dataset. Insider trading cases allege trading on material non-public information in breach of a duty—the classic Rule 10b-5 action—and the dataset is dotted with the insider-trading rings, tipping chains, and expert-network cases that have defined securities enforcement for a generation.

Ponzi schemes and offering frauds are the high-volume, investor-protection core of the docket: promoters who raise money on false promises, pay early investors with later investors' cash, and collapse. These cases frequently come with an emergency asset freeze and the appointment of a receiver, and they generate a long tail of follow-up releases as the receiver recovers and distributes funds. Market manipulation—pump-and-dump schemes, spoofing, microcap fraud—rounds out the trading-misconduct side. And Foreign Corrupt Practices Act cases allege that issuers bribed foreign officials and falsified their books to conceal it; the SEC and the Department of Justice jointly police the FCPA, and the SEC's side often settles for substantial disgorgement and penalties announced through these releases. More recently, two waves have reshaped the docket: a surge of crypto-asset cases testing whether particular tokens and platforms fall within the securities laws, and a cluster of SPAC-related actions over disclosures in special-purpose acquisition deals. Each wave is legible in the release stream as a rising frequency of cases citing the same statutes against a new kind of defendant.

The anatomy of a release and the case lifecycle

A Litigation Release is short by design—a headline that doubles as the case caption, a few paragraphs of summary, and links to the underlying court documents. The summary names the defendants, states the court in which the action was filed, describes the alleged conduct, lists the statutory provisions charged, and specifies the relief the SEC seeks: a permanent injunction against future violations, disgorgement of ill-gotten gains plus prejudgment interest, civil money penalties, and—where individuals are involved—officer-and-director bars or penny-stock bars. The release links to the filed complaint (a PDF, conventionally named with a “comp” prefix and the release year), and as the case progresses, to the final judgment and any injunction order (the “judg” and “inj” documents). These document links are the bridge from the summary to the full legal text for anyone who needs the particulars.

The crucial structural fact is that a single case is a sequence of releases, not one. The SEC files the complaint and issues a release; months later it obtains an emergency asset freeze and issues another; later still the defendant settles and a release announces the consent judgment; a final release reports the entry of judgment, the dollar amount of disgorgement and penalties, and the duration of any bar. Each carries its own LR number and its own date, which means the dataset is denser than the underlying case count and that the same defendant recurs across multiple releases for a single matter. This lifecycle is what makes the dataset analytically rich—an analyst can follow a case from filing to resolution—but it is also the source of the most common counting error: treating each release as a distinct case inflates both case counts and any dollar totals extracted from the text, because the same disgorgement figure may appear in the settlement release and again in the final-judgment release. Resolving releases back to cases, usually by clustering on shared defendants and adjacent dates, is the necessary first step in any rigorous analysis.

Joining to the company registry and the screening lists

The litigation-release table is most valuable not in isolation but as one node in the larger graph of securities-market data, and the defendant is the key that connects it. Three joins matter most.

The first is to the EDGAR company registry. When the defendant is a public company—an issuer charged with accounting fraud, an investment adviser, a broker-dealer—its name in the release can be resolved to a CIK, the Central Index Key EDGAR assigns to every filer, and from there to the company's ticker, industry, and full filing history. That resolution is what turns a release from a stand-alone press item into an enforcement event attached to a known company: it lets an analyst pull the 8-Ks the company filed around the time of the charges, read the periodic reports the SEC alleged were false, and study the market reaction to the enforcement announcement. The name-to-CIK match is not always clean—defendants are often individuals or private entities with no EDGAR presence, and company names in releases do not always match the registry exactly—but where it succeeds it is the most powerful join the dataset supports.

The second join is to the compliance screening lists. An SEC court action is precisely the kind of adverse event that due-diligence and sanctions-screening systems exist to surface: a named defendant in an SEC fraud case is a red flag for counterparties, lenders, and onboarding teams. Joining the litigation releases to the broader universe of federal enforcement and exclusion lists—by normalized defendant name—is what lets a screening engine answer “has this person or firm been charged by the SEC in court, and what was the outcome?” alongside the other enforcement signals it aggregates. The release stream is one of the higher-signal inputs to that kind of risk score because a court complaint reflects a formal charging decision by the agency, not merely an inquiry. The third, looser join is to the administrative-proceeding record: reading the two enforcement streams together is the only way to see the agency's complete output, to understand the forum choice in a given matter, and—post-Jarkesy—to track how cases migrate from one forum to the other.

Analytical uses

A multi-decade, defendant-named, date-stamped record of the SEC's court enforcement supports a distinctive set of analyses that no single case docket can.

Enforcement-trend analysis is the most immediate use. Because every release carries a date and an incrementing number, the corpus can be charted over time to show how the volume and composition of court enforcement have evolved—the post-Enron accounting-fraud wave, the financial-crisis-era cases, the rise of FCPA settlements, and the recent crypto and SPAC surges all appear as shifts in the frequency of releases citing particular statutes against particular kinds of defendant. Read against the legal backdrop, including the Jarkesy discontinuity, the series is a barometer of where the agency is putting its litigation resources.

Case-type and charge analysis exploits the summary text: classifying releases by fraud type and by the statutory provisions charged reveals which kinds of misconduct dominate the docket and how the mix changes—whether insider trading or offering fraud leads in a given year, how often the FCPA appears, when crypto enters the picture. Defendant-resolved enforcement history brings the joins to bear: aggregating releases by defendant surfaces repeat actors and, through the EDGAR join, connects an enforcement action to a public company's filings and market performance. And screening and due diligence uses the corpus as a high-signal adverse-media-and-enforcement source: matching a counterparty's name against the release stream answers whether the SEC has taken them to court, which is among the most material facts a compliance review can establish.

Python workflow: pulling releases and searching by name

The script below works from the public sec.gov litigation-releases listing, which accepts a year filter and returns every release numbered in that year. It does three things: tallies the number of releases per year over a span (the enforcement-trend metric), searches the body text of releases for a defendant name or keyword (the screening metric), and tallies charge-type keywords across a year's releases (the case-type metric). There is no JSON API for the releases, but the listing is public and stable; sec.gov requires a descriptive User-Agent header identifying the caller, and the script pauses between requests to stay well within the site's rate expectations. Because the page markup can change, the script isolates the release-number pattern and the listing URL so they are easy to update.

import requests
import re
import time
from collections import Counter

# SEC Litigation Releases are published on sec.gov as a year-filtered
# HTML listing -- there is no JSON API, but the listing is public and
# stable. EDGAR/sec.gov requires a descriptive User-Agent identifying
# the caller; requests without one are throttled or blocked. Keep the
# request rate modest (well under ~10/sec) and pause between years.
HEADERS = {"User-Agent": "AI Analytics research info@ai-analytics.org"}
LISTING = "https://www.sec.gov/enforcement-litigation/litigation-releases"

# Each release has a canonical page of the form
#   /enforcement-litigation/litigation-releases/lr-NNNNN
# and links to the underlying PDFs (complaints "comp", judgments
# "judg", injunctions "inj") under /files/litigation/litreleases/YYYY/.
LR_HREF = re.compile(r'/enforcement-litigation/litigation-releases/(lr-\d+)', re.I)
TAG = re.compile(r"<[^>]+>")


def fetch_year(year):
    # The listing accepts a ?year= filter that returns every litigation
    # release numbered in that year.
    params = {"year": year, "month": "All"}
    r = requests.get(LISTING, headers=HEADERS, params=params, timeout=60)
    r.raise_for_status()
    return r.text


def releases_in_year(year):
    html = fetch_year(year)
    # Dedupe: a single release links to its detail page and several PDFs.
    found = {m.group(1).lower() for m in LR_HREF.finditer(html)}
    return sorted(found, key=lambda lr: int(lr.split("-")[1]))


def release_text(lr):
    # Pull one release's detail page and strip the markup to plain text
    # so it can be searched for a defendant name or a keyword.
    url = f"{LISTING}/{lr}"
    r = requests.get(url, headers=HEADERS, timeout=60)
    r.raise_for_status()
    text = TAG.sub(" ", r.text)
    return re.sub(r"\s+", " ", text)


# --- 1. Releases per year ------------------------------------------------
def tally_by_year(start, end):
    counts = {}
    for year in range(start, end + 1):
        lrs = releases_in_year(year)
        counts[year] = len(lrs)
        print(f"{year}: {len(lrs):>4} litigation releases")
        time.sleep(1)  # be polite to sec.gov
    total = sum(counts.values())
    print(f"  {start}-{end}: {total:,} releases "
          f"({total / max(len(counts), 1):.0f}/yr average)")
    return counts


# --- 2. Search releases for a defendant or keyword -----------------------
def search(name, years):
    hits = []
    needle = name.lower()
    for year in years:
        for lr in releases_in_year(year):
            body = release_text(lr).lower()
            if needle in body:
                hits.append((lr, year))
            time.sleep(0.3)
    print(f"\n'{name}' appears in {len(hits)} release(s):")
    for lr, year in hits:
        print(f"  {lr.upper()}  ({year})  "
              f"https://www.sec.gov{LISTING.split('sec.gov')[1]}/{lr}")
    return hits


# --- 3. Charge-keyword mix across a year ---------------------------------
KEYWORDS = ["insider trading", "Ponzi", "accounting fraud",
            "offering fraud", "market manipulation",
            "Foreign Corrupt Practices Act", "misappropriat"]


def charge_mix(year):
    tally = Counter()
    for lr in releases_in_year(year):
        body = release_text(lr).lower()
        for kw in KEYWORDS:
            if kw.lower() in body:
                tally[kw] += 1
        time.sleep(0.3)
    print(f"\nCharge keywords across {year} releases:")
    for kw, n in tally.most_common():
        print(f"  {kw:<32} {n:>3}")
    return tally


tally_by_year(2020, 2024)
# search("Elon Musk", [2023, 2024])
# charge_mix(2024)

Two practical notes apply. First, the per-year tally counts releases, not distinct cases: because a single matter generates a sequence of releases over its lifecycle, the trend it produces is a trend in announcement volume, which is correlated with but not identical to the number of new cases filed. For a case-level series, the releases must be clustered back to matters—grouping on shared defendants and adjacent release dates and numbers—before counting. Second, the keyword search and charge-mix functions are deliberately simple substring matching over stripped HTML; they are a first pass, not a classifier. A production pipeline would parse the structured complaint PDFs the releases link to, extract the named statutory provisions and dollar figures directly, and resolve defendant names to EDGAR CIKs and to the screening lists rather than relying on free-text matching—the listing scrape is the entry point, not the finished analysis.

Limitations and analytical caveats

The litigation-release corpus is the most complete public record of the SEC's court enforcement, but it carries structural limitations that an analyst must internalize before drawing conclusions from it.

A release is an announcement, not an adjudication. A Litigation Release announcing a filed complaint reports the SEC's allegations—the government's charging position, which the defendant has not yet answered and a court has not yet tested. A defendant named in a complaint-stage release is alleged to have violated the securities laws, not adjudicated to have done so; the case may settle without admissions, be dismissed, or be litigated to a defense verdict. Treating the appearance of a name in a release as a finding of wrongdoing over-reads the document. The dataset is reliable as a record of what the SEC charged and when; the outcome lives in the later releases and the final judgments, and those must be read to know how a case actually resolved.

It is the court half, and the forum mix is not constant.Because the SEC adjudicates a large share of its cases administratively, the litigation releases are a partial view of total enforcement, and the partition between the court and administrative forums has shifted with law and policy—most sharply with Jarkesy, which redirected penalty-seeking fraud cases back into the courts. A time series of release counts therefore mixes changes in true enforcement intensity with changes in where the agency brings cases. Any longitudinal claim about whether SEC enforcement is rising or falling must account for the administrative stream and for the legal events that move cases between forums; the releases alone cannot answer it.

Releases are denser than cases, and the text is unstructured.One matter yields many releases, so naive counting double-counts cases and, worse, double-counts the dollar amounts that recur across a case's settlement and final-judgment releases. And the substance lives in prose, not coded fields: classifying a case by fraud type, extracting the statutes charged, or pulling the disgorgement figure all require text parsing, with all the noise and ambiguity that entails. The headline charge in the summary may understate a complaint that pleads several theories, and amounts stated in a release may be the relief sought rather than the relief ultimately obtained.

Name matching is ambiguous, and many defendants are individuals.The join to EDGAR and to the screening lists depends on matching defendant names, and names are messy: a public-company defendant may appear under a slightly different name than its registry entry, individuals share names, and the many private entities and individuals in the docket—the Ponzi promoter, the insider tipper, the unregistered fund—have no EDGAR presence at all. Resolving a release to a CIK succeeds for issuers and regulated firms far more reliably than for individuals, so any analysis that depends on the EDGAR join is implicitly weighted toward corporate defendants. Name-based screening must use normalized matching with human review, never a raw string compare, to avoid both false positives that smear an innocent namesake and false negatives that miss a defendant filed under a variant name.

Held with these caveats in mind, the sec_litigation_releases table is a uniquely valuable resource: a defendant-named, date-stamped, multi-decade record of the securities cases the SEC chose to put before a federal judge—roughly 11,800 releases through which accounting frauds, insider-trading rings, Ponzi schemes, manipulations, and foreign-bribery settlements enter the public record, the courtroom half of an enforcement program whose in-house proceedings tell the rest of the story and whose center of gravity, after Jarkesy, has tilted back toward the courts this dataset has tracked all along.