What Are Corporate Actions? A Developer's Guide to the Data

If you have ever loaded a year of daily bars and found a stock that "fell" 50% overnight on no news, you have already met a corporate action. So, what are corporate actions? They are decisions a company makes that change its shares: how many exist, what they are called, what they pay out, or whether they exist at all. Dividends, stock splits, mergers, spin-offs and ticker changes are the common ones.

For an investor they are a question of entitlement (do I get this dividend?). For a developer they are a data problem: every one of them leaves a mark in price history, volume, and the symbol you key your tables on. This guide covers the main types, the dates that matter, what each does to your data, and how to pull corporate actions as JSON from the OkamiStocks API.

What are corporate actions?

FINRA describes corporate actions as events that "may affect a company's stock and, therefore, its shareholders", ranging from a change to the company's name to issuing a dividend or restructuring through a merger or bankruptcy (FINRA, Corporate Actions by Public Companies). FINRA's own list of categories is a good map of the territory: name or trading symbol changes, stock splits, dividends, mergers and acquisitions, rights offerings, and liquidation or dissolution.

Two things worth knowing from the same page. First, FINRA does not approve corporate actions; it processes and announces them for over-the-counter securities on its Daily List, which carries "ex-dates, new issues, deleted issues, deletions, trading symbol and name changes". Second, companies usually announce an action themselves through a press release, which is why the first sign of one in your pipeline is often a news item rather than a price move.

Types of corporate actions

Most actions fall into one of a few buckets. The names below match how data feeds, including ours, tend to group them.

Cash dividends

A payment per share, in cash, to everyone who holds the stock on the record date. The amount is the rate (for example $0.24 per share). A regular dividend repeats on a schedule, often quarterly for US companies; a special dividend is a one-off.

Stock dividends and spin-offs

Instead of cash, holders receive more shares. The SEC's investor site notes that a stock dividend "may be additional shares in the company or in a subsidiary being spun off" (investor.gov, Ex-Dividend Dates). A spin-off creates a brand new ticker, and the parent's price drops by roughly the value of what was handed out.

Forward splits

A split increases the number of shares and divides the price by the same factor. FINRA's worked example: in a 2-for-1 split, a holder of 10 shares worth $100 each ends up with 20 shares worth $50 each, and "the total value of those shares is the same as it was before the split: $1,000" (FINRA, A Piece-by-Piece Guide to Stock Splits). Common ratios are 2-for-1, 3-for-2 and 3-for-1, but 4-for-1, 10-for-1 and larger happen.

Reverse splits

The same operation in the other direction: shares are merged into fewer, pricier ones. investor.gov's example: "if you owned 10,000 shares of a company before the reverse stock split, you will own a total of 1,000 shares after" (investor.gov, Reverse Stock Splits). FINRA adds that companies may do this "to maintain their listing on a stock market that has a minimum per-share price". Small holders are sometimes cashed out instead of receiving a fractional share.

Name and ticker changes

A company renames itself, or just changes its symbol. The business is the same; the key you store it under is not. Facebook becoming Meta (FB to META) is the textbook example.

Mergers, acquisitions and reorganizations

One company absorbs another. The acquired company's shares are converted into cash, into the acquirer's shares, or a mix, and its ticker stops trading. From a data point of view this is the one action that ends a time series rather than adjusting it.

Rights offerings, liquidations and the rest

Rights offerings let existing holders buy new shares, usually at a discount. Liquidation and dissolution wind a company up. These are rarer in a retail dataset but they do show up, and a feed that groups by type will put them in their own buckets.

The dates that matter

Every action carries a small set of dates, and the two that developers trip on are the record date and the ex-date.

• Declaration (announcement) date. The board announces the action and its terms.
• Record date. You must be a shareholder of record on this day to receive the dividend, the new shares, or the merger consideration.
• Ex-date (ex-dividend date). The first day the stock trades without the entitlement. investor.gov puts the rule plainly: "If you purchase a stock on its ex-dividend date or after, you will not receive the next dividend payment. Instead, the seller gets the dividend. If you purchase before the ex-dividend date, you get the dividend."
• Payment (payable) date. The cash or shares actually arrive.
• Effective date. For splits, name changes and mergers: the day the change applies in the market.

