SEC Litigation Releases Database

To pull every SEC litigation release that names a given public company by its ticker, query the /sec-litigation-releases endpoint and filter on the ticker field inside the entities array (entities.ticker). For Twitter you would set entities.ticker to TWTR; for Silvergate Capital you would use its symbol, and so on. The endpoint returns the matching releases — each containing the release number (releaseNo), publication date (releasedAt), title, summary, and the full list of parties (entities), along with the charges (complaints), violated provisions (violatedSections), and any penalties (penaltyAmounts).

Keep in mind that the ticker field on an entity is only populated when the company name in the release was successfully matched to a known publicly traded company. Private firms, individuals, and unmatched corporate names will appear in entities without a ticker, so a ticker search only retrieves cases where that match was made. To sweep all 50 hits at once, set the page size to its maximum and sort by releasedAt in descending order to get the most recent enforcement actions first.

Search the /sec-litigation-releases endpoint and filter on the CIK field inside the entities array (entities.cik). For example, Twitter's CIK 1418091 retrieves the litigations naming Twitter as a party; Flowers Foods (CIK 1128928) returns the insider-trading case against its employees; and Capital Bancorp (CIK 1419536) returns the prime-bank fraud release in which it was named a relief defendant.

CIK matching is generally more reliable than ticker matching because a company keeps the same CIK across name changes and re-listings, and private companies that previously filed with the SEC also have CIKs. As with the ticker filter, the cik field on an entity is only populated when the entity name was matched to a known SEC filer — releases naming individuals or unmatched names will not have it. Sort results by releasedAt descending to walk the company's enforcement history from most recent backward.

To pull a single release by its identifier, query the /sec-litigation-releases endpoint and filter on the release-number field (releaseNo) for the exact value you want. For instance, the release on the CodeSmart fraud final judgment is identified by LR-26115, the Silvergate Capital case by LR-26044, and the Burleson cherry-picking case by LR-26178. Setting releaseNo to LR-26115 returns that one release with all of its structured fields — title, publication date (releasedAt), summary, defendants (entities), charges (complaints), violated sections (violatedSections), penalties (penaltyAmounts), and any linked documents (resources).

Because the release number is unique, the response contains at most one matching record. Pagination is not needed for this lookup.

Query the /sec-litigation-releases endpoint and constrain the publication-date field (releasedAt) to the calendar year you want — for 2024, the value of releasedAt should fall between 2024-01-01 and 2024-12-31. Sort by releasedAt in descending order so the most recent release of the year comes back first. The endpoint returns at most 50 records per call, so you need to paginate.

Start with the page offset (from) at 0, then increment it by 50 on each subsequent call (50, 100, 150, …) until you have walked through the entire total.value reported in the response. Because the API caps a single query at 10,000 results and the SEC has published well under that in any single year, a one-year window is safe to fetch in this way without splitting further.

Poll the /sec-litigation-releases endpoint on a recurring schedule — for example every 60 seconds — with a query that matches every release (the release-number field set to any non-empty value), sorted by publication date (releasedAt) in descending order. The endpoint returns the 50 most recent releases; on each poll, compare the release identifiers (releaseNo or id) you see in the response against the ones you have already processed and act on anything new.

For a focused watchlist, layer a topical filter on top — for example require tags to include insider trading to alert only on insider-trading cases, or require entities.cik to match one of the CIKs on your watchlist to alert only on actions against specific companies. The new releases bubble up at the top of the sorted list, so a tight polling interval together with a small in-memory cache of seen release numbers is enough to drive a near real-time feed.

The /sec-litigation-releases endpoint returns at most 10,000 results per query and at most 50 results per page, so the dataset back to 1995 has to be split into windows that each stay under the 10,000-result cap. Slicing by calendar year is the recommended approach: for each year from the present back to 1995, query the publication-date field (releasedAt) constrained to that year (for 2024, between 2024-01-01 and 2024-12-31), sort by releasedAt descending, and walk the page offset (from) from 0 upward in increments of 50 until you have collected every release in that year.

Once one year is fully drained, move to the previous year and repeat. The per-query total.value in the response tells you how many results that year holds and therefore how many pages you need to fetch. As long as no single year exceeds 10,000 releases — which has been comfortably true historically — yearly slicing covers the entire database from 1995 to the present without bumping into the per-query cap.

On /sec-litigation-releases, each call returns at most 50 records, controlled by the page-size parameter (size, maximum 50). To walk further into the result set, advance the page-offset parameter (from) by the page size on each subsequent call — start at 0, then 50, then 100, and so on. The total number of matches is reported as total.value in the response, so you know in advance how many pages you need.

