# SEC EDGAR Company Search — US Public Companies (`agoradelmediterraneo/sec-edgar-company-search`) Actor

Search 12,000+ US public companies via official SEC EDGAR API. Returns CIK, ticker, SIC industry code, state of incorporation and filing links. Useful for financial research, due diligence and KYB workflows.

- **URL**: https://apify.com/agoradelmediterraneo/sec-edgar-company-search.md
- **Developed by:** [Agora](https://apify.com/agoradelmediterraneo) (community)
- **Categories:** Business, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 EDGAR Company Search — US Public Companies & Filings

Access the SEC's complete database of 12,000+ US public companies and 40M+ filings since 1993. Returns company profiles, tickers, exchanges, SIC codes, state of incorporation, addresses, and recent filing metadata — all from the official SEC EDGAR API. No API key required.

---

### Why SEC EDGAR?

EDGAR is the gold standard for US public company data:
- **Official** — the SEC's own database, not a third-party aggregator
- **Complete** — every company that has ever filed with the SEC since 1993
- **Real-time** — filings appear within minutes of submission
- **Free** — no API key, no rate limits for standard usage

For institutional workflows (fund research, M&A screening, compliance), EDGAR data is the authoritative source that doesn't require a Bloomberg terminal.

---

### Use Cases

#### 1. Investment Research & Fund Management
Pull all 10-K and 10-Q filings for a portfolio of 50 companies. Monitor 8-K current reports for material events. Track S-1 IPO filings in a specific SIC sector. Automate analyst briefing packs.

```json
{
  "query": "semiconductor",
  "formTypes": ["8-K", "S-1"],
  "recentFilingsCount": 5,
  "maxItems": 50
}
````

#### 2. M\&A Target Screening

Screen companies by SIC industry code and filter by filing history. Identify companies that haven't filed recent 10-Ks (potential distress signal), or those with recent S-4 merger filings.

#### 3. Compliance & KYC for US Entities

Verify that a US counterparty is indeed a registered public company. Retrieve their official CIK, EIN, state of incorporation, and registered addresses for AML/KYC documentation.

#### 4. Batch CIK Lookup

When you know the CIK codes (from a screener or internal database), retrieve full profiles for 200 companies in a single run — ticker, exchange, SIC, addresses, recent filings.

```json
{
  "cikList": ["0001318605", "0000320193", "0001045810", "0000789570"],
  "formTypes": ["10-K", "10-Q"],
  "recentFilingsCount": 3
}
```

#### 5. Data Pipeline for Analytics

Feed EDGAR structured data into Snowflake, BigQuery, or your data warehouse. Build company master tables with canonical SEC identifiers (CIK, EIN) that never change — unlike tickers or company names.

#### 6. Journalism & Academic Research

Automated company registry lookups for investigative journalism. Track ownership disclosures (SC 13D/13G), insider transactions (Form 4), and proxy statements (DEF 14A) at scale.

***

### Input

#### Search by name or ticker

```json
{
  "query": "Tesla",
  "formTypes": ["10-K", "10-Q"],
  "recentFilingsCount": 10,
  "maxItems": 20
}
```

#### Batch CIK lookup

```json
{
  "cikList": ["0001318605", "0000320193", "0001045810"],
  "formTypes": ["10-K"],
  "recentFilingsCount": 5
}
```

#### Input fields

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `query` | string | — | Company name (e.g. `Apple`) or ticker (e.g. `AAPL`) |
| `cikList` | array | — | SEC CIK codes for direct lookup (10-digit strings) |
| `formTypes` | array | all | Filter filings by form type (`10-K`, `10-Q`, `8-K`, `S-1`, `DEF 14A`, `4`…) |
| `recentFilingsCount` | integer | 10 | Recent filings to include per company (0–50) |
| `maxItems` | integer | 20 | Max companies to return (1–200) |

***

### Output

```json
{
  "cik": "0001318605",
  "name": "Tesla, Inc.",
  "ticker": "TSLA",
  "tickers": ["TSLA"],
  "exchange": "Nasdaq",
  "exchanges": ["Nasdaq"],
  "sic": "3711",
  "sic_description": "Motor Vehicles & Passenger Car Bodies",
  "entity_type": "operating",
  "category": "Large accelerated filer",
  "ein": "912197729",
  "state_of_incorporation": "TX",
  "city": "AUSTIN",
  "state": "TX",
  "zip": "78725",
  "country": "US",
  "phone": "512-516-8177",
  "recent_filings": [
    {
      "form": "10-K",
      "filed": "2026-01-30",
      "accession": "0001628280-26-004687",
      "description": "Annual Report",
      "url": "https://www.sec.gov/Archives/edgar/data/1318605/000162828026004687/"
    }
  ],
  "recent_filings_count": 1,
  "edgar_url": "https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK=1318605"
}
```

***

### Common Filing Types

| Form | Description | Typical use |
|------|-------------|-------------|
| 10-K | Annual report (audited) | Financial overview, risk factors |
| 10-Q | Quarterly report | Interim financials |
| 8-K | Current report (material events) | Earnings, M\&A, leadership changes |
| S-1 | IPO registration | Pre-IPO companies |
| S-4 | M\&A registration | Merger/acquisition disclosure |
| DEF 14A | Proxy statement | Shareholder vote items |
| SC 13D / 13G | Major ownership disclosure | >5% stake holders |
| Form 4 | Insider transaction | Director/executive trades |

***

### Pricing

**$0.01 per company** (Pay Per Event — charged per result returned, not per run).

| Volume | Cost |
|--------|------|
| 20 companies | $0.20 |
| 200 companies | $2.00 |
| 2,000 companies | $20.00 |

***

### FAQ

**Does this cover private companies?**
Only companies registered with the SEC: public companies on US exchanges, plus private companies with SEC filing obligations (bond offerings, Rule 506(b) exemptions that exceed thresholds, S-1 filers, etc.). Private companies with no SEC filings won't appear.

**How do I get the full financial data (income statement, balance sheet)?**
This actor returns filing metadata and direct links to SEC Archives. Follow the `url` in `recent_filings` to access the actual filing documents (10-K PDFs, XBRL data) on SEC.gov. For structured XBRL financial data, pair this actor with an XBRL parser or use SEC's XBRL API directly.

**What is a CIK and why should I care?**
CIK (Central Index Key) is the SEC's permanent unique identifier. Unlike tickers (which change on delisting or rename) or company names (which change on acquisition), CIKs never change. Build your integrations around CIK for stability.

**Why did my search return unexpected results?**
EDGAR full-text search matches your query string in recent filing content — not just company names. A search for "Goldman" might surface companies that mention Goldman Sachs in their filings. For precise lookup, use `cikList` mode with known CIK codes, or search by exact ticker.

**What's the rate limit?**
SEC EDGAR has no formal rate limit for standard usage. The actor implements 1-second pauses between requests to stay well within SEC's Fair Access guidelines.

***

### Related Actors

- [EU Company Search](https://apify.com/agoraintelligence/eu-company-search) — European equivalent (Companies House, INSEE, BORME)
- [GLEIF Company Search](https://apify.com/agoraintelligence/gleif-company-search) — global LEI lookup across 200+ countries
- [Sanctions Screening](https://apify.com/agoraintelligence/sanctions-screening) — OFAC + UN sanctions check for KYC
- [EU VAT Validator](https://apify.com/agoraintelligence/eu-vat-validator) — validate EU VAT numbers via VIES

***

*Data source: [SEC EDGAR](https://www.sec.gov/edgar) — US Securities and Exchange Commission. Public domain data, free access.*

# Actor input Schema

## `query` (type: `string`):

Company name (e.g. 'Apple', 'Tesla') or ticker symbol (e.g. 'AAPL', 'TSLA'). Leave empty to use cikList instead.

## `cikList` (type: `array`):

List of SEC CIK codes to fetch directly (10-digit numbers, e.g. '0000320193'). Max 500.

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

Only return recent filings of these types (e.g. \['10-K', '10-Q', '8-K']). Leave empty for all recent filings.

## `recentFilingsCount` (type: `integer`):

Number of most recent filings to include in each company record (0–50, default: 10).

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

Maximum number of companies to return (1–200).

## Actor input object example

```json
{
  "recentFilingsCount": 10,
  "maxItems": 20
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("agoradelmediterraneo/sec-edgar-company-search").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("agoradelmediterraneo/sec-edgar-company-search").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 '{}' |
apify call agoradelmediterraneo/sec-edgar-company-search --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEC EDGAR Company Search — US Public Companies",
        "description": "Search 12,000+ US public companies via official SEC EDGAR API. Returns CIK, ticker, SIC industry code, state of incorporation and filing links. Useful for financial research, due diligence and KYB workflows.",
        "version": "0.1",
        "x-build-id": "tmeOXUxSpK6qbeAr5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/agoradelmediterraneo~sec-edgar-company-search/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-agoradelmediterraneo-sec-edgar-company-search",
                "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/agoradelmediterraneo~sec-edgar-company-search/runs": {
            "post": {
                "operationId": "runs-sync-agoradelmediterraneo-sec-edgar-company-search",
                "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/agoradelmediterraneo~sec-edgar-company-search/run-sync": {
            "post": {
                "operationId": "run-sync-agoradelmediterraneo-sec-edgar-company-search",
                "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": {
                    "query": {
                        "title": "Company name or ticker",
                        "type": "string",
                        "description": "Company name (e.g. 'Apple', 'Tesla') or ticker symbol (e.g. 'AAPL', 'TSLA'). Leave empty to use cikList instead."
                    },
                    "cikList": {
                        "title": "Look up specific CIK codes",
                        "type": "array",
                        "description": "List of SEC CIK codes to fetch directly (10-digit numbers, e.g. '0000320193'). Max 500.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "formTypes": {
                        "title": "Filter recent filings by form type",
                        "type": "array",
                        "description": "Only return recent filings of these types (e.g. ['10-K', '10-Q', '8-K']). Leave empty for all recent filings.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "recentFilingsCount": {
                        "title": "Recent filings to include per company",
                        "minimum": 0,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Number of most recent filings to include in each company record (0–50, default: 10).",
                        "default": 10
                    },
                    "maxItems": {
                        "title": "Max companies",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of companies to return (1–200).",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
