How to Adjust Historical EPS for Stock Splits

Pull Amazon's annual diluted EPS from SEC XBRL the usual way, one value per fiscal year from the newest filing that reported it, and fiscal 2019 reads $23.01 while fiscal 2020 reads $2.09. That is a 90.9% drop in a year Amazon's net income rose 84.1%, to $21.33 billion. The business did not shrink. Amazon's 20-for-1 stock split put the 2020 figure on a new share basis in a later 10-K and left 2019 on the old one.

The arithmetic of adjusting historical EPS for stock splits is a single division. The hard part is knowing which values still need it, and that is where split-adjusted EPS series go wrong: StockFit's own rule for it has changed three times since we shipped it in June 2026. Below are the formula, why EPS from SEC filings sits on mixed split bases, two naive fixes that break, the filing-date rule that holds, Python you can run against SEC's free API, and the API call that applies the rule to every fact.

How a stock split affects EPS

A stock split changes the share count and nothing else. Net income, the numerator of earnings per share, stays the same, while the denominator, weighted-average shares outstanding, is multiplied by the split ratio. A 2-for-1 stock split halves EPS without any change in earnings power. To restate a pre-split figure onto today's basis:

split-adjusted EPS     = EPS as filed / cumulative split ratio
split-adjusted shares  = shares as filed × cumulative split ratio
cumulative split ratio = product of the ratios of every split the value predates
                         (2-for-1 forward = 2, 1-for-8 reverse = 0.125)

Three cases cover almost everything:

• Forward split. Walmart's 3-for-1 stock split in February 2024 turns its fiscal 2023 diluted EPS, originally filed at $4.27, into $1.42, the figure its fiscal 2024 10-K reports for that year.
• Reverse split. A 1-for-8 reverse stock split has a ratio of 0.125, so dividing by it multiplies EPS by eight. General Electric's 2021 reverse split turns its fiscal 2018 diluted EPS of -$2.62 into -$20.96.
• Multiple splits. Ratios compound. NVIDIA split 4-for-1 in 2021 and 10-for-1 in 2024, so a value filed before both is divided by 40: fiscal 2019's $6.63 becomes $0.17.

The accounting rule behind this is ASC 260-10-55-12: after a stock dividend, stock split, or reverse stock split, "the computations of basic and diluted EPS shall be adjusted retroactively for all periods presented to reflect that change in capital structure." That includes splits that happen after a period ends but before its financial statements are issued, and Deloitte's EPS roadmap walks through the edge cases. There is no time weighting: the new share count applies to the entire year, and to every period the filing presents. So each 10-K and 10-Q shows its periods on the share basis in force on the day it was issued. The catch is in "periods presented."

Why EPS from SEC filings sits on mixed split bases

A filing restates only the periods it presents. A 10-K's income statement usually covers three fiscal years (two for smaller reporting companies) and its balance sheet two year-ends, and a 10-Q compares each quarter with the same quarter a year earlier. After a split, the next filings restate those comparative periods on the new basis. Nothing restates the years before them.

Amazon effected its 20-for-1 split on May 27, 2022. Its fiscal 2022 10-K, filed February 3, 2023, re-presented fiscal 2020 diluted EPS as $2.09 (originally $41.83) and fiscal 2021 as $3.24 (originally $64.81). Fiscal 2019 is not in that filing. Its last appearance is the fiscal 2021 10-K, filed February 4, 2022, months before the split, at $23.01. A series built from the latest-filed value per year therefore puts 2019 on the old basis and 2020 on the new one. That is not a quirk of a homemade pipeline. SEC documents the same behavior for its own frames API: "The xbrl/frames API aggregates one fact for each reporting entity that is last filed that most closely fits the calendrical period requested." Its calendar 2019 and 2020 frames return $23.01 and $2.09 for Amazon.

With two splits, one history carries three bases at once. NVIDIA's latest-filed values for fiscal 2017 to 2019 come from 10-Ks filed before its 2021 split, fiscal 2020 to 2022 from 10-Ks filed between the splits, and fiscal 2023 onward from the current basis:

As filed, NVIDIA's diluted EPS falls 83.0% in fiscal 2020 and 95.6% in fiscal 2023. Both were weak years, but net income fell 32.5% and 55.2%. The rest of each drop is the share basis changing underneath the series. The same seam appears for every company we checked, in the year its as-filed EPS jumps to a newer basis:

In each case the split-adjusted change lands within 7 points of the net income change, the gap being buybacks or issuance moving the real share count. The as-filed change is a different story: a screen for EPS collapses run on latest-filed data would flag Amazon, Alphabet, Apple, Walmart, and Chipotle in years their net income grew.

