# SEC Form N-PX Proxy Voting Scraper (`automation-lab/sec-form-n-px-proxy-voting-scraper`) Actor

Extract institutional proxy votes from 2024+ SEC Form N-PX filings. Search by filer, CIK, accession, URL, or date and export normalized records with source links.

- **URL**: https://apify.com/automation-lab/sec-form-n-px-proxy-voting-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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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 Form N-PX Proxy Voting Scraper** turns public SEC EDGAR filings into analysis-ready institutional voting records.

Discover filings by filer, CIK, accession number, filing URL, and date range, then export one normalized row for every disclosed vote direction.

No SEC API key, browser, login, or paid data subscription is required.

### What does SEC Form N-PX Proxy Voting Scraper do?

The Actor discovers **2024+ structured Form N-PX and N-PX/A filings** and parses their official proxy-voting XML.

It returns filer and filing metadata, issuer identifiers, meeting dates, proposal text and categories, shares voted and on loan, vote directions, management recommendations, manager/series identifiers, and source links.

Unlike a general SEC filing search, it produces vote-level rows ready for comparison and aggregation.

Use the prefilled Vanguard filing for a fast first run.

### Who is this SEC proxy voting scraper for?

**Stewardship and ESG analysts**

- Compare how managers voted on compensation, governance, climate, and social proposals.
- Trace every result to the original SEC filing and XML document.
- Schedule annual refreshes after the N-PX filing season.

**Asset managers and compliance teams**

- Review disclosed votes and amendments.
- Build internal controls around filing dates, accessions, and report periods.
- Export evidence to spreadsheets, warehouses, or case-management systems.

**Governance researchers and journalists**

- Find proposals by issuer, category, meeting date, or vote direction.
- Compare management recommendations with institutional votes.
- Preserve reproducible source URLs in published research.

**Data product teams**

- Feed normalized records into fund comparison, stewardship, or alert products.
- Use the API, schedules, webhooks, and datasets instead of maintaining an EDGAR parser.

### Why use this Form N-PX data extractor?

- 🏛️ **Official source** — reads public SEC EDGAR data.
- 🔎 **Four discovery routes** — filer text, CIK, accession, or filing URL.
- 🧾 **Vote-level normalization** — one row per disclosed `voteRecord` direction.
- 🔗 **Strong provenance** — filing index and exact vote-document links.
- 🛡️ **Fail-closed validation** — invalid dates, accessions, CIKs, and non-SEC URLs are rejected.
- ⚡ **HTTP-only** — no browser overhead or residential proxy requirement.
- 🔁 **Automation-ready** — run via API, schedule, webhook, Make, Zapier, or MCP.
- 📦 **Flexible export** — download JSON, CSV, Excel, XML, or RSS from Apify datasets.

### What Form N-PX data can you extract?

| Category | Fields |
|---|---|
| Filer | `filerName`, `filerCik`, `reportType` |
| Filing | `filingType`, `accessionNumber`, `filingDate`, `periodOfReport` |
| Amendment | `isAmendment`, `amendmentNumber` |
| Security | `issuerName`, `cusip`, `isin`, `figi` |
| Proposal | `meetingDate`, `proposalText`, `proposalCategories`, `proposalSource` |
| Shares | `sharesVoted`, `sharesOnLoan`, `voteShares` |
| Decision | `voteDirection`, `managementRecommendation` |
| Fund context | `managerNumber`, `seriesIds`, `otherInformation` |
| Provenance | `filingIndexUrl`, `voteDocumentUrl`, `scrapedAt` |

Each output row repeats the relevant filing and proposal context, so it remains useful after filtering or export.

If a proposal contains multiple vote records, each direction is preserved as a separate row with its own share count.

### How much does it cost to extract SEC proxy votes?

This Actor uses **pay-per-event pricing**.

You pay a small run-start fee plus a fee for each normalized proxy-vote row saved.

| Event | Free | Starter | Scale | Business |
|---|---:|---:|---:|---:|
| Run start | $0.005 | $0.005 | $0.005 | $0.005 |
| Proxy vote row | $0.000032785 | $0.000028508 | $0.000022237 | $0.000017105 |

Higher Apify plans receive additional volume discounts.

