# SEC Company Facts API Scraper (`automation-lab/sec-company-facts-api-scraper`) Actor

Official SEC EDGAR Company Facts API scraper that resolves tickers or CIKs and flattens XBRL facts for finance, accounting, and compliance workflows.

- **URL**: https://apify.com/automation-lab/sec-company-facts-api-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## SEC Company Facts API Scraper

Extract official SEC EDGAR Company Facts API data by ticker or CIK and turn deeply nested XBRL JSON into clean dataset rows.

This actor is built for financial analysts, fintech data teams, accounting researchers, valuation workflows, compliance teams, and data engineers who need normalized public-company fundamentals without maintaining EDGAR plumbing.

### What does SEC Company Facts API Scraper do?

SEC Company Facts API Scraper fetches official data from the SEC EDGAR Company Facts API and flattens each fact into one dataset row.

It resolves tickers such as `AAPL` or `MSFT` to SEC CIKs, downloads `companyfacts` JSON, and emits rows with taxonomy, concept, unit, value, fiscal period, filing form, accession number, and source URL.

Use it when you need repeatable exports of public-company XBRL facts for spreadsheets, BI tools, databases, dashboards, or downstream analysis.

### Who is it for?

- 📈 **Equity analysts** collecting fundamentals for coverage lists.
- 🏦 **Fintech teams** enriching company databases with official SEC data.
- 🧾 **Accounting researchers** comparing reported XBRL concepts across issuers.
- 🛡️ **Compliance teams** auditing facts back to SEC accession numbers.
- 🧑‍💻 **Data engineers** building scheduled EDGAR ingestion pipelines.
- 🎓 **Academic researchers** studying public-company reporting trends.

### Why use this actor?

- ✅ Official SEC source, not a third-party scraped copy.
- ✅ Accepts both ticker symbols and CIK numbers.
- ✅ Flattens nested XBRL facts into table-ready records.
- ✅ Supports concept, taxonomy, unit, form, fiscal-year, and filed-date filters.
- ✅ Includes accession numbers, period dates, frames, and source URLs for traceability.
- ✅ Runs without browser automation, login, cookies, or residential proxies.

### Data source

The actor uses official SEC endpoints:

- `https://www.sec.gov/files/company_tickers.json`
- `https://data.sec.gov/api/xbrl/companyfacts/CIK##########.json`

The SEC asks automated clients to identify themselves. The input includes `userAgentContact` so you can provide a descriptive contact string for your organization.

### What data can you extract?

The SEC Company Facts API includes many XBRL concepts from taxonomies such as `us-gaap` and `dei`.

Common concepts include:

- Revenues
- Assets
- Liabilities
- NetIncomeLoss
- StockholdersEquity
- EntityCommonStockSharesOutstanding
- EarningsPerShareBasic
- CashAndCashEquivalentsAtCarryingValue

Available concepts vary by issuer and filing history.

### Output data table

| Field | Description |
| --- | --- |
| `inputIdentifier` | Ticker or CIK supplied in input |
| `cik` | 10-digit SEC CIK |
| `ticker` | Resolved ticker when available |
| `entityName` | Company name from SEC |
| `taxonomy` | XBRL taxonomy, e.g. `us-gaap` |
| `concept` | XBRL concept name |
| `label` | Human-readable SEC label |
| `description` | Concept description |
| `unit` | Measurement unit, e.g. `USD` or `shares` |
| `value` | Reported fact value |
| `fiscalYear` | Fiscal year |
| `fiscalPeriod` | Fiscal period such as FY, Q1, Q2, Q3 |
| `form` | SEC form such as 10-K or 10-Q |
| `filed` | Filing date |
| `frame` | SEC frame identifier when provided |
| `accessionNumber` | SEC accession number |
| `startDate` | Reporting period start |
| `endDate` | Reporting period end |
| `sourceUrl` | SEC Company Facts API URL |
| `scrapedAt` | Extraction timestamp |

### How much does it cost to extract SEC company facts?

This actor uses pay-per-event pricing:

- A small start fee per run.
- A per-row fee for each flattened SEC company fact saved to the dataset.

You control cost with `maxFactsPerCompany` and filters such as `concepts`, `forms`, `taxonomies`, `fiscalYearFrom`, and `filedAfter`.

For a focused fundamentals run, provide specific concepts like `Revenues`, `Assets`, and `NetIncomeLoss`. For a broad export, leave concept filters empty and raise `maxFactsPerCompany`.

