# EDGAR Diligence Report — Per-Issuer SEC Filing Brief (`nexgenwatch/edgar-diligence-report`) Actor

Per-issuer SEC/EDGAR diligence in one run — material 8-K events, filing history, and risk factors as structured findings plus a rendered markdown brief.

- **URL**: https://apify.com/nexgenwatch/edgar-diligence-report.md
- **Developed by:** [NexGen Watch](https://apify.com/nexgenwatch) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $16,750.00 / 1,000 diligence reports

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## EDGAR Diligence Report — Per-Issuer SEC Filing Brief

SEC filings are public but scattered across EDGAR. Investors, corporate-development, and compliance teams pay for the *brief*: one issuer, one run, the material events and filing history assembled into a diligence report they can read in minutes.

### What you get

- A per-issuer diligence report record with a rendered markdown brief (also written to the key-value store)
- Structured findings: an issuer profile, every in-window filing, material 8-K events by item code, and an optional risk-factor summary
- Every finding carries the SEC accession number and document URL, so each claim links back to its primary EDGAR source
- Report highlights: form counts, the latest 10-K / 10-Q / 8-K, and the high-signal 8-K events (results, leadership changes, and more)
- Deterministic assembly (ngd-diligence-v1): the same issuer and window produce the same brief every run

### Use cases by team

- **Investors / analysts:** Get a fast, sourced read on an issuer's recent filings before a call or memo.
- **Corporate development / M\&A:** Pull a target's material events and filing history into one diligence brief.
- **Compliance / legal:** Track an issuer's periodic and 8-K filings with accession IDs preserved for the record.
- **Data teams:** Feed structured, deterministic findings into a pipeline without scraping EDGAR yourself.

### Example inputs

*Diligence brief by ticker*

```json
{
  "company": "AAPL",
  "lookbackDays": 365,
  "includeRiskFactors": true
}
```

*Material events only, shorter window*

```json
{
  "company": "MSFT",
  "lookbackDays": 180,
  "formTypes": [
    "8-K"
  ],
  "maxFilings": 100
}
```

*Bounded findings for a large filer*

```json
{
  "company": "Tesla",
  "lookbackDays": 365,
  "maxFindings": 200
}
```

### 📊 Sample Output

```json
{
  "record_type": "diligence_report",
  "issuer_name": "Apple Inc.",
  "cik": "320193",
  "tickers": [
    "AAPL"
  ],
  "window": {
    "lookback_days": 365,
    "start_date": "2025-07-23",
    "end_date": "2026-07-23",
    "filings_in_window": 82
  },
  "finding_count": 98,
  "material_event_count": 14,
  "high_signal_event_count": 8,
  "form_counts": {
    "8-K": 9,
    "10-Q": 3,
    "10-K": 1,
    "4": 42,
    "SCHEDULE 13G": 1
  },
  "latest_10k": {
    "filed_date": "2025-10-31",
    "accession_number": "0000320193-25-000079"
  },
  "high_signal_events": [
    {
      "item_code": "2.02",
      "event": "Results of Operations and Financial Condition",
      "filed_date": "2026-04-30"
    },
    {
      "item_code": "5.02",
      "event": "Departure/Appointment of Directors or Certain Officers",
      "filed_date": "2026-04-20"
    }
  ],
  "report_kv_key": "DILIGENCE_REPORT_181617d3ab0da4846c5f",
  "method": "ngd-diligence-v1"
}
```

### How it works

Give it an issuer by ticker, name, or CIK. It resolves the CIK against SEC's official company\_tickers map, pulls the submission history from data.sec.gov, and scans the filings in your window from the EDGAR archives. It classifies each filing, extracts material 8-K events by item code, optionally summarizes the latest risk factors, and assembles everything into one diligence report — structured records plus a rendered markdown brief. Assembly is deterministic (`ngd-diligence-v1`), **not an LLM**: the same issuer and window produce the same brief every run.

### Pricing

| Event | FREE | BRONZE | SILVER | GOLD+ |
|---|---|---|---|---|
| Actor Start (`apify-actor-start`) | $0.05 | $0.05 | $0.05 | $0.05 |
| Diligence report (`diligence_report`) | $25.00 | $22.50 | $20.00 | $16.75 |

Prices are the filed pay-per-event amounts per plan tier (PLATINUM/DIAMOND match GOLD). Blocked and refused runs do not intentionally charge value events.

### Run it — API, CLI, MCP

API:

```bash
curl -X POST "https://api.apify.com/v2/acts/nexgenwatch~edgar-diligence-report/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" -d @input.json
```

CLI:

```bash
apify call nexgenwatch/edgar-diligence-report -i @input.json
```

MCP: expose `nexgenwatch/edgar-diligence-report` through Apify's MCP server, select it as a tool, and pass the same input object.

### Related actors — App Intelligence cluster

*Sibling actors are being published — check back shortly.*

### Compliance & honest limits

- Public, logged-out SEC EDGAR only (data.sec.gov, www.sec.gov). No login, no paywall, no private data.
- Records-and-filings framing only. This is a diligence brief, not investment advice, and it never infers undisclosed transactions.
- Bounded windows: lookbackDays, maxFilings, and maxFindings cap every run so it stays fast and predictable.
- An issuer with zero filings in your window still returns a valid, delivered report (GENUINE\_EMPTY) and is charged — the answer 'nothing filed' is the product.
- SEC fair-access requires a descriptive User-Agent with a real contact; the actor supplies a default and you can override it with secUserAgent.
- Accession numbers and document URLs are preserved on every finding so each claim links to the primary EDGAR source.

### FAQ

**What exactly do I get per run?**

One diligence\_report (structured, plus a rendered markdown brief in the key-value store) and diligence\_finding records for the issuer profile, each in-window filing, material 8-K events, and an optional risk-factor summary.

**How do I identify the issuer?**

Pass a ticker (AAPL), a company name, or a CIK in `company`; the actor resolves it against SEC's official company\_tickers map.

**Is this AI / does it use an LLM?**

No. Assembly is deterministic (ngd-diligence-v1): the same issuer and window produce the same brief every time. No LLM, no bring-your-own-key, no 'AI' claims.

**What are 'material events'?**

8-K item codes and their plain-English meaning (for example 2.02 results of operations, 5.02 director/officer changes), each with the filed date and accession number.

**How current is it?**

As current as EDGAR. The report stamps the exact window and lists the latest 10-K, 10-Q, and 8-K it found.

**What does it cost?**

$0.05 to start a run plus $25.00 per delivered report (less at higher tiers). A failed run charges nothing.

**Can I run it on a schedule or via MCP?**

Yes — API, CLI, and Apify MCP are all supported; pass the same input object.

### Troubleshooting

- **Run failed with INPUT\_LAW:** the SEC User-Agent was missing or invalid — set `secUserAgent` to a descriptive value with a real contact.
- **Issuer not found:** check the ticker or CIK, or try the full company name — resolution uses SEC's official ticker map.
- **Few findings returned:** widen `lookbackDays` or raise `maxFilings` / `maxFindings`; large filers hit the caps quickly.
- **Empty report:** the issuer had no filings in your window — that's a valid, delivered answer, not an error.
- **Run is slow:** lower `maxFilings` or narrow `formTypes` (for example \["8-K"]) to bound the scan.

### About

EDGAR Diligence Report turns SEC's public filing record into a per-issuer diligence brief you can read in minutes, with every finding linked to its primary EDGAR source. Built by NexGenData. Questions or need a custom feed? Open an issue on the Actor page.

# Actor input Schema

## `company` (type: `string`):

The issuer to diligence: a stock ticker (e.g. AAPL, MSFT) OR an SEC CIK (e.g. 320193 or CIK0000320193). Tickers are resolved against SEC's public company\_tickers map.

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

Cap 1: how many days back from today to include the issuer's filings in the diligence timeline.

## `formTypes` (type: `array`):

Exact SEC form types to keep (e.g. '10-K', '10-Q', '8-K', 'S-1', 'D', 'SC 13D', 'DEF 14A'). Empty keeps all filed form types in the window.

## `includeRiskFactors` (type: `boolean`):

When on, best-effort fetch of the latest in-window 10-K's primary document to extract a bounded Item 1A (Risk Factors) excerpt. A fetch/extract miss is non-fatal (the report is still delivered).

## `maxFilings` (type: `integer`):

Cap 2: maximum filings (most-recent first, within the lookback window) assembled into the digest this run.

## `maxFindings` (type: `integer`):

Cap 3: maximum diligence\_finding records returned in the report (issuer profile, filings, material events, risk-factor summary).

## `secUserAgent` (type: `string`):

Descriptive User-Agent with a real contact, e.g. 'YourCo Diligence/1.0 you@example.org'. Required by SEC fair-access. Falls back to the SEC\_USER\_AGENT env var, then a NexGenData default.

## Actor input object example

```json
{
  "company": "AAPL",
  "lookbackDays": 365,
  "formTypes": [],
  "includeRiskFactors": true,
  "maxFilings": 250,
  "maxFindings": 300
}
```

# 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 = {
    "company": "AAPL",
    "lookbackDays": 365,
    "maxFilings": 250,
    "maxFindings": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgenwatch/edgar-diligence-report").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 = {
    "company": "AAPL",
    "lookbackDays": 365,
    "maxFilings": 250,
    "maxFindings": 300,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgenwatch/edgar-diligence-report").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 '{
  "company": "AAPL",
  "lookbackDays": 365,
  "maxFilings": 250,
  "maxFindings": 300
}' |
apify call nexgenwatch/edgar-diligence-report --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nexgenwatch/edgar-diligence-report"
        }
    }
}

```

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/PjqEms5Fw7Ny5Eowa/builds/jokf6OGOt9NVibtex/openapi.json