A 100-row extraction costs about **$0.0083** on the Free plan.

Your Apify Free plan includes monthly platform credits, enough for many small filing checks.

Final production prices are always shown before you start a run.

### How to scrape SEC Form N-PX filings

1. Open **SEC Form N-PX Proxy Voting Scraper** on Apify.
2. Keep the prefilled SEC filing URL for a quick test, or remove it.
3. Add a filer query, one or more CIKs, accession numbers, or official filing URLs.
4. Set a 2024-or-later filing date range if needed.
5. Choose maximum filings and vote rows.
6. Click **Start**.
7. Preview the dataset, then export or integrate it.

**Search by filer**

```json
{
  "filerQuery": "BlackRock",
  "startDate": "2024-08-01",
  "endDate": "2024-08-31",
  "maxFilings": 2,
  "maxVotes": 100
}
````

**Fetch by CIK**

```json
{
  "ciks": ["1767306"],
  "startDate": "2024-01-01",
  "maxFilings": 3,
  "maxVotes": 500
}
```

**Reproduce an exact filing**

```json
{
  "accessions": ["0001420506-24-001637"],
  "maxFilings": 1,
  "maxVotes": 50
}
```

### Input parameters

| Parameter | Type | Default | Purpose |
|---|---|---|---|
| `filerQuery` | string | — | Search filer, fund, manager, or series text in SEC EFTS |
| `ciks` | string\[] | — | Read recent filings for exact registrant CIKs |
| `accessions` | string\[] | — | Resolve exact SEC accession numbers |
| `filingUrls` | URL\[] | sample filing | Read official archive filing/index/XML URLs |
| `startDate` | string | `2024-01-01` | Earliest filing date |
| `endDate` | string | — | Latest filing date |
| `includeAmendments` | boolean | `true` | Keep N-PX/A amendments |
| `maxFilings` | integer | `3` | Bound filing downloads |
| `maxVotes` | integer | `100` | Bound normalized output rows |
| `requestDelayMs` | integer | `150` | Delay between SEC requests |
| `userAgent` | string | descriptive Actor ID | SEC fair-access identification |

At least one discovery route must be present.

Multiple routes can be combined; matching filings are deduplicated by accession.

Explicit URLs must use `www.sec.gov/Archives/edgar/data/...` and point inside a filing directory.

### Output example

```json
{
  "filerName": "Vanguard Personalized Indexing Management, LLC",
  "filerCik": "0001767306",
  "filingType": "N-PX/A",
  "accessionNumber": "0001420506-24-001637",
  "filingDate": "2024-08-20",
  "periodOfReport": "2024-06-30",
  "isAmendment": true,
  "issuerName": "Snowflake Inc.",
  "cusip": "833445109",
  "isin": "US8334451098",
  "meetingDate": "2023-07-05",
  "proposalText": "To approve, on an advisory basis, the compensation of our named executive officers.",
  "proposalCategories": ["SECTION 14A SAY-ON-PAY VOTES"],
  "sharesVoted": 10650,
  "sharesOnLoan": 0,
  "voteDirection": "FOR",
  "voteShares": 10650,
  "managementRecommendation": "FOR",
  "filingIndexUrl": "https://www.sec.gov/Archives/edgar/data/1767306/000142050624001637/0001420506-24-001637-index.html",
  "voteDocumentUrl": "https://www.sec.gov/Archives/edgar/data/1767306/000142050624001637/FormN-PX_ProxyVoteTable.xml"
}
```

Optional fields appear only when the filer supplied them.

Numeric share fields remain numbers, dates use ISO `YYYY-MM-DD`, and source URLs are complete links.

### How filing discovery works

For CIK inputs, the Actor reads the official SEC submissions JSON and filters recent forms to N-PX/N-PX/A.

For filer text and accession inputs, it uses SEC full-text search metadata.

For every filing, it reads the archive index instead of guessing a filename.

It prefers a document identified as `PROXY VOTING RECORD`, then validates XML contents for structured `proxyTable` rows.

This handles filenames such as `proxytable.xml`, `votetable.xml`, and filer-specific names.

### Tips for best results

- 🎯 Start with one filing and 10–100 votes.
- 📅 Use narrow dates for broad filer names such as BlackRock or Vanguard.
- 🆔 Prefer CIKs over text when you need one exact registrant.
- 🔐 Keep a descriptive `userAgent` value under SEC fair-access guidance.
- 🧮 Raise `maxVotes` for full-filing exports; one annual filing can contain thousands of matters.
- 🔁 Schedule annual refreshes around filing season rather than polling aggressively.
- 🧾 Keep amendments enabled when audit completeness matters.
- 🔗 Store source URLs beside downstream analysis for reproducibility.

### Data quality and deduplication

Filings are deduplicated by accession number across all discovery routes.

Rows are deduplicated by accession, proposal position, vote-record position, issuer, meeting date, and direction.

The known template placeholder row found in some filer-generated XML is rejected because its issuer value is literally `issuerName`.

A run fails if matching filings download but no structured vote rows can be extracted.

The Actor intentionally focuses on the uniform structured XML era beginning in 2024; it does not claim to normalize older free-form filings.

### SEC fair-access behavior

Requests carry a descriptive User-Agent and are paced to at least 100 milliseconds apart.

HTTP 429 and server errors receive bounded exponential-backoff retries.

No browser, CAPTCHA solver, login, cookie, proxy, or private SEC credential is used.

Keep concurrency conservative and do not remove the request delay for large scheduled workloads.

See the [SEC privacy and security policy](https://www.sec.gov/privacy.htm) for current access guidance.

### Integrations for proxy-vote workflows

**SEC N-PX → Google Sheets**

Send annual vote rows to a stewardship review sheet, grouped by manager, issuer, and category.

**SEC N-PX → BigQuery or Snowflake**

Load normalized records into a warehouse and compare managers across filing years.

**SEC N-PX → Slack or Microsoft Teams**

Schedule a filer/date query and alert researchers when a new filing or amendment appears.

**SEC N-PX → Make or Zapier**

Trigger a no-code workflow that filters compensation proposals and creates review tasks.

**SEC N-PX → webhook**

Process completed datasets in a governance platform immediately after each scheduled run.

### Using the Apify API with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/sec-form-n-px-proxy-voting-scraper').call({
  accessions: ['0001420506-24-001637'],
  maxFilings: 1,
  maxVotes: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Use your Apify API token from environment variables; do not commit it to source control.

### Using the Apify API with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/sec-form-n-px-proxy-voting-scraper").call(
    run_input={
        "ciks": ["1767306"],
        "startDate": "2024-01-01",
        "maxFilings": 1,
        "maxVotes": 100,
    }
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~sec-form-n-px-proxy-voting-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"filerQuery":"BlackRock","startDate":"2024-08-01","endDate":"2024-08-31","maxFilings":1,"maxVotes":25}'
```