The T+1 change to the ex-date

Until 2024, the ex-date for a regular US cash dividend was one business day before the record date, because trades took two business days to settle (T+2). The SEC moved the standard settlement cycle to one business day (T+1), with a compliance date of May 28, 2024 (SEC press release 2023-29). With T+1, the ex-date and the record date are generally the same day. The Nasdaq and DTCC issuer alert for the transition spelled out the handover: no securities went ex on May 28, 2024, and the first record date to which the new rule applied was May 29, 2024 (Nasdaq T+1 Corporate Action Issuer Alert, DTCC).

So if your code derives the ex-date from the record date, the answer depends on the era: subtract one business day for record dates up to and including May 28, 2024, and use the same day from May 29, 2024 on. Better still, don't derive it: use the ex-date the feed gives you.

One exception stays the same under either regime. For a large distribution, 25% or more of the stock's value, the ex-date is deferred until one business day after the payment date, so the price drop lands after the shares or cash have gone out (investor.gov, same page).

What corporate actions do to your price data

This is where the "what are corporate actions" question becomes practical. Each type leaves a different fingerprint.

Two consequences follow for anyone computing returns, moving averages or 52-week ranges.

First, a raw close series is not comparable across a split. A 50% "drop" on the effective date of a 2-for-1 split is not a return of minus 50%. You either adjust the history (divide all pre-split prices by 2 and multiply pre-split volume by 2) or you look up the splits and handle the boundary yourself. Our historical bars endpoint takes an adjustment field for this: raw, split, dividend or all, so you can pick a split-adjusted series for volume-aware indicators and a fully adjusted one for total-return work.

Second, the ex-date gap from a dividend is real money, not noise. A backtest on raw closes under-counts the return of a dividend payer by every dividend it paid. If you want price-only returns, use raw bars and read the dividends separately; if you want total returns, use dividend or all adjustment. Either way, know which one you asked for and record it next to the data.

Ticker changes are the quietest problem. The chart looks fine, but the moment a symbol changes, a job keyed on the old one starts returning validation errors (a 422 on our API, since unknown symbols never 404; see Errors and recovery). A name-change feed with the old and new symbols is the fix.

Getting corporate actions as data

The OkamiStocks API exposes corporate actions on the Supreme plan through one endpoint: POST /api/v1/quote/corporate-actions. It returns every action for a ticker inside a date range, grouped by type. Full field reference: Corporate actions in the documentation.

The request body takes your API key as token, the ticker, a start and end date (YYYY-MM-DD, end on or after start), and an optional types filter. Here is the request exactly as the documentation shows it, with the key read from an environment variable:

export OKAMI_API_TOKEN='YOUR_API_TOKEN'

curl https://okamistocks.io/api/v1/quote/corporate-actions \
  -d token="$OKAMI_API_TOKEN" \
  -d ticker=AAPL \
  -d start=2024-01-01 \
  -d end=2024-06-30

The same call in Python:

import os
import requests

response = requests.post(
    "https://okamistocks.io/api/v1/quote/corporate-actions",
    headers={"Accept": "application/json"},
    json={"token": os.environ["OKAMI_API_TOKEN"], "ticker": "AAPL", "start": "2024-01-01", "end": "2024-06-30"},
    timeout=30,
)
print(response.status_code)
print(response.json())
response.raise_for_status()

A trimmed 200 response, in the shape the documentation shows:

{
  "data": {
    "ticker": "AAPL",
    "start": "2024-01-01",
    "end": "2024-06-30",
    "corporate_actions": {
      "cash_dividends": [
        {
          "ticker": "AAPL",
          "rate": 0.24,
          "ex_date": "2024-02-09"
        }
      ]
    }
  }
}

Things to notice about the shape:

• Results are grouped under plural keys such as cash_dividends, forward_splits and name_changes. Each type's entries carry that type's own fields (a cash dividend has a rate and an ex_date; a name change has old_ticker and new_ticker), so read the bucket you asked for rather than assuming one shared event object.
• The types filter uses singular names. Send types=cash_dividend,forward_split to narrow the response, and the matching results still come back under the plural bucket keys. Omit types to get everything. The names pass straight through to our data provider, so an unrecognized name is theirs to reject.
• An empty corporate_actions object is a success, not an error. It means nothing happened in that range. {"data": {"ticker": "AAPL", "start": "2024-07-01", "end": "2024-07-02", "corporate_actions": {}}} is a normal 200.
• Fields that name another ticker are consistent across types: new_ticker, old_ticker, source_ticker, acquirer_ticker, acquiree_ticker and alternate_ticker, plus ticker on each entry of a reorganization's stock_movements. The earlier *_symbol names were removed on October 29, 2026 and are no longer returned.

A small loop that walks every bucket without caring which types came back:

actions = response.json()["data"]["corporate_actions"]

for action_type, events in actions.items():
    for event in events:
        print(action_type, event)

Plans and errors

Corporate actions, like historical bars and news, need the Supreme plan ($20 a month, 600 requests a minute; see pricing). On Free or Standard the call returns 403 with {"message": "Corporate actions data requires a Supreme subscription."}.

Everything else follows the API's normal error contract, always as JSON:

• 401 when token is missing or wrong.
• 422 with a message and field-keyed errors when a field is malformed, for example {"message": "The start field must match the format Y-m-d.", "errors": {"start": ["The start field must match the format Y-m-d."]}}. A 422 under errors.ticker reading Error fetching data. Please try again shortly. is a transient fetch failure, not proof the ticker is wrong.
• 429 when you have used the minute's allowance; honor Retry-After.
• 503 when the historical capacity is saturated. Corporate actions share one request-capacity limiter with historical bars and news, so a burst of bar downloads can push an actions call into a 503. The body uses the message key and Retry-After tells you how many seconds to wait.

Mistakes to avoid in code

Most corporate-action bugs are not about finance. They are about assumptions baked into a schema or a loop.

1. Treating an empty result as a failure. corporate_actions: {} is the correct answer for a quiet quarter. Log it as "no actions", not as an error, and don't retry it.
2. Assuming one event shape. A dividend, a split and a name change don't share fields. Parse per bucket, and tolerate buckets you have never seen before.
3. Mixing singular and plural names. cash_dividend goes in the request; cash_dividends comes back. A filter that looks for cash_dividend in the response finds nothing and silently reports no dividends.
4. Still reading new_symbol and friends. Those keys stopped coming back on October 29, 2026. If your parser reads them with a default of None, it will quietly lose every name change. Switch to new_ticker and old_ticker.
5. Deriving the ex-date from the record date. The offset flipped on May 28, 2024 (see above), and large distributions break the rule anyway. Store the ex-date the feed gives you.
6. Keying everything on the ticker alone. A ticker is a label, not an identity. After a name change, join the old series to the new one through old_ticker and new_ticker instead of letting the old symbol's rows fall off the end.
7. Comparing series with different adjustments. A split-adjusted close next to a raw close is a chart of nothing. Store the adjustment value returned with every historical response alongside the bars, and refuse to join two series whose adjustments differ.
8. Parsing dates as timestamps. Action dates are calendar days (YYYY-MM-DD), not instants. Converting them to UTC midnight and then to New York time hands you the previous day.
9. Retrying 503 immediately. The limiter that answered 503 is the same one your historical downloads are leaning on. Read Retry-After, back off with jitter, and spread the two kinds of call out.

Corporate actions are the part of market data that doesn't look like market data: no ticks, no bars, just a handful of dated facts that change how every bar before or after them should be read. Pull them alongside your historical bars, store the dates, and most of the mysterious overnight cliffs in your charts turn out to have a name.

Ready to look at the real thing? Get a free API key, then see the corporate actions endpoint and historical bars in the documentation. Corporate actions are a Supreme feature; plan details are on the pricing section.