How to Use OpenAI API to Build a Custom SEC Filing Alert System

You'll create an automated system that monitors SEC filings and uses AI to identify the most important ones for your investment research. This tutorial takes about 2 hours and requires basic Python knowledge.

What You'll Need

• OpenAI API account - $20 starting credit (sufficient for 1000+ filing analyses)
• Python 3.8+ installed on your computer
• Gmail account for sending alerts
• SEC EDGAR access - free, no registration required
• Text editor - VS Code, Sublime, or similar

Time estimate: 2 hours | Difficulty: Intermediate

Step-by-Step Instructions

Step 1: Get OpenAI API Key and Set Up Account

Navigate to platform.openai.com/api-keys and create a new account if you don't have one. Click Create new secret key and name it "SEC Filing Monitor".

Copy the API key immediately - OpenAI only shows it once. Store it in a secure location like a password manager. You'll need this key for every API call, and it cannot be recovered if lost.

Add $20 credit to your account through the billing section. This covers approximately 1,000 filing analyses at current GPT-4 pricing of $0.01-0.03 per analysis.

Step 2: Install Python Libraries and Set Up Environment

Open your terminal or command prompt and install the required libraries:

pip install openai requests beautifulsoup4 lxml

Create a new project folder called sec-monitor and navigate into it. Create a file called config.py to store your credentials:

OPENAI_API_KEY = "your-api-key-here"
EMAIL_ADDRESS = "your-email@gmail.com"
EMAIL_PASSWORD = "your-app-password"

For Gmail, you'll need an app password instead of your regular password. Enable 2-factor authentication first, then generate an app password through your Google Account security settings.

Step 3: Connect to SEC EDGAR API for Filing Data

Create a file called sec_connector.py. The SEC requires a User-Agent header with your contact information for all API requests:

import requests
import json
from datetime import datetime, timedelta

class SECConnector:
    def __init__(self):
        self.headers = {
            "User-Agent": "YourName your@email.com"
        }
        self.base_url = "https://data.sec.gov/submissions/"

The SEC's EDGAR system provides free access to all public company filings through their REST API. Unlike paid services like Bloomberg Terminal, this direct access ensures you get filings the moment they're published.

Step 4: Write Prompt to Analyze Filing Importance

Create filing_analyzer.py with your OpenAI integration. The key is crafting a prompt that consistently identifies material information:

from openai import OpenAI
import config

client = OpenAI(api_key=config.OPENAI_API_KEY)

def analyze_filing(filing_text, company_name, filing_type):
    prompt = f"""
    Analyze this {filing_type} filing from {company_name}.
    
    Rate importance 1-10 based on:
    - Revenue/earnings surprises >5%
    - Management changes (CEO, CFO, key executives)
    - Major acquisitions, divestitures, or partnerships
    - Regulatory issues or legal settlements
    - Significant changes in business strategy
    
    Return JSON: {{"importance": number, "summary": "brief explanation"}}
    """

This structured approach ensures GPT-4 focuses on material events that actually move stock prices. Generic business updates or routine compliance filings should score 1-3, while major corporate events score 7-10.

Step 5: Set Up Automated Daily Script to Check Filings

Create the main script daily_monitor.py that runs your entire system:

import schedule
import time
from datetime import datetime
from sec_connector import SECConnector
from filing_analyzer import analyze_filing
from email_alerts import send_alert

def daily_filing_check():
    print(f"Starting daily check: {datetime.now()}")
    sec = SECConnector()
    recent_filings = sec.get_recent_filings()
    
    for filing in recent_filings:
        analysis = analyze_filing(
            filing['content'],
            filing['company'],
            filing['type']
        )
        
        if analysis['importance'] >= 7:
            send_alert(filing, analysis)

Schedule the script to run every weekday at 6:30 AM EST - after markets close in Asia but before US premarket trading begins. This timing ensures you see important filings before they impact stock prices.

Step 6: Configure Email Alerts for High-Priority Results

Create email_alerts.py to handle notifications:

import smtplib
from email.mime.text import MIMEText
from email.mime.multipart import MIMEMultipart
import config

def send_alert(filing, analysis):
    msg = MIMEMultipart()
    msg['From'] = config.EMAIL_ADDRESS
    msg['To'] = config.EMAIL_ADDRESS
    msg['Subject'] = f"HIGH PRIORITY: {filing['company']} {filing['type']} Filing"
    
    body = f"""
    Company: {filing['company']}
    Filing Type: {filing['type']}
    Importance Score: {analysis['importance']}/10
    Summary: {analysis['summary']}
    Link: {filing['url']}
    """

Set the importance threshold to 7 or higher to avoid alert fatigue. In testing, this typically generates 2-5 alerts per week from the Russell 1000, capturing genuinely significant corporate events without overwhelming your inbox.

Step 7: Test With Sample 10-K Filing

Before running the full system, test with a known filing to verify everything works. Download a recent Apple 10-K filing and run it through your analyzer:

test_filing = {
    "company": "Apple Inc",
    "type": "10-K",
    "content": "paste filing text here",
    "url": "https://sec.gov/filing-url"
}

result = analyze_filing(
    test_filing['content'],
    test_filing['company'],
    test_filing['type']
)
print(f"Score: {result['importance']}")
print(f"Summary: {result['summary']}")

A typical Apple 10-K should score 4-6 unless it contains major surprises. If your system consistently scores routine filings above 7, adjust the prompt to be more selective.

Step 8: Run and Monitor Your System

Start your monitoring system with:

python daily_monitor.py

The script will run continuously, checking for new filings every weekday morning. Monitor your OpenAI usage through their dashboard to ensure costs stay within budget.

Troubleshooting

OpenAI API rate limits: If you hit rate limits, add a 1-second delay between API calls using time.sleep(1). The free tier allows 3 requests per minute for GPT-4.

SEC API blocks requests: Ensure your User-Agent header includes your real email address. The SEC blocks requests without proper identification or that exceed 10 requests per second.

Email alerts not sending: Gmail requires app passwords for third-party applications. Never use your regular Gmail password in code - it won't work and creates security risks.

Expert Tips

• Pro tip: Focus on 8-K filings first - they contain breaking news and are shorter, cheaper to analyze than 10-Ks
• Add company size filters to prioritize S&P 500 filings over penny stocks for better signal-to-noise ratio
• Store analysis results in a SQLite database to track which companies trigger alerts most frequently
• Set up separate alert thresholds by filing type: 8-K importance ≥6, 10-K/10-Q importance ≥8

"The key to successful algorithmic trading is getting high-quality information before it's priced into the market. SEC filings are the ultimate source of material corporate information." — David Shaw, founder of D.E. Shaw & Co.

What to Do Next

Once your basic system is running, consider expanding it to track insider trading through Form 4 filings or building a web dashboard to visualize filing trends over time. As we explored in our analysis of AI-powered investment research, combining multiple data sources with AI analysis creates significant advantages in modern financial markets.