Programmatic detection of Stock Splits for EPS normalization (pre-split vs. post-split filings)

[amcamc92]

Hi everyone,

I am building a financial analysis pipeline using edgartools and I'm currently working on normalizing historical Earnings Per Share (EPS) data.

The Challenge

As we know, SEC filings report EPS based on the share count at the time of the filing (or restated in recent filings). To have a consistent historical series, I need to adjust EPS values for stock splits, but only for data points extracted from filings published BEFORE the split date.

Data extracted from filings published after a split is already adjusted/restated by the company, so double-adjusting must be avoided.

My Logic

For every EPS fact, I want to apply this check:
if filing_date < split_date: apply_adjustment(value, ratio)

Questions for the Community:

1.Detection: Is there a reliable way to programmatically detect a stock split event (Date and Ratio) using edgartools?

• Are there specific XBRL concepts you recommend watching? (e.g., us-gaap:StockholdersEquityNoteStockSplit...)
• Or is it better to monitor specific Form Types like 8-K (Item 3.03 or 5.03) to find these events?

2. Effective Date: How can I accurately extract the "effective date" or "record date" of the split directl from the filing metadata or XBRL facts?

3. Best Practices: Has anyone implemented a similar normalization pipeline using only SEC data? I am tryin to avoid relying on external APIs (like Yahoo Finance) to keep the data source consistent within the SEC ecosystem.

I would love to hear how you handle stock splits and if there are specific features in the library that could simplify this "point-in-time" adjustment.

Thanks in advance for your insights!

[amcamc92]

Hi @dgunning

Any thoughts on this? Is there any way to identify the stock splits or any means by doing so?

Thank you!

[dgunning]

Hi @amcamc92! Great question - stock split detection is definitely an important piece of the EPS normalization puzzle. Let me walk you through what edgartools provides and show you some concrete approaches.

Good News: EdgarTools Has Built-In Stock Split Detection

EdgarTools includes stock split detection capabilities in the edgar.ttm module. Here's what you can do:

1. Detecting Stock Splits from XBRL Facts

The most reliable method is using the XBRL concept StockholdersEquityNoteStockSplitConversionRatio1 from company facts:

from edgar import Company
from edgar.ttm import detect_splits

# Get company facts
company = Company("NVDA")
facts = company.facts._facts

# Detect all stock splits
splits = detect_splits(facts)

for split in splits:
    print(f"Split Date: {split['date']}, Ratio: {split['ratio']}:1")

Output for NVIDIA:

Split Date: 2021-06-03, Ratio: 4.0:1
Split Date: 2024-05-31, Ratio: 10.0:1

The detect_splits() function already handles several important edge cases:

• Deduplication: Prevents counting the same split multiple times
• Filing lag filtering: Ignores "historical echo" facts where old splits are reported in recent filings (>280 day lag)
• Duration filtering: Accepts instant facts or short-duration facts (monthly), rejects long-duration aggregations

2. Finding Related 8-K Filings (Item 5.03)

Item 5.03 ("Amendments to Articles of Incorporation or Bylaws; Change in Fiscal Year") is the standard disclosure for stock splits. You can find these filings:

from edgar import Company

company = Company("NVDA")
eight_ks = company.get_filings(form='8-K')

print("8-Ks with Item 5.03 (often stock splits):")
for filing in eight_ks:
    try:
        eight_k = filing.obj()
        if '5.03' in eight_k.items:
            print(f"  {filing.filing_date}: Items {eight_k.items}")
    except Exception:
        pass

Output:

8-Ks with Item 5.03 (often stock splits):
  2024-06-07: ['Item 5.03', 'Item 9.01']
  2024-03-14: ['Item 5.02', 'Item 5.03', 'Item 9.01']

Note: Item 5.03 covers all amendments to articles of incorporation, not just stock splits, so you'll still need to check the content or cross-reference with XBRL facts.

3. Complete EPS Normalization Workflow

Here's how to implement your exact logic (if filing_date < split_date: apply_adjustment):

from edgar import Company
from edgar.ttm import detect_splits

company = Company("NVDA")
facts = company.facts._facts

# Step 1: Detect all stock splits
splits = detect_splits(facts)

# Step 2: Get EPS facts
eps_facts = [f for f in facts 
             if 'earningspershare' in f.concept.lower() 
             and 'diluted' in f.concept.lower()
             and f.numeric_value is not None]