Poll the returned run ID or use an Apify webhook to receive completion events.

### Use SEC Form N-PX data with AI agents via MCP

The Actor can be called by AI assistants through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp).

**Claude Code**

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/sec-form-n-px-proxy-voting-scraper"
```

**Claude Desktop, Cursor, or VS Code**

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/sec-form-n-px-proxy-voting-scraper"
    }
  }
}
```

Authentication uses your Apify account on first connection.

Example prompts:

- "Use automation-lab/sec-form-n-px-proxy-voting-scraper to extract the first 100 votes from accession 0001420506-24-001637."
- "Find 2024 BlackRock N-PX filings and summarize votes against management by issuer."
- "Export compensation proposal votes for CIK 1767306 into a CSV-ready table with source links."

### Scheduling an N-PX filing monitor

Create an Apify schedule with a filer query or CIK, a recent filing-date window, and a conservative vote limit.

Connect a webhook that reads the default dataset when the run succeeds.

Deduplicate downstream by `accessionNumber`, `proposalText`, `issuerName`, `voteDirection`, and `voteShares`.

Update the date window periodically, or have your orchestration layer calculate it before each API call.

For annual compliance archives, retain both JSON data and original SEC source URLs.

### Is it legal to scrape SEC Form N-PX data?

SEC EDGAR filings are public government records.

This Actor accesses official public endpoints without bypassing authentication or technical restrictions.

You remain responsible for your use, retention, redistribution, attribution, and any privacy or regulatory obligations.

