# SEC EDGAR Full-Text Search Scraper (`logiover/sec-edgar-fulltext-scraper`) Actor

Search all SEC filings (10-K, 8-K, S-1, etc.) by any keyword or phrase via EDGAR full-text search. Extract company name, ticker, CIK, form type, filing date, accession number, and file URL. No API key required.

- **URL**: https://apify.com/logiover/sec-edgar-fulltext-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Full-Text Search Scraper — Search All SEC Filings by Keyword, Form Type & Date

Search SEC EDGAR's currently indexed full-text filings and extract structured company data, filing metadata and document links — no API key or login. Runs are bounded by `maxResults`, the Actor time budget and the SEC search index's own coverage and limits.

### What does SEC EDGAR Full-Text Search Scraper do?

This actor queries the SEC EDGAR full-text search engine (`efts.sec.gov`) — the same engine powering the official [EDGAR EFTS search interface](https://efts.sec.gov/LATEST/search-index) — to find filings that match a keyword, quoted phrase, or supported Boolean expression. It supports form filters such as 10-K annual reports, 8-K material events, S-1 IPO prospectuses, 10-Q quarterly reports, DEF 14A proxy statements, and 20-F foreign private issuer filings.

The Actor paginates through results using the `from` parameter (100 raw document hits per page), collecting up to your `maxResults` cap. Because EFTS can return several matching documents from one filing package, the Actor deduplicates run-wide by accession number and keeps the first document in SEC's upstream order. It supplies a descriptive `User-Agent`, defaults to direct access, retries transient failures, and verifies suspicious proxy-origin empty responses through another route.

### Who is it for?

- **Financial analysts and hedge funds** tracking narrative shifts (AI risk, ESG disclosures, supply chain) across thousands of annual reports simultaneously.
- **Compliance and legal teams** that need to monitor how specific regulatory language appears in filings across sectors.
- **Journalists and investigative reporters** searching for companies mentioning specific topics, events, or counterparties.
- **Academic researchers** building datasets of SEC disclosures for NLP, topic modeling, or event studies.
- **Corporate intelligence professionals** doing competitive benchmarking by searching for competitor names or product mentions inside rival filings.

### Use cases

- Find every 10-K that mentions "artificial intelligence risk" and build a dataset of AI-related risk disclosures across all public companies.
- Search for all 8-K filings mentioning a specific executive's name or a named acquisition target to reconstruct M\&A timelines.
- Track which companies filed S-1 prospectuses disclosing "cryptocurrency" holdings or revenue in a given year.
- Pull all DEF 14A proxy statements referencing a specific activist investor or shareholder proposal language.
- Monitor real-time filings for new disclosures about a specific geopolitical event, product recall, or regulatory investigation.

### Why use SEC EDGAR Full-Text Search Scraper?

- **No API key required** — queries the public EFTS endpoint used by EDGAR's own search UI.
- **14 output fields per filing** — company name, ticker, CIK, form type, filing date, period ending, accession number, document URL, EDGAR index page, description, locations, incorporation states, SIC codes, and relevance score.
- **Bulk pagination** — scans up to the 10,000-hit EFTS result window in pages of 100 and returns unique filing accessions.
- **Flexible form filtering** — filter by one or multiple form types (10-K, 8-K, S-1, etc.) or search across all forms.
- **Date range support** — narrow results to a specific date window with `dateFrom` and `dateTo`.
- **Export to CSV, JSON, Excel** — all results available via Apify's standard dataset export in any format.

### What data can you extract?

The actor returns one row per matching filing accession with the following fields:

| Field | Type | Description |
|-------|------|-------------|
| `companyName` | string | Full registered company name (e.g. "Apple Inc.") |
| `ticker` | string | Stock ticker symbol(s) (e.g. "AAPL", or "LAAI, VEST" for multiple) |
| `cik` | string | SEC Central Index Key — unique company identifier |
| `formType` | string | SEC form type (10-K, 8-K, 10-K/A, S-1, etc.) |
| `filingDate` | string | Date the filing was submitted (YYYY-MM-DD) |
| `periodEnding` | string | Period the filing covers (YYYY-MM-DD), e.g. fiscal year end |
| `accessionNo` | string | Accession number (e.g. "0001477932-26-002727") — unique filing ID |
| `fileUrl` | string | Direct URL to the first matched document in SEC's upstream order for that filing |
| `edgarUrl` | string | EDGAR filing index page URL for the full filing package |
| `fileDescription` | string | Human-readable description of the document (e.g. "FORM 10-K ANNUAL REPORT") |
| `bizLocations` | string | Business/mailing address(es) from the filing header |
| `incStates` | string | State(s) of incorporation |
| `sics` | string | SIC industry code(s) for the company |
| `relevanceScore` | number / null | Upstream relevance score when supplied (higher generally means a closer indexed match) |

**Example output record:**

```json
{
  "companyName": "Apple Inc.",
  "ticker": "AAPL",
  "cik": "0000320193",
  "formType": "10-K",
  "filingDate": "2024-11-01",
  "periodEnding": "2024-09-28",
  "accessionNo": "0000320193-24-000123",
  "fileUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/aapl-20240928.htm",
  "edgarUrl": "https://www.sec.gov/Archives/edgar/data/320193/000032019324000123/000032019324000123-index.htm",
  "fileDescription": "FORM 10-K",
  "bizLocations": "Cupertino, CA",
  "incStates": "CA",
  "sics": "3571",
  "relevanceScore": 18.5
}
```

### How to use

#### Option A — Search by keyword across all forms

1. Set `query` to your search phrase (e.g. `"supply chain disruption"`).
2. Leave `forms` empty (or remove it) to search all form types.
3. Optionally set `dateFrom` and `dateTo` for a date window.
4. Set `maxResults` to how many results you need.

**Input JSON:**

```json
{
  "query": "supply chain disruption",
  "maxResults": 500
}
```

#### Option B — Target specific form types and date range

1. Set `query` to your keyword.
2. Set `forms` to the form types you want (e.g. `["10-K", "10-K/A"]`).
3. Set `dateFrom` and `dateTo` for the filing date window.

**Input JSON:**

```json
{
  "query": "cryptocurrency exposure",
  "forms": ["10-K", "8-K", "S-1"],
  "dateFrom": "2023-01-01",
  "dateTo": "2024-12-31",
  "maxResults": 1000
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `query` | string | `artificial intelligence` | Optional full-text keyword or phrase; empty input uses the documented default |
| `forms` | array | `[]` | SEC form types to filter by. Empty = all forms |
| `sort` | string | `relevance` | Upstream relevance order, or client-side `dateDesc` / `dateAsc` after collection |
| `dateFrom` | string | `""` | Filing date start filter (YYYY-MM-DD) |
| `dateTo` | string | `""` | Filing date end filter (YYYY-MM-DD) |
| `maxResults` | integer | `200` | Maximum unique filing accessions to return (1–10000) |
| `proxyConfiguration` | object | direct (`useApifyProxy: false`) | Optional Apify proxy settings |

**Full input JSON:**

```json
{
  "query": "artificial intelligence risk",
  "forms": ["10-K"],
  "sort": "relevance",
  "dateFrom": "2022-01-01",
  "dateTo": "2024-12-31",
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

### Output example

```json
{
  "companyName": "Microsoft Corporation",
  "ticker": "MSFT",
  "cik": "0000789019",
  "formType": "10-K",
  "filingDate": "2024-07-30",
  "periodEnding": "2024-06-30",
  "accessionNo": "0000950170-24-087843",
  "fileUrl": "https://www.sec.gov/Archives/edgar/data/789019/000095017024087843/msft-20240630.htm",
  "edgarUrl": "https://www.sec.gov/Archives/edgar/data/789019/000095017024087843/000095017024087843-index.htm",
  "fileDescription": "FORM 10-K",
  "bizLocations": "Redmond, WA",
  "incStates": "WA",
  "sics": "7372",
  "relevanceScore": 22.4
}
```

### Tips for best results

- **Use quoted phrases** for exact matches (e.g. `"deepfake risk"`) to find filings that use that precise language.
- **Combine with date filters** to track how disclosure language evolved over time — compare 2021 vs. 2024 for the same query.
- **Filter by 8-K** for real-time event disclosures — 8-K filings are submitted within 4 business days of a material event.
- **Use 10-K for annual risk factor analysis** — annual reports contain the most detailed risk disclosures in Item 1A.
- **CIK is your stable ID** — use it to look up all filings by a company at `https://www.sec.gov/cgi-bin/browse-edgar?action=getcompany&CIK={cik}`.
- **Start broad, then narrow** — run with all forms and a wide date range first to understand result volume, then add filters.
- **Cross-reference the accessionNo** — it uniquely identifies the filing; use it to fetch exhibit lists or the full filing index.
- **High relevance score = closer keyword match** — sort by `relevanceScore` descending for the most on-topic results.
- **For foreign companies**, filter by form type `20-F` (annual) or `6-K` (periodic reports for foreign private issuers).
- **Use larger maxResults values for broader samples**, while accounting for EFTS's 10,000 raw-hit window and the Actor's four-minute pagination budget.

### Integrations

Connect SEC EDGAR Full-Text Search Scraper to your existing workflow:

- **Google Sheets** — export dataset to Sheets via Apify's native Google Sheets integration; auto-refresh on a schedule.
- **Slack** — configure webhooks to notify your team when new filings matching your query appear.
- **Zapier / Make** — connect to 1000s of apps; trigger workflows when new filing data is available.
- **Webhooks** — set up Apify webhooks to POST results to your own API endpoint on run completion.
- **Schedule** — run weekly or daily to monitor new filings for your query terms as companies file.

### API usage

**cURL:**

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/logiover~sec-edgar-fulltext-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "artificial intelligence risk",
    "forms": ["10-K"],
    "maxResults": 200
  }'
```

**Node.js (Apify client):**

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('logiover/sec-edgar-fulltext-scraper').call({
  query: 'artificial intelligence risk',
  forms: ['10-K'],
  maxResults: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/sec-edgar-fulltext-scraper").call(run_input={
    "query": "artificial intelligence risk",
    "forms": ["10-K"],
    "maxResults": 200,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use with AI agents (MCP)

SEC EDGAR Full-Text Search Scraper is compatible with the [Apify MCP server](https://apify.com/apify/actors-mcp-server), allowing AI agents like Claude, GPT-4, and others to search SEC filings directly via tool calls. Connect the MCP server and your agent can answer questions like: *"Find all 10-K filings from 2023 mentioning 'PFAS exposure' and list the companies by relevance score"* — without any manual data extraction.

### FAQ

#### Does this actor require an API key or login?

No. The SEC EDGAR full-text search endpoint (`efts.sec.gov`) is fully public and requires no authentication. The only requirement is a descriptive `User-Agent` header, which is set automatically.

#### How far back does the coverage go?

The SEC's current [Full-Text Search FAQ](https://www.sec.gov/edgar/search/efts-faq.html) describes coverage for electronically submitted EDGAR filings since 2001. Searchability still depends on what the SEC has indexed, and a query can match filing attachments such as exhibits as well as the main document.

#### How many results can I get per run?

The Actor can scan the first 10,000 raw document hits exposed by the EFTS result window. Set `maxResults` up to 10000; the final row count can be lower because documents sharing one accession are intentionally collapsed to one filing and because the four-minute pagination budget still applies. Each page fetches up to 100 raw hits.

#### Why do I get 0 results?

Check your query spelling and try broader terms. Very narrow phrases may have no exact matches. Also verify the form filter; SEC EFTS can include amendment variants (for example, `10-K/A`) when a base form such as `10-K` is selected. Inspect `formType`, then try removing form and date filters first.

#### Why are some fields null?

Not all filings have every metadata field populated. Foreign issuers often lack US state fields. Companies without a ticker (e.g. reporting-only entities) will have `ticker: null`.

#### Can I export results to CSV or Excel?

Yes. After the run, go to the dataset and click "Export" — choose CSV, JSON, Excel, or XML. You can also use the Apify API to fetch the dataset programmatically.

#### How fast is a run?

Runtime depends on result volume, SEC response time and retries. The Actor enforces a four-minute pagination budget and preserves any rows collected before that budget.

#### Is there a rate limit on the SEC EDGAR server?

The Actor sends a descriptive `User-Agent`, performs requests sequentially and backs off on throttling/service-unavailable responses. Upstream throttling can still occur, so callers should keep schedules and parallel runs conservative.

#### Is it legal to scrape EDGAR?

SEC EDGAR exposes public filing data for investor access. You remain responsible for following current SEC access guidance, respecting rate limits and assessing any downstream legal or compliance requirements for your use.

#### How often is EDGAR updated?

The SEC processes filings continuously on business days. New 8-K filings appear within hours of submission. Schedule this actor daily to capture new filings as they appear.

#### Can I search for multiple keywords at once?

Yes — EDGAR's full-text search supports boolean operators. Try `"supply chain" AND "force majeure"` or `"cybersecurity" OR "data breach"` in your query field.

#### What form types are available?

The input dropdown exposes common forms including 10-K, 10-Q, 8-K, S-1, 20-F, 6-K, DEF 14A, SC 13G, Form 4 and 13F-HR. Leave `forms` empty to search all form types covered by SEC EFTS.

### Is it legal?

This actor accesses the [SEC EDGAR Full-Text Search System](https://efts.sec.gov/LATEST/search-index), a public U.S. government service provided by the Securities and Exchange Commission. All data returned is in the public domain and freely accessible per U.S. government open data policy. No login, scraping of private content, or circumvention of access controls is involved. Users are responsible for ensuring their use of financial disclosure data complies with applicable securities laws and their organization's policies.

### Related scrapers

- [logiover/b2b-lead-scraper](https://apify.com/logiover/b2b-lead-scraper) — Extract B2B leads by sector and country from OpenStreetMap.
- [logiover/comtrade-trade-data-scraper](https://apify.com/logiover/comtrade-trade-data-scraper) — UN Comtrade international trade flow data.
- [logiover/company-dossier-generator](https://apify.com/logiover/company-dossier-generator) — AI-generated company intelligence dossiers from public sources.
- [logiover/github-activity-monitor](https://apify.com/logiover/github-activity-monitor) — Monitor GitHub repos for commits, issues, and releases.

### 📝 Changelog

#### 2026-08-01

- Completed the August 2026 full health check: verified empty/programmatic default, Console UI default, and two source-informed alternative inputs on Apify.
- Confirmed successful live execution, non-empty structured output, dataset-field/type integrity, and logical sample quality within the 5-minute quality window.
- Added stable run-wide accession-number deduplication for SEC EFTS document-level hits, retaining the first upstream-ranked document and applying maxResults to unique filings without changing input query/filter semantics.
- Aligned README, input and dataset contracts with the unique-filing output and retained matched-document URL semantics.
- Corrected README coverage, direct-proxy default, numeric example and query-language claims against current SEC documentation.

#### 2026-08-01 — Health-check remediation

- August 2026 monthly health-check remediation is in progress; this build contains fixes verified from empty/default, Console-default, targeted live probes, or field-level semantic review.
- Defaulted to direct SEC EFTS access, verifies suspicious proxy-origin empty responses through another route, and fails explicitly when transport errors prevent all output.
- Deduplicates SEC's document-level hits run-wide by accession number, keeps the first upstream-ranked matching document, and applies `maxResults` to unique filings without changing query/filter provenance.
- The final four-input matrix verdict will be appended after post-build cloud revalidation.

# Actor input Schema

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

Full-text keyword or phrase to search across all SEC filings (e.g. 'artificial intelligence risk', 'cryptocurrency exposure', 'supply chain disruption'). Leave empty to run the default broad search and pull recent filings.

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

Filter by one or more SEC form types. Leave empty to search all forms.

## `sort` (type: `string`):

Order of returned rows. 'Relevance' uses EDGAR's full-text ranking. 'Newest first' / 'Oldest first' re-sort the collected results by filing date.

## `dateFrom` (type: `string`):

Start date filter in YYYY-MM-DD format (e.g. 2023-01-01). Leave empty for no start date filter.

## `dateTo` (type: `string`):

End date filter in YYYY-MM-DD format (e.g. 2024-12-31). Leave empty for no end date filter.

## `maxResults` (type: `integer`):

Maximum number of unique filing accessions to return. Multiple matching documents from the same filing count once. Default 200, max 10000.

## `proxyConfiguration` (type: `object`):

Optional Apify proxy settings. Direct access is the reliable default for the public SEC EFTS endpoint; when proxying, suspicious empty responses are verified across fresh routes and finally direct.

## Actor input object example

```json
{
  "query": "artificial intelligence",
  "forms": [],
  "sort": "relevance",
  "dateFrom": "",
  "dateTo": "",
  "maxResults": 200,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "query": "artificial intelligence",
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/sec-edgar-fulltext-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 = {
    "query": "artificial intelligence",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/sec-edgar-fulltext-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 '{
  "query": "artificial intelligence",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call logiover/sec-edgar-fulltext-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/cJi7VXlTcD83xKTeZ/builds/6AsDqCWJvnzvQs3qj/openapi.json