# SEC Schedule 13G Passive Ownership Scraper (`automation-lab/sec-schedule-13g-passive-ownership-scraper`) Actor

📊 Extract normalized passive beneficial-ownership holders, positions, voting powers, amendments, and source links from public SEC Schedule 13G filings.

- **URL**: https://apify.com/automation-lab/sec-schedule-13g-passive-ownership-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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Schedule 13G Passive Ownership Scraper

Extract normalized passive beneficial-ownership positions from public SEC EDGAR **Schedule 13G and 13G/A** filings.

Turn filing XML and submission documents into analysis-ready JSON with issuer identifiers, CUSIPs, reporting persons, ownership percentages, share counts, voting powers, comments, signatures, and canonical source links.

- 🏦 Monitor passive holders crossing or amending significant ownership positions
- 📊 Build quarterly ownership histories without manually reading filings
- 🔔 Schedule recurring runs for compliance and investment-research alerts
- 🔗 Export to JSON, CSV, Excel, APIs, webhooks, databases, and AI workflows

[Run SEC Schedule 13G Passive Ownership Scraper](https://apify.com/automation-lab/sec-schedule-13g-passive-ownership-scraper)

### What does SEC Schedule 13G Passive Ownership Scraper do?

The Actor discovers and parses public SEC filings whose form type is Schedule 13G or Schedule 13G/A.

It supports two workflows:

1. Provide exact SEC filing or primary-document URLs.
2. Scan one or more EDGAR quarterly master indexes and apply optional issuer/date filters.

Each dataset row represents one unique filing accession. Repeated reporting persons and signatures remain nested inside the filing record so ownership details stay connected to their source.

### Who is it for?

#### Funds and investment analysts

Track passive or qualified beneficial owners, compare position amendments, and feed ownership screens.

#### RIAs and compliance teams

Review reportable holdings, filing dates, amendment status, signers, and SEC evidence in repeatable exports.

#### Financial-data engineers

Build normalized Schedule 13G feeds without maintaining XML variants, accession discovery, retries, and deduplication.

#### Investor-research products

Power alerts, holder profiles, issuer timelines, and ownership-change dashboards with source-linked data.

#### AI and automation teams

Give agents structured filing records instead of long SEC documents that require repeated interpretation.

### Why use this Actor?

- ✅ **13G-specific output** — focused on passive and qualified ownership rather than mixing 13D activist filings into one dataset
- ✅ **Person-level normalization** — captures each reporting person's shares, percentage, type, citizenship, and voting/dispositive powers
- ✅ **Historical discovery** — scans deterministic EDGAR quarterly indexes
- ✅ **Direct lookup** — extracts a known accession or primary document immediately
- ✅ **Source evidence** — preserves filing, document, and submission URLs
- ✅ **Fair-access design** — sequential requests, identifying User-Agent, conservative delay, and bounded retries
- ✅ **No login required** — the source is public SEC EDGAR data

### What Schedule 13G data can I extract?

| Field | Description |
|---|---|
| `accessionNumber` | Unique SEC filing accession |
| `formType` | Schedule 13G or 13G/A form label |
| `filingDate` | Date the filing entered EDGAR |
| `eventDate` | Date of event requiring the statement |
| `amendment` | Whether the filing is an amendment |
| `amendmentNumber` | Reported amendment sequence |
| `issuerName` | Issuer legal name |
| `issuerCik` | Issuer Central Index Key |
| `cusip` | Security CUSIP when disclosed |
| `securityClass` | Class or title of securities |
| `filingRules` | Applicable 13d-1 filing rule designations |
| `reportingPersons` | Nested normalized beneficial owners |
| `comments` | Reporting-person explanatory comments |
| `signatures` | Signer, title, person, and date details |
| `filingIndexUrl` | Canonical accession directory |
| `documentUrl` | Parsed primary or submission document |
| `submissionUrl` | Full SEC submission text URL |
| `rawMetadata` | Useful source-format and filing metadata |
| `scrapedAt` | Extraction timestamp |

### Reporting-person fields

Each object in `reportingPersons` can contain:

- `name`
- `cik`
- `type`
- `citizenshipOrOrganization`
- `soleVotingPower`
- `sharedVotingPower`
- `soleDispositivePower`
- `sharedDispositivePower`
- `aggregateBeneficialShares`
- `percentOfClass`
- `excludesCertainShares`
- `comments`

Numeric shares and percentages are returned as numbers when the filing exposes numeric values.

### How to scrape SEC Schedule 13G filings

1. Open the Actor input page.
2. Keep the sample filing URL for a one-filing extraction, or remove it for a quarterly scan.
3. Enter quarters in `YYYY/QTRN` format, such as `2026/QTR3`.
4. Optionally add issuer CIKs or a filing-date range.
5. Choose whether to include 13G/A amendments.
6. Set a low `maxItems` for a first run.
7. Click **Start**.
8. Open the dataset and export it in your preferred format.

Quarterly results are considered newest-first before the maximum is applied.

### Input options

| Input | Type | Default | Purpose |
|---|---|---:|---|
| `filingUrls` | array | sample URL | Exact SEC accession or document URLs |
| `quarters` | array | current sample quarter | EDGAR index periods in `YYYY/QTRN` format |
| `issuerCiks` | array | empty | Restrict quarterly discovery to issuers |
| `startDate` | string | empty | Inclusive `YYYY-MM-DD` lower boundary |
| `endDate` | string | empty | Inclusive `YYYY-MM-DD` upper boundary |
| `includeAmendments` | boolean | true | Include Schedule 13G/A records |
| `maxItems` | integer | 10 | Maximum unique filings saved |
| `userAgent` | string | supplied | SEC-compliant organization/contact header |
| `requestDelayMillis` | integer | 200 | Delay between filing extractions |

At least one valid filing URL or quarter must be supplied.

### Example input: exact filing

```json
{
  "filingUrls": [
    {
      "url": "https://www.sec.gov/Archives/edgar/data/2014982/000121390026018524/primary_doc.xml"
    }
  ],
  "quarters": [],
  "maxItems": 1
}
````

Use this mode to enrich an accession already found by another system.

### Example input: quarterly monitor

```json
{
  "filingUrls": [],
  "quarters": ["2026/QTR3"],
  "includeAmendments": true,
  "maxItems": 25,
  "requestDelayMillis": 200
}
```

Schedule this input daily to retrieve the newest filings in the selected quarter.

### Example input: issuer history

```json
{
  "filingUrls": [],
  "quarters": ["2025/QTR4", "2026/QTR1", "2026/QTR2"],
  "issuerCiks": ["2014982"],
  "startDate": "2025-10-01",
  "endDate": "2026-06-30",
  "maxItems": 100
}
```

This pattern creates a bounded issuer-specific history across several quarters.

### Example output

```json
{
  "accessionNumber": "0001213900-26-018524",
  "formType": "SCHEDULE 13G/A",
  "eventDate": "01/28/2026",
  "amendment": true,
  "amendmentNumber": 1,
  "issuerName": "SIM ACQUISITION CORP. I",
  "issuerCik": "2014982",
  "cusip": "G8431T101",
  "securityClass": "Class A Ordinary Shares, par value $0.0001 per share",
  "filingRules": ["Rule 13d-1(d)"],
  "reportingPersons": [
    {
      "name": "SIM Sponsor 1 LLC",
      "type": "OO",
      "citizenshipOrOrganization": "DE",
      "soleVotingPower": 7526669,
      "aggregateBeneficialShares": 7526669,
      "percentOfClass": 24.7
    }
  ],
  "documentUrl": "https://www.sec.gov/Archives/edgar/data/2014982/000121390026018524/primary_doc.xml"
}
```

Fields absent from a source document are omitted rather than invented.

### How much does it cost to extract SEC Schedule 13G filings?

This Actor uses pay-per-event pricing: a **$0.005 run-start fee** plus one result event for each unique filing saved.

| Apify plan tier | Price per filing |
|---|---:|
| Free | $0.0005984 |
| Bronze | $0.00052035 |
| Silver | $0.00040587 |
| Gold | $0.00031221 |
| Platinum | $0.00020814 |
| Diamond | $0.0001457 |

The run-start fee is added once per run. You can preview the estimated charge in Console before starting.

For cost control:

- begin with `maxItems: 5`
- use exact filing URLs for one-off enrichment
- filter by CIK and date for targeted histories
- avoid rescanning quarters you have already checkpointed in your own workflow

### Daily monitoring workflow

A practical ownership-monitor pipeline is:

1. Scan the current quarter with a bounded maximum.
2. Store accession numbers as unique keys.
3. Ignore accessions already seen.
4. Compare each reporting person's percentage and shares with the prior filing.
5. Send an alert when a new holder or material amendment appears.
6. Retain SEC source links for analyst review.

Apify schedules and webhooks can automate the first and last steps.

### Historical backfill workflow

For a historical dataset:

1. Split the desired range into EDGAR quarters.
2. Run a moderate number of quarters per job.
3. Filter issuer CIKs when researching a defined watchlist.
4. Merge exports by `accessionNumber`.
5. Sort by filing date or event date.
6. Preserve amendment numbers to reconstruct position changes.

The SEC quarterly indexes are finite, making backfills reproducible.

### Integrations

#### Google Sheets and Excel

Export CSV or XLSX for review, watchlists, and ownership models.

#### Webhooks and Slack

Send completed-run webhooks to an alert service and post selected holder changes to Slack.

#### PostgreSQL, Snowflake, and BigQuery

Use accession number as the filing key and store nested persons as JSON or normalize them into a child table.

#### Zapier and Make

Trigger downstream compliance tickets, emails, or CRM records after scheduled runs.

#### Apify API and SDK

Start jobs from data pipelines and consume dataset items programmatically.

### API usage in JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sec-schedule-13g-passive-ownership-scraper').call({
  quarters: ['2026/QTR3'],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use with the Apify API in Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/sec-schedule-13g-passive-ownership-scraper').call(
    run_input={'quarters': ['2026/QTR3'], 'maxItems': 10}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~sec-schedule-13g-passive-ownership-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"quarters":["2026/QTR3"],"maxItems":10}'
```

Poll the returned run ID, then download items from its default dataset.

### Use with MCP and AI agents

Connect the Actor through the [Apify MCP server](https://mcp.apify.com/?tools=automation-lab/sec-schedule-13g-passive-ownership-scraper).

#### Claude Code setup

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=automation-lab/sec-schedule-13g-passive-ownership-scraper"
```

Then ask:

> Extract the newest ten Schedule 13G filings and summarize holders above 10%.

#### Claude Desktop setup

Add this entry to the Claude Desktop MCP configuration:

```json
{
  "mcpServers": {
    "apify-sec-13g": {
      "url": "https://mcp.apify.com/?tools=automation-lab/sec-schedule-13g-passive-ownership-scraper"
    }
  }
}
```

#### Cursor setup

Use the same `mcpServers` JSON in Cursor's MCP settings and enable `apify-sec-13g` for the workspace.

#### VS Code setup

Open the VS Code MCP configuration, add the same HTTP server URL, and start the server before opening Copilot Chat.

Example prompts:

> Find amendments for issuer CIK 2014982 and compare ownership percentages by reporting person.

> Build a table of reporting persons, beneficial shares, class percentages, and SEC source URLs from the latest quarter.

MCP keeps source extraction deterministic while the model handles analysis and narrative.

### Data quality and deduplication

- Accessions are deduplicated before extraction and billing.
- Modern SEC XML is preferred for normalized ownership fields.
- Filing index metadata resolves the primary Schedule 13G document.
- Full submission text provides a fallback for older accession layouts.
- Malformed individual filings are logged and skipped while the batch continues.
- Canonical document URLs make every result auditable.

A reporting person's CIK is omitted when the filing does not provide one in that person's block.

### Tips for reliable results

- Use a descriptive User-Agent containing an organization and contact.
- Keep the request delay at or above the provided default for routine work.
- Use exact filing URLs when validating a specific document.
- Choose the quarter containing your date range.
- Include 13G/A when building ownership histories.
- Exclude amendments when you only need initial position disclosures.
- Treat CUSIPs as filing-provided identifiers and preserve leading zeros.

### Fair access and rate limits

SEC EDGAR is public, but automated clients should identify themselves and request data responsibly.

The Actor uses sequential filing extraction, a conservative delay, and bounded retry/backoff for transient responses. Do not reduce pacing to create an aggressive high-frequency crawler.

The Actor does not use a browser or proxy in its normal route.

### Legality

SEC filings are public government records. This Actor retrieves public EDGAR documents without bypassing authentication or access controls.

You remain responsible for:

- complying with SEC fair-access guidance
- using the data lawfully
- validating investment or compliance conclusions
- respecting any obligations that apply to your organization

The output is data extraction, not legal, investment, or compliance advice.

### FAQ

#### Does this Actor extract Schedule 13D?

No. This product is intentionally limited to Schedule 13G and 13G/A passive or qualified ownership filings. Use [SEC Schedule 13D Ownership Scraper](https://apify.com/automation-lab/sec-schedule-13d-ownership-scraper) for activist Schedule 13D filings.

#### Can I extract one known filing?

Yes. Provide an SEC accession directory, filing index, full submission, XML, or HTML document URL in `filingUrls`.

#### Can I monitor only one issuer?

Yes. Add its CIK to `issuerCiks` and scan the relevant current quarter.

#### Why is a field missing?

SEC filing formats and disclosed values vary. The Actor omits unavailable values instead of fabricating them.

#### Why did my run find no filings?

Check that the quarter uses `YYYY/QTRN`, the date filter overlaps that quarter, the CIK belongs to the issuer, and amendments are not unintentionally excluded.

#### Why was one filing skipped?

Inspect run warnings. A temporary SEC response or unusual legacy document can prevent one accession from parsing while other records still succeed.

#### Are results investment advice?

No. They are normalized public filing data and source links for further analysis.

### Related SEC scrapers

- [SEC Schedule 13D Ownership Scraper](https://apify.com/automation-lab/sec-schedule-13d-ownership-scraper) — activist beneficial-ownership filings
- [SEC EDGAR Company Filings Scraper](https://apify.com/automation-lab/sec-edgar-company-filings-scraper) — broader company filing discovery
- [SEC Form 4 Insider Trading Scraper](https://apify.com/automation-lab/sec-form-4-insider-trading-scraper) — officer, director, and owner transactions

Use separate form-specific Actors when you need normalized fields rather than one generic filing blob.

### Support

If a valid public Schedule 13G filing does not parse correctly, open an Actor issue and include:

- the SEC filing URL
- the run URL
- expected fields
- observed output or warning

That evidence helps reproduce format-specific edge cases quickly.

# Actor input Schema

## `filingUrls` (type: `array`):

Optional SEC Archives filing index, submission, XML, or HTML document URLs.

## `quarters` (type: `array`):

Quarterly master indexes to scan, formatted YYYY/QTRN. Newest matching filings are returned first.

## `issuerCiks` (type: `array`):

Optional issuer CIKs. Leave empty to include every issuer in the selected quarters.

## `startDate` (type: `string`):

Optional inclusive filing-date boundary in YYYY-MM-DD format.

## `endDate` (type: `string`):

Optional inclusive filing-date boundary in YYYY-MM-DD format.

## `includeAmendments` (type: `boolean`):

Include amended Schedule 13G filings as well as initial filings.

## `maxItems` (type: `integer`):

Maximum unique filing records to save.

## `userAgent` (type: `string`):

Descriptive organization/contact User-Agent sent to SEC.gov.

## `requestDelayMillis` (type: `integer`):

Polite delay between filing extractions. The effective minimum is 120 ms.

## Actor input object example

```json
{
  "filingUrls": [
    {
      "url": "https://www.sec.gov/Archives/edgar/data/2014982/000121390026018524/primary_doc.xml"
    }
  ],
  "quarters": [
    "2026/QTR3"
  ],
  "includeAmendments": true,
  "maxItems": 5,
  "userAgent": "Automation Lab SEC Schedule 13G research support@automation-lab.ai",
  "requestDelayMillis": 200
}
```

# 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 = {
    "filingUrls": [
        {
            "url": "https://www.sec.gov/Archives/edgar/data/2014982/000121390026018524/primary_doc.xml"
        }
    ],
    "quarters": [
        "2026/QTR3"
    ],
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-schedule-13g-passive-ownership-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 = {
    "filingUrls": [{ "url": "https://www.sec.gov/Archives/edgar/data/2014982/000121390026018524/primary_doc.xml" }],
    "quarters": ["2026/QTR3"],
    "maxItems": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-schedule-13g-passive-ownership-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 '{
  "filingUrls": [
    {
      "url": "https://www.sec.gov/Archives/edgar/data/2014982/000121390026018524/primary_doc.xml"
    }
  ],
  "quarters": [
    "2026/QTR3"
  ],
  "maxItems": 5
}' |
apify call automation-lab/sec-schedule-13g-passive-ownership-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Schedule 13G Passive Ownership Scraper",
        "description": "📊 Extract normalized passive beneficial-ownership holders, positions, voting powers, amendments, and source links from public SEC Schedule 13G filings.",
        "version": "0.1",
        "x-build-id": "jTXrKIt3DYr4IUe4f"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-schedule-13g-passive-ownership-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-schedule-13g-passive-ownership-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-schedule-13g-passive-ownership-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-schedule-13g-passive-ownership-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-schedule-13g-passive-ownership-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-schedule-13g-passive-ownership-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",
                "properties": {
                    "filingUrls": {
                        "title": "📄 SEC filing URLs",
                        "type": "array",
                        "description": "Optional SEC Archives filing index, submission, XML, or HTML document URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "quarters": {
                        "title": "📅 EDGAR quarters",
                        "type": "array",
                        "description": "Quarterly master indexes to scan, formatted YYYY/QTRN. Newest matching filings are returned first.",
                        "default": [
                            "2026/QTR3"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "issuerCiks": {
                        "title": "Issuer CIK filters",
                        "type": "array",
                        "description": "Optional issuer CIKs. Leave empty to include every issuer in the selected quarters.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Filed on or after",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive filing-date boundary in YYYY-MM-DD format."
                    },
                    "endDate": {
                        "title": "Filed on or before",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optional inclusive filing-date boundary in YYYY-MM-DD format."
                    },
                    "includeAmendments": {
                        "title": "Include 13G/A amendments",
                        "type": "boolean",
                        "description": "Include amended Schedule 13G filings as well as initial filings.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Maximum filings",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum unique filing records to save.",
                        "default": 10
                    },
                    "userAgent": {
                        "title": "SEC-compliant User-Agent",
                        "type": "string",
                        "description": "Descriptive organization/contact User-Agent sent to SEC.gov.",
                        "default": "Automation Lab SEC Schedule 13G research support@automation-lab.ai"
                    },
                    "requestDelayMillis": {
                        "title": "Delay between filings (ms)",
                        "minimum": 120,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Polite delay between filing extractions. The effective minimum is 120 ms.",
                        "default": 200
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```