SEC Forms
What are the forms that companies file with the sec?
Publicly traded companies file various forms with the U.S. Securities and Exchange Commission (SEC) to maintain transparency, protect investors, and disclose financial performance.
The primary SEC forms filed by companies are categorized below by their purpose:
Periodic Financial Reports
These are the most frequently reviewed forms, giving investors regular updates on a company's financial health.
Form 10-K (Annual Report): A comprehensive, audited report filed yearly (typically 60 to 90 days after fiscal year-end) detailing a company's business history, financial condition, executive compensation, audited financial statements (balance sheet, income statement, cash flow statement), and management's discussion and analysis (MD&A).
Form 10-Q (Quarterly Report): An unaudited financial report filed within 40 to 45 days after the end of each of the first three fiscal quarters. It provides a snapshot of performance during that quarter.
Form 20-F: The annual report equivalent of the 10-K, but filed by foreign private issuers trading on U.S. exchanges.
Current Reports (Unscheduled Material Events)
Form 8-K: Known as the "current report," companies must file this within four business days of a major, unscheduled corporate event that shareholders should know about. Triggers include executive appointments or resignations, bankruptcy, earnings releases, entering into or terminating material agreements, or changes in control.
Form 6-K: The equivalent of an 8-K, filed by foreign private issuers to submit information they made public under foreign laws or stock exchange rules.
Proxy & Shareholder Meeting Filings
Form DEF 14A (Definitive Proxy Statement): Sent to shareholders prior to an annual meeting. It discloses matters to be voted on (such as board elections and executive compensation packages), voting procedures, and major shareholder details.
Insider Ownership & Trading (Section 16 Filings)
Corporate insiders (officers, directors, and beneficial owners of more than 10% of a class of equity securities) must report their stock ownership and trading activities:
Form 3: Initial statement of beneficial ownership when someone becomes an insider.
Form 4: Filed within two business days to report any changes in ownership (e.g., buying or selling shares).
Form 5: An annual summary of transactions that should have been reported on Form 4 or were exempt.
Form 144: Notice of proposed sale of restricted or control securities by an affiliate or insider.
Registration Statements (Securities Offerings)
When companies want to issue new shares or register classes of securities to the public, they file registration statements:
Form S-1: The standard registration statement for newly public companies launching an Initial Public Offering (IPO).
Form S-3 / Form F-3: A "short-form" or shelf registration statement used by companies that are already publicly traded and meet specific reporting criteria to issue additional securities efficiently.
Form S-8: Used to register securities offered to employees through stock option, savings, or benefit plans.
Any other forms like 13?
You are likely thinking of the Section 13 filings, which regulate major shareholders, institutional managers, and large-scale market participants under the Securities Exchange Act of 1934.
The primary forms starting with "13" are:
Form 13F (Institutional Holdings Report)
Who files it: Institutional investment managers with discretion over $100 million or more in qualifying equity securities (such as mutual funds, hedge funds, pension funds, and large RIAs).
What it contains: A quarterly snapshot listing all U.S. equity holdings, options, and convertible debt under management.
When it's filed: Within 45 days after the end of each calendar quarter. (Note: This is one of the most widely watched reports for tracking what "smart money" or prominent investors like Warren Buffett are buying and selling).
Schedule 13D (The "Activist" Beneficial Ownership Report)
Who files it: Any individual or group that acquires more than 5% of a class of registered voting equity securities of a public company and intends to influence or control the company.
What it contains:
The buyer's identity, background, and funding sources.
The explicit purpose of the purchase (e.g., whether they intend to launch a proxy fight, push for a sale, demand board seats, or alter corporate strategy).
When it's filed: Typically within 5 to 10 business days of crossing the 5% threshold. Any material changes require a prompt amendment.
Schedule 13G (The "Passive" Beneficial Ownership Report)
Who files it: Investors who cross the 5% ownership threshold but hold the shares strictly passively (i.e., with no intention of changing or influencing company control). This includes eligible institutional investors (banks, insurance companies, mutual funds) and certain passive individual holders.
What it contains: A much shorter, streamlined disclosure compared to a 13D, simply confirming the investor's identity, size of holdings, and passive intent.
Note: If a passive 13G holder's intentions change or if they cross ownership caps (like 20% for general passive investors), they must rapidly convert and refile as an active Schedule 13D.
Form 13H (Large Trader Reporting)
Who files it: Individuals or firms whose trading volume hits "large trader" thresholds—specifically, executing transactions in National Market System (NMS) securities equal to or greater than 2 million shares or $20 million in a single day, or 20 million shares or $200 million during a calendar month.
What it contains: Identifying information about the trader and their accounts so the SEC can monitor systemic risk and market manipulation.
When it's filed: Promptly upon meeting the activity threshold, with annual updates.
Trying to build a process for gemini agents that can access sec.gov via rag. What is the best way to approach this?
Building a robust Retrieval-Augmented Generation (RAG) process for SEC filings requires addressing a few unique challenges inherent to EDGAR data: massive document sizes (10-Ks can exceed 200 pages), heavy reliance on tabular financial data, and strict SEC rate limits.
The best architecture leverages a hybrid retrieval strategy (vector + keyword) combined with hierarchical parsing and agentic tool use.
Phase 1: Data Ingestion & Storage Pipeline
SEC filings are distributed primarily in HTML, XBRL (structured data), and ASCII/text formats via the EDGAR database.
Accessing & Downloading Data:
EDGAR API: Use the official SEC EDGAR REST API. Ensure your agent sets a valid User-Agent header containing your name and contact email (required by the SEC).
Rate Limiting: SEC.gov strictly enforces a limit of 10 requests per second. Your ingestion pipeline must implement robust rate limiting and exponential backoff.
Document Parsing (The Critical Step):
Traditional PDF chunking destroys financial tables. Instead, use parsing libraries capable of handling structured HTML/XML (such as BeautifulSoup combined with table-extraction tools like pdfplumber or specialized financial parsers).
Hierarchical Chunking: Split 10-Ks and 10-Qs by section (e.g., Item 1. Business, Item 1A. Risk Factors, Item 7. MD&A, and the Financial Statements note blocks) rather than arbitrary token lengths. Financial context lives inside specific sections.
Storage Architecture:
Vector Database: Store text chunks and semantic embeddings (e.g., using Google's text-embedding-004 or similar models) in a vector store like PostgreSQL with pgvector or Vertex AI Vector Search.
Relational/Metadata Database: Maintain a companion SQL database tracking metadata (Company Name, CIK, Form Type, Fiscal Year/Quarter, Filing Date) so agents can filter pre-retrieval (e.g., "Only search 10-Ks filed by AAPL in 2025").
Phase 2: Retrieval Strategy for Agents
Standard vector search often fails on financial queries because numbers, ticker symbols, and specific accounting terms require precise matching.
Hybrid Search (Keyword + Semantic):
Combine sparse retrieval (BM25 for exact terms like "goodwill impairment" or specific FASB accounting standards) with dense vector retrieval (for conceptual queries like "what are the primary headwinds facing their supply chain?").
Table-Aware Retrieval:
Financial statements (Balance Sheets, Income Statements) should be stored either as markdown tables or converted into structured JSON/SQL rows. Allow the agent to query structured data directly or via a code interpreter rather than relying solely on fuzzy text search for numbers.
Query Expansion & Decomposition:
Financial questions are often multi-part (e.g., "How did Apple's R&D spend scale relative to revenue growth over the last 3 years?"). Configure your agentic workflow to decompose complex queries into sub-questions, query multiple filings/years, and synthesize the results.
Phase 3: Agentic Architecture & Guardrails
When building Gemini agents to execute this workflow, implement a multi-tool or multi-agent pattern using frameworks like the Google Agent Development Kit:
Tool Definition:
Give the agent specific tools rather than a single black-box RAG function:
search_sec_filings(cik, form_type, year, query): For semantic text search within a specific filing.
get_financial_statement_table(cik, statement_type, fiscal_year): To pull exact balance sheet/income statement rows.
lookup_company_cik(ticker): To map ticker symbols (e.g., AAPL) to SEC CIK numbers.
Grounding & Citation Enforcement:
Require the agent to cite the exact filing, item number, and paragraph/table for every financial figure it reports.
Verification Step:
Incorporate a "critic" or verification agent step where the model cross-references calculated metrics or extracted values against the primary source chunks before outputting the final response.
What specific type of filings or financial questions (e.g., quantitative screening vs. qualitative risk analysis) are you prioritizing for your initial prototype?
Looking for detailed steps on how to build an agent with RAG process to sec.gov
Building a production-grade Agentic RAG pipeline for SEC EDGAR requires moving beyond naive chunk-and-embed architectures. Because SEC filings (10-Ks, 10-Qs) are massive, heavily structured documents with complex financial tables, the optimal approach combines SEC API ingestion, section-aware parsing, hybrid retrieval, and agentic navigation.
Here is a comprehensive architectural blueprint and step-by-step implementation guide.
Step 1: SEC EDGAR API Connection & Ingestion Pipeline
The SEC provides programmatic access via the EDGAR REST API. Your ingestion service must follow SEC compliance guidelines strictly.
Compliance Setup (User-Agent Header):
The SEC requires a custom User-Agent header containing your organization name and contact email (e.g., User-Agent: SampleCompanyName AdminContact@sample.com). Requests lacking this or exceeding 10 requests per second will be blocked.
Entity Resolution (Ticker to CIK Mapping):
Download the master CIK-to-ticker JSON mapping file provided by the SEC ([https://www.sec.gov/files/company_tickers.json](https://www.sec.gov/files/company_tickers.json)) to map user queries (e.g., "AAPL") to the Central Index Key (CIK) required for API endpoints.
Filing Metadata & Download:
Query the submissions endpoint ([https://data.sec.gov/submissions/CIK](https://data.sec.gov/submissions/CIK){cik.zfill(10)}.json) to retrieve a manifest of all historical filings, their accession numbers, and primary document file names.
Download the raw .htm files for target forms (10-K, 10-Q, 8-K).
Step 2: Structure-Aware Parsing & Chunking
Standard text splitters shred financial tables and lose vital accounting context. You must parse filings while preserving document topology.
HTML Parsing & Section Extraction:
Use BeautifulSoup or specialized financial parsers to strip boilerplate markup while retaining structural headings (e.g., Item 1. Business, Item 1A. Risk Factors, Item 7. Management’s Discussion and Analysis, and Item 8. Financial Statements).
Table Preservation:
Financial statements (Balance Sheets, Income Statements) must be converted into clean Markdown tables or structured JSON (or stored directly in a relational table) rather than flat text strings, allowing precise row/column evaluation.
Hierarchical / Node-Level Chunking:
Instead of arbitrary 500-token windows, chunk filings by structural nodes (sections, subsections, or individual note disclosures).
Attach robust metadata to every chunk: ticker, cik, form_type, filing_date, fiscal_year, fiscal_period, and section_name.
Step 3: Dual-Store Storage Architecture
Split your persistence layer between structured metadata and vector representations to support multi-faceted queries.
Relational / Metadata Database (PostgreSQL / SQL):
Maintain a relational table mapping filings to companies, dates, and sections. This allows pre-retrieval filtering (e.g., restricting a search strictly to Apple's 10-K filed in FY2025).
Vector Index (pgvector or Vertex AI Vector Search):
Generate dense embeddings (e.g., using Google's text-embedding-004) for each structural chunk and store them alongside their metadata and source pointers.
Step 4: Hybrid Retrieval & Reranking Strategy
Financial queries require exact terminology matching (e.g., specific accounting standards or line items) alongside semantic understanding.
Hybrid Search (BM25 + Dense Vector):
Combine keyword search (sparse BM25 for exact codes, footnote markers, or rare terms) with semantic similarity search (dense vector retrieval).
Two-Phase Retrieval with Reranking:
Retrieve top N candidates (e.g., 20 chunks) via hybrid search, then pass them through a cross-encoder reranker to score and filter down to the top 4–5 most relevant passages before injecting them into the LLM context window.
Step 5: Agentic Navigation & Tooling Design
Rather than forcing a single RAG function to guess, build an agentic loop equipped with specialized tools. This allows the Gemini model to dynamically inspect filings like a financial analyst:
lookup_cik(ticker): Resolves ticker symbols to SEC CIK numbers.
list_company_filings(cik, form_type, limit): Queries available 10-K/10-Q filings for a given company and timeframe.
get_filing_table_of_contents(accession_number): Returns the structural outline of the document so the agent can inspect section nodes.
search_sec_filings(query, cik, section, year): Executes a hybrid search across specific filing sections.
get_financial_statement_data(cik, statement_type, year): Pulls structured tabular financial data directly for precise numerical queries.
Step 6: Grounding, Verification, and Citations
To ensure your agent does not hallucinate financial figures:
Mandatory Citations: Instruct the agent to append explicit metadata citations (Form Type, Filing Date, Item Section, and Source URI) to every claim.
Self-Correction Loop: Implement a validation step where a secondary prompt or code execution check verifies that extracted numerical facts reconcile with the retrieved table chunks before returning the final response.
Steps and python code for build user agent
Building an SEC RAG Agent requires setting up a structured workflow where the model acts as the orchestrator, querying EDGAR endpoints or local filing databases through specialized Python tools.
Below is a step-by-step guide accompanied by a complete, production-grade implementation using Python and the Google GenAI SDK with automatic function calling.
Step 1: Project Setup & Dependencies
Create your project workspace and install the official Google GenAI SDK:
mkdir sec_agent_project
cd sec_agent_project
pip install --upgrade google-genai requests beautifulsoup4 pandas
export GEMINI_API_KEY="your_api_key_here"
export GEMINI_API_KEY="AQ.Ab8RN6KB2CCPBskinzfayCzx1xLwxrSxcWU4-U1FQfm4n1efEw"
Step 2: Complete Python Implementation (sec_agent.py)
This script defines an agent equipped with tools to fetch company CIK codes from the SEC, download recent filing lists, and search through filing contents.
import os
import requests
from google import genai
from google.genai import types
# Initialize the Gemini Client
# (Pulls GEMINI_API_KEY from environment automatically)
client = genai.Client()
# SEC requires a custom User-Agent with contact info
SEC_HEADERS = {
"User-Agent": "InstitutionalResearchUser admin@research-firm.com"
}
def lookup_cik(ticker: str) -> str:
"""Look up the SEC CIK number for a given stock ticker symbol.
Args:
ticker: The stock ticker symbol (e.g., 'AAPL', 'MSFT').
"""
url = "https://www.sec.gov/files/company_tickers.json"
response = requests.get(url, headers=SEC_HEADERS)
if response.status_code != 200:
return "Error connecting to SEC EDGAR."
data = response.json()
ticker_upper = ticker.upper()
for entry in data.values():
if entry["ticker"] == ticker_upper:
# CIK needs to be zero-padded to 10 digits for EDGAR API endpoints
return str(entry["cik_str"]).zfill(10)
return f"Ticker {ticker} not found."
def get_company_filings(cik: str, form_type: str = "10-K") -> list:
"""Retrieve a list of recent filings for a company given its CIK and form type.
Args:
cik: The 10-digit zero-padded CIK string.
form_type: The SEC form type (e.g., '10-K', '10-Q', '8-K').
"""
url = f"https://data.sec.gov/submissions/CIK{cik}.json"
response = requests.get(url, headers=SEC_HEADERS)
if response.status_code != 200:
return [{"error": "Failed to fetch company submissions from SEC."}]
data = response.json()
recent = data["filings"]["recent"]
filings = []
for i in range(len(recent["form"])):
if recent["form"][i] == form_type:
filings.append({
"form": recent["form"][i],
"filing_date": recent["filingDate"][i],
"accession_number": recent["accessionNumber"][i],
"primary_document": recent["primaryDocument"][i] # Fixed key lookup
})
if len(filings) >= 5: # Return top 5 recent matches
break
return filings
def run_sec_agent(user_query: str):
"""Executes the Gemini agent with SEC tools configured."""
print(f"\n[User Query]: {user_query}\n" + "-"*40)
response = client.models.generate_content(
model="gemini-2.5-flash",
contents=user_query,
config=types.GenerateContentConfig(
tools=[lookup_cik, get_company_filings],
system_instruction=(
"You are an expert financial analyst AI assistant specializing in SEC EDGAR filings. "
"Use the provided tools to locate company identifiers and check filing histories. "
"Always provide structured, professional answers with explicit details."
),
temperature=0.1,
),
)
print(f"[Agent Response]:\n{response.text}")
if __name__ == "__main__":
# Test the agent workflow
run_sec_agent("Find the CIK for Apple (AAPL) and list its 3 most recent 10-K annual reports.")
Step 3: Scaling to Full RAG (Vector Search Integration)
For deep document querying (e.g., "What did management say about supply chain risks in Item 7 of Apple's latest 10-K?"), extend the pattern above into a complete retrieval loop:
Ingestion Worker: Build a background script that downloads the primary .htm filing documents using the accession numbers retrieved via get_company_filings.
Structural Chunking & Parsing: Strip HTML boilerplate via BeautifulSoup, breaking text down by sections (Item 1, Item 7, etc.).
Embeddings & Vector Indexing: Generate vector embeddings for text chunks using Google's embedding models (text-embedding-004) and store them in a vector store like pgvector.
Custom RAG Tool: Wrap your vector database query inside a Python function (e.g., search_sec_vector_db(query, ticker, section)) and pass it to Gemini as a tool alongside lookup_cik. This allows the agent to dynamically search local filing chunks whenever financial context or qualitative analysis is requested.
# 1. Deactivate any active environments if needed, then remove the old project folder or stay inside it
cd ~/sec_agent_project
# 2. Create a clean virtual environment named 'venv'
python3 -m venv venv
# 3. Activate the virtual environment
source venv/bin/activate
# 4. Upgrade pip and install your SEC agent dependencies cleanly
pip install --upgrade pip
pip install google-genai requests beautifulsoup4 pandas
Running inside an isolated venv ensures that updates to google-genai won't break your other libraries (like OpenBB or local SDKs), and your sec_agent.py script will run without version collisions.
Now that your virtual environment is set up and your baseline dependencies are clean, you are ready to test, expand, and scale your SEC RAG agent.
Step 1: Run and Verify Your Baseline Script
First, make sure your virtual environment is active and run your initial tool-use script:
# 1. Activate the environment (if not already active)
source venv/bin/activate
# 2. Run the script
python sec_agent.py
john_iacovacci1@cloudshell:~/sec_agent_project/venv (sentiment-analysis-379200)$ python sec_agent.py
[User Query]: Find the CIK for Apple (AAPL) and list its 3 most recent 10-K annual reports.
----------------------------------------
Direct use of automatic function calling (AFC) in Models.generate_content is not recommended. Instead, we recommend to use AFC in Chat.send_message. Similarly, direct use of AFC in Models.generate_content_stream is not recommended. Instead, we recommend to use AFC in Chat.send_message_stream.
[Agent Response]:
Here is the requested information for Apple (AAPL):
**CIK Number:** 0000320193
**3 Most Recent 10-K Annual Reports:**
1. **Filing Date:** 2025-10-31
**Accession Number:** 0000320193-25-000079
2. **Filing Date:** 2024-11-01
**Accession Number:** 0000320193-24-000123
3. **Filing Date:** 2023-11-03
**Accession Number:** 0000320193-23-000106
john_iacovacci1@cloudshell:~/sec_agent_project/venv (sentiment-analysis-379200)$
Fantastic! Your SEC agent is up, running, and successfully executing automatic function calling.
As you can see in the output, the agent autonomously:
Called lookup_cik to map AAPL to its 10-digit CIK (0000320193).
Called get_company_filings using that CIK to query the SEC submissions API.
Extracted and cleanly structured Apple's three most recent 10-K filings with their exact filing dates and accession numbers.
What's Next?
Now that your agent can discover and list filings, the next logical step is to give it the ability to download and ingest the actual filing text so it can answer qualitative questions.
Here is how you can add the file-downloading capability to your script:
1. Add the Download Tool Function
Append this function to your sec_agent.py script:
def download_filing_document(cik: str, accession_number: str, primary_document: str) -> str:
"""Download the raw primary HTML document for a specific SEC filing.
Args:
cik: The 10-digit zero-padded CIK string.
accession_number: The unique accession number of the filing (e.g., '0000320193-25-000079').
primary_document: The primary document file name (e.g., 'aapl-20251031.htm').
"""
# EDGAR archive path removes hyphens from the accession number
acc_no_no_hyphen = accession_number.replace("-", "")
url = f"https://www.sec.gov/Archives/edgar/data/{int(cik)}/{acc_no_no_hyphen}/{primary_document}"
response = requests.get(url, headers=SEC_HEADERS)
if response.status_code == 200:
filename = f"filing_{cik}_{accession_number}.htm"
with open(filename, "w", encoding="utf-8") as f:
f.write(response.text)
return f"Successfully downloaded filing to local storage as {filename}."
return f"Failed to download filing. HTTP Status code: {response.status_code}"
2. Register It as a Tool
Add download_filing_document to your tools=[...] list inside run_sec_agent() so Gemini can invoke it whenever it needs to pull down a report.
3. Test a Combined Query
Try updating your test prompt to see the agent chain multiple tools together:
import os
import requests
from google import genai
from google.genai import types
# Initialize the Gemini Client
client = genai.Client()
# SEC requires a custom User-Agent with contact info
SEC_HEADERS = {
"User-Agent": "InstitutionalResearchUser admin@research-firm.com"
}
def lookup_cik(ticker: str) -> str:
"""Look up the SEC CIK number for a given stock ticker symbol.
Args:
ticker: The stock ticker symbol (e.g., 'AAPL', 'MSFT').
"""
url = "https://www.sec.gov/files/company_tickers.json"
response = requests.get(url, headers=SEC_HEADERS)
if response.status_code != 200:
return "Error connecting to SEC EDGAR."
data = response.json()
ticker_upper = ticker.upper()
for entry in data.values():
if entry["ticker"] == ticker_upper:
return str(entry["cik_str"]).zfill(10)
return f"Ticker {ticker} not found."
def get_company_filings(cik: str, form_type: str = "10-K") -> list:
"""Retrieve a list of recent filings for a company given its CIK and form type.
Args:
cik: The 10-digit zero-padded CIK string.
form_type: The SEC form type (e.g., '10-K', '10-Q', '8-K').
"""
url = f"https://data.sec.gov/submissions/CIK{cik}.json"
response = requests.get(url, headers=SEC_HEADERS)
if response.status_code != 200:
return [{"error": "Failed to fetch company submissions from SEC."}]
data = response.json()
recent = data["filings"]["recent"]
filings = []
for i in range(len(recent["form"])):
if recent["form"][i] == form_type:
filings.append({
"form": recent["form"][i],
"filing_date": recent["filingDate"][i],
"accession_number": recent["accessionNumber"][i],
"primary_document": recent["primaryDocument"][i]
})
if len(filings) >= 3: # Return top 3 recent matches
break
return filings
def download_filing_document(cik: str, accession_number: str, primary_document: str) -> str:
"""Download the raw primary HTML document for a specific SEC filing.
Args:
cik: The 10-digit zero-padded CIK string.
accession_number: The unique accession number of the filing (e.g., '0000320193-25-000079').
primary_document: The primary document file name (e.g., 'aapl-20251031.htm').
"""
acc_no_no_hyphen = accession_number.replace("-", "")
url = f"https://www.sec.gov/Archives/edgar/data/{int(cik)}/{acc_no_no_hyphen}/{primary_document}"
response = requests.get(url, headers=SEC_HEADERS)
if response.status_code == 200:
filename = f"filing_{cik}_{accession_number}.htm"
with open(filename, "w", encoding="utf-8") as f:
f.write(response.text)
return f"Successfully downloaded filing to local storage as {filename}."
return f"Failed to download filing. HTTP Status code: {response.status_code}"
def run_sec_agent(user_query: str):
"""Executes the Gemini agent using a chat session for robust automatic function calling."""
print(f"\n[User Query]: {user_query}\n" + "-"*40)
chat = client.chats.create(
model="gemini-2.5-flash",
config=types.GenerateContentConfig(
tools=[lookup_cik, get_company_filings, download_filing_document],
system_instruction=(
"You are an expert financial analyst AI assistant specializing in SEC EDGAR filings. "
"Use the provided tools to locate company identifiers, check filing histories, "
"and download primary filing documents when requested. "
"Always provide structured, professional answers with explicit details."
),
temperature=0.1,
)
)
response = chat.send_message(user_query)
print(f"[Agent Response]:\n{response.text}")
if __name__ == "__main__":
# Test the multi-step agent workflow
run_sec_agent("Find the CIK for Apple, get its most recent 10-K filing details, and download the primary HTML document.")
john_iacovacci1@cloudshell:~/sec_agent_project/venv (sentiment-analysis-379200)$ python sec_agent.py
[User Query]: Find the CIK for Apple, get its most recent 10-K filing details, and download the primary HTML document.
----------------------------------------
[Agent Response]:
Here are the details of your request:
**Company:** Apple Inc.
**CIK:** 0000320193
**Most Recent 10-K Filing Details:**
* **Accession Number:** 0000320193-25-000079
* **Filing Date:** 2025-10-31
* **Form Type:** 10-K
* **Primary Document Name:** aapl-20250927.htm
**Primary HTML Document Download Status:**
The primary HTML document for the specified 10-K filing has been successfully downloaded to local storage as `filing_0000320193_0000320193-25-000079.htm`.
john_iacovacci1@cloudshell:~/sec_agent_project/venv (sentiment-analysis-379200)$
john_iacovacci1@cloudshell:~/sec_agent_project/venv (sentiment-analysis-379200)$ ls -lt
total 1512
-rw-rw-r-- 1 john_iacovacci1 john_iacovacci1 1520317 Oct 16 11:41 filing_0000320193_0000320193-25-000079.htm
-rw-r--r-- 1 john_iacovacci1 john_iacovacci1 4136 Oct 16 11:41 sec_agent.py
drwxrwxr-x 2 john_iacovacci1 john_iacovacci1 4096 Oct 15 19:22 bin
drwxrwxr-x 3 john_iacovacci1 john_iacovacci1 4096 Oct 15 19:22 include
drwxrwxr-x 3 john_iacovacci1 john_iacovacci1 4096 Oct 15 19:22 lib
lrwxrwxrwx 1 john_iacovacci1 john_iacovacci1 3 Oct 15 19:22 lib64 -> lib
-rw-rw-r-- 1 john_iacovacci1 john_iacovacci1 183 Oct 15 19:22 pyvenv.cfg
john_iacovacci1@cloudshell:~/sec_agent_project/venv (sentiment-analysis-379200)$
No comments:
Post a Comment