> ## Documentation Index
> Fetch the complete documentation index at: https://fruitstand.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# How Do I Find Stock Splits and Reverse Splits in Price Data?

> Find stock splits and reverse splits in daily prices with SQL: the adjustment-factor test, 1,878 splits since 2025, and how to rule out spinoffs and bad data.

*By [Fruit Stand Team](https://fruitstand.dev/about.md) · November 15, 2026 · Guides*

Compare each day's adjustment factor, `adjusted_close / close`, with the
day before. On a split day the factor steps by the split ratio while the
adjusted price barely moves: Nvidia's factor stepped exactly 10x on June 10,
2024\. Across every US stock and ETF since January 2025, the test finds
1,878 splits with clean ratios, 1,580 of them reverse splits.

Below are the queries to list one ticker's splits and every split in the
market, what the counts show, how to tell a split from a crash or a bad
print, and when a backtest should use raw prices instead of adjusted ones.

> [!NOTE]
>
> Fruit Stand publishes the Historical Stock Prices listing used here. Every
> query in this post was run on November 15, 2026, against the listing, with
> prices through November 13, 2026. Split ratios and dates for the companies
> named were checked against their own press releases or SEC filings the same
> day.

## What a split looks like in daily prices

A split changes the number of shares, not what the company is worth. So on
the first day at the new price, the raw `close` jumps or drops by the split
ratio, and the split- and dividend-adjusted `adjusted_close` moves only by
the day's real gain or loss.

The adjustment factor, `adjusted_close / close`, shows the split directly.
It's 1.0 on the latest date and shrinks going back each time a split or
dividend is applied. Divide one day's factor by the day before's and you get:

| Factor step | What it usually means |
| - | - |
| About 1.000 | A normal day |
| 1.001 to about 1.1 | A dividend or distribution |
| 2, 3, 10 or 1.5 (3-for-2) | A forward split of that ratio |
| 0.1, 0.05 or 0.4 (1-for-2.5) | A reverse split: 1-for-10, 1-for-20, 1-for-2.5 |
| Anything else above about 1.2 | A spinoff, a large special distribution, or bad data |

Nvidia is the usual example: its close went from $1,208.88 on June 7, 2024,
to $121.79 on June 10, its factor stepped by 10.0, and its adjusted price
rose 0.75%. [How to Calculate Stock Returns From Daily Prices in
SQL](https://fruitstand.dev/blog/calculate-stock-returns-sql.md) shows the returns either side of that
day, and [Adjusted Close vs. Close](https://fruitstand.dev/blog/adjusted-close-vs-close.md) explains
how the factor is built.

Note the date. Nvidia's [8-K](https://www.sec.gov/Archives/edgar/data/1045810/000104581024000113/nvda-20240522.htm)
says the new shares were distributed after the close on June 7 and trading
on a split-adjusted basis began June 10. Price data marks the split on June
10, the first day at the new price. Press releases often call the earlier
date the effective date.

## List every split for one ticker

This query finds every day where the factor stepped more than 20% and the raw
close moved more than 20% too:

```sql theme={null}
with px as (
    select code, date, close,
           lag(close) over (partition by code order by date) as prev_close,
           (adjusted_close / close)
             / lag(adjusted_close / close) over (partition by code order by date) as factor_step
    from security_price_history_vw
    where exchange_code = 'US'
      and code = 'NVDA'
)
select date, prev_close, close,
       round(factor_step, 4) as factor_step,
       iff(factor_step >= 1,
           round(factor_step, 2) || '-for-1',
           '1-for-' || round(1 / factor_step, 2)) as ratio
from px
where abs(ln(factor_step)) > ln(1.2)
  and abs(ln(close / prev_close)) > ln(1.2)
order by date;
```

| Date | Previous close | Close | Factor step | Ratio |
| - | -: | -: | -: | - |
| 2000-06-27 | \$165.94 | \$71.26 | 1.9995 | 2-for-1 |
| 2001-09-17 | \$75.76 | \$33.99 | 1.9994 | 2-for-1 |
| 2006-04-07 | \$61.22 | \$30.53 | 2.0000 | 2-for-1 |
| 2007-09-11 | \$50.79 | \$34.58 | 1.4999 | 1.5-for-1 (3-for-2) |
| 2021-07-20 | \$751.19 | \$186.12 | 4.0000 | 4-for-1 |
| 2024-06-10 | \$1,208.88 | \$121.79 | 10.0000 | 10-for-1 |

Those are Nvidia's six splits, which turned one original share into 480
(2 × 2 × 2 × 1.5 × 4 × 10). Swap in any ticker. For Lucid Group (`LCID`) the
query returns a single row: a 1-for-10 reverse split on September 2, 2025,
when the close went from $1.98 to $17.66.

Both filters matter. The factor step alone also catches big special
dividends, and the close move alone catches every crash.

## List every split and reverse split in the market

The same test across every stock and ETF needs a few more guards. This
version saves the results to a temporary table, `splits`, for the queries
that follow:

```sql theme={null}
create or replace temporary table splits as
with px as (
    select code, date, close,
           lag(close) over (partition by code order by date) as prev_close,
           adjusted_close / lag(adjusted_close) over (partition by code order by date) as adj_move,
           (adjusted_close / close)
             / lag(adjusted_close / close) over (partition by code order by date) as factor_step
    from security_price_history_vw
    where exchange_code = 'US'
      and date >= '2024-12-01'
),
steps as (
    select px.*, s.name, s.asset_class, s.exchange,
           iff(factor_step >= 1, 'split', 'reverse split') as kind,
           iff(factor_step >= 1, factor_step, 1 / factor_step) as n
    from px
    join security_vw s on s.code = px.code and s.exchange_code = 'US'
    where px.date >= '2025-01-01'
      and s.asset_class in ('stock', 'etf')
      and least(px.close, px.prev_close) >= 0.01
      and factor_step > 0
      and abs(ln(factor_step)) > ln(1.2)
      and abs(ln(px.close / px.prev_close)) > ln(1.2)
      and abs(ln(adj_move)) < ln(2)
),
ratios as (
    select *,
           case
               when n >= 1.9 and abs(n / round(n) - 1) < 0.03 then 1
               when n < 3 and abs(n * 2 / round(n * 2) - 1) < 0.003 then 2
               when n < 3 and abs(n * 3 / round(n * 3) - 1) < 0.003 then 3
               when n < 2 and abs(n * 4 / round(n * 4) - 1) < 0.003 then 4
               when kind = 'reverse split' and abs(n * 2 / round(n * 2) - 1) < 0.003 then 2
           end as q
    from steps
)
select code, date, name, asset_class, exchange, prev_close, close,
       round(n, 3) as raw_ratio,
       case
           when q is null then 'unclear'
           when kind = 'split' then round(n * q) || '-for-' || q
           when q <= 2 then '1-for-' || round(n * q) / q
           else q || '-for-' || round(n * q)
       end as ratio,
       kind
from ratios
order by date, code;
```

What each guard does:

* **Stocks and ETFs only.** Mutual funds pay large year-end distributions
  that step the factor by 20% or more with no split.
* **Prices of at least one cent.** Below that, a quote moving from $0.0002 to
  $0.0001 halves the close in one tick, and the factor flips back and forth
  without any corporate action.
* **The adjusted price moved less than 2x either way.** Real reverse splits
  are often followed by a big drop the same day, so a tight limit here
  misses them.
* **Rounding to a clean ratio.** Whole numbers within 3% (2-for-1, 1-for-10,
  1-for-17), and the common fractions 3-for-2, 4-for-3, 5-for-4 and
  1-for-2.5 within 0.3%. Anything else is labelled `unclear`.

Then count them:

```sql theme={null}
select kind, asset_class,
       count_if(ratio <> 'unclear') as clean_days,
       count(distinct iff(ratio <> 'unclear', code, null)) as clean_tickers,
       count_if(ratio = 'unclear') as unclear_days
from splits
group by kind, asset_class
order by kind, asset_class;
```

## How many splits and reverse splits there were

From January 2, 2025, to November 13, 2026:

| | Clean-ratio days | Tickers | Unclear days |
| - | -: | -: | -: |
| Reverse splits, stocks | 1,363 | 1,060 | 13 |
| Reverse splits, ETFs | 217 | 195 | 2 |
| Forward splits, stocks | 214 | 207 | 80 |
| Forward splits, ETFs | 84 | 84 | 18 |
| **Total** | **1,878** | | **113** |

Reverse splits outnumbered forward splits by more than five to one. Some
companies did several: Workhorse Group (`WKHS`) shows up twice, at 1-for-12.5
in March 2025 and 1-for-12 in December 2025.

By venue, with how many of the splits were in shares that traded under \$1
just before or after:

```sql theme={null}
select kind,
       case
           when exchange in ('NASDAQ') then 'Nasdaq'
           when exchange in ('NYSE') then 'NYSE'
           when exchange in ('NYSE ARCA', 'BATS', 'AMEX', 'NYSE MKT') then 'NYSE Arca, Cboe BZX, NYSE American'
           when exchange like 'OTC%' or exchange = 'PINK' then 'OTC'
           else 'Other'
       end as venue,
       count(*) as days,
       count_if(least(prev_close, close) < 1) as under_1_dollar
from splits
where ratio <> 'unclear'
group by kind, venue
order by kind, days desc;
```

| Venue | Reverse splits | Under \$1 | Forward splits |
| - | -: | -: | -: |
| Nasdaq | 964 | 835 | 55 |
| OTC markets | 368 | 334 | 154 |
| NYSE Arca, Cboe BZX, NYSE American | 203 | 63 | 61 |
| NYSE | 44 | 24 | 28 |
| Other | 1 | 1 | 0 |

The reverse-split count is mostly Nasdaq stocks trying to get back above $1.
Nasdaq requires a minimum bid of $1.00, and Workhorse's [March 2025
release](https://www.sec.gov/Archives/edgar/data/1425287/000121390025022950/ea023404101ex99-1_work.htm)
gave that as the reason for its split. Of 964 Nasdaq reverse splits, 835
were in shares under \$1. The ETF reverse splits are mostly leveraged and
inverse funds, whose prices decay over time: 176 of the 217 have "2x",
"ultra", "short", "daily" or similar in their names.

Forward splits are rarer, and the OTC ones are mostly foreign companies'
shares and ADRs trading over the counter in the US, such as Japanese
companies that split at home.

The most common ratios:

| Reverse split | Days | Forward split | Days |
| - | -: | - | -: |
| 1-for-10 | 355 | 2-for-1 | 92 |
| 1-for-20 | 156 | 3-for-1 | 47 |
| 1-for-5 | 146 | 5-for-1 | 36 |
| 1-for-25 | 77 | 4-for-1 | 34 |
| 1-for-4 | 72 | 10-for-1 | 30 |
| 1-for-3 | 72 | 3-for-2 | 15 |

### Checking a simpler rule

A quick first pass is "the close went up more than 4x while the adjusted
price moved less than 50%." Since January 2025 that matches 1,568 days.
Of those, 1,381 are reverse splits the full query confirms, 147 are
sub-penny quotes ticking between $0.0001 and $0.0009, 36 are mutual funds,
and 4 have ratios that don't round cleanly. So the simple rule is about 88%
right, and nearly all its misses are sub-penny quotes.

## Notable splits, checked against company sources

| Ticker | Ratio found | First day at new price | Company source |
| - | - | - | - |
| WKHS | 1-for-12.5 | 2025-03-17 | [8-K, Mar 2025](https://www.sec.gov/Archives/edgar/data/1425287/000121390025022950/ea023404101ex99-1_work.htm): 1-for-12.5, split-adjusted trading March 17 |
| ORLY | 15-for-1 | 2025-06-10 | [O'Reilly release, Mar 13, 2025](https://corporate.oreillyauto.com/2025/03/13/oreilly-automotive-inc-board-of-directors-approves-15-for-1-stock-split-subject-to-shareholder-approval-of-an-increase-in-the-number-of-authorized-shares-of-common-stock/): post-split trading from June 10 |
| LCID | 1-for-10 | 2025-09-02 | [10-K for 2025](https://www.sec.gov/Archives/edgar/data/1811210/000162828026011053/lcid-20251231.htm): 1-for-10, effective August 29 |
| NFLX | 10-for-1 | 2025-11-17 | [8-K exhibit, Oct 30, 2025](https://www.sec.gov/Archives/edgar/data/1065280/000106528025000407/ex991_q425stocksplit.htm): split-adjusted trading from November 17 |
| AMCR | 1-for-5 | 2026-01-15 | [Amcor release](https://www.amcor.com/media/news/amcor-completes-one-for-five-reverse-stock-split): split-adjusted trading on the NYSE from January 15 |
| BKNG | 25-for-1 | 2026-04-06 | [Q1 2026 release (8-K)](https://www.sec.gov/Archives/edgar/data/1075531/000107553126000024/q1-26bkngearningsrelease.htm): split effected April 2 |

Every one matches on ratio. The dates differ only where the company names
the effective date and trading starts at the next open, as with Lucid
(effective Friday, August 29; the next trading day was September 2, after
Labor Day) and Booking (effected Thursday, April 2; markets were closed on
Good Friday, so trading resumed April 6).

## What the unclear ones are

The 113 unclear days are worth a look, because they're what an automated
split detector gets wrong:

* **Spinoffs.** A spinoff removes value from the parent's price, so the
  factor steps by the spun-off share. DuPont (`DD`) stepped by 2.39 on
  November 3, 2025, after it [distributed Qnity
  Electronics](https://www.dupont.com/news/dupont-completes-separation-of-qnity-electronics.html),
  and FedEx (`FDX`) stepped by 1.241 on June 1, 2026, when [FedEx Freight
  began trading](https://www.nasdaq.com/press-release/fedex-completes-spin-fedex-freight-2026-06-01).
  FedEx's 1.241 is less than 1% from 5-for-4, which is why the query only
  accepts fractions within 0.3%.
* **Large special distributions** from REITs and companies selling assets,
  and year-end distributions from some leveraged and option-income ETFs.
* **Foreign shares that split abroad.** A 2-for-1 split at home can show up
  as 2.05 on a thinly traded US over-the-counter line, whose quote doesn't
  move exactly with the home market. Most fall within the 3% tolerance; some
  don't.
* **Bad raw prices.** If a vendor's raw close is wrong for a stretch of
  days while the adjusted price stays right, the factor steps by an odd
  ratio and steps back when the raw price is corrected. Before treating an
  odd ratio as a split, check the price against a second source.

## How to tell a split from a crash or a data error

| | Raw close | Adjusted close | Factor | Next day |
| - | - | - | - | - |
| Split | Jumps or drops by a clean ratio | Normal move | Steps by the same ratio | Stays at the new level |
| Crash or rally | Big move | Same big move | Unchanged | Usually stays |
| Bad print | Big move | Same big move | Unchanged | Snaps back |
| Missed split (vendor error) | Drops by a clean ratio | Same drop | Unchanged | Stays, until the vendor fixes it |
| Bad raw price | Off for a stretch | Normal | Steps by an odd ratio | Steps back later |

The last two columns do most of the work. This finds one-day spikes on NYSE
and Nasdaq that reversed the next day with no change in the factor:

```sql theme={null}
with px as (
    select code, date, close,
           lag(close) over (partition by code order by date) as prev_close,
           lead(close) over (partition by code order by date) as next_close,
           (adjusted_close / close)
             / lag(adjusted_close / close) over (partition by code order by date) as factor_step
    from security_price_history_vw
    where exchange_code = 'US'
      and date >= '2024-12-01'
)
select px.code, px.date, px.prev_close, px.close, px.next_close
from px
join security_vw s on s.code = px.code and s.exchange_code = 'US'
where px.date >= '2025-01-01'
  and s.exchange in ('NYSE', 'NASDAQ')
  and s.name not ilike '%test stock%'
  and least(px.prev_close, px.close) >= 1
  and abs(ln(px.factor_step)) < ln(1.05)
  and abs(ln(px.close / px.prev_close)) > ln(2)
  and abs(ln(px.next_close / px.prev_close)) < ln(1.2)
order by px.date;
```

It returns 30 days on 25 tickers since January 2025, such as a close of
$2.76 between $10.00 and \$8.89. A stock can double and give it all back the
next day, but rarely, so treat these as suspect prints and check them
against another source before trading on them.

The `test stock` filter matters too. Nasdaq's test tickers, such as `ZVZZT`,
have prices in the data, and the security master lists four of them. Their
prices swing wildly and would fill this list.

## Adjusted prices for returns, raw prices for price filters

Adjusted prices are right for returns, moving averages and anything else
that compares prices across time. The [backtest
guide](https://fruitstand.dev/blog/backtest-trading-strategy-snowflake.md) covers why.

But any rule about the price level itself has to use the raw `close`:
"stocks under $5," "skip anything under $1," minimum share prices for
shorting, or position sizing by share count. Adjusted prices rewrite old
levels. Forward splits push old adjusted prices down, and reverse splits
push them up, sometimes by thousands of times. On January 2, 2024:

| Ticker | Raw close | Adjusted close today |
| - | -: | -: |
| LCID | \$4.15 | \$41.50 |
| NVDA | \$481.68 | \$48.03 |
| WKHS | \$0.36 | \$1,082.70 |

Workhorse traded at 36 cents that day. After reverse splits of 1-for-20
(2024), 1-for-12.5 and 1-for-12 (both 2025), its adjusted price says
\$1,082.70.

Across the whole market the error adds up:

```sql theme={null}
select count(*) as stocks,
       count_if(p.close < 5) as under_5_raw,
       count_if(p.adjusted_close < 5) as under_5_adjusted,
       count_if(p.adjusted_close < 5 and p.close >= 5) as wrongly_flagged,
       count_if(p.adjusted_close >= 5 and p.close < 5) as wrongly_missed
from security_price_history_vw p
join security_vw s on s.code = p.code and s.exchange_code = p.exchange_code
where p.exchange_code = 'US'
  and p.date = '2024-01-02'
  and s.type = 'Common Stock'
  and s.exchange in ('NYSE', 'NASDAQ');
```

Of 4,523 NYSE and Nasdaq common stocks with a price that day, 1,200 closed
under $5. A screen on `adjusted_close` finds 725: it misses 525 that really
were under $5, mostly later reverse-splitters, and includes 50 that weren't.
That's 575 stocks, about 13%, on the wrong side of the line.

The fix is to filter on `close` and compute returns from `adjusted_close`,
in the same query.

## Build a split-adjusted series without dividends

Some charts and price-return calculations want prices adjusted for splits
but not dividends. With no splits table, you can build it from the detected
split days: round each split's factor step to its ratio, which drops the
small dividend part, and divide every earlier close by the product of the
later ratios.

```sql theme={null}
with px as (
    select date, close, adjusted_close,
           (adjusted_close / close)
             / lag(adjusted_close / close) over (order by date) as factor_step,
           close / lag(close) over (order by date) as close_move
    from security_price_history_vw
    where exchange_code = 'US'
      and code = 'AAPL'
),
marked as (
    select *,
           iff(abs(ln(factor_step)) > ln(1.2) and abs(ln(close_move)) > ln(1.2),
               iff(factor_step >= 1, round(factor_step, 2), 1 / round(1 / factor_step, 2)),
               1) as split_ratio
    from px
),
adjusted as (
    select date, close, adjusted_close,
           close / exp(coalesce(sum(ln(split_ratio)) over (
               order by date rows between 1 following and unbounded following), 0)) as split_adjusted_close
    from marked
)
select date, close, round(split_adjusted_close, 4) as split_adjusted_close, adjusted_close
from adjusted
where date in ('2014-06-06', '2014-06-09', '2020-08-28', '2020-08-31', '2026-11-13')
order by date;
```

| Date | Close | Split-adjusted | Split- and dividend-adjusted |
| - | -: | -: | -: |
| 2014-06-06 | \$645.57 | \$23.06 | \$20.19 |
| 2014-06-09 | \$93.70 | \$23.43 | \$20.51 |
| 2020-08-28 | \$499.23 | \$124.81 | \$120.86 |
| 2020-08-31 | \$129.04 | \$129.04 | \$124.96 |
| 2026-11-13 | \$356.27 | \$356.27 | \$356.27 |

Apple's 7-for-1 (2014) and 4-for-1 (2020) splits combine to 28, so $645.57
becomes $23.06. From June 6, 2014, to November 13, 2026, the split-adjusted
series gives a price return of 1,445%, and the fully adjusted one a total
return of 1,665%. The gap is the dividends.

What this method leaves out:

* It only removes splits the test finds. A missed or unclear event stays in
  the series as a jump, so check the `split_ratio` rows for any ticker you use.
* Rounding to two decimals assumes clean ratios. An odd ratio such as
  1-for-12.5 works; a 1-for-7.75 would need more decimals.
* Spinoffs aren't splits, so they're left in, which is usually what you want
  for a price-only series.
* There's no dividend table, so you can't build the reverse (dividends but
  not splits) this way.

## Limitations of finding splits from prices

* **No announcement, record or payable dates.** Prices only show the first
  day at the new price. For event studies around the announcement, you need
  the company's release or 8-K.
* **Spinoffs step the factor too.** Large ones land in `unclear`, but a small
  one can land near 5-for-4 or 4-for-3. Check fractional ratios by hand.
* **No delisted securities.** The Historical Stock Prices listing covers
  securities that still trade, so a company that reverse split and was
  delisted anyway isn't in these counts. The real number of reverse splits
  is higher.
* **A split only appears once the vendor applies it.** If the adjusted price
  hasn't been updated yet, a split looks like a crash in both columns for a
  day or two.
* **Share classes and temporary tickers count separately.** `RUSHA` and
  `RUSHB` are one company, and an OTC stock can show up under a temporary
  ticker with a `D` added after a reverse split as well as its usual one.

Other data tools have the same problem. A [Microsoft Q\&A
question](https://learn.microsoft.com/en-us/answers/questions/5642517/excel-stockhistory-function-inconsistency-for-netf)
from December 1, 2025, reports Excel's `STOCKHISTORY` returning Netflix's
pre-split prices around \$1,000 after its 10-for-1 split, while recent prices
were split-adjusted. On QuantConnect's forum, a [user traced a profit
spike](https://www.quantconnect.com/forum/discussion/9465/can-039-t-get-stocks-split-event-for-tops/)
in a backtest to Top Ships' 1-for-25 reverse split in August 2020, which their
algorithm never saw as a split event. Running the factor test on your own
data catches both kinds of problem.

## F.A.Q.

> [accordion] How do I know if a stock had a reverse split?
>
> Look for a day when the raw close jumped by a clean multiple, such as 10x or 20x, while the adjusted close barely moved. In SQL, divide `adjusted_close / close` by the previous day's value; a reverse split shows as 0.1 for 1-for-10, 0.05 for 1-for-20. Confirm the ratio in the company's press release or 8-K.

> [accordion] Is there a table of stock splits in the Historical Stock Prices listing?
>
> No. The listing has daily prices, adjusted prices and the security master, but no splits or dividends table. The queries in this post rebuild split dates and ratios from the prices, which is enough for most backtests and screens.

> [accordion] Why are there so many more reverse splits than forward splits?
>
> Mostly because of exchange price minimums. Nasdaq requires a $1.00 minimum bid, and companies that fall below it often reverse split to stay listed. Of 1,580 reverse splits since January 2025, 1,257 were in shares trading under $1. Leveraged and inverse ETFs also reverse split often, because their prices tend to decay.

> [accordion] Should a backtest use adjusted or raw prices?
>
> Both. Use `adjusted_close` for returns and signals, and the raw `close` for anything about the price level, such as a "stocks under $5" filter or share counts. On January 2, 2024, a $5 screen on adjusted prices put 575 of 4,523 NYSE and Nasdaq stocks on the wrong side.

> [accordion] Why does a split show up a day after the date in the press release?
>
> Companies often give the effective date as the day the new shares are distributed, after that day's close. Price data marks the split on the first trading day at the new price. Nvidia's split was effective after the close on June 7, 2024, and traded split-adjusted from June 10.

To find splits and reverse splits across every US stock and ETF in SQL,
start a free 30-day trial of the [Historical Stock Prices listing on the
Snowflake Marketplace](https://app.snowflake.com/marketplace/listing/GZTYZTG3LNFA).
The schema is in the [dataset docs](https://fruitstand.dev/datasets/historical-stock-prices.md).
Questions? Reach out at [contact@fruitstand.dev](mailto:contact@fruitstand.dev).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.