The maximum value of from is 10000, which caps a single query at 10,000 results regardless of how many actually match. If total.value exceeds 10,000, narrow the query — typically by adding a tighter date range on the publication-date field (releasedAt) — until each sub-query stays within the cap, then iterate those sub-queries to cover the full set.

To pull SEC enforcement actions classified as insider trading, query the /sec-litigation-releases endpoint and require the tags field (tags) to include the value insider trading. The release against seven Flowers Foods employees, for example, carries exactly that tag, and the endpoint returns it along with every other release where the SEC's allegations centered on trading on material nonpublic information.

The tags field is an array of topical labels assigned to each release, so a single release can carry several tags (for instance insider trading alongside securities fraud). Combine the tag filter with other constraints — for example pairing it with a date range on releasedAt, or with entities.ticker set to a specific symbol — to scope to insider-trading actions in a particular period or against a particular issuer.

Bribery cases are surfaced two complementary ways on /sec-litigation-releases. The first is the topical tags field (tags): require tags to contain the value bribery. The second is the violated-sections field (violatedSections): require it to contain the phrase Foreign Corrupt Practices Act, since FCPA charges are recorded there alongside the specific securities-law sections cited (the field also accepts the longer phrasing Foreign Corrupt Practices Act (FCPA)).

For the widest coverage, combine the two so either condition is sufficient — a release tagged bribery even without an explicit FCPA citation will still surface, and FCPA cases that were not tagged bribery will too. The returned records carry the full narrative (summary, complaints), defendants (entities), and any settlement or penalty information (hasAgreedToSettlement, hasAgreedToPayPenalty, penaltyAmounts).

Query the /sec-litigation-releases endpoint and require the tags field (tags) to contain the value ponzi scheme. The Cowan Asset Management case from 1996 and the Lahr and Megas case from 2022 both carry this tag, and the filter returns every release the SEC categorized as a Ponzi-scheme matter from 1995 to the present.

For a tighter view, pair the tag filter with a date range on the publication-date field (releasedAt) to scope to a specific period, or with the agreed-to-settlement flag (hasAgreedToSettlement) to separate settled cases from still-litigated ones. Each returned release also lists the specific charges (complaints), the defendants (entities), and the dollar amounts ordered (penaltyAmounts.penaltyAmount).

Query the /sec-litigation-releases endpoint and require the tags field (tags) to contain the value crypto. The Silvergate Capital release, for example, carries the tags disclosure fraud, crypto, and compliance failure, and the filter returns it together with every other release the SEC labeled as crypto-related.

To broaden the net beyond what the crypto tag catches, combine that filter with a full-text search of the narrative fields — for instance requiring the summary (summary) or complaints (complaints) to mention digital-asset terminology — or with an issuer filter on entities.ticker or entities.cik if you are tracking a specific crypto company. Each match comes back with the full structured payload, including the defendants (entities), violated provisions (violatedSections), and any penalties imposed (penaltyAmounts).

Query the /sec-litigation-releases endpoint and require the agreed-to-settlement flag (hasAgreedToSettlement) to be true. The endpoint returns every release where at least one defendant entered into a settlement — for instance the Silvergate Capital release and the Burleson cherry-picking release have this flag set, while a release that is still actively contested has it false.

Combine the settlement flag with other filters as needed: pair it with a tag (tags) to look only at settled bribery or insider-trading cases, with a date range on releasedAt to constrain a period, or with entities.cik to look at settlements involving a specific company. Each returned release exposes the settlement detail through the related fields — whether the defendant also agreed to pay (hasAgreedToPayPenalty), the per-defendant dollar amounts (penaltyAmounts), and the requested reliefs the SEC sought (requestedRelief).

Query the /sec-litigation-releases endpoint and require the agreed-to-pay-penalty flag (hasAgreedToPayPenalty) to be true. The endpoint returns the releases where at least one defendant agreed to a monetary payment — the World Tree Financial case, the CodeSmart fraud final judgment, and the Silvergate Capital release all carry this flag set, while cases that ended without a payment (or have not yet) carry it false.

The accompanying penalty amounts are recorded in the penalties array (penaltyAmounts), where each entry contains the cleaned dollar value (penaltyAmounts.penaltyAmount), the raw text as written in the release (penaltyAmounts.penaltyAmountText), and the party the penalty was imposed on (penaltyAmounts.imposedOn). Note that a release can have the agreed-to-settlement flag (hasAgreedToSettlement) set without hasAgreedToPayPenalty — for example a non-monetary settlement involving only injunctions and bars — so filtering specifically on hasAgreedToPayPenalty isolates the cases that produced a payment.

