Fundamentals APIs — Financials, Filings & Company Data

import requests
import pandas as pd

# EDGAR requires a User-Agent header with your email
headers = {"User-Agent": "YourApp/1.0 ([email protected])"}

# Get all XBRL facts for Apple (CIK = 0000320193)
url = "https://data.sec.gov/api/xbrl/companyfacts/CIK0000320193.json"
data = requests.get(url, headers=headers).json()

# Extract revenue (us-gaap:Revenues or RevenueFromContractWithCustomerExcludingAssessedTax)
revenue_facts = data["facts"]["us-gaap"]["RevenueFromContractWithCustomerExcludingAssessedTax"]
units = revenue_facts["units"]["USD"]

# Filter for 10-K annual filings only
annual = [u for u in units if u["form"] == "10-K"]
for a in annual[-5:]:
    print(f"  {a['end']}: ${a['val']/1e9:.1f}B")

# Output:
# 2021-09-25: $365.8B
# 2022-09-24: $394.3B
# 2023-09-30: $383.3B
# 2024-09-28: $391.0B
# 2025-09-27: $410.2B

# Search all filings for a keyword
search_url = "https://efts.sec.gov/LATEST/search-index?q=\"artificial intelligence\"&dateRange=custom&startdt=2025-01-01&enddt=2026-03-06&forms=10-K"
results = requests.get(search_url, headers=headers).json()

print(f"Found {results['hits']['total']['value']} 10-K filings mentioning 'artificial intelligence'")
for hit in results["hits"]["hits"][:5]:
    print(f"  {hit['_source']['display_names'][0]} — {hit['_source']['file_date']}")

# Get recent insider filings for Apple
filings_url = "https://data.sec.gov/submissions/CIK0000320193.json"
company = requests.get(filings_url, headers=headers).json()

# Filter for Form 4 (insider transactions)
recent = company["filings"]["recent"]
form4_indices = [i for i, f in enumerate(recent["form"]) if f == "4"]

for i in form4_indices[:5]:
    print(f"  {recent['filingDate'][i]} — {recent['primaryDocument'][i]}")

import requests

FMP_KEY = "YOUR_FMP_KEY"
base = "https://financialmodelingprep.com/api/v3"

# Income Statement (quarterly)
income = requests.get(f"{base}/income-statement/AAPL?period=quarter&limit=8&apikey={FMP_KEY}").json()
for q in income[:4]:
    print(f"  {q['date']} — Revenue: ${q['revenue']/1e9:.1f}B, Net Income: ${q['netIncome']/1e9:.1f}B")

# Balance Sheet (annual)
balance = requests.get(f"{base}/balance-sheet-statement/AAPL?limit=5&apikey={FMP_KEY}").json()

# Key Financial Ratios
ratios = requests.get(f"{base}/ratios/AAPL?limit=5&apikey={FMP_KEY}").json()
for r in ratios[:3]:
    print(f"  {r['date']} — P/E: {r['priceEarningsRatio']:.1f}, ROE: {r['returnOnEquity']:.1%}")

# DCF (Discounted Cash Flow) valuation
dcf = requests.get(f"{base}/discounted-cash-flow/AAPL?apikey={FMP_KEY}").json()
print(f"  DCF value: ${dcf[0]['dcf']:.2f} vs Market: ${dcf[0]['Stock Price']:.2f}")

import simfin as sf

# Set your API key (free) and data directory
sf.set_api_key("free")
sf.set_data_dir("~/simfin_data/")

# Download and cache income statements (annual)
df_income = sf.load_income(variant="annual", market="us")

# Filter for Apple
aapl = df_income.loc["AAPL"]
print(aapl[["Revenue", "Net Income", "Shares (Diluted)"]].tail())

# Download balance sheets
df_balance = sf.load_balance(variant="quarterly", market="us")

# Download cash flow statements
df_cashflow = sf.load_cashflow(variant="annual", market="us")

# Calculate Free Cash Flow for all companies
df_cashflow["FCF"] = df_cashflow["Net Cash from Operating Activities"] + df_cashflow["Net Cash from Investing Activities"]

import requests

# QuiverQuant — Congressional Trading
headers = {"Authorization": f"Bearer {QUIVER_KEY}"}

# Recent congressional trades
congress = requests.get("https://api.quiverquant.com/beta/historical/congresstrading/AAPL", headers=headers).json()
for t in congress[:5]:
    print(f"  {t['TransactionDate']} — {t['Representative']} ({t['Party']}) — {t['Transaction']} ${t['Range']}")