The seam is not even in the same place across statements. Amazon's quarterly series switches basis inside 2021: Q1 2021 diluted EPS last appeared in the Q1 2022 10-Q, filed before the split, at $15.79, while Q2 2021 was restated to $0.76 by the Q2 2022 10-Q. On the balance sheet, that same 10-Q restated shares outstanding at December 31, 2021 from 509 million to 10.175 billion, but no filing after the split reports December 31, 2020, so that count stays at 503 million. Annual EPS, quarterly EPS, and the balance sheet each break at a different period, so a single split factor per period cannot be right for all of them.

Two naive split adjustments, and how they break

The obvious repair is to divide everything that predates the split. There are two ways to decide what predates it, and both fail on real filings.

Mistake 1: divide every period that ended before the split

Take the latest-filed series and divide each year that ended before May 27, 2022 by 20. Fiscal 2019 comes out right at $1.15. Fiscal 2020 and 2021 were already restated, so dividing them again gives $0.10 and $0.16: two years double-scaled, and a collapse still in the series, now in 2020 against an adjusted 2019.

Mistake 2: use the originally filed values instead

Original values sidestep restatements. Every figure is on the basis of its own filing, so dividing everything that ended before the split looks safe, and for Amazon it works: $41.83 / 20 = $2.09. It breaks when a period ends before a split but is filed after it, because ASC 260 requires that filing to use the new share count. Its values are already adjusted.

• Alphabet's quarter ended June 30, 2022 closed 15 days before its July 15 split, but its 10-Q was filed July 27 with diluted EPS of $1.21 on the post-split basis. Divided by 20 it becomes $0.06.
• Walmart's fiscal 2024 ended January 31, 2024, 23 days before its February 23 split. Its 10-K, filed March 15, reports diluted EPS of $1.91 and says so directly: "All share and per share information, including share based compensation, throughout this Annual Report on Form 10-K has been retroactively adjusted to reflect the stock split." Divided by 3 it becomes $0.64.

Both mistakes classify a value by its period. The basis of a value is set by its filing.

The rule that works: classify each value by its filing date

Every figure in a filing is on the share basis in force when that filing was issued. So the question for each value is whether the filing that supplied it came before or after the first filing on the post-split basis, not when its period ended. For Amazon that first filing is the Q2 2022 10-Q, filed July 29, 2022. In Python, against SEC's free companyconcept API:

from datetime import date
import requests

UA = {"User-Agent": "Your Name you@example.com"}  # SEC asks for a descriptive User-Agent


def annual_eps(cik: int) -> list[dict]:
    """Every annual diluted EPS fact a company filed in a 10-K, restatements included."""
    url = f"https://data.sec.gov/api/xbrl/companyconcept/CIK{cik:010d}/us-gaap/EarningsPerShareDiluted.json"
    facts = requests.get(url, headers=UA, timeout=30).json()["units"]["USD/shares"]
    return [
        f for f in facts
        if f["form"] == "10-K" and f.get("start")
        and (date.fromisoformat(f["end"]) - date.fromisoformat(f["start"])).days > 300
    ]


def latest_filed(facts: list[dict]) -> list[dict]:
    """One value per fiscal year, taken from the newest filing that reported it."""
    newest = {}
    for f in facts:
        if f["end"] not in newest or f["filed"] > newest[f["end"]]["filed"]:
            newest[f["end"]] = f
    return [newest[end] for end in sorted(newest)]


SPLIT_RATIO = 20.0              # Amazon's 20-for-1
SPLIT_DATE = "2022-05-27"       # the date on the split record
FIRST_NEW_BASIS = "2022-07-29"  # first filing on the post-split basis (Q2 2022 10-Q)

series = [f for f in latest_filed(annual_eps(1018724)) if f["end"] >= "2016-12-31"]
print(f"{'FY end':<12}{'latest filed':>13}{'filed':>12}{'period rule':>13}{'filing rule':>13}")
for f in series:
    period_rule = f["val"] / SPLIT_RATIO if f["end"] < SPLIT_DATE else f["val"]
    filing_rule = f["val"] / SPLIT_RATIO if f["filed"] < FIRST_NEW_BASIS else f["val"]
    print(f"{f['end']:<12}{f['val']:>13.2f}{f['filed']:>12}{period_rule:>13.2f}{filing_rule:>13.2f}")

Run on October 20, 2026, it prints:

FY end       latest filed       filed  period rule  filing rule
2016-12-31           4.90  2019-02-01         0.25         0.25
2017-12-31           6.15  2020-01-31         0.31         0.31
2018-12-31          20.14  2021-02-03         1.01         1.01
2019-12-31          23.01  2022-02-04         1.15         1.15
2020-12-31           2.09  2023-02-03         0.10         2.09
2021-12-31           3.24  2024-02-02         0.16         3.24
2022-12-31          -0.27  2025-02-07        -0.27        -0.27
2023-12-31           2.90  2026-02-06         2.90         2.90
2024-12-31           5.53  2026-02-06         5.53         5.53
2025-12-31           7.17  2026-02-06         7.17         7.17

The filing rule column has no seam: $1.15 for 2019, $2.09 for 2020, the 2022 loss where it belongs, and it matches the StockFit API value for value. The period rule column is Mistake 1. The same rule works on originally filed, point-in-time values: Alphabet's Q2 2022 figure was filed after the switch, so it stays $1.21, which matters if you keep first-filed values to avoid lookahead bias from restated financials.

The dates on a split record are not the boundary

The script hard-codes July 29, 2022. You cannot read that date off a split record, because the dates on a record describe the split, not the filings around it. The StockFit /api/company/stock-splits endpoint returns two dates per event, and neither marks the switch reliably:

firstDisclosedAt, the first filing that tags the split ratio in XBRL, can land on either side of the switch. Alphabet's Q1 2022 10-Q tagged the announced split 91 days early while still reporting on the old basis ($24.62), and Walmart first tagged its split in a 10-Q 84 days after its post-split 10-K. Use it as the boundary and Walmart's $1.91 is divided by 3 again, while Alphabet's Q1 2021 EPS, last filed in that April 2022 10-Q at $26.29, is never divided at all (it should read $1.31).

The record's own date works better, until a company tags its announcement. CrowdStrike announced its board's approval of a 4-for-1 split on June 3, 2026, and that is the date on its split record. The shares were distributed weeks later, as its 8-K states: "Each stockholder of record at the close of business on June 25, 2026 (the “record date”), will receive, after the close of business on July 1, 2026, three additional shares for every share held on the record date, and trading is expected to begin on a split-adjusted basis on July 2, 2026." In between, on June 4, CrowdStrike filed its 10-Q for the quarter ended April 30, 2026 on the old basis, with 253.7 million basic weighted-average shares. That is correct accounting, not a filer error: when a split is declared before the statements are issued but the shares do not trade on the new basis until afterward, Deloitte's roadmap says "EPS should be calculated for all periods by using the number of common shares on a pre-split basis." Treat June 3 as the boundary and that 10-Q's diluted EPS of $0.11 is never scaled to $0.03. The next 10-Q, filed August 27, 2026, reported 1,019.4 million weighted-average shares for its quarter and restated the year-ago quarter's 249.9 million to 999.6 million.

StockFit learned each of these the hard way. We have split-adjusted EPS by default since June 2026, and the boundary has moved three times since: from jumps in a share-count series to firstDisclosedAt, then to the split record's date in July, and, since October 2, after CrowdStrike, to the first filing that reports on the new basis.

Detect the first filing on the new basis from share counts

The boundary is visible in the filings themselves: it is the first filing after the split whose own weighted-average share count moved by the full ratio. Filings in between keep reporting the old count.

import math
import requests

UA = {"User-Agent": "Your Name you@example.com"}


def first_new_basis_filing(cik: int, split_date: str, ratio: float) -> tuple[str, str] | None:
    """Date and accession of the first filing whose current-period share count moved by the full split ratio."""
    url = (f"https://data.sec.gov/api/xbrl/companyconcept/CIK{cik:010d}"
           "/us-gaap/WeightedAverageNumberOfDilutedSharesOutstanding.json")
    facts = requests.get(url, headers=UA, timeout=30).json()["units"]["shares"]

    current = {}  # accession -> that filing's current-period count (its latest period end)
    for f in facts:
        if f["form"] in ("10-K", "10-Q") and (f["accn"] not in current or f["end"] > current[f["accn"]]["end"]):
            current[f["accn"]] = f
    filings = sorted(current.values(), key=lambda f: f["filed"])

    before = [f for f in filings if f["filed"] < split_date]
    if not before:
        return None
    reference = before[-1]["val"]  # last count reported before the split date
    for f in filings:
        if f["filed"] >= split_date:
            step = math.log(f["val"] / reference) / math.log(ratio)  # ~0 = old basis, ~1 = new basis
            if abs(step - 1) <= 0.15:
                return f["filed"], f["accn"]
    return None


