# SEC Enforcement Actions Database - Orders, Complaints and More

> Access the SEC Enforcement Actions Database featuring over 10,000 actions from 1997 to present. Search detailed information on administrative proceedings, orders, complaints, penalties, settlements, violated securities laws, involved parties, and agencies. Real-time updates provide structured JSON data for in-depth analysis of SEC enforcement actions.

Source: https://sec-api.io/docs/sec-enforcement-actions-database-api

The Enforcement Actions Database provides access to all SEC enforcement actions from 1997 to present, including administrative proceedings, orders, complaints, civil actions and more. The database includes structured data in JSON format extracted from SEC enforcement actions, providing the following information:

- Publication date of the action
- Name and roles of parties being charged, including their tickers and CIKs
- Nature of the charges and complaints
- Penalty amounts and whether settlements were reached
- Parallel actions taken by other agencies, such as criminal charges by the Department of Justice
- Requested reliefs, such as injunctions and civil penalties
- Violated securities laws
- Persons conducting the investigation and litigating the case
- Other agencies involved in the investigation

Users can search the Enforcement Actions Database by all of the above fields via an API. The database also includes links to related documents, such as court filings, original SEC press releases, litigation releases, and more.

Examples of enforcement actions include charges related to insider trading, bribery, market manipulation, misleading investors, and other violations of securities laws. The database is updated in real-time as new enforcement actions are published by the SEC.

Dataset size:

Over 10,000 SEC enforcement actions from 1997 to present.

Data update frequency:

New charges and actions are added to the database as they are published by the SEC in real-time.

Survivorship bias free:

Yes. The database includes all SEC enforcement actions from 1997 to present.

## API Endpoint

To search the Enforcement Actions Database, send a HTTP `POST` request with the search criteria as JSON payload to the following API endpoint:

https://api.sec-api.io/sec-enforcement-actions

Supported HTTP methods: `POST`

Request and response content type: `JSON`

### Authentication

To authenticate your API requests, use the API key displayed in your user profile. You can utilize your API key in one of two ways. Choose the method that best fits your use case:

- **Authorization Header**: Include your API key as an `Authorization` header in your requests. For instance, before sending a `POST` request to `https://api.sec-api.io/sec-enforcement-actions`, ensure the header is set as follows: `Authorization: YOUR_API_KEY`.
- **Query Parameter:** Alternatively, append your API key directly to the URL as a query parameter. For example, when making `POST` requests, use the URL `https://api.sec-api.io/sec-enforcement-actions?token=YOUR_API_KEY` instead of the base endpoint.

## Search API

To search the Enforcement Actions Database, make a POST request to `https://api.sec-api.io/sec-enforcement-actions`, providing your search criteria as a JSON payload.

### Request Structure

The Search API recognizes the following JSON payload parameters:

- `query` (string, required) - The search criteria in the format `field:value` defining the structured data `field` to search in and the `value` to search for in this field. The search expression is formatted with the [Lucene syntax](https://sec-api.io/resources/lucene-query-syntax-overview) and supports `AND` and `OR` operators. Examples: `entities.ticker:IEP` or `tags:bribery AND filedAt:[2019-01-01 TO 2022-12-31]`.
- `from` (string, optional) - Pagination control to specify the starting position of the results. Max: 10000. Default: 0.
- `size` (string, optional) - Determines the number of results to be returned per request. Max: 50. Default: 50.
- `sort` (array, optional) - Specifies the field by which results should be sorted. By default, results are sorted by `releasedAt` in descending order.

#### Query Examples

**Loading All Data**
In order to download structured data of all enforcement actions published between 2004 and 2022, you can use a date range query as follows. This query will return the first 50 results. In order to retrieve all results, you can paginate through the results by increasing the `from` parameter by 50 on each subsequent request.

```json
{
  "query": "releasedAt:[2004-01-01 TO 2022-12-31]",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

**Monitoring Most Recent Enforcement Actions**
To monitor the most recent enforcement actions published by the SEC, you can use the following query. This query will return the 50 most recent enforcement actions. You can then periodically query the API to retrieve the latest enforcement actions, for example, every 60 seconds.

```json
{
  "query": "releaseNo:*",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

**Searching for Specific Companies**
If you are interested in enforcement actions involving specific companies, you can use the `ticker` or `cik` filters. The example will return actions involving Archer-Daniels-Midland (ticker: ADM, CIK: 7084).

```json
{
  "query": "entities.ticker:ADM",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### Response Structure

The Search API returns a JSON object with two main fields: `total` and `data`. The `total` field indicates the total number of results matching the search criteria, while the `data` field contains an array of enforcement actions that match the query. Each object in the `data` array represents an enforcement action and includes the following fields:

- `id` (string) - A system internal unique identifier of the enforcement action.
- `releaseNo` (string) - The SEC release number of the enforcement action, e.g., `2011-279`.
- `releasedAt` (string) - The publication date and time of the enforcement action, e.g.`2024-08-27T13:30:00-04:00`. Format: `yyyy-MM-ddTHH:mm:ssXXX`. Records prior to 2012 only have the date part, e.g., `2011-12-29`.
- `url` (string) - The URL to the original SEC press release.
- `resources` (array of objects) - An array of objects with `label` and `url` fields, providing links to related documents, such as litigation releases and complaints.
- `title` (string) - The title of the enforcement action.
- `summary` (string) - A brief summary of the enforcement action.
- `tags` (array of strings) - Tags associated with the enforcement action, such as `bribery`, `insider trading`, etc.
- `entities` (array of objects) - An array of objects representing the parties involved in the enforcement action.The `ticker` and `cik` fields are optional and are only present if the `name` was successfully matched to a known publicly traded company.
  - `name` (string) - The name of the party involved.
  - `type` (string) - The type of the party, such as `individual`, `company`, or `other`.
  - `role` (string) - The role of the party, such as `respondent`, `defendant`, or `other`.
  - `ticker` (string) - The ticker symbol of the party, if available.
  - `cik` (string) - The Central Index Key (CIK) of the party, if available.
- `complaints` (array of strings) - An array of complaints or charges filed in the enforcement action, such as "Magyar Telekom paid approximately $9 million through four sham contracts to funnel money to government officials in Montenegro."
- `parallelActionsTakenBy` (array of strings) - An array of other agencies that took parallel actions related to the enforcement action, such as `U.S. Department of Justice` in case of criminal charges.
- `hasAgreedToSettlement` (boolean) - Indicates whether the defendant has agreed to a settlement.
- `hasAgreedToPayPenalty` (boolean) - Indicates whether the defendant has agreed to pay a penalty.
- `penaltyAmounts` (array of objects) - An array of penalty objects with `penaltyAmount`, `penaltyAmountText` and `imposedOn` fields. Each object represents a penalty imposed on a party involved in the enforcement action. A charge can have multiple penalties, for example, if multiple defendants are involved.
  - `penaltyAmount` (number) - The cleaned penalty amount in USD.
  - `penaltyAmountText` (string) - The original penalty amount as stated in the enforcement action.
  - `imposedOn` (string) - The party on which the penalty was imposed.
- `requestedRelief` (array of strings) - An array of requested reliefs in the enforcement action, such as `disgorgement of profits`, `injunction`, `civil penalty`, etc.
- `violatedSections` (array of strings) - An array of securities laws violated by the defendants, such as `Section 10(b) of the Securities Exchange Act of 1934` or `Foreign Corrupt Practices Act (FCPA)`.
- `investigationConductedBy` (array of strings) - An array of persons or entities that conducted the investigation leading to the enforcement action.
- `litigationLedBy` (array of strings) - An array of persons or entities that litigated the case.
- `otherAgenciesInvolved` (array of objects) - An array of other agency objects (`name`, `country`) involved in the investigation or enforcement action, such as the Swiss Office of the Attorney General (Switzerland) in case of international cooperation.

#### Response Example

JSON

```json
{
    "total": {
      "value": 235,
      "relation": "eq"
    },
    "data": [
      {
        "releaseNo": "2011-279",
        "releasedAt": "2011-12-29",
        "url": "https://www.sec.gov/news/press/2011/2011-279.htm",
        "resources": [
          {
            "label": "SEC complaint v. the companies",
            "url": "https://www.sec.gov/litigation/complaints/2011/comp22213-co.pdf"
          },
          {
            "label": "SEC Complaint v. the executives",
            "url": "https://www.sec.gov/litigation/complaints/2011/comp22213-ex.pdf"
          },
          {
            "label": "Litigation Release No. LR-22213",
            "url": "https://www.sec.gov/litigation/litreleases/2011/lr22213.htm"
          }
        ],
        "title": "SEC Charges Magyar Telekom and Former Executives with Bribing Officials in Macedonia and Montenegro",
        "summary": "The SEC charged Magyar Telekom and three former executives with bribing officials in Macedonia and Montenegro, resulting in a $95 million settlement involving both civil and criminal charges.",
        "tags": ["bribery", "foreign corrupt practices", "telecommunications"],
        "entities": [
          {
            "name": "Magyar Telekom",
            "type": "company",
            "role": "defendant",
            "ticker": "MYTAY",
            "cik": "1047564"
          },
          {
            "name": "Deutsche Telekom AG",
            "type": "company",
            "role": "defendant",
            "ticker": "DTEGY",
            "cik": "946770"
          },
          {
            "name": "Elek Straub",
            "type": "individual",
            "role": "defendant"
          },
          {
            "name": "Andras Balogh",
            "type": "individual",
            "role": "defendant"
          },
          {
            "name": "Tamas Morvai",
            "type": "individual",
            "role": "defendant"
          }
        ],
        "complaints": [
          "Magyar Telekom and its executives bribed government and political party officials in Macedonia and Montenegro to win business and shut out competition.",
          "Magyar Telekom's subsidiaries in Macedonia made illegal payments of approximately $6 million under bogus consulting and marketing contracts.",
          "Magyar Telekom paid approximately $9 million through four sham contracts to funnel money to government officials in Montenegro.",
          "Deutsche Telekom AG violated books and records and internal controls provisions of the FCPA."
        ],
        "parallelActionsTakenBy": ["U.S. Department of Justice"],
        "hasAgreedToSettlement": true,
        "hasAgreedToPayPenalty": true,
        "penaltyAmounts": [
          {
            "penaltyAmount": 31200000,
            "penaltyAmountText": "$31.2 million",
            "imposedOn": "Magyar Telekom"
          },
          {
            "penaltyAmount": 59600000,
            "penaltyAmountText": "$59.6 million",
            "imposedOn": "Magyar Telekom"
          },
          {
            "penaltyAmount": 4360000,
            "penaltyAmountText": "$4.36 million",
            "imposedOn": "Deutsche Telekom AG"
          }
        ],
        "requestedRelief": [
          "disgorgement of profits",
          "civil penalties",
          "permanent injunctions"
        ],
        "violatedSections": ["Foreign Corrupt Practices Act (FCPA)"],
        "investigationConductedBy": ["Adam Eisner", "Charles Cain"],
        "litigationLedBy": ["Robert Dodge"],
        "otherAgenciesInvolved": [
          {
            "name": "Fraud Section of the Department of Justice's Criminal Division",
            "country": "United States"
          },
          {
            "name": "Federal Bureau of Investigation",
            "country": "United States"
          },
          {
            "name": "Hungarian Financial Supervisory Authority",
            "country": "Hungary"
          },
          {
            "name": "German Federal Financial Supervisory Authority (BaFin)",
            "country": "Germany"
          },
          {
            "name": "Swiss Office of the Attorney General",
            "country": "Switzerland"
          }
        ]
      }
    ]
}
```

## FAQ

Common questions about querying the SEC Enforcement Actions Database, the response shape, and the bulk archives.

### How do I look up an SEC enforcement action by its release number?

To look up an enforcement action by its SEC release number, query the `/sec-enforcement-actions` endpoint and filter on the release number field (`releaseNo`). The value of `releaseNo` should equal the exact identifier the SEC assigned to the action, for example `2011-279` or `2017-133`.

The response object echoes back the same `releaseNo` along with the publication date (`releasedAt`), the title (`title`), the original press release link (`url`), and any related court filings or orders attached to the action (`resources`). Because release numbers are unique, a successful lookup returns a single record.

```json
{
  "query": "releaseNo:\"2011-279\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I find all SEC enforcement actions involving a specific publicly traded company by ticker?

To find all enforcement actions involving a specific publicly traded company by its stock ticker, query the `/sec-enforcement-actions` endpoint and filter on the ticker field inside the parties array (`entities.ticker`). The value of `entities.ticker` should equal the company's trading symbol, for example `HAL` for Halliburton or `MYTAY` for Magyar Telekom.

The ticker field is only populated when the party name was successfully matched to a known publicly traded company, so this filter targets corporate respondents and defendants rather than individuals. To page through every matching action, sort by publication date in descending order (`releasedAt`) and step the `from` offset forward by the page size (max `50`).

```json
{
  "query": "entities.ticker:HAL",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I retrieve all enforcement actions against a company using its SEC identifier?

To retrieve every enforcement action involving a specific company by its SEC identifier, query the `/sec-enforcement-actions` endpoint and filter on the CIK field inside the parties array (`entities.cik`). The value of `entities.cik` should equal the Central Index Key assigned to the company, for example `45012` for Halliburton or `1493318` for eToro.

Filtering by `entities.cik` is more reliable than filtering by ticker because the CIK never changes when a company rebrands or delists. The response includes every action where the company appears in any role (`entities.role`), so the same query catches matters where the company is a defendant, a respondent, or a settling party.

```json
{
  "query": "entities.cik:45012",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I pull every SEC enforcement action published in a given year and paginate through the full result set?

To pull every enforcement action published in a given year, query the `/sec-enforcement-actions` endpoint and filter on the publication date (`releasedAt`). The value of `releasedAt` should be between the first and last day of the target year, for example between `2022-01-01` and `2022-12-31`. Sort the results by `releasedAt` in descending order so the page boundaries are stable.

The endpoint returns up to 50 records per page, controlled by the `size` parameter. To paginate, start with `from` at `0`, then increase it by `50` on each subsequent call until the `total.value` count is reached. The `from` offset is capped at `10000`; if a single year contains more than that, split the date range into shorter sub-windows (for example month by month) and paginate each window independently.

```json
{
  "query": "releasedAt:[2022-01-01 TO 2022-12-31]",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How can I monitor the most recently published SEC enforcement actions in near real time?

To monitor the most recently published actions in near real time, query the `/sec-enforcement-actions` endpoint and sort by the publication date (`releasedAt`) in descending order. The database is updated as new actions are published by the SEC, so a recurring poll of the top of the sort order surfaces newly added records.

A simple monitoring loop uses a match-all query such as the presence of any release number (the `releaseNo` field exists), keeps `from` at `0`, and asks for the first page (up to `50` records). On each poll, compare the returned `releaseNo` values against the ones already seen and treat the unseen ones as new. A polling interval of around 60 seconds is sufficient because actions are published infrequently.

```json
{
  "query": "releaseNo:*",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I find SEC actions related to bribery or Foreign Corrupt Practices Act violations?

To find actions related to bribery or Foreign Corrupt Practices Act violations, query the `/sec-enforcement-actions` endpoint and filter on either the topical tags array (`tags`) or the list of violated laws (`violatedSections`). Bribery cases commonly carry tags such as `bribery`, `foreign corrupt practices`, or `FCPA violations`, and the value of `violatedSections` typically contains a phrase such as `Foreign Corrupt Practices Act (FCPA)` or `books and records provisions of the FCPA`.

Combining both filters with an OR catches cases that were tagged but not explicitly labeled with a statute, and vice versa. Each returned action also exposes a free-text summary (`summary`) and the underlying allegations (`complaints`) for further confirmation.

```json
{
  "query": "tags:\"bribery\" OR tags:\"foreign corrupt practices\" OR violatedSections:\"Foreign Corrupt Practices Act (FCPA)\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I search for insider-trading enforcement cases?

To search for insider-trading enforcement cases, query the `/sec-enforcement-actions` endpoint and filter on the topical tags array (`tags`). The value of `tags` should contain `insider trading`. The tag is applied when the SEC's release describes trading on material non-public information, so it captures both individual tipping cases and broader market-manipulation matters with an insider-trading component.

For a fuller view, the narrative complaint text (`complaints`) and the case title (`title`) often contain the phrase `insider trading` even on actions that were not tagged that way, so a free-text search of `complaints` can be used as a secondary check.

```json
{
  "query": "tags:\"insider trading\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I list enforcement actions where the defendant agreed to a settlement?

To list actions where the charged party agreed to a settlement, query the `/sec-enforcement-actions` endpoint and filter on the settlement flag (`hasAgreedToSettlement`). The value of `hasAgreedToSettlement` should be `true`.

This flag captures matters that were resolved without a contested trial, including consent orders and administrative settlements. The related field `hasAgreedToPayPenalty` indicates whether a monetary penalty was part of the settlement, and the specific dollar amounts and the party each was imposed on are listed under the penalties array (`penaltyAmounts`).

```json
{
  "query": "hasAgreedToSettlement:true",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I find cases where the charged party agreed to pay a monetary penalty?

To find cases where the charged party agreed to pay a monetary penalty, query the `/sec-enforcement-actions` endpoint and filter on the penalty-agreed flag (`hasAgreedToPayPenalty`). The value of `hasAgreedToPayPenalty` should be `true`.

This filter narrows the result set to actions that include at least one financial sanction the defendant accepted. The actual amounts appear in the penalties array (`penaltyAmounts`), where each entry carries the cleaned numeric amount (`penaltyAmounts.penaltyAmount`), the original text as the SEC stated it (`penaltyAmounts.penaltyAmountText`), and the party the penalty was imposed on (`penaltyAmounts.imposedOn`).

```json
{
  "query": "hasAgreedToPayPenalty:true",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I identify the largest enforcement penalties ever imposed and which party they were levied against?

To identify the largest enforcement penalties ever imposed, query the `/sec-enforcement-actions` endpoint and sort or rank results on the numeric penalty amount inside the penalties array (`penaltyAmounts.penaltyAmount`). Each action can carry multiple entries in `penaltyAmounts`, so a single record may contribute several values; the party each amount was levied against is named on the same object under `penaltyAmounts.imposedOn`.

Because an action can have several penalty entries (one per defendant or one per type of sanction), build the ranking by flattening `penaltyAmounts` across all returned actions and ordering the flattened list by `penaltyAmounts.penaltyAmount` in descending order. The corresponding action context, including the title (`title`), release number (`releaseNo`), and publication date (`releasedAt`), comes from the parent record.

```json
{
  "query": "penaltyAmounts.penaltyAmount:[1000000 TO *]",
  "from": 0,
  "size": 50,
  "sort": [{"penaltyAmounts.penaltyAmount":{"order":"desc"}}]
}
```

### How do I total the penalty dollars imposed on a single company across all its SEC actions?

To total the penalty dollars imposed on a single company across all its SEC actions, first pull every action that involves the company by querying the `/sec-enforcement-actions` endpoint with a filter on the CIK or ticker (`entities.cik` or `entities.ticker`). The value of `entities.cik` should equal the company's CIK, for example `45012` for Halliburton.

Then iterate the penalties array on each returned action (`penaltyAmounts`) and keep only the entries where the party named on the penalty (`penaltyAmounts.imposedOn`) matches the company's name. Sum the numeric amounts (`penaltyAmounts.penaltyAmount`) across all kept entries. Filtering on `imposedOn` is necessary because the same action can also list penalties imposed on individual officers or co-defendants that should not be counted toward the company total.

```json
{
  "query": "entities.cik:45012",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I find SEC enforcement actions that were brought in parallel with criminal charges by the Department of Justice?

To find actions that were brought in parallel with criminal charges by the Department of Justice, query the `/sec-enforcement-actions` endpoint and filter on the parallel actions array (`parallelActionsTakenBy`). The value of `parallelActionsTakenBy` should contain `U.S. Department of Justice`.

This field lists the other agencies that took related action on the same underlying conduct, so a match indicates a coordinated civil-and-criminal posture. Related agencies such as the Federal Bureau of Investigation are sometimes added to the same array, and the broader list of cooperating bodies (`otherAgenciesInvolved`) can be inspected for additional context on the investigation.

```json
{
  "query": "parallelActionsTakenBy:\"U.S. Department of Justice\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I locate actions where international regulators cooperated with the SEC?

To locate actions where international regulators cooperated with the SEC, query the `/sec-enforcement-actions` endpoint and filter on the cooperating agencies array (`otherAgenciesInvolved`). The value of `otherAgenciesInvolved.country` should be anything other than `United States`. Examples of non-US cooperators that appear on the records include `Hungarian Financial Supervisory Authority` (Hungary), `German Federal Financial Supervisory Authority (BaFin)` (Germany), and `Swiss Office of the Attorney General` (Switzerland).

The name of each cooperating body sits alongside the country on the same object (`otherAgenciesInvolved.name`), so the response identifies both the foreign regulator and the jurisdiction. Pairing this filter with a tag such as `foreign corrupt practices` narrows the set to cross-border bribery matters specifically.

```json
{
  "query": "otherAgenciesInvolved.country:* AND NOT otherAgenciesInvolved.country:\"United States\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I search for cases that violate a specific securities law section?

To search for cases that violate a specific securities law section, query the `/sec-enforcement-actions` endpoint and filter on the list of violated laws (`violatedSections`). The value of `violatedSections` should contain the text of the statute or rule, for example `Section 10(b) of the Securities Exchange Act of 1934`, `Foreign Corrupt Practices Act (FCPA)`, or `books and records provisions of the FCPA`.

Because `violatedSections` is stored as free-text strings extracted from the SEC's release, a partial phrase match (for example `Section 10(b)`) works well to capture variations in how the SEC cites the same statute. Each returned action also exposes the underlying allegations (`complaints`) and the requested remedies (`requestedRelief`) so the legal posture of the case is visible.

```json
{
  "query": "violatedSections:\"Section 10(b) of the Securities Exchange Act of 1934\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I find enforcement actions where the SEC requested disgorgement of profits?

To find actions where the SEC requested disgorgement of profits, query the `/sec-enforcement-actions` endpoint and filter on the requested remedies array (`requestedRelief`). The value of `requestedRelief` should contain `disgorgement of profits` (or the closely related `disgorgement of ill-gotten gains`, which appears on some older releases).

The `requestedRelief` array often lists multiple remedies on the same action, such as `prejudgment interest`, `civil penalties`, `permanent injunctions`, or `cease and desist order`. Combining this filter with the settlement flag (`hasAgreedToSettlement`) separates contested disgorgement requests from those resolved by consent.

```json
{
  "query": "requestedRelief:\"disgorgement of profits\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I distinguish actions targeted at companies from those targeted at individuals?

To distinguish actions targeted at companies from those targeted at individuals, look at the party-type field inside the parties array (`entities.type`). The value of `entities.type` is `company` for corporate respondents and `individual` for natural persons; a third value, `other`, covers parties that fit neither.

Querying the `/sec-enforcement-actions` endpoint with a filter where `entities.type` should equal `company` returns matters with at least one corporate defendant, and the same query with `entities.type` set to `individual` returns matters with at least one individual defendant. A single action commonly lists both types together — for example a company and its named executives — so the two queries overlap on mixed matters.

```json
{
  "query": "entities.type:company",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I find cases naming a specific individual as a defendant?

To find cases naming a specific individual as a defendant, query the `/sec-enforcement-actions` endpoint and filter on the entity name combined with the role inside the parties array. The value of `entities.name` should equal the person's full name, for example `Jeannot Lorenz`, and the value of `entities.role` should be `defendant`.

Both conditions need to apply to the same entry inside `entities`, so this is a nested filter rather than two independent filters at the document level. The response includes the broader context of the matter — the title (`title`), summary (`summary`), and any co-defendants in the same `entities` array — so it is straightforward to see the company or other individuals named alongside the target person.

```json
{
  "query": "entities.name:\"Jeannot Lorenz\" AND entities.role:\"defendant\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I retrieve the original SEC press release link and any related litigation release or complaint documents for an action?

To retrieve the original SEC press release link and the related court filings for an action, look at the press release URL on the top-level object (`url`) and the related-documents array (`resources`). The `url` field points to the original SEC press release page; for older matters this is on `sec.gov/news/press/...` and for newer matters it is on `sec.gov/newsroom/press-releases/...`.

Each entry inside `resources` carries a human-readable label (`resources.label`) and a direct link to the document (`resources.url`). Typical labels include `SEC Complaint`, `SEC Order`, `Litigation Release No. LR-22213`, and amended-rule documents for non-enforcement releases. Querying the `/sec-enforcement-actions` endpoint for a specific release number (`releaseNo`) returns a single record whose `url` and `resources` together provide the complete document trail.

```json
{
  "query": "releaseNo:\"2011-279\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I search the narrative text of charges and complaints filed by the SEC?

To search the narrative text of charges and complaints, query the `/sec-enforcement-actions` endpoint and filter on the complaints array (`complaints`). Each element of `complaints` is a sentence-level description of a specific allegation, such as `Magyar Telekom paid approximately $9 million through four sham contracts to funnel money to government officials in Montenegro`.

A free-text term match against `complaints` finds actions whose allegations mention a given concept, party, or scheme. Combining this with a phrase from the case summary (`summary`) or title (`title`) tightens the match when the same word appears in many unrelated matters. The complaint sentences are returned in full on the response, so the matching context is visible without dereferencing the original PDF.

```json
{
  "query": "complaints:\"sham contracts\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I find enforcement actions led by a specific SEC attorney or investigator?

To find actions led by a specific SEC attorney or investigator, query the `/sec-enforcement-actions` endpoint and filter on either the investigation team (`investigationConductedBy`) or the litigation team (`litigationLedBy`). Each field is an array of names; the value should equal the staffer's full name, for example `Charles Cain` or `Melissa R. Hodgman`.

The two arrays serve different roles: `investigationConductedBy` lists the staff that gathered facts and prepared the case, while `litigationLedBy` lists the attorneys that argued or settled it. Some matters list multiple people in each role. A union over the two fields catches every action a given staffer touched, regardless of which side of the workflow they were on.

```json
{
  "query": "investigationConductedBy:\"Charles Cain\" OR litigationLedBy:\"Charles Cain\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I filter for SEC actions in a particular industry sector such as hedge funds or telecommunications?

To filter actions by industry sector, query the `/sec-enforcement-actions` endpoint and filter on the topical tags array (`tags`). The value of `tags` should contain the sector descriptor — for example `hedge fund` for hedge fund matters, `telecommunications` for telecom matters, or `binary options` for retail-fraud schemes built around a particular product.

The `tags` field captures both the industry and the nature of the misconduct, so a sector tag often appears alongside a charge-type tag such as `improper expense allocations` or `disclosure fraud`. Browsing the distinct values that appear on `tags` across an initial page of results helps identify which sector labels the SEC uses in practice.

```json
{
  "query": "tags:\"hedge fund\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I find cases involving multiple defendants and list all parties charged in each?

To find cases involving multiple defendants and list every charged party, query the `/sec-enforcement-actions` endpoint and inspect the parties array on each returned action (`entities`). Iterate through `entities` and keep entries where the role (`entities.role`) is `defendant`. Each kept entry carries the party's name (`entities.name`), party type (`entities.type`, either `company` or `individual`), and optionally the ticker (`entities.ticker`) and CIK (`entities.cik`) when the party matches a publicly traded company.

To restrict the query to matters with more than one defendant in the first place, target multi-party releases by filtering on a known co-defendant (`entities.name`) or by checking whether the parallel actions array (`parallelActionsTakenBy`) is non-empty, since coordinated matters typically name several parties.

```json
{
  "query": "entities.role:\"defendant\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I separate defendants from settling parties within the same enforcement action?

To separate defendants from settling parties within the same action, look at the role field inside the parties array (`entities.role`). The value of `entities.role` is one of `defendant`, `settling party`, `respondent`, or `other`. A single action can mix these — for example, a release may name some parties as `defendant` and others as `settling party` when only a subset agreed to terms.

Querying the `/sec-enforcement-actions` endpoint returns the full `entities` array on each action, so the separation is done client-side by filtering `entities` on the desired role value. The action-level flag for whether any party agreed to settle (`hasAgreedToSettlement`) tells you whether the action contains settling parties at all before you bother to split the array.

```json
{
  "query": "entities.role:\"settling party\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I track trends in SEC enforcement activity over time, such as actions per year?

To track trends in SEC enforcement activity over time, query the `/sec-enforcement-actions` endpoint for one year at a time using the publication date filter (`releasedAt`). The value of `releasedAt` should be between January 1 and December 31 of the target year, for example between `2019-01-01` and `2019-12-31`. The response object's total count (`total.value`) reports the number of matching actions, which is the annual volume.

Repeating the query year by year and recording each `total.value` produces a time series of enforcement activity. To break the trend down further by topic, layer in a tag filter (`tags`) or a violated-section filter (`violatedSections`) and re-run the per-year sweep for that subcategory. Sorting the underlying results by `releasedAt` ascending lets you also reconstruct the within-year cadence.

```json
{
  "query": "releasedAt:[2019-01-01 TO 2019-12-31]",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"asc"}}]
}
```

### How do I rank the most common types of charges or themes brought by the SEC?

To rank the most common types of charges or themes, query the `/sec-enforcement-actions` endpoint over the desired time window (filtering on `releasedAt`) and tally the values that appear in the topical tags array (`tags`) across the result set. Each action carries multiple tags such as `bribery`, `insider trading`, `disclosure fraud`, `whistleblower awards`, or `hedge fund`, so the tally counts tag occurrences rather than actions.

A companion view comes from tallying the violated-laws array (`violatedSections`), which reflects the statutory framing — for example `Foreign Corrupt Practices Act (FCPA)` or `Section 10(b) of the Securities Exchange Act of 1934` — rather than the thematic framing. Paginating through the result set with `from` stepping by `50` ensures the tally covers every action, not just the first page.

```json
{
  "query": "releasedAt:[2020-01-01 TO 2022-12-31]",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I combine multiple filters, for example FCPA cases that ended in a settlement within a date window?

To combine multiple filters, query the `/sec-enforcement-actions` endpoint with a compound condition. For FCPA cases that ended in a settlement within a date window, the violated-laws array (`violatedSections`) should contain `Foreign Corrupt Practices Act (FCPA)`, the settlement flag (`hasAgreedToSettlement`) should be `true`, and the publication date (`releasedAt`) should be between the start and end of the target window, for example between `2018-01-01` and `2022-12-31`.

All three conditions must hold on the same action. The query syntax supports boolean composition across these fields, so they can be joined in a single request rather than fetched separately and intersected client-side. The response includes the full set of matching records with the dollar penalties (`penaltyAmounts`), parties (`entities`), and complaint narrative (`complaints`) available for downstream analysis.

```json
{
  "query": "violatedSections:\"Foreign Corrupt Practices Act (FCPA)\" AND hasAgreedToSettlement:true AND releasedAt:[2018-01-01 TO 2022-12-31]",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I sort enforcement actions from oldest to newest to reconstruct a historical timeline?

To sort actions from oldest to newest, query the `/sec-enforcement-actions` endpoint and order results by the publication date (`releasedAt`) in ascending order. The endpoint sorts by `releasedAt` descending by default, so overriding the sort direction is required.

Note that records prior to 2012 only carry the date portion of `releasedAt` (for example `2011-12-29`), while later records carry a full timestamp with a timezone offset (for example `2024-08-27T13:30:00-04:00`). The ascending sort handles both shapes correctly because they share the same lexicographic prefix. To rebuild a complete historical timeline, paginate by stepping `from` forward by `50` until every record is retrieved.

```json
{
  "query": "releaseNo:*",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"asc"}}]
}
```

### How do I retrieve a complete dump of every action published since 1997 within the pagination cap?

To retrieve a complete dump of every action published since 1997, query the `/sec-enforcement-actions` endpoint repeatedly using narrow date windows on the publication date (`releasedAt`) and paginating within each window. The `from` offset is capped at `10000`, so any window whose total count would exceed that cap must be split into smaller sub-windows.

A practical approach is to sweep year by year from 1997 forward: for each year, the value of `releasedAt` should be between January 1 and December 31 of that year, sorted ascending. Step `from` by `50` until the page is empty or the year's `total.value` is reached. If a single year's total exceeds the offset cap, split that year into quarters or months and repeat. Together this yields the full historical set without any window hitting the pagination ceiling.

```json
{
  "query": "releasedAt:[1997-01-01 TO 1997-12-31]",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"asc"}}]
}
```

### How do I find whistleblower-related SEC announcements and the associated award amounts?

To find whistleblower-related announcements, query the `/sec-enforcement-actions` endpoint and filter on the topical tags array (`tags`). The value of `tags` should contain `whistleblower awards`. The matching records cover SEC press releases that announce awards to tipsters whose information led to successful enforcement actions.

When present, the dollar figures appear in the penalties array (`penaltyAmounts`), with the numeric amount on `penaltyAmounts.penaltyAmount` and the original text on `penaltyAmounts.penaltyAmountText`. Because award announcements often omit the structured fields used on charging documents, some records carry only the title (`title`) and summary (`summary`) with the dollar figure stated in the title text itself (for example `SEC Issues Awards Totaling $98 Million to Two Whistleblowers`). For those records, parsing the amount from `title` or `summary` is the fallback.

```json
{
  "query": "tags:\"whistleblower awards\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

### How do I compute the total dollars the SEC has ordered in penalties for a given category of misconduct, such as FCPA cases?

To compute the total dollars the SEC has ordered in penalties for a given category of misconduct, first pull every action in that category by querying the `/sec-enforcement-actions` endpoint with a filter on either the violated-laws array (`violatedSections`) or the topical tags array (`tags`). For FCPA cases, the value of `violatedSections` should contain `Foreign Corrupt Practices Act (FCPA)`, or the value of `tags` should contain `foreign corrupt practices` or `FCPA violations`.

Then paginate through the full result set by stepping `from` by `50`, and on each returned action sum the numeric penalty amounts inside the penalties array (`penaltyAmounts.penaltyAmount`). The grand total is the sum of `penaltyAmounts.penaltyAmount` across every entry in every matching action. The party each amount was imposed on sits on the same object (`penaltyAmounts.imposedOn`), so the total can also be broken down per defendant if needed.

```json
{
  "query": "violatedSections:\"Foreign Corrupt Practices Act (FCPA)\"",
  "from": 0,
  "size": 50,
  "sort": [{"releasedAt":{"order":"desc"}}]
}
```

## References

- [SEC Enforcement Actions and Litigation](https://www.sec.gov/enforcement-litigation)
- [SEC Litigation Releases](https://www.sec.gov/enforcement-litigation/litigation-releases)
- [SEC Administrative Proceedings](https://www.sec.gov/enforcement-litigation/administrative-proceedings)

### Miscellaneous

- [Stanford Securities Class Action Clearinghouse](https://securities.stanford.edu/)
- [NYU Securities Enforcement Empirical Database](https://www.law.nyu.edu/centers/state-impact/centers/securities-enforcement-empirical-database)