SEC APIsec.gov ↗
Search SEC-registered companies by name or ticker and retrieve filings with type, date, accession number, SIC code, and exchange data via two endpoints.
What is the SEC API?
The SEC EDGAR API exposes 2 endpoints for searching SEC-registered companies and retrieving their regulatory filings. The search_company endpoint queries the full SEC company tickers index by name or ticker symbol and returns CIK numbers alongside company names. The get_company_filings endpoint returns company metadata — including SIC code, state of incorporation, fiscal year end, and listed exchanges — plus a list of recent filings with accession numbers, filing types, and dates.
curl -X GET 'https://api.parse.bot/scraper/6b52a6ac-40c7-4863-a0a4-17dd6f4be10c/search_company?limit=5&query=Apple' \ -H 'X-API-Key: $PARSE_API_KEY'
Typed, relational, agent-ready
A generated client with real types, enums, and the links between objects — the structure a flat JSON response can't carry. Autocompletes in your editor and reads cleanly to coding agents.
- Fully typed · autocompletes
- Objects link to objects
- Typed errors & pagination
Typed Python client. Set up the SDK in your uv project, then pull this API’s typed client:
uv add parse-sdk uv run parse init uv run parse add --marketplace sec-gov-api
uv run parse add --marketplace pulls a pinned snapshot of this canonical API — it won’t change underneath you. To customize it, subscribe and swap to your own copy.
"""SEC EDGAR Company & Filings API — bounded, re-runnable walkthrough."""
from parse_apis.sec_edgar_company___filings_api import SecEdgar, CompanyNotFound
client = SecEdgar()
# Search for companies matching "Tesla" — limit caps total items fetched.
for company in client.companysummaries.search(query="Tesla", limit=3):
print(company.company_name, company.ticker, company.cik)
# Drill down: take the first Apple result and get full company details + filings.
match = client.companysummaries.search(query="Apple", limit=1).first()
if match:
detail = match.details()
print(detail.company_name, detail.sic_description, detail.exchanges)
for filing in detail.filings[:3]:
print(filing.filing_type, filing.filing_date, filing.description)
# Direct lookup by CIK using the companies collection.
try:
apple = client.companies.get(cik="320193")
print(apple.company_name, apple.total_recent_filings)
except CompanyNotFound as exc:
print(f"Not found: {exc}")
print("exercised: companysummaries.search / CompanySummary.details / companies.get")
Search for SEC-registered companies by name or ticker symbol. Returns matching companies with their name, ticker, and CIK number. Searches the full SEC company tickers index, matching against both company name and ticker symbol (case-insensitive substring match). No pagination; results are capped by the limit parameter.
| Param | Type | Description |
|---|---|---|
| limit | integer | Maximum number of results to return. |
| query | string | Company name or ticker to search for (case-insensitive substring match). |
{
"type": "object",
"fields": {
"query": "string - the search query used",
"companies": "array of objects with company_name, ticker, and cik",
"total_matches": "integer - number of matching companies returned"
},
"sample": {
"data": {
"query": "Apple",
"companies": [
{
"cik": "320193",
"ticker": "AAPL",
"company_name": "Apple Inc."
},
{
"cik": "1418121",
"ticker": "APLE",
"company_name": "Apple Hospitality REIT, Inc."
}
],
"total_matches": 5
},
"status": "success"
}
}About the SEC API
Company Search
The search_company endpoint accepts a query string and performs a case-insensitive substring match against the SEC's full company tickers index, matching on both company name and ticker symbol. The response includes each match's company_name, ticker, and cik (the SEC's Central Index Key), plus a total_matches count. An optional limit parameter caps the number of results returned. Pagination is not supported; narrow your query string to reduce the result set.
Company Filings and Details
The get_company_filings endpoint takes a cik value (leading zeros not required) and returns two categories of data. Company-level fields include company_name, entity_type, sic, state, fiscal_year_end (in MMDD format), website, tickers, and exchanges. The filings array contains one object per filing, each with accession_number, filing_type (e.g. 10-K, 8-K, DEF 14A), filing_date, report_date, primary_document, and description. Use the limit parameter to control how many filings are returned.
Data Coverage and Relationships
The two endpoints are designed to work in sequence: run search_company to find a company's CIK, then pass that CIK to get_company_filings. The CIK is returned zero-padded to 10 digits in the filings response, but both formats are accepted as input. SIC codes and exchange names reflect the company's current registration data on EDGAR, not historical snapshots.
Official Source Notes
SEC EDGAR is a public regulatory database maintained by the U.S. Securities and Exchange Commission. SEC does provide a public data API at https://data.sec.gov/, documented at https://www.sec.gov/developer. The Parse API surfaces a structured, consistent interface over the same underlying data, handling CIK normalization and index matching for you.
The SEC API is a managed, monitored endpoint for sec.gov — not a raw scraper you maintain. Every endpoint is automatically health-checked on a schedule, and when sec.gov changes and a check fails, the API is automatically queued for repair and re-verified. It is built to keep working as the site underneath it changes.
This isn't an official sec.gov API — it's an independent, maintained REST wrapper over public data. Where the source has no official API (or only a limited one), Parse gives you a stable contract over a source that never promised one, and keeps it current. Need a new endpoint or field? You can revise it yourself in plain English and the agent rebuilds it against the live site in minutes — contributing the change back to the shared API is free.
Will this API break when the source site changes?+
Is this an official API from the source site?+
Can I fix or extend this API myself if I need a new endpoint or field?+
What happens if I call an endpoint that has an issue?+
- Look up a public company's CIK by ticker symbol before pulling its 10-K filings
- Retrieve the most recent 8-K filings for a watchlist of companies to monitor material events
- Map SIC codes from
get_company_filingsto industry buckets for sector-level analysis - Extract
fiscal_year_endfields to align financial data across companies with non-calendar fiscal years - Build a filing alert system that checks
filing_datefields for newly submitted documents - Resolve company names to canonical CIKs for deduplicating multi-source financial datasets
- Pull
exchangesandtickersarrays to verify current exchange listing status of a company
| Tier | Price | Credits/month | Rate limit |
|---|---|---|---|
| Free | $0/mo | 100 | 5 req/min |
| Hobby | $30/mo | 1,000 | 20 req/min |
| Developer | $100/mo | 5,000 | 100 req/min |
One credit = one API call regardless of which marketplace API you call. Exceeding the rate limit returns a 429 response. Authenticate with the X-API-Key header.
Does the SEC have an official developer API?+
What does `get_company_filings` return beyond the filings list?+
filings array, the endpoint returns company_name, cik (zero-padded to 10 digits), entity_type, sic, state (state of incorporation), fiscal_year_end (MMDD format), website, tickers, and exchanges. These fields come from the company's current EDGAR registration record.Does `search_company` support paginating through large result sets?+
limit results from a single pass through the SEC tickers index. If you need a specific company, use a more precise query string to reduce the match count. You can fork this API on Parse and revise it to add offset-based pagination if your use case requires iterating through large result sets.Does the API return the full text or document content of individual filings?+
accession_number, filing_type, filing_date, report_date, primary_document filename, and a short description for each filing, but not the document body or exhibit contents. You can fork this API on Parse and revise it to add a document-retrieval endpoint using the accession number.