📊 Hedge Fund Tracker
If this tool is helping you, please ⭐ the repo! It really helps discoverability.
SEC 13F Filing Tracker | Institutional Portfolio Analysis | AI-Powered Stock Research
A comprehensive Python tool for tracking hedge fund portfolios through SEC filings (13F, 13D/G, Form 4). Transform raw SEC EDGAR data into actionable investment insights. Built for financial analysts, quantitative traders, and retail investors seeking to analyze institutional investor strategies, portfolio changes, and discover stock opportunities by following elite fund managers.
⫶☰ Table of Contents
🚀 Quick Start
# Clone the repository
git clone https://github.com/dokson/hedge-fund-tracker.git
cd hedge-fund-tracker
# Install Python dependencies
pipenv install
# Install and build the React frontend
pipenv run build-frontend
# Run the application (opens web UI in your browser)
pipenv run app
🐳 Or use Docker (no local build required)
python scripts/generate_secrets.py --write # creates .env with freshly generated secrets
docker compose up --build
docker compose starts the app and a Postgres container. The required secrets
(POSTGRES_PASSWORD, MASTER_KEY, RESET_PASSWORD_TOKEN_SECRET, VERIFICATION_TOKEN_SECRET) have
no defaults: if any of them is missing, docker compose up aborts instead of starting. Optional API
keys can be copied into the same .env from .env.example.
The app will be available at http://localhost:8000.
✨ Key Features
| Feature |
Description |
| 🌐 Web UI |
Research-first React interface with an editorial landing page, compact filing register, familiar tables and charts, light/dark themes, and SSE streaming for long-running AI tasks. |
| 📊 Visual Analytics |
Interactive charts (Recharts) to track institutional holdings, sectoral trends, and quarterly portfolio evolutions. |
| 🆚 Comparative Analysis |
Combines quarterly (13F) and non-quarterly (13D/G, Form 4) filings for an up-to-date view. |
| 📋 Fund & Stock Pages |
Per-fund portfolio pages (holdings, weights, quarter-over-quarter deltas, composition by stock and by sector) and per-ticker analysis pages (which tracked funds own it and how their conviction is shifting). |
| 🔍 Smart Ticker Resolution |
Multi-fallback system (yfinance → OpenFIGI → TradingView) resolves CUSIPs into actionable stock symbols, with company-rename handling via TradingView’s name-search fallback. Form 4 reverse lookups (ticker → CUSIP) go through Financial Modeling Prep. |
| 🤖 AI Financial Analyst |
An LLM ranks stocks by “Promise Score” from the institutional filing data (how many tracked funds hold a stock, how large the positions are, how they changed) and writes a due-diligence report on a single ticker. |
| ⚙️ Automated Data Pipeline |
Scheduled GitHub Actions to fetch, process, and commit the latest SEC filings directly to your repository. |
| 🌐 GitHub Pages Demo |
Static deployment with bundled data — all analysis features work without a backend. |
| ⭐ Personalized Watchlist |
Star your favorite funds or stocks for quick access and personalized tracking across the platform. |
| 🏷️ Sector & Industry |
Every stock is auto-tagged with Yahoo Finance industry; sector is derived via sector_hierarchy.csv. ETFs share a single “ETF” bucket. New tickers run through a yfinance → same-Company match → Groq LLM fallback chain. |
| 🔎 Global Search |
Top-bar search across tickers, companies, fund names and managers, with grouped results, keyboard navigation (⌘K) and company logos inline. |
| 🖼️ Company Logos |
Logos served via Cloudinary’s edge CDN, sourced lazily from Financial Modeling Prep, shown in a dedicated 32px slot on a white or dark plate chosen from the artwork so light marks stay visible. |
The navigation’s 13F baseline labels the newest usable quarterly snapshot, not the freshness of every price or disclosure. Latest Filings filters and orders the latest saved position disclosures by publication date, shows their separate position dates, and labels each reference price as a historical market-price estimate rather than a fund’s cost basis. Smart Score is a relative institutional screen, not a return forecast; its Momentum component measures net fund buying, not price momentum. Strategy and fund-return pages show sample and coverage limits before their results; fund returns estimate reported 13F holdings, not certified manager performance. Research context is kept for the session: filters, sorting and list position survive opening a stock or fund and coming back, while explicit URL parameters still win.
📦 Installation
Prerequisites
-
📥 Clone and navigate:
git clone https://github.com/dokson/hedge-fund-tracker.git
cd hedge-fund-tracker
-
📲 Install dependencies: Navigate to the project root and run the following command. This will create a virtual environment and install all required packages.
pipenv install
💡 Tip: If pipenv is not found, you might need to use python -m pipenv install. This can happen if the user scripts directory is not in your system’s PATH.
-
🔨 Build the frontend: Build the React interface (required once before first run):
pipenv run build-frontend
-
▶️ Run the application: Execute within the project’s virtual environment:
pipenv run app
This starts a FastAPI server (default http://localhost:8000, auto-increments if port is busy) and opens the web UI in your browser automatically.
⚠️ Note on CLI mode (Legacy): The terminal CLI is a deprecated version of the tool, built before the development of the Web UI. While still functional, it reads its API keys from a .env file, which the Web UI writes for you the first time you save a key on the AI Settings page (or you can create it yourself from .env.example). So, if you still wish to use the “old school” CLI, just run:
pipenv run app-cli
Data Management
The data update operations (downloading and processing filings) are inside a dedicated script. This keeps the main application focused on analysis, while the updater handles populating and refreshing the database.
To run the data update operations, you need to use the updater.py script from the project root:
pipenv run python -m database.updater
Database Updater
The updater.py script includes semi-automated maintenance tasks:
- Sorting: Upon exit (option
0), the script automatically sorts the database/stocks.csv file by ticker to maintain performance and prevent Git diff noise.
- Auto-Documentation: This README’s excluded funds section is synchronized whenever the database is refreshed manually.
This will open a separate menu for data management:
┌───────────────────────────────────────────────────────────────────────────────┐
│ Hedge Fund Tracker - Database Updater │
├───────────────────────────────────────────────────────────────────────────────┤
│ 0. Exit │
│ 1. Generate latest 13F reports for all known hedge funds │
│ 2. Fetch latest non-quarterly filings for all known hedge funds │
│ 3. Generate 13F report for a known hedge fund │
│ 4. Manually enter a hedge fund CIK to generate a 13F report │
└───────────────────────────────────────────────────────────────────────────────┘
API Configuration
The tool can utilize API keys for enhanced functionality, but all are optional:
💡 Note — Ticker resolution:
Forward path (CUSIP → ticker) runs the chain in this order, no API key required for any step:
- yfinance — free, no key, covers the majority of US-listed equities.
- OpenFIGI — Bloomberg’s free identifier-mapping endpoint. Works without
OPENFIGI_API_KEY at 25 req/min; with a key the limit is raised to 250 req/min.
- TradingView — public symbol-search endpoint, queried by ISIN (US-listings only). When ISIN returns only non-US listings (typical for recently-renamed issuers), it retries by company name using the description TradingView itself reports — which carries the current name even if the SEC filing still lists the old one (e.g. Ekso Bionics → ChronoScale).
Reverse path (ticker → CUSIP) for Form 4 filings goes through Financial Modeling Prep. The free FMP_API_KEY is required (250 req/day); without it, unresolved tickers open a GitHub issue and the CUSIP stays null until the next 13F cycle exposes it.
💡 Note: You don’t need to use all the APIs. For the generative AI models (OpenRouter, Google AI Studio, Groq AI, Ollama Cloud, and Z.AI), you only need the API keys for the services you plan to use.
The default provider is Google AI Studio, so a single free AI Studio key is enough to get started. Experimenting with different models is encouraged, as the quality of AI-generated analysis, both for identifying promising stocks and for conducting due diligence, can vary. However, top-performing stocks are typically identified consistently across all tested models. Every model in the bundled database/models.csv runs within its provider’s free tier.
Using other providers’ models: OpenRouter can call a provider with your key (BYOK, configured in your OpenRouter integrations); add the model to database/models.csv with Client set to OpenRouter and no code change is needed. OpenRouter bills 5% of the model’s list price on top, from your OpenRouter credits.
📁 Project Structure
hedge-fund-tracker/
├── 📁 .github/
│ ├── 📁 ISSUE_TEMPLATE/ # Bug report + feature request forms
│ ├── 📁 scripts/
│ │ └── 🐍 fetcher.py # Script for data fetching (scheduled by workflows/filings-fetch.yml)
│ └── 📁 workflows/ # GitHub Actions for automation
│ ├── ⚙️ dependabot-automerge.yml # GitHub Actions: Dependabot PR auto-merge
│ ├── ⚙️ deploy-pages.yml # GitHub Actions: Deploy to GitHub Pages
│ ├── ⚙️ filings-fetch.yml # GitHub Actions: Filings fetching job
│ ├── ⚙️ lint.yml # GitHub Actions: Lint + type-check
│ ├── ⚙️ popularity-refresh.yml # GitHub Actions: Excluded-funds popularity ranking
│ ├── ⚙️ refresh-badges.yml # GitHub Actions: README badge refresh
│ └── ⚙️ run-tests.yml # GitHub Actions: Python + frontend tests
├── 📁 app/ # Main application logic
│ ├── 📁 ai/ # LLM clients (OpenRouter, Google, Groq, Ollama, Z.AI) + analyst agent
│ ├── 📁 analysis/ # Portfolio, stock and performance analysis
│ ├── 📁 api/ # FastAPI routers (data, ai, sse, settings, admin, …)
│ ├── 📁 auth/ # Accounts, sessions and BYOK API-key storage
│ ├── 📁 backtest/ # Strategy Performance backtest engine
│ ├── 📁 db/ # SQLAlchemy models and session wiring
│ ├── 📁 frontend/ # React + Vite web UI
│ │ ├── 📁 public/ # Static assets (404.html, logo + favicons)
│ │ ├── 📁 scripts/ # copy-database.mjs (bundles CSVs for GH Pages)
│ │ ├── 📁 src/
│ │ │ ├── 📁 components/ # Shared UI components (AppSidebar, GlobalSearch, ModelSelector, TerminalOutput, …)
│ │ │ ├── 📁 lib/ # config.ts (IS_GH_PAGES_MODE), dataService.ts (CSV I/O), aiClient.ts (SSE), routes.ts, menuDoors.ts
│ │ │ └── 📁 pages/ # Landing, Dashboard, QuarterlyTrends, StrategyPerformance, FundPortfolio, StockBrowser, StockAnalysis, Learn, AIRanking, AIDueDiligence, FundsConfig, AISettings, DatabasePage
│ │ ├── 📦 package.json
│ │ └── ⚙️ vite.config.ts
│ ├── 📁 scraper/ # SEC EDGAR fetching and filing parsers
│ ├── 📁 security/ # Envelope encryption for stored secrets
│ ├── 📁 stocks/ # Ticker resolution + price fetching
│ ├── 📁 utils/ # Logging, console, GitHub issue alerts
│ ├── 🐍 server.py # FastAPI server (serves frontend + all API endpoints)
│ └── ▶️ main.py # Entry point: web server (default) or CLI (--cli)
├── 📁 database/ # Data storage
│ ├── 📁 2025Q1/ # Quarterly reports
│ │ ├── 📊 fund_1.csv # Individual fund quarterly report
│ │ ├── 📊 fund_2.csv
│ │ └── 📊 fund_n.csv
│ ├── 📁 YYYYQN/
│ ├── 📝 excluded_hedge_funds.csv # Funds deliberately not tracked (see Notable Exclusions)
│ ├── 📝 hedge_funds.csv # Curated hedge funds list -> EDIT THIS to add or remove funds to track
│ ├── 📝 models.csv # LLMs list to use for AI Financial Analyst -> EDIT THIS to add or remove AI models
│ ├── 📊 non_quarterly.csv # Stores latest 13D/G and Form 4 filings
│ ├── 📊 performance.csv # Backtested strategy equity curves
│ ├── 📊 sector_hierarchy.csv # Yahoo Finance sector → industry taxonomy
│ ├── 📊 stocks.csv # Master data for stocks (CUSIP-Ticker-Name-Sector-Industry)
│ └── ▶️ updater.py # Main entry point for updating the database
├── 📁 docs/ # Design notes and long-form documentation
├── 📁 scripts/ # Maintenance scripts (generate_secrets.py, regenerate_reports.py, …)
├── 📁 tests/ # Python test suite
├── 📝 .env.example # Template for your API keys and secrets
├── ⛔ .gitignore # Git ignore rules
├── ⚙️ alembic.ini # Database migration configuration
├── 🐳 compose.yaml # App + Postgres services
├── 🐳 Dockerfile # Multi-stage image (Node build → Python runtime)
├── ▶️ entrypoint.sh # Container start-up: seed data, write .env, run migrations
├── 🧾 LICENSE # Proprietary (code) + bundled MIT (original work)
├── 🧾 LICENSE-DOCS # CC BY 4.0 (Markdown documentation)
├── 🧾 LICENSE-DATA # CC BY-NC 4.0 (database/ data files)
├── 🛠️ Pipfile # Project dependencies
├── 🔏 Pipfile.lock # Locked dependency versions
└── 📖 README.md # Project documentation (this file)
📝 Hedge Funds Configuration File: database/hedge_funds.csv contains the list of hedge funds to monitor (CIK, name, manager) and can also be edited at runtime.
📝 LLMs Configuration File: database/models.csv contains the list of available LLMs for AI analysis and can also be edited at runtime.
This tracker leverages the following types of SEC filings to provide a comprehensive view of institutional activity.
🏢 Hedge Funds Selection
This tool tracks a curated list of what I found to be the top-performing institutional investors that file with the U.S. SEC, identified based on their performance over the last 3-5 years. This curation is the result of my own methodology designed to identify the top percentile of global investment funds. My selection methodology is detailed below.
Selection Methodology
Modern portfolio theory (MPT) offers many methods for quantifying the risk-return trade-off, but they are often ill-suited for analyzing the limited data available in public filings. Consequently, the hedge_funds.csv was therefore generated using my own custom selection algorithm designed to identify top-performing funds while managing for volatility.
Note: The selection algorithm is external to this project and was used only to produce the curated hedge_funds.csv list.
My approach prioritizes high cumulative returns but also analyzes the path taken to achieve them: it penalizes volatility, similar to the Sharpe Ratio, but this penalty is dynamically adjusted based on performance consistency; likewise, drawdowns are penalized, echoing the principle of the Sterling Ratio, but the penalty is intentionally dampened to avoid overly punishing funds that recover effectively from temporary downturns.
List Management
The list of hedge funds is actively managed to maintain its quality; funds that underperform may be replaced, while new top performers are periodically added.
However, despite their strong performance, several funds with portfolios predominantly focused on Healthcare and Biotech, such as Nextech Invest, Enavate Sciences, Caligan Partners, and Boxer Capital Management, have been intentionally excluded. These funds invest in highly specialized sectors where I lack the necessary expertise. Consequently, I consider them too risky for my personal investment profile, given the complexity and volatility inherent in biotech and healthcare ventures.
Notable Exclusions
The quality of the output analysis is directly tied to the quality of the input data. To enhance the accuracy of the insights and opportunities identified, many popular high-profile funds have been intentionally excluded by design (the list below is automatically managed and capped to 50 funds, but you can see the full list in excluded_hedge_funds.csv):
💡 Note: For convenience, key information for these funds, including their CIKs, is maintained in the database/excluded_hedge_funds.csv file.
Adding Custom Funds
Want to track additional funds? Simply edit database/hedge_funds.csv and add your preferred institutional investors. For example, to add Berkshire Hathaway, Pershing Square and ARK-Invest, you would add the following lines:
"CIK","Fund","Manager","Denomination","CIKs","URL"
"0001067983","Berkshire Hathaway","Warren Buffett","Berkshire Hathaway Inc","","https://www.berkshirehathaway.com/"
"0001336528","Pershing Square","Bill Ackman","Pershing Square Capital Management, L.P.","","https://pershingsquareholdings.com/"
"0001697748","ARK Invest","Cathie Wood","ARK Investment Management LLC","","https://www.ark-invest.com/"
💡 Note: hedge_funds.csv currently includes not only traditional hedge funds but also other institutional investors (private equity funds, large banks, VCs, pension funds, etc., that file 13F to the SEC) selected from what I consider the top 5% of performers.
If you wish to track any of the Notable Exclusions hedge funds, you can copy the relevant rows from excluded_hedge_funds.csv into hedge_funds.csv.
Columns for Custom Funds:
-
Denomination: This is the exact legal name used by the fund in its filings. It is essential for accurately processing non-quarterly filings (13D/G, Form 4) as the scraper uses it to identify the fund’s specific transactions within complex filing documents.
-
CIKs (optional): A comma-separated list of additional CIKs. This field is used to track filings from related entities or subsidiaries. Some investment firms have complex structures where different legal entities file separately (e.g., a management company and a holding company).
Example: Jeffrey Ubben’s ValueAct Holdings (CIK = 0001418814) also has filings under ValueAct Capital Management (CIK = 0001418812). By adding 0001418812 to the CIKs column, the tool aggregates non-quarterly filings from both entities for a complete view.
"CIK","Fund","Manager","Denomination","CIKs","URL"
"0001418814","ValueAct","Jeffrey Ubben","ValueAct Holdings, L.P.","0001418812","https://valueact.com/"
-
URL (optional): Official fund website.
🧠 AI Models Selection
The AI Financial Analyst ranks stocks by “Promise Score”, a score a language model produces from the institutional filing data on this site: how many tracked funds hold a stock, how large those positions are, and how they changed over recent quarters. It runs in two steps — the model first proposes how much weight to give each of those inputs for the selected quarter, then scores every stock using those weights. It is a ranking of filing activity, not a forecast of returns.
The models included in database/models.csv have been selected because they have demonstrated the best performance and reliability for these specific tasks. Through experimentation, they have proven effective at interpreting the prompts and providing insightful, well-structured responses.
Adding Custom AI Models
You can easily add or change the AI models used for analysis by editing the database/models.csv file. This allows you to experiment with different Large Language Models (LLMs) from supported providers.
To add a new model, open database/models.csv and add a new row with the following columns:
- ID: The specific model identifier as required by the provider’s API.
- Description: A brief, user-friendly description that will be displayed in the selection menu.
- Client: The provider of the model. Must be one of
Google, Groq, Ollama, OpenRouter, or ZAI.
Here are the official model lists for each provider:
⚠️ Limitations & Considerations
It’s crucial to understand the inherent limitations of tracking investment strategies solely through SEC filings:
| Limitation |
Impact |
Mitigation |
| 🕒 Filing Delay |
Data can be 45+ days old |
Focus on long-term strategies |
| 🧩 Incomplete Picture |
Only US long positions shown |
Use as part of broader analysis |
| 📉 No Short Positions |
Missing hedge information |
Consider reported positions carefully |
| 🌎 Limited Scope |
No non-US stocks or other assets |
Supplement with additional data |
A Truly Up-to-Date View
Many tracking websites rely solely on quarterly 13F filings, which means their data can be over 45 days old and miss many significant trades. Non-quarterly filings like 13D/G and Form 4 are often ignored because they are more complex to process and merge.
This tracker helps overcome that limitation by integrating multiple filing types. When analyzing the most recent quarter, the tool automatically incorporates the latest data from 13D/G and Form 4 filings. As a result, the holdings, deltas, and portfolio percentages reflect not just the static 13F snapshot, but also any significant trades that have occurred since. This provides a more dynamic and complete picture of institutional activity.
🐳 Docker Deployment
You can run the full application in Docker — no Python or Node.js installation required.
What Docker Provides
- Multi-stage build: frontend compiled in Node, served by Python — single optimized image
- Postgres service: a
postgres:18-alpine container on a pgdata volume, published on loopback only; Alembic migrations run at start-up from entrypoint.sh
- Persistent data:
database/, __llmcache__/, and __reports__/ are mounted as volumes
- Health check:
/health endpoint monitored by Docker
- Non-root user: runs as
hedgefund user inside the container
- API keys: read from mounted
.env file or passed as environment variables
Planned: Public Cloud Deployment
This is a roadmap item, not a supported configuration. The current release is meant for local or private-network use only; see SECURITY.md for the supported security posture.
The experimental authentication and Postgres stack in this repository is groundwork for a future hosted mode.
The container itself already carries the pieces a hosted deployment would build on: setting DOCKER_ENV=1 selects the containerized configuration, API keys are passed as environment variables, and entrypoint.sh seeds the database and generates .env from those environment variables on first start.
Before public deployment can be supported, the next step will need:
- Postgres reachable over
DATABASE_URL instead of the bundled loopback-only container
- The four secrets produced by
scripts/generate_secrets.py (MASTER_KEY, MASTER_KEY_VERSION, RESET_PASSWORD_TOKEN_SECRET, VERIFICATION_TOKEN_SECRET) supplied by the platform’s secret store
- HTTPS terminated in front of the application, since the app serves plain HTTP inside the container
🌐 GitHub Pages Deployment
The frontend can be deployed as a static demo on GitHub Pages — no Python backend required. AI features and data updates are disabled in this mode, but all core analysis pages work with bundled data.
Live demo: https://{username}.github.io/hedge-fund-tracker/
What’s Available in GitHub Pages Mode
| Page |
Status |
Latest Filings (/latest) |
Fully functional |
Quarterly Trends (/quarterly) |
Fully functional |
Strategy Performance (/performance) |
Fully functional |
Fund Portfolios (/funds) |
Fully functional |
Stocks (/stocks, /stock/:ticker) |
Fully functional |
FAQ (/learn) |
Fully functional (statically pre-rendered for SEO) |
Most Promising Stocks (/ai-ranking) |
Disabled (requires local backend) |
Stock Due Diligence (/ai-diligence) |
Disabled (requires local backend) |
Funds Configuration (/funds-config) |
Hidden (Admin section not rendered) |
AI Settings (/ai-settings) |
Hidden (Admin section not rendered) |
Update Operations (/database) |
Hidden (Admin section not rendered) |
How to Deploy
- Fork the repository on GitHub
- Enable GitHub Pages: Go to Settings > Pages > Source: “GitHub Actions”
- Push to
master — the deploy workflow (.github/workflows/deploy-pages.yml) runs automatically
The build step (npm run build:gh-pages) bundles all CSV data into dist/database/ so the static site is fully self-contained.
Local Development
For full functionality (AI analysis, data updates, file editing), run locally:
pipenv install
pipenv run build-frontend
pipenv run app
⚙️ Automation with GitHub Actions
This repository includes a GitHub Actions workflow (.github/workflows/filings-fetch.yml) designed to keep your data effortlessly up-to-date by automatically fetching the latest SEC filings.
How It Works
- Scheduled Runs: The workflow runs automatically to check for new 13F, 13D/G, and Form 4 filings from the funds you are tracking (
hedge_funds.csv). It runs four times a day from Monday to Friday (at 01:30, 13:30, 17:30, and 21:30 UTC) and once on Saturday (at 04:00 UTC).
- Safe Branching Strategy: Instead of committing directly to your main branch, the workflow pushes all new data to a dedicated branch named
automated/filings-fetch.
- GitHub Pages Deploy: A separate workflow (
.github/workflows/deploy-pages.yml) automatically rebuilds and deploys the static frontend to GitHub Pages whenever frontend or database files change on master.
- User-Controlled Merging: This approach gives you full control. You can review the changes committed by the bot and then merge them into your main branch whenever you’re ready. This prevents unexpected changes and allows you to manage updates at your own pace.
- Automated Alerts: If the script encounters a non-quarterly filing where it cannot identify the fund owner based on your
hedge_funds.csv configuration, it will automatically open a GitHub Issue in your repository, alerting you to a potential data mismatch that needs investigation.
How to Enable It
- Fork the Repository: Create your own fork of this project on GitHub.
- Enable Actions: GitHub Actions are typically enabled by default on forked repositories. You can verify this under the Actions tab of your fork.
- Configure Secrets (optional): Workflows run with the
GITHUB_TOKEN that GitHub Actions provides automatically (it is not a personal key you create) and require no extra setup. If you want a higher OpenFIGI rate limit during ticker resolution (250 req/min vs 25), add OPENFIGI_API_KEY as a repository secret under Settings > Secrets and variables > Actions.
🗃️ Technical Stack
| 🗂️ Category |
🦾 Technology |
| Core |
Python 3.14+, pipenv, Docker (optional) |
| Backend |
FastAPI, uvicorn |
| Persistence & Accounts |
PostgreSQL, SQLAlchemy, Alembic, FastAPI Users, cryptography (envelope encryption for stored keys) |
| Frontend |
React 19, Vite, TypeScript, Tailwind CSS |
| UI Components |
shadcn/ui, Radix UI, Lucide, Sonner |
| Data Viz & State |
Recharts, TanStack Query v5 |
| Web Scraping |
curl_cffi, Beautiful Soup 4, lxml |
| Reliability |
Tenacity, Python-Dotenv |
| Stocks Data |
yfinance, OpenFIGI, TradingView, Financial Modeling Prep, Nasdaq API |
| Gen AI |
toon-format, Google AI SDK, OpenAI SDK |
| Code Quality (Python) |
Ruff (lint + format), Pyright (type-check), pre-commit |
| Code Quality (Frontend) |
oxlint (React, JSX-a11y, TypeScript rules), oxfmt, TypeScript strict |
| CI/CD |
GitHub Actions (lint, tests, deploy), Vitest (frontend tests), unittest (Python tests) |
🤝🏼 Contributing & Support
Read CONTRIBUTING.md before opening a PR — it covers the test policy, lint policy, branch hygiene, and what makes a good PR. For deep architectural context (modules, footguns, data flow) see AGENTS.md.
💬 Loved it? Help it grow
✍🏻 Feedback
This tool is in active development, and your input is valuable. For questions or design discussion, open a Discussion — keeping conversations public benefits future contributors.
📚 References
🙏🏼 Acknowledgments
This project began as a fork of sec-web-scraper-13f by Gary Pang. The original tool provided a solid foundation for scraping 13F filings from the SEC’s EDGAR database. It has since been significantly re-architected and expanded into a comprehensive analysis platform, incorporating multiple filing types, AI-driven insights, and automated data management.
📄 License
This repository is licensed in parts, with documentation and data carved out separately:
See LICENSE for the code terms, LICENSE-DOCS for the documentation terms and LICENSE-DATA for the data terms.
⭐ Star History
![dependabot[bot]](https://avatars.githubusercontent.com/in/29110?v=4)
![github-actions[bot]](https://avatars.githubusercontent.com/in/15368?v=4)
评论