### Quick start

1. Open the actor on Apify.
2. Enter ticker symbols or CIKs in `identifiers`.
3. Optionally set `concepts`, `forms`, and `fiscalYearFrom`.
4. Keep `maxFactsPerCompany` reasonable for the first run.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, or through the Apify API.

### Example input

```json
{
  "identifiers": ["AAPL", "MSFT"],
  "concepts": ["Revenues", "Assets", "NetIncomeLoss"],
  "taxonomies": ["us-gaap"],
  "forms": ["10-K", "10-Q"],
  "fiscalYearFrom": 2022,
  "maxFactsPerCompany": 500
}
````

### Example output

```json
{
  "inputIdentifier": "AAPL",
  "cik": "0000320193",
  "ticker": "AAPL",
  "entityName": "Apple Inc.",
  "taxonomy": "us-gaap",
  "concept": "Revenues",
  "label": "Revenues",
  "unit": "USD",
  "value": 383285000000,
  "fiscalYear": 2023,
  "fiscalPeriod": "FY",
  "form": "10-K",
  "filed": "2023-11-03",
  "accessionNumber": "0000320193-23-000106",
  "sourceUrl": "https://data.sec.gov/api/xbrl/companyfacts/CIK0000320193.json",
  "scrapedAt": "2026-07-01T00:00:00.000Z"
}
```

### Input reference

#### `identifiers`

Ticker symbols or CIK numbers. Examples: `AAPL`, `MSFT`, `0000320193`.

#### `concepts`

Optional XBRL concept names. Leave empty to include every concept returned by SEC.

#### `taxonomies`

Optional taxonomy names. Use `us-gaap` for financial statement concepts or `dei` for document/entity facts.

#### `forms`

Optional SEC forms such as `10-K`, `10-Q`, or `8-K`.

#### `units`

Optional units such as `USD`, `shares`, or `USD/shares`.

#### `fiscalYearFrom`

Only include rows with fiscal year greater than or equal to the selected year.

#### `filedAfter`

Only include facts filed on or after a `YYYY-MM-DD` date.

#### `maxFactsPerCompany`

Maximum flattened rows emitted for each company.

#### `requestDelayMs`

Delay between SEC requests. Keep a modest delay for SEC fair access.

#### `userAgentContact`

A descriptive contact string sent to SEC in the User-Agent header.

### Tips for better results

- Start with a few companies and a few concepts.
- Use `fiscalYearFrom` to avoid very old filing history.
- Use `forms: ["10-K"]` for annual-only datasets.
- Use `forms: ["10-K", "10-Q"]` for annual and quarterly facts.
- Leave `concepts` empty only when you really need broad XBRL coverage.
- Keep your SEC User-Agent contact accurate for production workflows.

### Common analyst workflows

- Build a revenue and assets table for a watchlist.
- Pull annual 10-K facts for public SaaS companies.
- Compare `NetIncomeLoss` across fiscal years.
- Export accession-linked rows for audit trails.
- Create a normalized feed for a warehouse or lakehouse.

### Integrations

You can connect the dataset to:

- Google Sheets through Apify integrations.
- BigQuery, Snowflake, or Postgres through API exports.
- Python notebooks for valuation models.
- Node.js ETL jobs for scheduled enrichment.
- BI tools that ingest CSV or JSON.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sec-company-facts-api-scraper').call({
  identifiers: ['AAPL', 'MSFT'],
  concepts: ['Revenues', 'Assets'],
  fiscalYearFrom: 2022,
  maxFactsPerCompany: 200,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/sec-company-facts-api-scraper').call(run_input={
    'identifiers': ['AAPL', 'MSFT'],
    'concepts': ['Revenues', 'Assets'],
    'fiscalYearFrom': 2022,
    'maxFactsPerCompany': 200,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items[:5])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~sec-company-facts-api-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"identifiers":["AAPL"],"concepts":["Revenues","Assets"],"maxFactsPerCompany":100}'
```

### MCP usage