Follow SEC fair-access policies, use conservative request rates, and verify critical conclusions against the original filing.

This tool provides data extraction, not legal, investment, compliance, or voting advice.

### Limitations

- Only structured Form N-PX XML filed in 2024 or later is supported.
- SEC source availability and schema details can change.
- Some filers omit optional identifiers or contextual fields.
- `voteDirection` reflects the filed value; the Actor does not infer intent.
- One proposal can produce multiple rows when multiple vote records are disclosed.
- A CIK route reads recent submissions; use accession or filer search for an exact older structured filing.
- Results are not enriched with market data, issuer tickers, or proprietary ESG scores.

### FAQ

**How fast is the SEC Form N-PX scraper?**

A one-filing, 10-row evaluation typically finishes quickly because it uses direct HTTP and structured XML. Large filings take longer because the XML may contain thousands of proxy matters.

**How much does an N-PX extraction cost?**

Cost equals the displayed run-start fee plus the displayed per-vote-row price. Set `maxVotes` to control the maximum variable charge.

**How is this different from SEC EDGAR search?**

EDGAR search finds filing documents. This Actor discovers them and converts structured proxy-vote tables into normalized, exportable rows.

**Why did my filer search return no results?**

Check spelling, use a narrower date range, or use the registrant CIK. The Actor deliberately rejects pre-2024 dates because older filings are not covered by this structured parser.

**Why did the run fail after finding a filing?**

The filing may not contain a valid structured `PROXY VOTING RECORD` XML document. Use a 2024+ N-PX accession and inspect the linked SEC filing index.

**Why are ISIN, FIGI, series ID, or manager number missing?**

Those fields are optional in SEC filings. Missing source values are not invented.

**Does it support N-PX amendments?**

Yes. Leave `includeAmendments` enabled to include N-PX/A filings, amendment flags, and amendment numbers.

**Do I need a proxy or SEC API key?**

No. The Actor uses anonymous official SEC endpoints with descriptive identification and fair-access pacing.

### Other SEC and finance scrapers

