# SEC Enforcement & Litigation Release Delta Feed (`stefano_seggio/sec-enforcement-litigation-delta-feed`) Actor

Structures SEC.gov's own Litigation Releases and Administrative Proceedings feeds into delta events: respondent, statute/rule citations, monetary sanctions, and a best-effort linked EDGAR CIK. Outside the saturated 10-K/8-K/Form-4 filings-scraper niche. Pay-per-event: billed only for what changed.

- **URL**: https://apify.com/stefano\_seggio/sec-enforcement-litigation-delta-feed.md
- **Developed by:** [Stefano Seggio](https://apify.com/stefano_seggio) (community)
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $50.00 / 1,000 new enforcement releases

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## SEC Enforcement & Litigation Release Delta Feed

#### SEC.gov has no API. This gives you one — with the entity matching already done.

If you track enforcement actions against companies, your only option today is refreshing a static SEC.gov webpage and reading it yourself — and even then, the release only names a person or entity, never the actual EDGAR-registered company you have on file. **This Actor solves that**: it turns SEC.gov's litigation releases and administrative proceedings into a structured, cross-linked, delta-tracked feed.

***

### Why this outperforms a standard scraper

- **Delta tracking, not re-scraping.** Every release is fingerprinted on every run. Unchanged releases are never re-delivered — and never billed.
- **Pay only for what's new.** A genuinely new enforcement release costs $0.05. A correction to a release you've already received costs $0.02 — rare, since SEC releases are essentially immutable once published. An unchanged release costs nothing.
- **Automatic entity resolution.** The named respondent is cross-linked to their real EDGAR filer CIK, with a confidence score — including former company names — instead of leaving that match to you. Monetary sanctions (sought vs. ordered) are extracted directly from the administrative proceeding PDFs.

### See it before you trust it

```json
{
  "record_id": "LR-26636",
  "event_type": "NEW_LISTING",
  "release_type": "litigation_release",
  "release_date": "2026-09-12",
  "title": "SEC Charges Investment Adviser with Overbilling Advisory Clients",
  "primary_respondent": "Example Capital Management LLC",
  "linked_edgar_cik": "0001234567",
  "edgar_match_confidence": 0.94,
  "monetary_sanctions": { "sought_usd": 450000, "ordered_usd": 310000 }
}
```

Notice `linked_edgar_cik` and `edgar_match_confidence` — that match is automatic, not something you build yourself. And `monetary_sanctions` is parsed straight out of the PDF, not left for you to read by hand.

### Zero-risk trial

Unchanged runs cost **$0.00**. Run it once against real data before you commit to anything:

```bash
curl -X POST "https://api.apify.com/v2/acts/EDhT9Mvrdm2hzTECA/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"userAgent": "YourCompany your-email@example.com", "maxItemsPerRun": 50, "onlyNew": true}'
```

```python
import requests

response = requests.post(
    "https://api.apify.com/v2/acts/EDhT9Mvrdm2hzTECA/run-sync-get-dataset-items",
    params={"token": "<YOUR_API_TOKEN>"},
    json={"userAgent": "YourCompany your-email@example.com", "maxItemsPerRun": 50, "onlyNew": True},
)
records = response.json()
print(f"{len(records)} records returned")
```

```javascript
const response = await fetch(
  "https://api.apify.com/v2/acts/EDhT9Mvrdm2hzTECA/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>",
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      userAgent: "YourCompany your-email@example.com",
      maxItemsPerRun: 50,
      onlyNew: true,
    }),
  }
);
const records = await response.json();
console.log(`${records.length} records returned`);
```

### Pricing

| Event | What it means | Price |
|---|---|---|
| New Enforcement Release | A litigation release or administrative proceeding seen for the first time. | $0.05 |
| Updated Release Content | Content on a previously-delivered release changed on a later run — rare, since SEC releases are essentially immutable. | $0.02 |

Actor-start fee: $0.00005/GB-memory (one-time per run, not per record).

### What you get on every record

- Release/proceeding type, date, and title, exactly as published
- Primary respondent name, as named in the release
- Linked EDGAR CIK with a numeric match-confidence score
- Cited statutes/rules where present in the release
- Monetary sanctions broken out as sought vs. ordered, parsed from the source PDF
- Delta classification: NEW\_LISTING or UPDATED, so you never process the same release twice

### Input parameters

| Field | Type | Description | Default |
|---|---|---|---|
| `userAgent` | string | Identifies your requests to SEC.gov per their fair-access policy — use your company name and an email. | required |
| `maxItemsPerRun` | integer | Caps how many releases are processed in one run. | 50 |
| `onlyNew` | boolean | When true, only NEW\_LISTING events are returned; set false to also see UPDATED events. | true |

### Source & reliability

Source is SEC.gov's own public litigation-release and administrative-proceeding feeds — no third-party aggregator in between. This Actor runs on the same delta-engine pattern behind this operator's whole fleet: canonicalize, fingerprint, persist state across runs, retry with backoff on transient failures, and — critically — distinguish a genuine upstream outage from an actual code defect in its own error reporting, so a bad day for SEC.gov's servers never gets mistaken for a broken pipeline.

# Actor input Schema

## `sources` (type: `array`):

Which of SEC.gov's own enforcement feeds to walk each run. 'Litigation Releases' are HTML pages under sec.gov/enforcement-litigation/litigation-releases/lr-NNNNN (RSS at .../litigation-releases/rss, live-verified). 'Administrative Proceedings' link directly to PDF orders under sec.gov/files/litigation/admin/YYYY/34-NNNNNN.pdf (RSS at .../administrative-proceedings/rss, live-verified) and require a separate PDF text-extraction pass.

## `onlyNew` (type: `boolean`):

When true (default), only NEW\_LISTING and content-changed (UPDATED) records are pushed as charged events. Set false to also push free, uncharged SNAPSHOT\_NO\_DIFF records for every release the walk touches.

## `maxItemsPerRun` (type: `integer`):

Caps the number of charged (result/result-summary) events this run will push, independent of your Apify spending limit. 0 means no Actor-side cap.

## `enableCikLinking` (type: `boolean`):

When true (default), each parsed respondent name is looked up against SEC's own EDGAR company database (browse-edgar company search) to attach a linked\_edgar\_cik. A match scoring below cikMatchConfidenceThreshold is left null rather than guessed.

## `cikMatchConfidenceThreshold` (type: `number`):

Minimum name-match confidence (0-1) required before linked\_edgar\_cik is populated. Default 0.80 is deliberately conservative - a real respondent, 'Invesco Alpha Inc.', shares a name substring with the real, unrelated NYSE-listed Invesco Ltd, and a lower threshold would risk wrongly attaching a real public company's CIK to an unrelated enforcement action in your vendor-risk feed.

## `watchlistNames` (type: `array`):

Entity or individual names (case-insensitive substring match against parsed respondents) you specifically want flagged. A match sets is\_watchlist\_match: true.

## `userAgent` (type: `string`):

SEC's own fair-access policy (sec.gov/os/webmaster-faq#developers) requires automated requests to sec.gov/data.sec.gov to declare a descriptive User-Agent identifying the requester, typically '<Your Company Name> <your-contact-email>'. Sent verbatim on every request.

## `requestDelayMs` (type: `integer`):

A flat delay applied between every successful request to sec.gov/data.sec.gov, independent of retries - a deliberately conservative default since this Actor's endpoints were live-verified for shape and availability only, not load-tested against SEC's general fair-access ceiling.

## `maxRetries` (type: `integer`):

Retry attempts for a 429/5xx response or a network-level failure before a request is treated as failed for this run. Exponential backoff (1000ms \* 2^attempt, jittered, capped at 15s).

## `requestTimeoutSecs` (type: `integer`):

AbortSignal timeout applied to every individual HTTP request (feed page, release page, PDF download, EDGAR lookup).

## `deltaStateName` (type: `string`):

Names the Key-Value Store this schedule's seen-release state is kept in. Run two schedules - e.g. one full-coverage, one watchlist-only - without them draining each other's baseline by giving each a distinct name here.

## `resetState` (type: `boolean`):

When true, clears this schedule's stored seen-release state before walking, so the next run re-baselines from scratch. Use for testing or recovering a corrupted state store, not routine operation.

## Actor input object example

```json
{
  "sources": [
    "litigation_releases",
    "administrative_proceedings"
  ],
  "onlyNew": true,
  "maxItemsPerRun": 0,
  "enableCikLinking": true,
  "cikMatchConfidenceThreshold": 0.8,
  "watchlistNames": [],
  "userAgent": "DeltaRegistrySECMonitor/1.0 (+https://apify.com/stefano_seggio/sec-enforcement-litigation-delta-feed)",
  "requestDelayMs": 750,
  "maxRetries": 4,
  "requestTimeoutSecs": 30,
  "deltaStateName": "default",
  "resetState": false
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("stefano_seggio/sec-enforcement-litigation-delta-feed").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("stefano_seggio/sec-enforcement-litigation-delta-feed").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call stefano_seggio/sec-enforcement-litigation-delta-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,stefano_seggio/sec-enforcement-litigation-delta-feed"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/EDhT9Mvrdm2hzTECA/builds/VVKgMJe2tpNQqTQae/openapi.json