# SEC EDGAR Exhibit Index Extractor (`apex-nexus/sec-edgar-exhibit-index`) Actor

Normalized exhibit table for one SEC filing (CIK or accession number): one row per exhibit with filing metadata, form, filing date, exhibit number, description and document URL, plus a summary row with the total exhibit count. Public SEC data only; no credentials, proxies or LLMs.

- **URL**: https://apify.com/apex-nexus/sec-edgar-exhibit-index.md
- **Developed by:** [Valunex](https://apify.com/apex-nexus) (community)
- **Categories:** Business
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 exhibits

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## SEC EDGAR Exhibit Index Extractor — material contracts & exhibits lookup

**Apify Actor:** `apex-nexus~sec-edgar-exhibit-index` (Actor id `muoyK1mdp1NdqwWOy`, account `apex-nexus`, owner userId `cgh1CqgRIRsjx7PlQ`)
**Store page:** https://apify.com/apex-nexus/sec-edgar-exhibit-index — public, isPublic = true, notice = NONE, categories \[BUSINESS], PUBLIC on the Apify Store since 2026-11-05T02:16 CET.
Live metadata (read-only `GET /v2/actors/muoyK1mdp1NdqwWOy`, no flip): isPublic=true, categories \[BUSINESS], seoTitle "SEC EDGAR Exhibit Index Extractor", seoDescription set, exampleRunInput `{"cikOrAccession":"0000320193-24-000123"}` (real accession example, not a placeholder). Effective pricing record: PAY_PER_EVENT — $0.0001 per Actor Start + $0.005 per exhibit row (primary event, 20% Apify margin); the single `pricingInfos` record; free when nothing is returned.
**Pricing:** PAY_PER_EVENT — $0.0001 per Actor Start + $0.005 per exhibit row written to the dataset (primary event, 20% Apify margin). Free when nothing to return: a filing with no exhibits finishes with a summary row `{ "exhibitCount": 0 }` and only the $0.0001 start event is charged.
**Kind:** A — extractor/convert tool on public data (bring your own identifier). Explicitly NOT a change tracker: no watchlist state, no delta alerts, no state between runs, no scheduled monitoring.
**Actor source:** `actor/` (`main.py`, `README.md`, `requirements.txt`, `Dockerfile`, `tests/`, `tools/`) + `actor/.actor/` (`actor.json`, `input-schema.json`, `output_schema.json`, `dataset_schema.json`)
**Competitor comparison:** `knowledge/competitor-comparison-sec-edgar-exhibit-index.md` (5 Apify Store competitors, pricing, README structure, example inputs)
**Buyer-demand record:** `knowledge/n8-sec-edgar-exhibit-index-demand.md`

### What it does

Give the Actor a single SEC identifier and it returns a normalized exhibit table from the public EDGAR filing index — one row per exhibit, ready to copy into a spreadsheet or CSV:

```json
{ "cik", "accession", "form", "filingDate", "exhibitNumber", "description", "documentUrl" }
```

plus a summary count row (`{ ..., "exhibitCount": N }`, exhibit fields `null` on the summary row). Law firms, M\&A professionals, compliance desks, and research analysts use it to pull an exhibit inventory (material contracts, agreements, subsidiary lists, consents, …) from an EDGAR filing without opening every EDGAR index page by hand.

### 30-second quickstart

Open https://apify.com/apex-nexus/sec-edgar-exhibit-index on the Apify Store, paste this into the input editor and run (or `POST /v2/actors/muoyK1mdp1NdqwWOy/runs` with the same body):

```json
{ "cikOrAccession": "0000320193-24-000123" }
```

`cikOrAccession` (required): a SEC CIK (up to 10 digits, e.g. `320193` for Apple) or an accession number (e.g. `0000320193-24-000123`). With a CIK, the most recent filing in the feed that lists exhibits is used; if the latest filing has none, the Actor falls back through recent filings. Default input = Apple's 10-K accession `0000320193-24-000123`. Typical default run finishes in seconds.

### Example input → output pairs

All three pairs below were run on the live Actor against public SEC EDGAR data. Output shown is the **first dataset item**; each run also ends with a summary row `{ ..., "exhibitCount": N }`.

#### Pair 1 — default run: Apple 10-K accession `0000320193-24-000123` (FY2024, filed 2024-11-01)

Input:

```json
{ "cikOrAccession": "0000320193-24-000123" }
```

Output (first of 12 exhibit rows; run `k3MJauKDiWlPrvE5y`, SUCCEEDED):

```json
{
  "cik": "0000320193",
  "accession": "0000320193-24-000123",
  "form": "10-K",
  "filingDate": "2024-11-01",
  "exhibitNumber": "4.1",
  "description": "EX-4.1",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/a10-kexhibit4109282024.htm"
}
```

Summary row: `{ "exhibitCount": 12 }`.

#### Pair 2 — Apple latest 10-K accession `0000320193-26-000026` (filed 2026-11-03)

Input:

```json
{ "cikOrAccession": "0000320193-26-000026" }
```

Output (first of N exhibit rows; run `8EYdQRWq0Q84XA8Kq`, SUCCEEDED):

```json
{
  "cik": "0000320193",
  "accession": "0000320193-26-000026",
  "form": "10-K",
  "filingDate": "2026-11-03",
  "exhibitNumber": "4.1",
  "description": "EX-4.1",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019326000026/a10-kexhibit4109262026.htm"
}
```

#### Pair 3 — Apple FY2025 10-K accession `0000320193-25-000079` (filed 2025-10-31): subsidiaries + consents

Input:

```json
{ "cikOrAccession": "0000320193-25-000079" }
```

Output (first of 3 items; SUCCEEDED):

```json
{
  "cik": "0000320193",
  "accession": "0000320193-25-000079",
  "form": "10-K",
  "filingDate": "2025-10-31",
  "exhibitNumber": "4.1",
  "description": "EX-4.1",
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019325000079/a10-kexhibit4109272025.htm"
}
```

That filing's exhibit table also includes `21.1` (subsidiaries) and `23.1` (consents) — the Exhibit 21 subsidiary list and Exhibit 23 consents are the rows M\&A diligence typically wants.

### Input

```json
{ "cikOrAccession": "0000320193-24-000123" }
```

- `cikOrAccession` (required): a SEC CIK (up to 10 digits, e.g. `320193`) or an accession number (e.g. `0000320193-24-000123`). With a CIK, the most recent filing in the feed that lists exhibits is used; if the latest filing has none, the Actor falls back through recent filings.

See `actor/.actor/input-schema.json` for the full tool-friendly schema (title, description, default).

### Output — one dataset row per exhibit

| Field | Type | Description |
|-------|------|-------------|
| `cik` | string | SEC CIK (10 digits) |
| `accession` | string | SEC accession number |
| `form` | string | SEC form type (e.g. `10-K`, `8-K`) |
| `filingDate` | string | Date filed with EDGAR (YYYY-MM-DD) |
| `exhibitNumber` | string|null | Exhibit number as published (e.g. `10.19`) |
| `description` | string|null | Exhibit description (e.g. `EX-10.19`) |
| `documentUrl` | string (uri)|null | Direct public SEC Archives URL of the exhibit document |

The last item of every run is a summary row `{ "cik": ..., "accession": ..., "form": ..., "filingDate": ..., "exhibitNumber": null, "description": null, "documentUrl": null, "exhibitCount": N }`. See `actor/.actor/output_schema.json` and `actor/.actor/dataset_schema.json`.

### Sources (read-only, public US government data, no API key)

- CIK → recent filings: `https://data.sec.gov/submissions/CIK{CIK}.json`
- EDGAR filing index: `https://www.sec.gov/Archives/edgar/data/{CIK}/{accessionDigits}/{accession}-index.htm`

No credentials, no proxies, no LLMs, no commercial inference, no scraping of non-public content. Deterministic HTML table parsing only.

### Limits & behavior

- One filing per run. Default input = Apple 10-K accession `0000320193-24-000123`.
- Free when nothing to return (no exhibits found → summary row with `exhibitCount: 0`; only the $0.0001 Actor Start event charged).
- Explicitly NOT a change tracker: no watchlist state, no delta alerts, no state between runs, no scheduled monitoring.
- Invalid or unresolvable input finishes with an empty dataset rather than crashing.

### Build & test

```bash
cd products/sec-edgar-exhibit-index/actor
python3 -m pytest tests/          # unit tests against a captured index page
python3 tools/smoke_test.py       # live smoke test against real SEC data
```

### Pricing & positioning vs Store competitors

Competitor scan (Apify Store, 5 closest SEC exhibit/filing-document listings; plus earlier incumbent scouting from `knowledge/n8-sec-edgar-exhibit-index-demand.md`):

| Competitor | Pricing | Users/30d | Example input | Notes |
|---|---|---|---|---|
| taroyamada/sec-material-contract-intelligence | PPE $0.001/start + $0.008/item | 1 | real (tickers/ciks/accessions/date range) | 398 total runs; material-contract angle |
| spotless_studios/sec-edgar-filings-scraper | PPE $0.00005/start | 1 | real (`searchQuery` + forms) | 3 total runs |
| bb-tradetec/sec-filing-document-manifest | PPE $0.0004/start + $0.00005/item | 1 | real (accession query) | 85 total runs; document manifest job |
| corent1robert/sec-edgar-licensing-deals-scraper | PPE (start not listed) | 0 | placeholder | 90 total runs |
| seaf999ield/biopharma-sec-event-stream | PPE (start not listed) | 1 | placeholder | 14 total runs |
| Earlier incumbents (demand record) | $0.001–$5.00 per 1,000 filings or $0.04/run | ≤3 | — | george.the.developer, datamule, johnveds15, constructive_calm |

**Our position:** $0.0001/start + $0.005 per exhibit row — cheapest per-exhibit row among item-priced competitors ($0.005 vs $0.008 at taroyamada), and none of the 5 is a dedicated exhibit-index-to-table converter; general filing scrapers return filing metadata, not exhibit inventories. Free when nothing is returned.

**Pricing decision:** keep current effective pricing — no price change without an owner/KYC step (POLICY #5/#6). Pricing/publication flips remain separate scheduled director tasks (Apify cap: 5 publications per rolling 24h).

### Quality gate (POLICY #6, verified live)

Default run (input `{"cikOrAccession":"0000320193-24-000123"}`): run `k3MJauKDiWlPrvE5y`, status SUCCEEDED, exhibit rows returned within seconds (< 1 min ✓, ≥ 1 item ✓). Re-verified: accession `0000320193-26-000026` (SUCCEEDED, exhibit rows) and `0000320193-25-000079` (SUCCEEDED, incl. EX-21.1 subsidiaries / EX-23.1 consents).

### Claims statement

All claims in this README are limited to what the product verifiably does: it reads a public SEC EDGAR filing index (by CIK or accession number) and returns a normalized exhibit table — one row per exhibit with filing metadata, exhibit number, description and direct document URL — plus a summary count row. This README contains no revenue, user, or adoption claims, because none are verified. Current official readings (2026-11-05 CET): totalRuns=2, totalUsers30Days=1, bookmarkCount=0, actorReviewCount=0; every observed run carries owner userId `cgh1CqgRIRsjx7PlQ` — 0 buyer runs, $0 verified revenue (see `knowledge/portfolio.md`).

# Changelog

This Actor's version history is a separate document: https://apify.com/apex-nexus/sec-edgar-exhibit-index/changelog.md

# Actor input Schema

## `cikOrAccession` (type: `string`):

CIK (up to 10 digits, e.g. 320193) or accession number (e.g. 0000320193-24-000123) of the EDGAR filing whose exhibit index you want extracted. With a CIK, the most recent filing in the feed is used.

## Actor input object example

```json
{
  "cikOrAccession": "0000320193-24-000123"
}
```

# Actor output Schema

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

All exhibit rows emitted by the Actor run (one row per exhibit, plus a summary count row).

# 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("apex-nexus/sec-edgar-exhibit-index").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("apex-nexus/sec-edgar-exhibit-index").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 apex-nexus/sec-edgar-exhibit-index --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apex-nexus/sec-edgar-exhibit-index"
        }
    }
}
```

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/muoyK1mdp1NdqwWOy/builds/ebCOkgUdnKCjKdxdA/openapi.json