# Step 3: Apply normalization logic
def normalize_eps_for_splits(fact, splits):
    """Normalize EPS for stock splits that occurred after the filing date"""
    if not fact.filing_date:
        return fact.numeric_value
    
    cumulative_ratio = 1.0
    for split in splits:
        # Only adjust if filing was BEFORE the split date
        if fact.filing_date < split['date']:
            cumulative_ratio *= split['ratio']
    
    return fact.numeric_value / cumulative_ratio if cumulative_ratio > 1.0 else fact.numeric_value

# Step 4: Process your EPS data
for fact in eps_facts:
    original = fact.numeric_value
    normalized = normalize_eps_for_splits(fact, splits)
    
    if original != normalized:
        print(f"Period {fact.period_end}, Filed {fact.filing_date}:")
        print(f"  Original: ${original:.2f}, Normalized: ${normalized:.2f}")

Example Output:

Period 2011-07-31, Filed 2011-08-25:
  Original: $0.44, Normalized: $0.11
Period 2015-01-25, Filed 2016-02-17:
  Original: $1.23, Normalized: $0.31

4. Extracting Effective Dates

The detect_splits() function uses period_end from the XBRL fact as the effective date. This is typically:

• The record date or effective date of the split
• Reported in the quarterly filing that includes the split event
• More reliable than parsing text from 8-K filings

If you need the exact announcement date vs effective date, you can:

1. Use the split date from XBRL facts as the effective date
2. Cross-reference with the 8-K filing date (usually filed within 4 days of announcement)

# Cross-reference split dates with 8-K filings
for split in splits:
    split_date = split['date']
    # Find 8-K filings near the split date
    nearby_8ks = [f for f in company.get_filings(form='8-K') 
                  if abs((f.filing_date - split_date).days) < 30]
    
    for filing in nearby_8ks:
        eight_k = filing.obj()
        if '5.03' in eight_k.items:
            print(f"Split {split_date}: Announced in 8-K on {filing.filing_date}")

Built-In Split Adjustment (Bonus)

EdgarTools also has a built-in apply_split_adjustments() function that handles the normalization automatically:

from edgar import Company
from edgar.ttm import detect_splits, apply_split_adjustments

company = Company("AAPL")
facts = company.facts._facts

# Detect splits
splits = detect_splits(facts)

# Apply adjustments to ALL facts (EPS, share counts, etc.)
adjusted_facts = apply_split_adjustments(facts, splits)

This function:

• Adjusts per-share metrics (EPS, dividends) by dividing by the cumulative ratio
• Adjusts share counts by multiplying by the cumulative ratio
• Only adjusts facts from filings before the split date (exactly your logic!)
• Preserves the original facts in a calculation_context field

Notes and Limitations

1. XBRL Concept Availability: StockholdersEquityNoteStockSplitConversionRatio1 is the standard GAAP concept. Most companies report it, but coverage isn't 100% universal.

2. Item 5.03 Detection: Works well for filings from 2005 onwards. Earlier filings used different item numbering (Item 3.03 pre-2004).

3. Historical Coverage: XBRL facts are available from around 2009-2010 for most companies. For earlier splits, you'd need to parse historical text filings or use external data sources.

4. Reverse Splits: The same logic works for reverse splits (ratio < 1.0), just ensure you handle the division correctly.

