# Regulatory Enforcement Search & Monitor (`thescrapelab/regulatory-enforcement-search-monitor`) Actor

Search and monitor official SEC litigation, ESMA sanctions, CNIL sanctions, and FDIC bank-failure records with normalized evidence and optional AI-assisted entity matching.

- **URL**: https://apify.com/thescrapelab/regulatory-enforcement-search-monitor.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 official evidence records

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/platform/actors/running/actors-in-store#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

## Regulatory Enforcement Search & Monitor

Search official **SEC litigation, ESMA sanctions, CNIL sanctions, and FDIC bank-failure records** in one normalized dataset. Run it with no input to discover recent records, or add company and person names for repeatable compliance monitoring.

> **Independent, unofficial tool:** This Actor is not affiliated with, sponsored by, or endorsed by the SEC, ESMA, CNIL, or FDIC. “Official” refers only to the public records used as sources.

The Actor is built for compliance research, third-party due diligence, investigations, vendor monitoring, and alerting workflows. Every row links back to official evidence. It does not produce a risk score or legal conclusion.

### Start in seconds

Open the **Input** tab and click **Start**. The default settings are already small and safe, so an empty input works:

```json
{}
```

To check specific names, provide only a watchlist:

```json
{
  "entityQueries": ["Example Holdings Ltd", "Example National Bank"]
}
```

Results appear in the default dataset and can be downloaded as JSON, CSV, Excel, XML, or other Apify-supported formats. RSS and JSON feeds are also created by default.

### Official sources

- US Securities and Exchange Commission litigation releases
- European Securities and Markets Authority sanctions register
- French CNIL sanctions tables
- US Federal Deposit Insurance Corporation bank failures

FDIC failures are institution-risk signals, not enforcement actions. CNIL's English tables frequently disclose only an organization type, so those rows support discovery but are not treated as named-entity matches.

### What you can do

- Discover recent enforcement, sanction, and bank-failure records
- Check up to 25 organization or person names in one run
- Schedule repeat checks and return only new or changed evidence
- Send normalized records into review, CRM, alerting, or data pipelines
- Audit why a name matched and whether an official record changed
- Consume results through the Apify API, CSV export, RSS, or JSON Feed

### Simple input

Most users only need these four fields:

- `entityQueries` — optional company or person names. Leave empty for recent-record discovery.
- `sources` — official sources to search. All four are selected by default.
- `lookbackDays` — history window from 1 to 365 days. Default: `365`.
- `maxResultsPerSource` — maximum rows returned from each source. Default: `3`.

The collapsed **Advanced options** section contains only two choices:

- `outputMode` — return all matches, only new and changed records, or only new records.
- `useAiMatching` — optionally review ambiguous name matches after exact matching has run.

Monitoring state is namespaced automatically. Valid RSS and JSON feeds are created automatically. API users can still override `monitoringKey` or set `includeFeeds` to `false`, but normal Console users do not need to configure either field.

AI matching is off by default and requires at least one `entityQueries` value. It evaluates no more than 20 ambiguous candidates per run and uses a fixed production confidence threshold. AI never creates or changes official facts.

### Useful, traceable output

Each dataset row contains:

- official authority, jurisdiction, record ID, source URL, and document links
- event date, category, event type, stage, and status
- disclosed entity names and identifiers
- official or clearly labelled constructed summary
- explicitly stated monetary penalties when conservative extraction is possible
- watchlist match method, confidence, reason, and matched query
- stable record and content hashes with `new`, `changed`, `unchanged`, or `unknown` status

The default dataset view puts the most useful review fields first: date, title, entities, summary, authority, jurisdiction, category, event type, match method, change status, and official source.

Example row:

```json
{
  "schemaVersion": "1.0",
  "recordId": "…",
  "source": "fdic-bank-failures",
  "sourceRecordId": "12345",
  "signalCategory": "institution-failure",
  "eventType": "bank-failure",
  "authority": "Federal Deposit Insurance Corporation",
  "jurisdiction": "United States",
  "entityNames": ["Example National Bank"],
  "title": "Example National Bank — bank failure",
  "eventDate": "2026-01-01T00:00:00.000Z",
  "sourceUrl": "https://www.fdic.gov/bank-failures/failed-bank-list",
  "matchedQueries": ["Example National Bank"],
  "matchMethod": "exact_entity",
  "matchConfidence": 1,
  "changeType": "new",
  "contentHash": "…"
}
```

Every row is validated before it is written. Invalid dates, insecure source URLs, malformed hashes, missing required fields, and unexpected fields cause the run to fail instead of silently producing a broken dataset.

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor(
    "thescrapelab/regulatory-enforcement-search-monitor"
).call(run_input={
    "entityQueries": ["Example Holdings Ltd"],
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["eventDate"], item["title"], item["sourceUrl"])
```

### Monitoring and feeds

The Actor remembers previously seen records for the same sources, names, and history window. Use `newAndChanged` for scheduled alerts or `newOnly` when only first appearances matter. Records withheld by an Apify spending limit are not marked as delivered, so a later run can still return them.

Each successful run provides:

- normalized dataset results and CSV export
- `RUN_SUMMARY` with source health, counts, warnings, and billing limits
- `RSS_XML` and `JSON_FEED` for the rows delivered by that run
- `AI_EVALUATIONS` when optional AI matching is enabled

### Data handling and privacy

- The Actor runs with **limited permissions** and cannot access unrelated resources in your Apify account.
- Exact matching runs inside the Actor. With `useAiMatching: false` (the default), watchlist queries and record evidence are not sent to an AI provider.
- If optional AI matching is enabled, only a bounded ambiguous-candidate payload is sent to the Actor owner's configured OpenRouter or OpenAI account. That payload can include the watchlist query, disclosed official entity names, record title, authority, event date, and a short official excerpt.
- Apify stores the run input and outputs according to your platform storage and retention settings. Monitoring state contains stable record hashes and timestamps; never submit names or other data you are not authorized to process.

### Cost and performance

The Actor uses direct HTTP requests rather than a browser and defaults to **128 MB RAM**. A small default run normally completes in seconds; the five-minute timeout leaves headroom for temporary official-source delays and bounded retries without increasing the charge for runs that finish earlier.

Pricing is pay per event, so you pay for useful work rather than a subscription:

- **$0.00020 per run start**
- **$0.00049 per official evidence record** delivered to the dataset ($0.49 per 1,000 records)
- **$0.00099 per ambiguous candidate evaluated with optional AI matching**

A no-match watchlist run costs only the start event. The default input can return at most 12 records and therefore costs at most about **$0.0061** with AI disabled. A 100-record run costs about **$0.0492**. The Actor respects Apify's maximum run charge and stops adding payable rows before that limit is exceeded.

The Apify Console displays the active price and maximum run charge before a paid run. Start with the default three rows per source, inspect relevance, and increase the limit only when needed. AI matching is off by default, capped at 20 candidates, and never requires users to supply an AI provider key.

### Reliability and limitations

- Public sources can change, throttle, go offline, correct records, or limit history.
- A single source failure does not discard valid results from other sources; the run summary reports partial coverage.
- If every selected source fails, the run fails rather than returning a misleading successful empty result.
- CNIL type-only rows cannot match a named watchlist entry.
- ESMA may publish anonymized subjects, which are not treated as named matches.
- SEC page structure varies, so penalty extraction remains conservative.
- Entity matching supports evidence triage, not identity resolution.
- This Actor is not a complete global enforcement database and does not provide legal, compliance, investment, or safety advice.

Always review high-impact decisions against the official URLs supplied in the dataset.

### Troubleshooting and support

- No watchlist results: use the exact disclosed legal name and widen the history window.
- No CNIL watchlist matches: run discovery mode because the English tables commonly omit entity names.
- Fewer rows than requested: open `RUN_SUMMARY` to review source coverage and spending-limit status.
- `changeType` is `unknown`: monitoring state was temporarily unavailable, but `outputMode: all` allowed evidence delivery to continue.
- AI mode fails immediately: the Actor owner must configure the provider secret; users never provide it in input.

For support, contact `contact@thescrapelab.com` and include the Apify run ID. Never send API keys or other secrets.

# Actor input Schema

## `entityQueries` (type: `array`):

Enter up to 25 exact organization or person names. Leave empty to discover the latest records from every selected source.

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

All four official sources are selected by default. FDIC failures are institution-risk signals rather than enforcement actions.

## `lookbackDays` (type: `integer`):

Include records published or effective during this period.

## `maxResultsPerSource` (type: `integer`):

Maximum dataset rows from each source. Start with 3 to preview the data cheaply.

## `outputMode` (type: `string`):

Return all matches, or only records that are new or changed since a previous run with the same configuration.

## `useAiMatching` (type: `boolean`):

Off by default and requires at least one company or person name. Exact matching always runs first; AI only reviews a small bounded set of ambiguous candidates.

## `monitoringKey` (type: `string`):

Advanced API-only override. Normally a stable namespace is derived automatically from the selected sources, names, and history window.

## `includeFeeds` (type: `boolean`):

Advanced API-only switch. Valid RSS and JSON feeds are created by default.

## Actor input object example

```json
{
  "entityQueries": [],
  "sources": [
    "sec-litigation",
    "esma-sanctions",
    "cnil-sanctions",
    "fdic-bank-failures"
  ],
  "lookbackDays": 365,
  "maxResultsPerSource": 3,
  "outputMode": "all",
  "useAiMatching": false,
  "includeFeeds": true
}
```

# Actor output Schema

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

Default dataset rows linked to their official sources.

## `resultsCsv` (type: `string`):

CSV export of the default dataset.

## `runSummary` (type: `string`):

Source status, matching counts, monitoring state, billing limits, and warnings.

## `aiEvaluations` (type: `string`):

Accepted and rejected candidate evaluations when optional AI matching is enabled.

## `rssFeed` (type: `string`):

RSS 2.0 feed of delivered records, created by default.

## `jsonFeed` (type: `string`):

JSON Feed 1.1 representation of delivered records, created by default.

# 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 = {
    "entityQueries": [],
    "sources": [
        "sec-litigation",
        "esma-sanctions",
        "cnil-sanctions",
        "fdic-bank-failures"
    ],
    "lookbackDays": 365,
    "maxResultsPerSource": 3,
    "outputMode": "all",
    "useAiMatching": false,
    "includeFeeds": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/regulatory-enforcement-search-monitor").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 = {
    "entityQueries": [],
    "sources": [
        "sec-litigation",
        "esma-sanctions",
        "cnil-sanctions",
        "fdic-bank-failures",
    ],
    "lookbackDays": 365,
    "maxResultsPerSource": 3,
    "outputMode": "all",
    "useAiMatching": False,
    "includeFeeds": True,
}

# Run the Actor and wait for it to finish
run = client.actor("thescrapelab/regulatory-enforcement-search-monitor").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 '{
  "entityQueries": [],
  "sources": [
    "sec-litigation",
    "esma-sanctions",
    "cnil-sanctions",
    "fdic-bank-failures"
  ],
  "lookbackDays": 365,
  "maxResultsPerSource": 3,
  "outputMode": "all",
  "useAiMatching": false,
  "includeFeeds": true
}' |
apify call thescrapelab/regulatory-enforcement-search-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thescrapelab/regulatory-enforcement-search-monitor"
        }
    }
}

```

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/kjKxWkLgidhQESbde/builds/kAWkTUmPBKvgR8WJg/openapi.json