Use Apify MCP with Claude Code or Claude Desktop to run this actor from natural language.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/sec-company-facts-api-scraper
```

Claude Code setup:

```bash
claude mcp add apify-sec-company-facts https://mcp.apify.com/?tools=automation-lab/sec-company-facts-api-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-sec-company-facts": {
      "url": "https://mcp.apify.com/?tools=automation-lab/sec-company-facts-api-scraper"
    }
  }
}
```

Example prompts:

- "Run the SEC Company Facts API Scraper for AAPL and MSFT and summarize recent revenues."
- "Extract 10-K facts for NVDA since fiscal year 2021."
- "Create a CSV of Assets and NetIncomeLoss for these tickers."

### Scheduling

Schedule this actor to refresh watchlists monthly, quarterly, or after expected filing windows.

For quarterly monitoring, use ticker lists plus `forms: ["10-Q"]`. For annual fundamentals, use `forms: ["10-K"]`.

### Data quality notes

The actor returns what the SEC Company Facts API provides. Concept availability, units, frames, and periods depend on issuer filings and XBRL tagging.

Some companies use different concepts for similar metrics. For robust analysis, map concepts carefully in your downstream pipeline.

### SEC fair-access guidance

The actor is intentionally HTTP-only, sequential, and low-rate by default. It includes a User-Agent contact field because SEC systems request that automated tools identify themselves.

Avoid very large unnecessary runs. Filter concepts and years when possible.

### Troubleshooting

#### Why did my ticker fail?

The actor resolves tickers from SEC `company_tickers.json`. If a symbol is missing, try the company's CIK.

#### Why are there fewer rows than expected?

Your filters may be too narrow. Remove `concepts`, `forms`, `units`, `filedAfter`, or `fiscalYearFrom` and try again.

#### Why do values appear multiple times?

SEC facts can repeat across forms, periods, frames, amendments, and accession numbers. Use `form`, `filed`, `accessionNumber`, `startDate`, and `endDate` to choose the row you need.

### FAQ

#### Is this SEC company facts scraper using official data?

Yes. It fetches SEC EDGAR Company Facts API JSON directly from `data.sec.gov` and ticker mappings from `sec.gov`.

#### Can I scrape by ticker instead of CIK?

Yes. Enter tickers such as `AAPL` or `MSFT`; the actor resolves them to SEC CIKs before fetching facts.

#### How do I keep SEC XBRL extraction costs low?

Use concept, form, fiscal-year, and max-row filters. Start with a small `maxFactsPerCompany`, then increase it for production exports.

### Legality

This actor uses public SEC EDGAR API endpoints. You are responsible for using the data in compliance with SEC terms, fair-access policies, and applicable laws.

### Related scrapers

Explore related Automation Lab actors:

- https://apify.com/automation-lab/company-website-scraper
- https://apify.com/automation-lab/website-contact-finder
- https://apify.com/automation-lab/google-search-results-scraper

### Changelog

#### 0.1

- Initial version.
- Ticker/CIK input.
- Official SEC Company Facts fetch.
- XBRL fact flattening.
- Concept, taxonomy, form, unit, filed-date, and fiscal-year filters.

# Actor input Schema

## `identifiers` (type: `array`):

Public-company ticker symbols or SEC CIK numbers. Examples: AAPL, MSFT, 0000320193.

## `concepts` (type: `array`):

Optional XBRL concept filters, for example Revenues, Assets, NetIncomeLoss. Leave empty for all concepts.

## `taxonomies` (type: `array`):

Optional taxonomy filters such as us-gaap or dei. Leave empty for all taxonomies.

## `forms` (type: `array`):

Optional form filters such as 10-K, 10-Q, 8-K. Leave empty for all forms.

## `units` (type: `array`):

Optional unit filters such as USD, shares, USD/shares. Leave empty for all units.

## `fiscalYearFrom` (type: `integer`):

Only include facts with fiscal year greater than or equal to this year.

## `filedAfter` (type: `string`):

Only include facts filed on or after this YYYY-MM-DD date.

## `maxFactsPerCompany` (type: `integer`):

Maximum flattened fact rows to emit for each company.

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

Delay between SEC API requests. Keep non-zero to be courteous to SEC EDGAR.

## `userAgentContact` (type: `string`):

Descriptive User-Agent/contact string sent to SEC, as requested by SEC fair-access guidance.

## Actor input object example

```json
{
  "identifiers": [
    "AAPL",
    "MSFT"
  ],
  "concepts": [
    "Revenues",
    "Assets",
    "NetIncomeLoss"
  ],
  "taxonomies": [
    "us-gaap"
  ],
  "forms": [
    "10-K",
    "10-Q"
  ],
  "fiscalYearFrom": 2022,
  "filedAfter": "2022-01-01",
  "maxFactsPerCompany": 20,
  "requestDelayMs": 200,
  "userAgentContact": "automation-lab-sec-company-facts-api-scraper contact@automation-lab.com"
}
```

# Actor output Schema

## `overview` (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 = {
    "identifiers": [
        "AAPL",
        "MSFT"
    ],
    "concepts": [
        "Revenues",
        "Assets",
        "NetIncomeLoss"
    ],
    "taxonomies": [
        "us-gaap"
    ],
    "forms": [
        "10-K",
        "10-Q"
    ],
    "fiscalYearFrom": 2022,
    "filedAfter": "2022-01-01",
    "maxFactsPerCompany": 20,
    "requestDelayMs": 200,
    "userAgentContact": "automation-lab-sec-company-facts-api-scraper contact@automation-lab.com"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-company-facts-api-scraper").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 = {
    "identifiers": [
        "AAPL",
        "MSFT",
    ],
    "concepts": [
        "Revenues",
        "Assets",
        "NetIncomeLoss",
    ],
    "taxonomies": ["us-gaap"],
    "forms": [
        "10-K",
        "10-Q",
    ],
    "fiscalYearFrom": 2022,
    "filedAfter": "2022-01-01",
    "maxFactsPerCompany": 20,
    "requestDelayMs": 200,
    "userAgentContact": "automation-lab-sec-company-facts-api-scraper contact@automation-lab.com",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-company-facts-api-scraper").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 '{
  "identifiers": [
    "AAPL",
    "MSFT"
  ],
  "concepts": [
    "Revenues",
    "Assets",
    "NetIncomeLoss"
  ],
  "taxonomies": [
    "us-gaap"
  ],
  "forms": [
    "10-K",
    "10-Q"
  ],
  "fiscalYearFrom": 2022,
  "filedAfter": "2022-01-01",
  "maxFactsPerCompany": 20,
  "requestDelayMs": 200,
  "userAgentContact": "automation-lab-sec-company-facts-api-scraper contact@automation-lab.com"
}' |
apify call automation-lab/sec-company-facts-api-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/sec-company-facts-api-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Company Facts API Scraper",
        "description": "Official SEC EDGAR Company Facts API scraper that resolves tickers or CIKs and flattens XBRL facts for finance, accounting, and compliance workflows.",
        "version": "0.1",
        "x-build-id": "yqUD4PaUtmdTmh06y"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-company-facts-api-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-company-facts-api-scraper",
                "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/automation-lab~sec-company-facts-api-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-company-facts-api-scraper",
                "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/automation-lab~sec-company-facts-api-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-company-facts-api-scraper",
                "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",
                "required": [
                    "identifiers"
                ],
                "properties": {
                    "identifiers": {
                        "title": "Tickers or CIKs",
                        "minItems": 1,
                        "type": "array",
                        "description": "Public-company ticker symbols or SEC CIK numbers. Examples: AAPL, MSFT, 0000320193.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "concepts": {
                        "title": "Concept names",
                        "type": "array",
                        "description": "Optional XBRL concept filters, for example Revenues, Assets, NetIncomeLoss. Leave empty for all concepts.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "taxonomies": {
                        "title": "Taxonomies",
                        "type": "array",
                        "description": "Optional taxonomy filters such as us-gaap or dei. Leave empty for all taxonomies.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "forms": {
                        "title": "SEC forms",
                        "type": "array",
                        "description": "Optional form filters such as 10-K, 10-Q, 8-K. Leave empty for all forms.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "units": {
                        "title": "Units",
                        "type": "array",
                        "description": "Optional unit filters such as USD, shares, USD/shares. Leave empty for all units.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fiscalYearFrom": {
                        "title": "Fiscal year from",
                        "minimum": 1990,
                        "maximum": 2100,
                        "type": "integer",
                        "description": "Only include facts with fiscal year greater than or equal to this year."
                    },
                    "filedAfter": {
                        "title": "Filed after date",
                        "type": "string",
                        "description": "Only include facts filed on or after this YYYY-MM-DD date."
                    },
                    "maxFactsPerCompany": {
                        "title": "Maximum facts per company",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Maximum flattened fact rows to emit for each company.",
                        "default": 20
                    },
                    "requestDelayMs": {
                        "title": "Request delay (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Delay between SEC API requests. Keep non-zero to be courteous to SEC EDGAR.",
                        "default": 200
                    },
                    "userAgentContact": {
                        "title": "SEC User-Agent contact",
                        "type": "string",
                        "description": "Descriptive User-Agent/contact string sent to SEC, as requested by SEC fair-access guidance."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