On the /sec-litigation-releases endpoint, the penalty information lives inside an array of per-defendant penalty objects (penaltyAmounts), with the cleaned dollar value carried as a numeric string in penaltyAmounts.penaltyAmount. To find the largest penalties over a period, constrain the publication-date field (releasedAt) to that window and sort the results by penaltyAmounts.penaltyAmount in descending order — releases like the $50 million Silvergate Capital penalty rise to the top, ahead of smaller hits such as the $526,974 ordered against Thomas Megas.

Keep in mind that penaltyAmounts is an array — a single release can carry several penalty entries, one per defendant (Silvergate alone has separate entries for the company and for two of its officers). Because the value is stored as a numeric string in USD, treat it as a number when comparing. Page through the results in 50-record batches to compile a leaderboard of the largest fines for the window.

To total the SEC penalties imposed on a specific company, first retrieve every release naming that company by querying the /sec-litigation-releases endpoint with entities.cik set to the company's CIK (or entities.ticker set to its symbol if you don't have the CIK — the /mapping endpoint can resolve a ticker to a CIK first if needed). Sort by publication date (releasedAt) descending and page through the matches in 50-record batches.

For each returned release, walk the penalties array (penaltyAmounts) and sum the cleaned dollar values in penaltyAmounts.penaltyAmount. Because a release can list penalties against several defendants — officers as well as the company itself — restrict the sum to the entries whose penaltyAmounts.imposedOn matches the company's name when you only want what the company itself paid, or sum every entry to get the total dollars the SEC extracted from the entire case complex. The values are stored as numeric strings in USD, so convert to a number before adding.

Query the /sec-litigation-releases endpoint and filter on the per-defendant penalty target (penaltyAmounts.imposedOn) for the individual's name — for example Alan J. Lane returns the Silvergate Capital release where the former CEO was personally fined $1 million, and Wesley Perkins returns the World Tree Financial release where he was fined $160,000. The endpoint returns every release that records a penalty against that person.

Within each returned release, the dollar amount the individual paid lives alongside the name in the same penalty object: the cleaned numeric value in penaltyAmounts.penaltyAmount and the original wording from the release in penaltyAmounts.penaltyAmountText. Because the penalties array can list several defendants in a single case, pick out the entry whose imposedOn matches the individual to get their share. Names are written as they appear in the release, so use the full form (for instance Thomas Megas rather than just Megas) when filtering.

Query the /sec-litigation-releases endpoint and filter on the requested-relief field (requestedRelief) for the phrase officer-and-director bar. The CodeSmart fraud release names this relief explicitly, as does the Provectus release against the former CEO; the Silvergate Capital release records a closely related variant (officer-and-director bars, plural). Use a phrase match on officer-and-director so both singular and plural wordings are covered.

The requestedRelief field is an array of free-text relief descriptions taken from the release, so it commonly carries several entries alongside the bar — permanent injunction, disgorgement of ill-gotten gains, civil penalties, and so on. Pair the relief filter with other constraints — for example a date range on releasedAt or a tag on tags — to narrow to officer-and-director-bar actions of a specific kind or period.

Query the /sec-litigation-releases endpoint and filter on the requested-relief field (requestedRelief) for the word disgorgement. The relief wording is taken verbatim from the release, so the same concept appears in several forms — disgorgement, disgorgement of profits, disgorgement of ill-gotten gains, disgorgement plus interest — and a partial match on disgorgement covers all of them.

The CodeSmart fraud release, the World Tree Financial release, the Internet Casino Sports Gaming release, and many others all carry a disgorgement entry in requestedRelief. Combine the filter with a date range on the publication-date field (releasedAt) to scope to a period, or with the agreed-to-pay-penalty flag (hasAgreedToPayPenalty) when you only want disgorgement orders that the defendant agreed to pay. The actual dollar amount, when one was set, is recorded in penaltyAmounts.penaltyAmount.

Query the /sec-litigation-releases endpoint and filter on the violated-sections field (violatedSections) for the phrase Rule 10b-5. The endpoint returns every release that cited the anti-fraud rule under the Securities Exchange Act — the CodeSmart fraud release, the Internet Casino Sports Gaming release, the Cowan Ponzi-scheme release, and the Burleson cherry-picking release all carry this entry in violatedSections.