for name, cik, split_date, ratio in [
    ("Amazon", 1018724, "2022-05-27", 20),
    ("Alphabet", 1652044, "2022-07-15", 20),
    ("Walmart", 104169, "2024-02-23", 3),
    ("CrowdStrike", 1535527, "2026-06-03", 4),
]:
    print(f"{name:<12} split dated {split_date}  first filing on new basis: {first_new_basis_filing(cik, split_date, ratio)}")

Amazon       split dated 2022-05-27  first filing on new basis: ('2022-07-29', '0001018724-22-000019')
Alphabet     split dated 2022-07-15  first filing on new basis: None
Walmart      split dated 2024-02-23  first filing on new basis: ('2024-03-15', '0000104169-24-000056')
CrowdStrike  split dated 2026-06-03  first filing on new basis: ('2026-08-27', '0001535527-26-000031')

It finds Amazon's and Walmart's switches, and for CrowdStrike it skips the June 4 10-Q and lands on August 27. Alphabet returns None, and that is a data limit, not a bug: until a 10-Q filed in July 2024, Alphabet tagged weighted-average shares only per share class (6,902 million Class A, 887 million Class B, and 6,337 million Class C diluted in its Q2 2022 10-Q), and SEC's companyconcept endpoint serves only facts that apply to the whole entity. Covering multi-class filers means reading the dimensional facts in each filing's XBRL instance, the trap our post on extracting EPS and share count with Arelle covers in detail.

Run the classification per fact, not per period. Each value carries its own filing date, so Amazon's fiscal 2020 EPS (restated in 2023) and its December 31, 2020 share count (last filed before the split) get different answers inside the same fiscal year, which is exactly what the seams above require.

Split-adjusted EPS history from the StockFit API

StockFit applies this rule to every split-sensitive fact by default. /api/earnings/eps-history returns the split-adjusted series in one call:

curl "https://api.stockfit.io/v1/api/earnings/eps-history?symbol=AMZN&period=annual&limit=10" \
  -H "Authorization: Bearer $STOCKFIT_API_KEY"

[
  {
    "period": "2021-12-31", "fiscalYear": 2021, "fiscalPeriod": "FY",
    "eps": 3.3, "epsDiluted": 3.24, "netIncome": 33364000000,
    "sharesOutstanding": 10117000000, "sharesOutstandingDiluted": 10296000000, "epsGrowth": 0.5493
  },
  {
    "period": "2020-12-31", "fiscalYear": 2020, "fiscalPeriod": "FY",
    "eps": 2.13, "epsDiluted": 2.09, "netIncome": 21331000000,
    "sharesOutstanding": 10005000000, "sharesOutstandingDiluted": 10198000000, "epsGrowth": 0.8205
  },
  {
    "period": "2019-12-31", "fiscalYear": 2019, "fiscalPeriod": "FY",
    "eps": 1.17, "epsDiluted": 1.15, "netIncome": 11588000000,
    "sharesOutstanding": 9880000000, "sharesOutstandingDiluted": 10080000000, "epsGrowth": 0.1359
  },
  ...
]

epsGrowth for 2020 reads 0.8205 here and -0.9092 with splitAdjust=false, which returns every value as most recently filed, the series in the charts above. The same parameter works on /api/financials/income-statement, the balance sheet, /api/financials/chart/per-share, and the dividend history. Only per-share values and share counts change; dollar amounts never do.

The income statement shows the receipts. Adjusted periods carry a splitFactor, and each value's sources entry names the filing that supplied it, with before when a later filing changed it (trimmed to the per-share fields):

[
  {
    "period": "2021-12-31",
    "fiscalYear": 2021,
    "dateFiled": "2022-02-04",
    "facts": {
      "weightedAverageSharesOutstanding": 10117000000,
      "weightedAverageSharesOutstandingDiluted": 10296000000,
      "eps": 3.3,
      "epsDiluted": 3.24
    },
    "sources": {
      "0001018724-22-000005": {
        "type": "10-K",
        "dateFiled": "2022-02-04",
        "facts": {
          "weightedAverageSharesOutstanding": {},
          "weightedAverageSharesOutstandingDiluted": {},
          "eps": {},
          "epsDiluted": {}
        }
      },
      "0001018724-23-000004": {
        "type": "10-K",
        "dateFiled": "2023-02-03",
        "facts": {
          "weightedAverageSharesOutstanding": {"before": 506000000},
          "weightedAverageSharesOutstandingDiluted": {"before": 515000000},
          "eps": {"before": 65.96},
          "epsDiluted": {"before": 64.81}
        }
      }
    }
  },
  {
    "period": "2019-12-31",
    "fiscalYear": 2019,
    "dateFiled": "2020-01-31",
    "facts": {
      "weightedAverageSharesOutstanding": 9880000000,
      "weightedAverageSharesOutstandingDiluted": 10080000000,
      "eps": 1.17,
      "epsDiluted": 1.15
    },
    "sources": {
      "0001018724-20-000004": {
        "type": "10-K",
        "dateFiled": "2020-01-31",
        "facts": {
          "weightedAverageSharesOutstanding": {},
          "weightedAverageSharesOutstandingDiluted": {},
          "eps": {},
          "epsDiluted": {}
        }
      }
    },
    "splitFactor": 20
  }
]

