# Regulatory Change Monitor (`constant_quadruped/regulatory-change-monitor`) Actor

Real-time monitoring of SEC, CFTC, FINRA & Federal Register changes for compliance teams and AI agents. Clean, RAG-ready structured output: what changed, who it affects, action required.

- **URL**: https://apify.com/constant\_quadruped/regulatory-change-monitor.md
- **Developed by:** [CQ](https://apify.com/constant_quadruped) (community)
- **Categories:** AI, Agents, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Feed Monitor (Federal Register + SEC)

Scheduled monitoring of the **U.S. Federal Register** (any agency, by slug) plus **SEC press-release & litigation RSS** — and any other RSS/Atom feed you add — for compliance teams and AI agents. It finds **newly published** rules, notices, and releases matching your agencies + keywords and emits **clean, structured, RAG-ready records**.

Built by a branch compliance manager to cut down the manual work of watching for newly published regulatory items. (Tracks **new items**, not edits to existing documents — see Limitations.)

### What it actually does
- Queries the **Federal Register JSON API** (free, official, keyless) filtered by the agency slugs and keywords you provide.
- Parses any **RSS/Atom feeds** you list. **Defaults: two SEC feeds** (press releases + litigation releases).
- Flags **items it hasn't seen before** across runs (ID-based), so a scheduled run emits only new entries.
- Adds a lightweight **inferred compliance area** and a one-line **suggested action** to each item.

### What you get (per item)
| field | meaning |
|---|---|
| `title`, `summary`, `url` | the document (summary = Federal Register abstract or RSS summary) |
| `source`, `agency`, `type` | Federal Register or the RSS feed title, and document type |
| `published_date`, `retrieved_at` | timing |
| `keywords_matched` | which of your terms appeared in the title/abstract |
| `affected_area` | a **keyword-heuristic** guess (Reg BI, AML, Reg S-P, Advertising, Custody…); often "General / uncategorized" |
| `action_required` | a one-line heuristic prompt (update WSPs / review / watch enforcement) based on document type |
| `markdown` | included only when `outputFormat: "markdown"` |

### Input
- **agencies** — Federal Register agency *slugs* (default: `securities-and-exchange-commission`, `commodity-futures-trading-commission`). To cover CFPB, FinCEN, CFTC, etc., add their Federal Register slugs and/or their RSS feeds.
- **keywords** — filter to matching items. Federal Register results are filtered server-side by full-text term search (one query per keyword); RSS items are kept only if a keyword appears as a substring of the title/summary. Leave empty to get everything from the selected agencies/feeds.
- **daysBack** — Federal Register lookback window (default 7).
- **rssFeeds** — extra feeds (SEC/FINRA/state). Defaults to two SEC feeds.
- **onlyNew** — remember IDs across runs and emit only unseen items (default true).
- **outputFormat** — `structured` (default) or `markdown`.

### Use it as a scheduled monitor
Set an Apify **Schedule** (e.g., daily) with `onlyNew: true`. Each run pushes only newly seen items to the dataset — pipe that into Slack, email, a list, or a RAG knowledge base.

### Limitations — read this
- **Not real-time.** It polls on each run; it does not stream or push. Freshness = your schedule + the Federal Register's own publishing lag.
- **New-item detection only, not content-change detection.** Tracking is by document ID. If a document is revised but keeps its ID/number, it will **not** be re-flagged. "Change" here means "new item since last run."
- **No built-in CFPB / FinCEN / CFTC connectors.** Those are reachable only if they publish in the Federal Register (add the slug) or you supply their RSS feed. Only the Federal Register and your RSS feeds are queried.
- **`affected_area` and `action_required` are simple keyword / document-type heuristics**, not legal analysis. They miss often and can mislabel. Treat them as triage hints.
- **Keyword matching is literal** (case-insensitive) — no synonyms or semantic search. For RSS it is substring matching on title/summary; for the Federal Register it is the API's own full-text term search, so the `keywords_matched` field (which only checks the title/abstract substring) can be empty even on a returned item that matched on body text.
- **RSS coverage depends on the feed.** Default SEC feeds may change or rate-limit; verify feeds for your use.
- Not legal or compliance advice.

### Sources
- Federal Register API: https://www.federalregister.gov/developers/documentation/api/v1
- SEC press releases & litigation releases RSS (default feeds; configurable).

# Actor input Schema

## `agencies` (type: `array`):

Agency slugs to monitor on the Federal Register (free official API). Examples: securities-and-exchange-commission, commodity-futures-trading-commission, consumer-financial-protection-bureau, financial-crimes-enforcement-network.
## `keywords` (type: `array`):

Only emit items matching these terms (case-insensitive). Leave empty to get everything from the selected agencies.
## `daysBack` (type: `integer`):

Look back this many days for new/updated documents.
## `rssFeeds` (type: `array`):

Additional regulatory RSS/Atom feeds to fold in (press releases, litigation, notices).
## `onlyNew` (type: `boolean`):

Remember items across runs (in the Actor key-value store) and only emit ones not seen before — ideal for a scheduled monitor.
## `outputFormat` (type: `string`):

structured = clean JSON fields; markdown = also add a ready-to-ingest markdown field for RAG/LLM pipelines.

## Actor input object example

```json
{
  "agencies": [
    "securities-and-exchange-commission",
    "commodity-futures-trading-commission"
  ],
  "keywords": [
    "regulation best interest",
    "rollover",
    "cybersecurity",
    "marketing",
    "custody",
    "anti-money laundering"
  ],
  "daysBack": 7,
  "rssFeeds": [
    "https://www.sec.gov/news/pressreleases.rss",
    "https://www.sec.gov/rss/litigation/litreleases.xml"
  ],
  "onlyNew": true,
  "outputFormat": "structured"
}
````

# Actor output Schema

## `regulatoryItems` (type: `string`):

Dataset of new/changed regulatory items matching the configured agencies and keywords.

# 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 = {
    "agencies": [
        "securities-and-exchange-commission",
        "commodity-futures-trading-commission"
    ],
    "keywords": [
        "regulation best interest",
        "rollover",
        "cybersecurity",
        "marketing",
        "custody",
        "anti-money laundering"
    ],
    "rssFeeds": [
        "https://www.sec.gov/news/pressreleases.rss",
        "https://www.sec.gov/rss/litigation/litreleases.xml"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("constant_quadruped/regulatory-change-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 = {
    "agencies": [
        "securities-and-exchange-commission",
        "commodity-futures-trading-commission",
    ],
    "keywords": [
        "regulation best interest",
        "rollover",
        "cybersecurity",
        "marketing",
        "custody",
        "anti-money laundering",
    ],
    "rssFeeds": [
        "https://www.sec.gov/news/pressreleases.rss",
        "https://www.sec.gov/rss/litigation/litreleases.xml",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("constant_quadruped/regulatory-change-monitor").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "agencies": [
    "securities-and-exchange-commission",
    "commodity-futures-trading-commission"
  ],
  "keywords": [
    "regulation best interest",
    "rollover",
    "cybersecurity",
    "marketing",
    "custody",
    "anti-money laundering"
  ],
  "rssFeeds": [
    "https://www.sec.gov/news/pressreleases.rss",
    "https://www.sec.gov/rss/litigation/litreleases.xml"
  ]
}' |
apify call constant_quadruped/regulatory-change-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=constant_quadruped/regulatory-change-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Regulatory Change Monitor",
        "description": "Real-time monitoring of SEC, CFTC, FINRA & Federal Register changes for compliance teams and AI agents. Clean, RAG-ready structured output: what changed, who it affects, action required.",
        "version": "1.0",
        "x-build-id": "YEISA1i3olQaaPs16"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/constant_quadruped~regulatory-change-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-constant_quadruped-regulatory-change-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/constant_quadruped~regulatory-change-monitor/runs": {
            "post": {
                "operationId": "runs-sync-constant_quadruped-regulatory-change-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/constant_quadruped~regulatory-change-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-constant_quadruped-regulatory-change-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "agencies": {
                        "title": "Federal Register agencies",
                        "type": "array",
                        "description": "Agency slugs to monitor on the Federal Register (free official API). Examples: securities-and-exchange-commission, commodity-futures-trading-commission, consumer-financial-protection-bureau, financial-crimes-enforcement-network.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Keywords / topics",
                        "type": "array",
                        "description": "Only emit items matching these terms (case-insensitive). Leave empty to get everything from the selected agencies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Look back this many days for new/updated documents.",
                        "default": 7
                    },
                    "rssFeeds": {
                        "title": "Extra RSS feeds (SEC/FINRA/state)",
                        "type": "array",
                        "description": "Additional regulatory RSS/Atom feeds to fold in (press releases, litigation, notices).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "onlyNew": {
                        "title": "Only emit NEW items",
                        "type": "boolean",
                        "description": "Remember items across runs (in the Actor key-value store) and only emit ones not seen before — ideal for a scheduled monitor.",
                        "default": true
                    },
                    "outputFormat": {
                        "title": "Output format",
                        "enum": [
                            "structured",
                            "markdown"
                        ],
                        "type": "string",
                        "description": "structured = clean JSON fields; markdown = also add a ready-to-ingest markdown field for RAG/LLM pipelines.",
                        "default": "structured"
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```