Because violatedSections is a free-text array of cited provisions taken from the SEC's complaint, the rule may appear alongside related citations such as Section 10(b) of the Securities Exchange Act of 1934, Rules 10b-5, 13a-14, 13b2-1, 13b2-2, 14a-3 and 14a-9 (a combined enumeration), or simply Rules 10b-5. A phrase match on 10b-5 is the most reliable way to capture every wording. Pair the filter with a date range on releasedAt or with entities.ticker / entities.cik to narrow to a specific period or issuer.

Query the /sec-litigation-releases endpoint and filter on the parallel-actions field (parallelActionsTakenBy) for either Department of Justice or U.S. Attorney. The Lahr and Megas Ponzi-scheme release lists both U.S. Attorney's Office for the Eastern District of Pennsylvania and Fraud Section of the Department of Justice; the CodeSmart fraud release lists U.S. Attorney's Office for the Eastern District of New York. A phrase match on either of those substrings covers the common ways the DOJ and the various U.S. Attorney's offices are written.

The parallelActionsTakenBy field is an array of free-text agency strings — alongside DOJ entries you will often see state regulators and federal banking authorities, which is how the Silvergate Capital release picks up the Federal Reserve Board and the California Department of Financial Protection and Innovation. To get only criminal-parallel cases, restrict the filter to DOJ-family strings rather than the broader set.

On the /sec-litigation-releases endpoint, the other-agencies field (otherAgenciesInvolved) is an array of agency objects, each with a name (otherAgenciesInvolved.name) and a country (otherAgenciesInvolved.country). To find cases that involved a non-U.S. regulator or law-enforcement body, filter on otherAgenciesInvolved.country and exclude United States — what remains are the releases where the cooperating agency is foreign, for example a Swiss Office of the Attorney General or a U.K. Financial Conduct Authority entry.

If you want a particular country, set otherAgenciesInvolved.country to that country's name directly. You can also filter on the agency name (otherAgenciesInvolved.name) when you are tracking a specific foreign regulator. The returned releases carry the full structured payload — defendants (entities), charges (complaints), and any parallel criminal actions (parallelActionsTakenBy) — which together give the cross-border context of each case.

Query the /sec-litigation-releases endpoint and filter on the investigation-conducted-by field (investigationConductedBy) for the office's name — for example New York Regional Office returns the CodeSmart fraud release, and Los Angeles Regional Office returns the World Tree Financial release. The field is an array of free-text entries that lists both individual staff members and the offices they belong to, so a phrase match on the office name is the right way to scope to a single regional office.

The wording in investigationConductedBy mirrors how the release names the office, so values such as New York Regional Office, SEC's Los Angeles Regional Office, or Division of Enforcement may appear. A substring match on the core office name (for example New York Regional) captures the small variations. Pair the filter with a date range on the publication-date field (releasedAt) when you need a regional-office caseload for a specific period.

Query the /sec-litigation-releases endpoint and filter on the litigation-led-by field (litigationLedBy) for the attorney's name. For example, filtering on Jorge G. Tenreiro returns the Silvergate Capital release, where he is one of the lead litigators; filtering on Matthew Scarlato returns the Lahr and Megas Ponzi-scheme release. The field is an array of names taken directly from the release.

Names are written as they appear in the release — typically first name, middle initial, last name — so use the full form when filtering. The same person may also appear in the investigation-conducted-by field (investigationConductedBy) for cases where they led the investigation as well, so to capture an attorney's full footprint across the dataset, query both fields. Sort by publication date (releasedAt) descending to walk the attorney's caseload from most recent backward.

Each litigation release returned by /sec-litigation-releases carries a resources array (resources) where every entry has a label (resources.label) and a URL (resources.url) pointing at a related document on the SEC's site. The Lahr and Megas release, for example, exposes three resources — the SEC complaint, the judgment, and the memorandum opinion — each with its own label and a direct PDF URL; the CodeSmart fraud release exposes a single judgment PDF.

To extract the documents for a release, read its resources array and iterate over the entries, using resources.label to tell complaints, judgments, opinions, and administrative-proceeding releases apart, and resources.url to fetch the actual PDF. The array can be empty for older releases where no linked documents were captured, so handle that case before downloading.

The court caption and docket number for an action are recorded together in the case-citations field (caseCitations) on each release returned by /sec-litigation-releases. The field is an array of citation strings — for the CodeSmart fraud release the entry reads Securities and Exchange Commission v. DiScala et al., No. 1:14-cv-04346 (E.D.N.Y. filed July 17, 2014; amended Jan. 19, 2016)., where the case caption (Securities and Exchange Commission v. DiScala et al.), the docket number (1:14-cv-04346), and the court abbreviation (E.D.N.Y.) all sit inside one string.