Fiscal 2021's diluted EPS of 3.24 comes from the fiscal 2022 10-K, which replaced the 64.81 Amazon first reported, so it is served as filed. Fiscal 2019's values come from filings made before the split, so they are scaled by its splitFactor of 20. The audit trail stays as filed either way: follow before back to the original figure and the accession number on EDGAR.

The split events themselves come from /api/company/stock-splits (Stock and Pro plans), detected from XBRL ratio tags and corroborated against share-count cliffs, which our post on how to detect stock splits in historical data explains:

[
  {
    "date": "2022-05-27",
    "ratio": 20,
    "type": "forward",
    "accession": "0001018724-22-000019",
    "firstDisclosedAt": "2022-07-29"
  }
]

The EPS history, income statement, and per-share chart work on every plan. Free returns the latest fiscal year and four quarters, Starter 5 years and 20 quarters, and Stock, ETF, and Pro up to 40 years and 80 quarters. Get a free API key to try it, or see the stock split API for app developers and point-in-time fundamentals for quants.

Check any EPS history for split seams

Whatever your source, you can test a series for basis seams without knowing its splits. Net income does not change with the share basis, so when EPS moves far more than net income in a year, the share count underneath it jumped:

import os
import requests

API = "https://api.stockfit.io/v1/api"
HEADERS = {"Authorization": f"Bearer {os.environ['STOCKFIT_API_KEY']}"}


def eps_history(symbol: str, split_adjust: bool) -> list[dict]:
    params = {"symbol": symbol, "period": "annual", "limit": 10, "splitAdjust": str(split_adjust).lower()}
    rows = requests.get(f"{API}/earnings/eps-history", params=params, headers=HEADERS, timeout=30).json()
    return sorted(rows, key=lambda r: r["period"])  # oldest first


def basis_seams(rows: list[dict], tolerance: float = 1.5) -> list[str]:
    """Flag years where EPS moved far more than net income: the share basis changed underneath."""
    flags = []
    for prev, cur in zip(rows, rows[1:]):
        if min(prev["epsDiluted"], cur["epsDiluted"], prev["netIncome"], cur["netIncome"]) <= 0:
            continue  # ratios across a loss year say nothing about the share basis
        implied_share_jump = (cur["netIncome"] / prev["netIncome"]) / (cur["epsDiluted"] / prev["epsDiluted"])
        if implied_share_jump > tolerance or implied_share_jump < 1 / tolerance:
            flags.append(f"FY{cur['fiscalYear']}: implied share-count jump {implied_share_jump:.1f}x")
    return flags


for symbol in ["AMZN", "NVDA", "WMT"]:
    print(symbol, "as filed:     ", basis_seams(eps_history(symbol, split_adjust=False)))
    print(symbol, "split-adjusted:", basis_seams(eps_history(symbol, split_adjust=True)))

AMZN as filed:      ['FY2020: implied share-count jump 20.3x']
AMZN split-adjusted: []
NVDA as filed:      ['FY2020: implied share-count jump 4.0x', 'FY2023: implied share-count jump 10.1x']
NVDA split-adjusted: []
WMT as filed:      ['FY2022: implied share-count jump 3.0x']
WMT split-adjusted: []

On the as-filed series it recovers each split ratio from the data alone: 20.3x for Amazon, 4.0x and 10.1x for NVIDIA's two splits, 3.0x for Walmart. On the split-adjusted series it finds nothing. Treat a flag as a lead, not a verdict: a large stock-financed acquisition also moves the share count, and loss years are skipped because the ratio means nothing across a sign change.

One caveat applies to any adjusted series, ours included. EPS is reported rounded to the cent, and dividing a rounded value by a large ratio magnifies the rounding: Chipotle's fiscal 2016 diluted EPS of $0.77 becomes $0.02 after its 50-for-1 split, where the exact quotient is $0.0154. When growth rates on small early values matter, compute them from net income and the split-adjusted share counts, which the same endpoint returns.

Data verified October 20, 2026: every as-filed EPS value in this post matches the latest-filed fact in SEC's companyconcept API, and every split-adjusted value comes from the StockFit API with splitAdjust=true. Figures are historical filing data, not investment advice.

FAQ