SEC Filings Search API: Free EDGAR Endpoints, Paid Options, and Working Code

TLDR: The SEC already runs a free SEC filings search API. data.sec.gov returns every company's filing history and XBRL financial data as JSON with no key, and the JSON endpoint behind EDGAR Full-Text Search covers filing text since 2001. You need a declared User-Agent and no more than 10 requests per second. Pay for a vendor when you need parsed sections, faster alerts, or support. Use a research API when the job is answering questions about filings.
Most teams that go looking for an SEC filings API are trying to do one of four things: find a company's latest 10-K, find every filing that mentions a phrase, pull a financial number across years, or get a cited answer to a question that spans several filings. EDGAR covers the first three for free, with sharp edges. This guide maps each job to an endpoint, shows working Python for the free three, and says where paid indexers and You.com earn their cost.
What should an SEC filings search API do?
"Search" hides four different retrieval problems, and each one has a different best source:
JobExample questionFree EDGAR sourceReturnsResolve the filerWhat is Apple's CIK?company_tickers.jsonTicker, CIK, and company name for filers that have a tickerList filingsWhat did this company file in the last year?Submissions API on data.sec.govForm type, dates, accession numbers, and primary document namesSearch textWhich 2026 10-Ks disclose a material weakness?JSON endpoint behind EDGAR Full-Text SearchMatching documents with filer, form, and datePull numbersWhat was revenue in each of the last ten fiscal years?XBRL Company Concept, Company Facts, and Frames APIsTagged financial facts with period, value, and source filingAnswer a questionHow did the export-control risk factors change year over year?NoneNeeds a reader on top of retrieval: an LLM, a research API, or an analyst
The last row causes most of the confusion. A filing index tells you which documents match; it does not read them. Some vendors sell better indexes and some sell reading, so know which one you are buying.
What does EDGAR give you for free?
The SEC's EDGAR API documentation says the data.sec.gov APIs "do not require any authentication or API keys." They cover each filer's submission history and the XBRL data extracted from financial statements in 10-Q, 10-K, 8-K, 20-F, 40-F, and 6-K filings and their variants. The JSON updates as filings are disseminated, typically in under a second for submissions and under a minute for XBRL, with longer delays at peak filing times. Nightly bulk ZIP files of both datasets are republished at about 3:00 a.m. ET.
EndpointWhat it is forLimits worth knowingdata.sec.gov/submissions/CIK##########.jsonA filer's names, tickers, and filing historyThe recent block holds at least one year or 1,000 filings, whichever is more; older filings sit in extra files listed under filesdata.sec.gov/api/xbrl/companyconcept/...Every value one company reported for one tag, such as revenueThe same fact repeats in each later filing that restates itdata.sec.gov/api/xbrl/companyfacts/...All tagged facts for one company in one callLarge payloads for big filersdata.sec.gov/api/xbrl/frames/...One fact per company for a period, across all filersPeriods are calendar-aligned approximations of fiscal periodsefts.sec.gov/LATEST/search-indexFull-text search of filings since 2001100 hits per page and a 10,000-hit window; not a documented API
Two rules apply to all of it. The SEC's fair access guidelines limit each user to 10 requests per second in total, regardless of how many machines send them, and the SEC reserves the right to block IP addresses that exceed it. And the Accessing EDGAR Data page asks automated clients to declare a User-Agent in the form "Sample Company Name AdminContact@<sample company domain>.com". In our tests, a request without one came back 403 Forbidden. data.sec.gov also does not support CORS, so these calls belong on a server, not in browser code.
Full-text search needs a caveat of its own. The Full-Text Search FAQ documents the search interface and its query syntax, but the SEC does not list the JSON endpoint behind that interface among its documented APIs. The hosted edgar.tools service and the open-source EdgarTools library both build on it, but it can change without notice, so isolate it behind one function.
How do you search SEC filings in Python?
The script below uses only the Python standard library, so it runs anywhere Python 3.9 or later is installed. It resolves a ticker to a CIK, lists the newest annual and quarterly reports, runs a full-text query, and pulls one financial concept by year. We ran it against EDGAR on November 4, 2026, and the four requests finished in under two seconds.
import json
import time
import urllib.parse
import urllib.request
# The SEC asks automated clients to declare who they are. Use your own name and email.
USER_AGENT = "Example Research Co admin@example.com"
MIN_INTERVAL = 0.125 # 8 requests per second, under the SEC's 10 per second limit
_last_call = 0.0
def get_json(url: str) -> dict:
"""GET a JSON document from SEC.gov with a declared User-Agent and a simple throttle."""
global _last_call
wait = MIN_INTERVAL - (time.monotonic() - _last_call)
if wait > 0:
time.sleep(wait)
req = urllib.request.Request(url, headers={"User-Agent": USER_AGENT, "Accept-Encoding": "identity"})
with urllib.request.urlopen(req, timeout=30) as resp:
_last_call = time.monotonic()
return json.load(resp)
def ticker_to_cik(ticker: str) -> str:
"""Map a ticker to the 10-digit, zero-padded CIK that data.sec.gov expects."""
for row in get_json("https://www.sec.gov/files/company_tickers.json").values():
if row["ticker"].upper() == ticker.upper():
return str(row["cik_str"]).zfill(10)
raise KeyError(f"unknown ticker {ticker}")
def filing_url(cik: str, accession: str, document: str) -> str:
return f"https://www.sec.gov/Archives/edgar/data/{int(cik)}/{accession.replace('-', '')}/{document}"
def recent_filings(cik: str, forms: set[str], limit: int = 10) -> list[dict]:
"""Newest filings of the given form types from the Submissions API."""
recent = get_json(f"https://data.sec.gov/submissions/CIK{cik}.json")["filings"]["recent"]
rows = []
for i, form in enumerate(recent["form"]):
if form in forms:
rows.append({
"form": form,
"filed": recent["filingDate"][i],
"period": recent["reportDate"][i],
"url": filing_url(cik, recent["accessionNumber"][i], recent["primaryDocument"][i]),
})
if len(rows) == limit:
break
return rows
def full_text_search(query: str, forms: str, start: str, end: str, max_filings: int = 200) -> list[dict]:
"""Search filing text through the JSON endpoint behind EDGAR Full-Text Search.
Hits are documents, not filings: one filing can match in its main document and in
several exhibits. This keeps the first hit per accession number. The index serves
100 hits per page and refuses to page past 10,000, so narrow by date for big sets.
"""
filings: dict[str, dict] = {}
offset = 0
while len(filings) < max_filings and offset < 10_000:
params = urllib.parse.urlencode({
"q": query, "forms": forms, "dateRange": "custom",
"startdt": start, "enddt": end, "from": offset,
})
hits = get_json(f"https://efts.sec.gov/LATEST/search-index?{params}")["hits"]["hits"]
if not hits:
break
for hit in hits:
src = hit["_source"]
accession, document = hit["_id"].split(":", 1)
if accession in filings:
continue
filings[accession] = {
"company": src["display_names"][0],
"form": src["form"],
"filed": src["file_date"],
"url": filing_url(src["ciks"][0], accession, document),
}
offset += len(hits)
return list(filings.values())[:max_filings]
def annual_values(cik: str, tag: str, unit: str = "USD") -> dict[str, int]:
"""One value per fiscal year for a us-gaap concept, from the XBRL Company Concept API.
The same fact is repeated in every later filing that restates it. Keeping only facts
that carry an annual 'frame' (CY2024, not CY2024Q3 or CY2024Q4I) leaves one per year.
"""
data = get_json(f"https://data.sec.gov/api/xbrl/companyconcept/CIK{cik}/us-gaap/{tag}.json")
out = {}
for fact in data["units"].get(unit, []):
frame = fact.get("frame", "")
if fact.get("form", "").startswith("10-K") and frame.startswith("CY") and "Q" not in frame:
out[frame] = fact["val"]
return dict(sorted(out.items()))
if __name__ == "__main__":
cik = ticker_to_cik("AAPL")
for f in recent_filings(cik, {"10-K", "10-Q"}, limit=3):
print(f["form"], f["filed"], f["url"])
for f in full_text_search('"material weakness"', "10-K", "2026-01-01", "2026-10-31", max_filings=5):
print(f["filed"], f["form"], f["company"])
print(annual_values(cik, "RevenueFromContractWithCustomerExcludingAssessedTax"))
A few decisions in that code are deliberate:
Where do the free endpoints fall short?
The free stack handles a lot of production work, but plan for these limits:
When is a paid SEC filings API worth it?
Paid indexers sell what EDGAR does not: richer queries over filing metadata, pre-parsed content, and someone to call. sec-api.io's Query API, for example, searches EDGAR filings and exhibits back to 1993 (its pricing page counts more than 20 million filings and more than 100 million exhibits and attachments) with Lucene syntax across fields like ticker, form type, 8-K item codes, and exhibit types. It says new filings are searchable less than 300 milliseconds after they appear on EDGAR. Each response holds up to 50 filings, and one query can page through up to 10,000.
OptionPrice as of November 2026Full-text searchBest forEDGAR data.sec.gov plus Full-Text SearchFreeYes, since 2001, 10,000-hit windowMost internal tools, research, and prototypesEdgarTools (open source)Free, MIT licenseYes, through EDGAR's full-text index, since 2001Python teams that want parsed sections, typed filing objects, and XBRL statements without writing the plumbingsec-api.io Personal & Startups$49 a month billed annually ($588 a year)Not includedIndividual developers and small startups using metadata search and extractorssec-api.io Business Internal Use$199 a month billed annually ($2,388 a year)Included, 20 requests per secondTeams using the data inside their own organizationedgar.toolsTiered; full-text search on Professional and aboveYes, backed by EDGAR's full-text indexTeams that want EdgarTools parsing as a hosted, cited service
Before you pay anyone, note that the sec-api.io Free plan covers 100 API calls with no credit card, which is enough to test a query. The honest test is speed across all filers and parsing at scale. If you need a push stream of every new filing, clean Item 1A text from thousands of 10-Ks, or plan to redistribute the data (sec-api.io puts redistribution on its custom Enterprise plan), a paid indexer can save real engineering time. If you run a nightly job over a watchlist, the free endpoints and the code above will do it. Before you write your own 10-K parser, try EdgarTools: its README lists Item 1A and Item 7 section text, full-text search, and rate limiting within the SEC's 10 per second, all in your own process. edgar.tools is the hosted platform built on it.
Where does You.com fit, and where does it not?
You.com is not a filing index, and it is not where the numbers you will compute on should come from. Where it helps is the last row of the first table: reading filings and answering questions with citations a reviewer can check.
There are two ways to do that. The Research API runs multiple searches, reads the sources, and returns a Markdown answer with inline citations, and its source_control setting, currently in beta, can restrict it to a strict domain allowlist such as sec.gov. The Finance Research API searches a finance-optimized index that includes SEC filings, company fundamentals, earnings transcripts, and financial news, but it does not accept source_control.
import json
import os
import urllib.request
def ask_filings(question: str, effort: str = "standard") -> dict:
"""Ask the You.com Research API a question, answered only from pages on sec.gov."""
body = {
"input": question,
"research_effort": effort, # lite, standard, deep, or exhaustive
"source_control": {"include_domains": ["sec.gov"]},
}
req = urllib.request.Request(
"https://api.you.com/v1/research",
data=json.dumps(body).encode(),
headers={"X-API-Key": os.environ["YDC_API_KEY"], "Content-Type": "application/json"},
method="POST",
)
with urllib.request.urlopen(req, timeout=150) as resp:
output = json.load(resp)["output"]
return {
"answer": output["content"], # Markdown with [[1, 2]] style citations
"sources": [s["url"] for s in output.get("sources", [])],
}
if __name__ == "__main__":
result = ask_filings(
"How did the risk factors about export controls change between Nvidia's "
"two most recent 10-K filings? Quote the filings."
)
print(result["answer"])
for i, url in enumerate(result["sources"], 1):
print(i, url)
The pairing that works is EDGAR to find, a research API to read. Use full-text search to build the candidate set, such as every 10-K that mentions a going-concern doubt, then send scoped questions about specific companies to the Research API and store the cited sources beside each answer. Because include_domains is a strict allowlist, the answer's sources are limited to sec.gov rather than commentary about the filing.
Cost is per question. At published prices as of November 2026, the Research API costs $12 per 1,000 requests at lite, $50 at standard, $100 at deep, and $450 at exhaustive. The Finance Research API costs $110 per 1,000 at deep and $500 at exhaustive. Two hundred standard questions a month come to $10. Standard requests typically take 10 to 30 seconds, and the example allows 150. Deep and exhaustive requests can run up to two and five minutes, so raise the timeout above that. The Research API also accepts background: true for polling; the Finance Research API has no background mode.
Treat the answers as research, not as filings. You.com's own documentation says the Finance Research API is "not a structured data feed or time series API" and tells users to follow citations to the primary source before numbers inform investment decisions, client reports, or regulatory filings. For figures you will compute on, use the XBRL APIs above. For more on how the Research API handles depth and citations, see our Research API guide and the Finance Research API launch post.
How do you choose?
Filings rarely live alone in a pipeline. Our guides to earnings call transcript APIs and alternative data APIs cover the sources that usually sit next to EDGAR, and building an AI equity research team shows how they combine in one workflow.
Before you commit to any option, run the same 20 real questions through it: five filer lookups, five text searches, five financial pulls, and five questions that need reading. Time each one, check every citation or URL, and price the run at your real monthly volume.
Frequently Asked Questions
Yes. The SEC's data.sec.gov APIs return each company's filing history and the XBRL financial data from its statements as JSON, with no account or API key. The JSON endpoint behind EDGAR Full-Text Search covers filing text since 2001. Every request needs a User-Agent that names you and gives a contact email, and all of your traffic together must stay at or under 10 requests per second.
The SEC runs EDGAR Full-Text Search, which covers electronic filings since 2001 and supports exact phrases, OR, NOT, suffix wildcards, and NEAR proximity. It documents the search page and its syntax, but not the JSON endpoint behind it. That endpoint serves 100 hits per page and stops at 10,000 hits, so slice large searches by date and keep the call in one function in case it changes.
The SEC's fair access guidelines allow each user no more than 10 requests per second in total, regardless of how many machines send them, and the SEC reserves the right to block IP addresses that exceed it. Requests must also declare a User-Agent with a company name and contact email. In our tests, a request without one returned 403 Forbidden. Throttle all of your threads through one shared limiter.
Use the XBRL APIs on data.sec.gov. Company Concept returns every value a company reported for one tag, Company Facts returns all of its tagged facts, and Frames returns one value per company for a period. Deduplicate by the frame field, because later filings repeat restated values, and do not label periods with fy, which describes the filing rather than the period.
It depends on latency and parsing. sec-api.io says new filings are searchable within 300 milliseconds and offers Lucene queries over filing metadata plus section extractors. As of November 2026, full-text search starts on its Business Internal Use plan at $199 a month billed annually. For nightly jobs over a watchlist, the free EDGAR endpoints and open-source EdgarTools usually cover the work.
Yes, if you treat the answer as research rather than as the filing. The You.com Research API can restrict its sources to sec.gov with a strict domain allowlist and returns Markdown with inline citations. The Finance Research API adds fundamentals, transcripts, and news. Use EDGAR to find the filings, and use the XBRL APIs for any number you will compute on.
LI Test
LI Test
Share Article:
Related resources.

Introducing the You.com Extract API: fetch and parse any URL, with 80% higher accuracy on PDFs
November 17, 2026
Product Updates

How to Use the You.com Research API in Python
November 11, 2026
Blog

How to Use the You.com Web Search API in Rust
November 6, 2026
Blog

How to Use the You.com Contents API in Python
November 4, 2026
Blog

How to Build AI SDR Research with the You.com Research API
October 30, 2026
Blog