# Government contracts
contracts = requests.get("https://api.quiverquant.com/beta/historical/govcontracts/MSFT", headers=headers).json()

# Patent filings
patents = requests.get("https://api.quiverquant.com/beta/historical/patents/GOOGL", headers=headers).json()

import requests

headers = {"User-Agent": "YourApp/1.0 ([email protected])"}

# Company search by ticker -> CIK mapping
tickers = requests.get("https://www.sec.gov/files/company_tickers.json", headers=headers).json()
# Find CIK for any ticker
ticker_map = {v["ticker"]: v["cik_str"] for v in tickers.values()}
aapl_cik = ticker_map["AAPL"]  # 320193

# Get all submissions/filings
submissions = requests.get(f"https://data.sec.gov/submissions/CIK{str(aapl_cik).zfill(10)}.json", headers=headers).json()
print(f"Company: {submissions['name']}")
print(f"SIC: {submissions['sic']} — {submissions['sicDescription']}")

# Recent filings
recent = submissions["filings"]["recent"]
for i in range(5):
    print(f"  {recent['filingDate'][i]} — {recent['form'][i]} — {recent['primaryDocument'][i]}")

import sqlite3
import requests
import json
from datetime import datetime

class FinancialDB:
    """Local SQLite database for fundamental data."""

    def __init__(self, db_path="financials.db"):
        self.conn = sqlite3.connect(db_path)
        self._create_tables()

    def _create_tables(self):
        self.conn.executescript("""
        CREATE TABLE IF NOT EXISTS income_statements (
            ticker TEXT, date TEXT, period TEXT,
            revenue REAL, gross_profit REAL, operating_income REAL,
            net_income REAL, eps REAL, shares_outstanding REAL,
            PRIMARY KEY (ticker, date, period)
        );
        CREATE TABLE IF NOT EXISTS balance_sheets (
            ticker TEXT, date TEXT,
            total_assets REAL, total_liabilities REAL,
            total_equity REAL, cash REAL, total_debt REAL,
            PRIMARY KEY (ticker, date)
        );
        CREATE TABLE IF NOT EXISTS insider_trades (
            ticker TEXT, date TEXT, insider_name TEXT,
            transaction_type TEXT, shares REAL, price REAL,
            value REAL
        );
        """)

    def load_from_fmp(self, ticker, api_key):
        """Load financials from Financial Modeling Prep."""
        base = "https://financialmodelingprep.com/api/v3"

        # Income statements
        income = requests.get(
            f"{base}/income-statement/{ticker}?limit=20&apikey={api_key}"
        ).json()

        for q in income:
            self.conn.execute(
                "INSERT OR REPLACE INTO income_statements VALUES (?,?,?,?,?,?,?,?,?)",
                (ticker, q["date"], q["period"], q["revenue"],
                 q["grossProfit"], q["operatingIncome"],
                 q["netIncome"], q["eps"], q["weightedAverageShsOut"])
            )
        self.conn.commit()

    def load_from_edgar(self, ticker, cik):
        """Load from SEC EDGAR Company Facts (free, no key)."""
        headers = {"User-Agent": "FinDB/1.0 ([email protected])"}
        url = f"https://data.sec.gov/api/xbrl/companyfacts/CIK{str(cik).zfill(10)}.json"
        data = requests.get(url, headers=headers).json()

        # Extract revenue
        for key in ["Revenues", "RevenueFromContractWithCustomerExcludingAssessedTax"]:
            if key in data["facts"].get("us-gaap", {}):
                units = data["facts"]["us-gaap"][key]["units"]["USD"]
                for u in units:
                    if u["form"] in ("10-K", "10-Q"):
                        self.conn.execute(
                            "INSERT OR REPLACE INTO income_statements (ticker, date, period, revenue) VALUES (?,?,?,?)",
                            (ticker, u["end"], "FY" if u["form"] == "10-K" else "Q", u["val"])
                        )
                break
        self.conn.commit()

    def query(self, sql):
        return self.conn.execute(sql).fetchall()

# Usage
db = FinancialDB()
db.load_from_fmp("AAPL", "YOUR_FMP_KEY")
db.load_from_fmp("MSFT", "YOUR_FMP_KEY")

# Compare revenue growth
results = db.query("""
    SELECT ticker, date, revenue/1e9 as revenue_bn
    FROM income_statements
    WHERE period = 'FY' AND ticker IN ('AAPL', 'MSFT')
    ORDER BY ticker, date DESC LIMIT 10
""")
for r in results:
    print(f"  {r[0]} — {r[1]} — ${r[2]:.1f}B")