5. Filing Date Availability: Most XBRL facts include filing_date, but if it's missing for any facts, you'll need to handle that gracefully (perhaps conservative approach: don't adjust if filing date is unknown).

Complete Working Example

Here's a complete script you can adapt for your pipeline:

from edgar import Company
from edgar.ttm import detect_splits
from datetime import datetime

def build_normalized_eps_series(ticker):
    """Build a normalized EPS series for a company, adjusted for stock splits"""
    company = Company(ticker)
    facts = company.facts._facts
    
    # Detect stock splits
    splits = detect_splits(facts)
    print(f"\n{ticker} Stock Splits Detected:")
    for split in splits:
        print(f"  {split['date']}: {split['ratio']}:1")
    
    # Get EPS facts
    eps_facts = [
        f for f in facts 
        if 'earningspershare' in f.concept.lower() 
        and 'diluted' in f.concept.lower()
        and f.numeric_value is not None
        and f.filing_date is not None
    ]
    
    # Sort by period
    eps_facts.sort(key=lambda f: f.period_end)
    
    # Normalize for splits
    normalized_series = []
    for fact in eps_facts:
        cumulative_ratio = 1.0
        for split in splits:
            if fact.filing_date < split['date']:
                cumulative_ratio *= split['ratio']
        
        normalized_value = fact.numeric_value / cumulative_ratio if cumulative_ratio > 1.0 else fact.numeric_value
        
        normalized_series.append({
            'period': fact.period_end,
            'filing_date': fact.filing_date,
            'original_eps': fact.numeric_value,
            'normalized_eps': normalized_value,
            'split_adjusted': cumulative_ratio > 1.0,
            'cumulative_ratio': cumulative_ratio
        })
    
    return normalized_series

# Use it
eps_data = build_normalized_eps_series("NVDA")

# Show the results
print("\nNormalized EPS Series:")
for row in eps_data[-10:]:  # Last 10 periods
    print(f"{row['period']}: ${row['normalized_eps']:.2f} "
          f"({'adjusted' if row['split_adjusted'] else 'original'})")

This gives you a fully SEC-sourced, split-adjusted EPS series without relying on external APIs like Yahoo Finance.

Let me know if you have questions about any of this or need help adapting it to your specific use case!

[amcamc92]

Thanks for the breakdown, @dgunning.

I was expecting to get something like this, or at least similar to the most recent splits:

I understand why the earlier splits (2000–2007) are missing, as they pre-date the SEC's XBRL requirements. However, I noticed an issue with the 2021 and 2024 detections:

• Date Mismatch: The tool is returning the XBRL filing dates (e.g., 2021-06-03) instead of the actual effective/record dates (2021-07-20).

Why does the tool prioritize the filing date over the effective date in these cases? I’d appreciate your insights on whether this can be improved or if I should look into a hybrid approach for historical splits.

Thank you!

[dgunning]

Great catch @amcamc92 — you're right that the dates were off.

The issue was that detect_splits() was using period_end from whichever XBRL fact it encountered first for a given split. When that fact came from a 10-Q or 10-K, period_end is the end of the reporting period (e.g., June 30), not the actual split effective date.

I've pushed a fix that prioritizes 8-K instant facts when selecting the split date. An 8-K instant fact's period_end reflects the actual event date, since 8-Ks are filed within days of the event and instant facts represent a point-in-time.

The priority order is now:

1. 8-K instant fact (best — period_end is the actual effective date)
2. Any instant fact (good — as-of date, usually close)
3. Short-duration fact (acceptable — period end, approximate)

This should give you more accurate split dates for companies like AAPL and NVDA. The fix will be in the next release — update and give it a try:

from edgar import Company
from edgar.ttm import detect_splits

company = Company("AAPL")
facts = company.facts._facts
splits = detect_splits(facts)

for split in splits:
    print(f"Split Date: {split['date']}, Ratio: {split['ratio']]:1")

One caveat: for pre-XBRL splits (before ~2009), the data simply isn't available in structured form from the SEC. For those, an external data source would still be needed.

Let me know if the dates look better now!

[amcamc92]

Thanks for your response @dgunning !

However, the investigation shows conflicting split dates for both AAON, TSLA and AAPL:

AAON Case:

• 2013: yfinance (July 3) vs edgartools (July 2). Diff: 1 day.
• 2023: yfinance (Aug 17) vs edgartools (Aug 16). Diff: 1 day.
• 2014: yfinance has a split on July 17. edgartools has one on June 5. Diff: ~42 days. This is a large discrepancy.

TSLA Case:

• 2020: yfinance (Aug 31) vs edgartools (Aug 10). Diff: 21 days.
• 2022: yfinance (Aug 25) vs edgartools (Aug 5). Diff: 20 days.

AAPL Case:

• 2014: edgartools (June 6) vs yfinance (June 9). Diff: 3 days.
• 2020: edgartools (Aug 28) vs yfinance (Aug 31). Diff: 3 days.

Analysis:

yfinance generally uses the Ex-Dividend Date (or Ex-Split Date), which is when the stock actually starts trading at the new price. This is the correct date for adjusting price history. However, edgartools derives splits from XBRL facts, which often record the Record Date or the Filing Date of the period where the split occurred. For splits, there is often a lag between Record/Announcement and Ex-Date.

Is there a way to extract from XBRL structured data the Ex-Split Date?

Thanks!