For most releases the array carries a single citation, but a case that produced parallel filings can carry several entries. To extract the structured pieces, parse each string into its components — caption (everything before the , No.), docket number (the No. segment), court and filing date (the parenthetical). Use the release-number field (releaseNo) to look up the specific release first and then read its caseCitations array.

On /sec-litigation-releases, every party named in a case is recorded in the entities array (entities), and each entity carries a role (entities.role) that distinguishes between primary defendants (defendant) and relief defendants (relief defendant). The Parrish prime-bank fraud release, for example, names Eduard Akopian and Capital Bancorp with entities.role set to relief defendant, alongside the primary defendants whose role is defendant.

To find cases that include a relief defendant, query the endpoint and require entities.role to be relief defendant. To find cases where a specific individual was named as a relief defendant, combine the role filter with a filter on the entity name (entities.name) for that person. Relief defendants are parties who allegedly received ill-gotten gains but are not themselves charged with wrongdoing, which is why they appear in the same entities array but with a distinct role value.

Every party in the entities array (entities) on a release returned by /sec-litigation-releases carries a type (entities.type) that tells you what kind of party it is. The value company marks corporate parties — for example Silvergate Capital Corporation or Flowers Foods, Inc. — and the value individual marks natural persons such as Alan J. Lane or James Burleson. A third value, other, covers everything that fits neither, such as the non-existent trust entity in the Cowan Ponzi-scheme release.

To isolate corporate defendants in a result set, walk each release's entities array and keep the entries where entities.type is company and entities.role is defendant; do the symmetric thing with entities.type equal to individual for natural-person defendants. You can also push the filter into the query itself — for instance requiring entities.type to be individual and entities.role to be defendant — to retrieve only releases that name at least one individual defendant.

Query the /sec-litigation-releases endpoint and filter on the violated-sections field (violatedSections) for the phrase Investment Advisers Act of 1940. The Burleson cherry-picking release and the World Tree Financial release both cite Sections 206(1) and (2) of the Investment Advisers Act of 1940 in violatedSections, and the Cowan release cites the broader Sections 206(1), (2), and (4) of the Investment Advisers Act of 1940. A phrase match on Investment Advisers Act captures every variant.

For a tighter view, combine the filter with the agreed-to-settlement flag (hasAgreedToSettlement) or with a date range on the publication-date field (releasedAt) to scope to settled adviser cases in a given period. Each returned release exposes the related defendants (entities, often of type individual for the adviser and company for the advisory firm), the charges (complaints), and the requested reliefs (requestedRelief).

There is no dedicated aggregation endpoint, so build the year-over-year counts client-side from /sec-litigation-releases. For each year you want to chart, query the endpoint with two filters combined: the publication-date field (releasedAt) restricted to that year (for 2024, between 2024-01-01 and 2024-12-31), and the tags field (tags) set to the misconduct label you care about — for example insider trading, ponzi scheme, or crypto. The response carries the count of matching releases as total.value, which is the data point for that year.

Repeat the query for each year in the window — 2015 through 2024 for a ten-year trend, say — and plot the resulting total.value series against the year axis. When you also need the individual releases (for example to drill into a year), paginate through the matches by walking the page-offset field (from) in 50-record increments; for a pure count, reading total.value from the first page is enough.

Like other aggregations, this is built client-side on top of /sec-litigation-releases. First, retrieve every release in the window by querying the endpoint with the publication-date field (releasedAt) restricted to the decade you care about (for the years 2015 through 2024, between 2015-01-01 and 2024-12-31), sorted by releasedAt descending. Paginate through the matches by walking the page-offset (from) in 50-record increments; if the window holds more than 10,000 releases, split it into smaller date sub-windows (typically by year) so each sub-query stays under the per-query cap.

For each retrieved release, walk the entities array (entities) and the penalties array (penaltyAmounts) together: every entity of type company (entities.type equals company) is keyed by its CIK (entities.cik) or ticker (entities.ticker) when present, and you add up the cleaned dollar amounts in penaltyAmounts.penaltyAmount whose penaltyAmounts.imposedOn matches that company's name. The amounts are numeric strings in USD, so convert before adding. Sort the resulting company-keyed totals in descending order to produce the most-fined-corporations leaderboard for the period.