- [SEC EDGAR Scraper](https://apify.com/automation-lab/sec-edgar-scraper)
- [SEC Form 4 Insider Transactions Scraper](https://apify.com/automation-lab/sec-form-4-insider-transactions-scraper)
- [SEC Form D Scraper](https://apify.com/automation-lab/sec-form-d-scraper)
- [SEC Form N-PORT Mutual Fund Holdings Scraper](https://apify.com/automation-lab/sec-form-nport-mutual-fund-holdings-scraper)
- [SEC Schedule 13D Ownership Scraper](https://apify.com/automation-lab/sec-schedule-13d-ownership-scraper)
- [SEC Schedule 13G Passive Ownership Scraper](https://apify.com/automation-lab/sec-schedule-13g-passive-ownership-scraper)
- [SEC Litigation Releases Scraper](https://apify.com/automation-lab/sec-litigation-releases-scraper)
- [SEC Investor Alerts Scraper](https://apify.com/automation-lab/sec-investor-alerts-scraper)

Use these related Actors when the workflow needs broad filing metadata, insider transactions, private offerings, fund holdings, beneficial ownership, or enforcement information rather than vote-level N-PX records.

# Actor input Schema

## `filerQuery` (type: `string`):

Search SEC EDGAR full text for a filer, manager, fund, or series name.

## `ciks` (type: `array`):

Add SEC registrant CIKs, with or without leading zeros.

## `accessions` (type: `array`):

Add exact 18-digit SEC accession numbers, such as 0001420506-24-001637.

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

Add official www.sec.gov Archives filing index or XML document URLs.

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

Include filings on or after this date. Structured N-PX support begins in 2024.

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

Optionally set the latest filing date in YYYY-MM-DD format.

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

Keep N-PX/A restatements and amendments in the output.

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

Limit filing downloads across all discovery routes.

## `maxVotes` (type: `integer`):

Stop after this many normalized vote-direction rows.

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

Keep requests conservatively paced. Values below 100 ms are rejected.

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

Send a descriptive application/contact identifier under SEC fair-access guidance.

## Actor input object example

```json
{
  "filingUrls": [
    {
      "url": "https://www.sec.gov/Archives/edgar/data/1767306/000142050624001637/0001420506-24-001637-index.html"
    }
  ],
  "startDate": "2024-01-01",
  "includeAmendments": true,
  "maxFilings": 1,
  "maxVotes": 10,
  "requestDelayMs": 150,
  "userAgent": "Automation-Lab SEC Form N-PX Scraper/1.0 (contact: support@automation-lab.example)"
}
```

# 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/1767306/000142050624001637/0001420506-24-001637-index.html"
        }
    ],
    "startDate": "2024-01-01",
    "includeAmendments": true,
    "maxFilings": 1,
    "maxVotes": 10,
    "requestDelayMs": 150,
    "userAgent": "Automation-Lab SEC Form N-PX Scraper/1.0 (contact: support@automation-lab.example)"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/sec-form-n-px-proxy-voting-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/1767306/000142050624001637/0001420506-24-001637-index.html" }],
    "startDate": "2024-01-01",
    "includeAmendments": True,
    "maxFilings": 1,
    "maxVotes": 10,
    "requestDelayMs": 150,
    "userAgent": "Automation-Lab SEC Form N-PX Scraper/1.0 (contact: support@automation-lab.example)",
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/sec-form-n-px-proxy-voting-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/1767306/000142050624001637/0001420506-24-001637-index.html"
    }
  ],
  "startDate": "2024-01-01",
  "includeAmendments": true,
  "maxFilings": 1,
  "maxVotes": 10,
  "requestDelayMs": 150,
  "userAgent": "Automation-Lab SEC Form N-PX Scraper/1.0 (contact: support@automation-lab.example)"
}' |
apify call automation-lab/sec-form-n-px-proxy-voting-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC Form N-PX Proxy Voting Scraper",
        "description": "Extract institutional proxy votes from 2024+ SEC Form N-PX filings. Search by filer, CIK, accession, URL, or date and export normalized records with source links.",
        "version": "0.1",
        "x-build-id": "sB9z7oHUzD4GZpczQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~sec-form-n-px-proxy-voting-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-sec-form-n-px-proxy-voting-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-form-n-px-proxy-voting-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-sec-form-n-px-proxy-voting-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-form-n-px-proxy-voting-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-sec-form-n-px-proxy-voting-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": {
                    "filerQuery": {
                        "title": "Filer or fund search",
                        "type": "string",
                        "description": "Search SEC EDGAR full text for a filer, manager, fund, or series name."
                    },
                    "ciks": {
                        "title": "Registrant CIKs",
                        "type": "array",
                        "description": "Add SEC registrant CIKs, with or without leading zeros.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "accessions": {
                        "title": "Accession numbers",
                        "type": "array",
                        "description": "Add exact 18-digit SEC accession numbers, such as 0001420506-24-001637.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "filingUrls": {
                        "title": "SEC filing URLs",
                        "type": "array",
                        "description": "Add official www.sec.gov Archives filing index or XML document URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "startDate": {
                        "title": "Filed on or after",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Include filings on or after this date. Structured N-PX support begins in 2024.",
                        "default": "2024-01-01"
                    },
                    "endDate": {
                        "title": "Filed on or before",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Optionally set the latest filing date in YYYY-MM-DD format."
                    },
                    "includeAmendments": {
                        "title": "Include N-PX amendments",
                        "type": "boolean",
                        "description": "Keep N-PX/A restatements and amendments in the output.",
                        "default": true
                    },
                    "maxFilings": {
                        "title": "Maximum filings",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Limit filing downloads across all discovery routes.",
                        "default": 3
                    },
                    "maxVotes": {
                        "title": "Maximum vote rows",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Stop after this many normalized vote-direction rows.",
                        "default": 100
                    },
                    "requestDelayMs": {
                        "title": "SEC request delay (milliseconds)",
                        "minimum": 100,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Keep requests conservatively paced. Values below 100 ms are rejected.",
                        "default": 150
                    },
                    "userAgent": {
                        "title": "SEC User-Agent",
                        "type": "string",
                        "description": "Send a descriptive application/contact identifier under SEC fair-access guidance.",
                        "default": "Automation-Lab SEC Form N-PX Scraper/1.0 (contact: support@automation-lab.example)"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```