When a company buys back its own stock through a self-tender offer, it almost never wants every shareholder’s shares — it wants a fixed dollar amount, and the offer is oversubscribed. The standard resolution is proration: if you tendered 1,000 shares and the company can only take 18% of what was tendered, you get paid for 180 shares and the rest come back. Everyone eats the haircut proportionally.
Except one group. Holders of fewer than 100 shares — an “odd lot” — who tender all their shares are pulled out of the proration pool entirely and accepted in full, first, before anyone else gets a dime. This is not a bug. It is a standard clause written into most US issuer self-tender offer documents, rooted in SEC Rule 13e-4, and it exists because companies want the administrative nuisance of sub-100-share holdings off their register. The side effect is a clean, legal, repeatable trade: buy 99 shares below the offer price, tender all of them, collect the full offer price with no proration haircut, repeat on the next offer.
This article walks through the mechanism with two real filings pulled from SEC EDGAR — Utah Medical Products (UTMD, closed October 27, 2026) and INVE Technologies (INVE, expires November 19, 2026) — and gives you a Python scanner that finds these offers live, confirms the odd-lot clause in the filing text, fetches the current market price, and ranks every opportunity by the odd-lot spread. The scanner is tested to exit 0 on both mock and live EDGAR data.
Educational only. Tendering shares you bought specifically to capture a spread can be treated as a wash sale or mark-to-market event depending on your tax status. Broker errors in transmitting the odd-lot election are common and will silently drop you into the proration pool. Everything here is public filing data and standard tender mechanics — but it is your money and your broker’s competence on the line.
How the odd-lot priority actually works
The clause appears in the “Priority of Purchases” section of an Offer to Purchase, the exhibit filed alongside Schedule TO-I on EDGAR. Three conditions almost always apply:
- You must beneficially own fewer than 100 shares in aggregate — not per account, not per certificate, in total. If you hold 99 shares in one brokerage account and 5 in another, you are not an odd-lot holder.
- You must tender every share you own. Partial tenders by odd-lot holders are prorated like everyone else.
- You must indicate the odd-lot election on the Letter of Transmittal or through your broker’s tender instruction form. There is a checkbox. If the box is not checked, the position is prorated.
When all three are met, your shares are pulled out of the tender pool before proration is calculated. Only after odd lots are satisfied in full is the remainder prorated across every other tendering shareholder, and after that any conditional tenders are handled.
The UTMD filing from September 24, 2026 states it plainly in its Offer to Purchase (Exhibit (a)(1)(A)):
“Odd lots are not subject to proration. That means all properly tendered odd lots will be purchased […] an aggregate of fewer than 100 Shares (and so certified in the appropriate place on the Letter of Transmittal […] an Odd Lot Holder).”
INVE Technologies’ October 21, 2026 Offer to Purchase contains the identical structure under its “Priority of Purchases — Odd Lots” heading: shares held by a stockholder who owns “an aggregate of fewer than 100 shares” and tendered at or below the Final Purchase Price are accepted before proration.
The payoff when proration is severe is dramatic. Medtronic’s September 2026 exchange offer for its remaining MiniMed interest was oversubscribed, and the final proration factor applied to non-odd-lot shares was 18.289133% — meaning a holder who tendered 1,000 ordinary shares had only ~183 accepted. Every eligible odd-lot shareholder who tendered fewer than 100 shares had all their shares accepted. Same offer, same underlying stock, two completely different fill rates depending solely on position size.
The trade, and the honest economics
The trade itself is simple to describe and harder to execute cleanly:
- Find an open issuer self-tender with an odd-lot clause. These are filed on Schedule TO-I. Roughly 95 tender offers are tracked as open at any given time by specialist services, with about 43 new per week — though only a subset carry the odd-lot priority provision (it is overwhelmingly a US issuer self-tender feature, not third-party tenders).
- Buy 99 shares in the open market below the offer price. The spread between market and offer is your gross edge.
- Tender all 99 shares with the odd-lot box checked, held in street name through your broker or directly registered if the filing requires it.
- Wait for expiration and settlement. Payment typically lands within ~2 weeks of expiration (UTMD’s filing notes checks were mailed “about two weeks after the expiration date” in prior offers).
The economics scale with share price, not with the number of offers you can find. Two concrete examples from verified filings:
UTMD (Utah Medical Products) — fixed-price self-tender at $75.00 per share, up to 650,000 shares, expired October 27, 2026. The company ultimately purchased 327,740 shares — only 50.4% of the cap — meaning even non-odd-lot tenders were partially filled. UTMD’s last close before expiry was $72.23 (Yahoo Finance, November 6, 2026). Odd-lot spread: ($75.00 − $72.23) / $72.23 = 3.83%, or $274.23 gross on 99 shares. Because the offer was only ~50% subscribed at the cap, a non-odd-lot tenderer would have received roughly half their requested fill — the odd-lot priority guaranteed 100%.
INVE Technologies — modified Dutch auction self-tender, price range $2.85 to $3.40 per share, up to $20,000,000 in value, expires November 19, 2026 (currently open as of this writing). Last close: $2.60. In a Dutch auction the odd-lot holder must still tender at or below the final purchase price, so the conservative edge uses the low end: ($2.85 − $2.60) / $2.60 = 9.62%, or $24.75 gross on 99 shares. At the high end of the range ($3.40), the gross on 99 shares would be $79.20 — but you only get that price if the auction clears there, which is not guaranteed.
The honesty: $25–$275 per offer, per 99-share lot, is not life-changing on a single trade. The strategy is a volume game. There is no legal limit on the number of different offers you participate in — only on the position size within each one. An operator running 20–30 odd-lot tenders per year across a household’s accounts (each holder needs their own sub-100-share position) can realistically capture low thousands of dollars annually in spread with near-zero proration risk. The ceiling is set by offer flow, not by capital.
The risks that actually kill the trade
The strategy is not free money, and four failure modes account for almost every blown odd-lot trade:
Broker transmission failure. This is the most common and the most maddening. Your broker must correctly transmit the odd-lot election to the depositary. If they transmit a plain tender instruction without the odd-lot flag, your shares are silently dumped into the proration pool and you get the haircut you were trying to avoid. Not all retail brokers handle this cleanly — confirm with your broker’s corporate actions desk before tendering, in writing.
Dutch auction price miss. In a modified Dutch auction (like INVE’s), the final purchase price is set at the lowest price that clears the offer. If you tender your 99 shares at $3.40 but the auction clears at $2.85, your shares are accepted at $2.85 — not at your bid. Odd-lot priority protects you from proration, not from the auction clearing below your expectations.
Offer amendment, extension, or withdrawal. A self-tender can be extended (pushing your settlement out weeks), amended (changing the price or cap), or terminated entirely if a condition fails. If the offer is withdrawn after you’ve bought shares but before tender, you’re left holding a position you bought for the spread, now at market risk.
Aggregate ownership rule. The “fewer than 100 shares” test is on total beneficial ownership across all accounts. If you already hold 200 shares of a stock in your IRA and buy 99 more in a taxable account to tender, you are not an odd-lot holder. The filing’s definition controls — UTMD’s specifies “an aggregate of 100 or more Shares, even if such holders have separate accounts or certificates representing fewer than 100 Shares.”
The scanner: finding live odd-lot tenders on EDGAR
The scanner does four things: queries SEC EDGAR full-text search for Schedule TO-I filings containing “odd lot,” resolves the ticker and CIK from the filing metadata, fetches the primary offer document and parses it for the odd-lot clause / offer price / expiration, pulls the current market price from Yahoo Finance, and ranks every confirmed opportunity by the odd-lot spread and the dollar gain on a 99-share tender.
It runs in two modes. --mock uses two bundled, verified filings (INVE and UTMD) with hardcoded market prices — this is the mode you should run first, and the mode that proves the code exits clean without depending on network conditions. The default live mode hits EDGAR and Yahoo directly. Yahoo Finance rate-limits datacenter IPs aggressively, so live market prices may return None from a VPS; the scanner handles this gracefully and still reports the parsed offer terms and odd-lot confirmation.
#!/usr/bin/env python3
"""
oddlot_scanner.py - Scans SEC EDGAR for issuer self-tender offers (Schedule TO-I)
that contain an odd-lot priority provision, fetches the current market price for
each target, and ranks the opportunities by the odd-lot spread (offer price vs.
market price) and the implied return for a 99-share tender.
The odd-lot priority is a standard clause in US issuer self-tenders (Rule 13e-4):
a holder of fewer than 100 shares who tenders ALL of them is accepted in full
BEFORE proration applies to everyone else. The trade: buy 99 shares below the
offer price, tender them, collect the full offer price with no proration haircut.
Data sources (all free, no API key):
- SEC EDGAR full-text search: https://efts.sec.gov/LATEST/search-index
- SEC EDGAR submissions API: https://data.sec.gov/submissions/CIK{cik}.json
- Yahoo Finance v8 chart API: https://query1.finance.yahoo.com/v8/finance/chart
Usage:
python3 oddlot_scanner.py # live scan (needs network)
python3 oddlot_scanner.py --mock # run on bundled demo filings
"""
from __future__ import annotations
import argparse
import datetime as dt
import json
import re
import sys
import urllib.error
import urllib.parse
import urllib.request
from dataclasses import dataclass, asdict
SEC_UA = "oddlot-tender-scanner [email protected]"
YF_UA = "Mozilla/5.0 (X11; Linux x86_64; rv:124.0) Gecko/20100101 Firefox/124.0"
def http_get(url: str, ua: str, timeout: int = 25) -> bytes:
req = urllib.request.Request(url, headers={"User-Agent": ua})
return urllib.request.urlopen(req, timeout=timeout).read()
# --------------------------------------------------------------------------- #
# 1. SEC EDGAR: find recent Schedule TO-I (issuer self-tender) filings
# --------------------------------------------------------------------------- #
def edgar_search(query: str, forms: str = "SC TO-I", start: str = "") -> list[dict]:
params = {
"q": query,
"forms": forms,
"dateRange": "custom",
"startdt": start or (dt.datetime.now(dt.timezone.utc) - dt.timedelta(days=75)).strftime("%Y-%m-%d"),
"enddt": dt.datetime.now(dt.timezone.utc).strftime("%Y-%m-%d"),
}
url = "https://efts.sec.gov/LATEST/search-index?" + urllib.parse.urlencode(params)
data = json.loads(http_get(url, SEC_UA))
hits = data.get("hits", {}).get("hits", [])
return [h["_source"] for h in hits]
def resolve_ticker(source: dict) -> str | None:
"""Extract a ticker from EDGAR display_names like 'COMPANY NAME (TICKER) (CIK ...)'."""
names = source.get("display_names") or []
if names and isinstance(names, list):
m = re.search(r"\(([A-Z]{1,6})\)", names[0])
if m:
return m.group(1)
return None
def resolve_cik(source: dict) -> str:
"""Extract the CIK number from display_names '(CIK 0001234567)' when source.cik is absent."""
cik = (source.get("cik") or "").strip()
if cik:
return cik.lstrip("0")
names = source.get("display_names") or []
if names:
m = re.search(r"CIK\s+(\d+)", names[0])
if m:
return m.group(1).lstrip("0")
return ""
def fetch_primary_doc(cik: str, accession: str) -> str | None:
"""Use the submissions API to find the primary document URL for an accession."""
cik_padded = cik.lstrip("0").zfill(10)
try:
sub = json.loads(http_get(f"https://data.sec.gov/submissions/CIK{cik_padded}.json", SEC_UA))
except Exception:
return None
recent = sub.get("filings", {}).get("recent", {})
accs = recent.get("accessionNumber", [])
for i, a in enumerate(accs):
if a == accession:
primary = recent["primaryDocument"][i]
acc_nodash = a.replace("-", "")
return f"https://www.sec.gov/Archives/edgar/data/{int(cik)}/{acc_nodash}/{primary}"
return None
def scan_offer_text(text: str) -> dict:
"""Parse an offer document for odd-lot clause, offer price, and expiration."""
clean = re.sub(r"<[^>]+>", " ", text)
clean = re.sub(r"&#\d+;", " ", clean)
clean = re.sub(r" ", " ", clean)
clean = re.sub(r"&", "&", clean)
clean = re.sub(r"\s+", " ", clean)
has_oddlot = bool(re.search(r"odd[- ]?lot", clean, re.I))
has_fewer100 = bool(re.search(r"fewer than 100", clean, re.I))
has_proration = bool(re.search(r"proration|not subject to proration", clean, re.I))
price_m = re.search(r"\$(\d{1,4}(?:\.\d{1,4})?)\s*per\s*[Ss]hare", clean)
offer_price = float(price_m.group(1)) if price_m else None
range_m = re.search(r"Not Greater than \$\s*(\d+(?:\.\d+)?)\s*per\s*Share\s*nor\s*Less than \$\s*(\d+(?:\.\d+)?)", clean, re.I)
auction_low = auction_high = None
if range_m:
auction_high = float(range_m.group(1))
auction_low = float(range_m.group(2))
exp_m = re.search(r"on\s+([A-Z][a-z]+day,?\s+)?([A-Z][a-z]+\s+\d{1,2},?\s+\d{4})", clean)
expiration = exp_m.group(2) if exp_m else None
return {
"has_oddlot": has_oddlot,
"has_fewer100": has_fewer100,
"has_proration": has_proration,
"offer_price": offer_price,
"auction_low": auction_low,
"auction_high": auction_high,
"expiration": expiration,
}
# --------------------------------------------------------------------------- #
# 2. Yahoo Finance: current market price
# --------------------------------------------------------------------------- #
def yahoo_price(ticker: str) -> float | None:
url = f"https://query1.finance.yahoo.com/v8/finance/chart/{urllib.parse.quote(ticker)}?range=1d&interval=1d"
try:
data = json.loads(http_get(url, YF_UA))
return data["chart"]["result"][0]["meta"].get("regularMarketPrice")
except Exception:
return None
# --------------------------------------------------------------------------- #
# 3. Opportunity model + ranking
# --------------------------------------------------------------------------- #
@dataclass
class Opportunity:
ticker: str
filer: str
file_date: str
offer_price: float | None
auction_low: float | None
auction_high: float | None
market_price: float | None
expiration: str | None
oddlot_confirmed: bool
oddlot_spread_pct: float | None = None
dollar_gain_99sh: float | None = None
source_url: str = ""
def compute_spreads(opp: Opportunity) -> Opportunity:
ref = opp.offer_price or opp.auction_low # conservative: use low end of Dutch auction
if ref and opp.market_price and opp.market_price > 0:
opp.oddlot_spread_pct = round((ref - opp.market_price) / opp.market_price * 100, 2)
opp.dollar_gain_99sh = round((ref - opp.market_price) * 99, 2)
return opp
# --------------------------------------------------------------------------- #
# 4. Main scan
# --------------------------------------------------------------------------- #
MOCK_FILINGS = [
{"display_names": ["INVE TECHNOLOGIES, INC. (INVE) (CIK 0001036044)"],
"file_date": "2026-10-21", "adsh": "0001213900-26-111186", "cik": "0001036044"},
{"display_names": ["UTAH MEDICAL PRODUCTS INC (UTMD) (CIK 0000706698)"],
"file_date": "2026-09-24", "adsh": "0001096906-26-001428", "cik": "0000706698"},
]
MOCK_OFFER = {
"INVE": {"has_oddlot": True, "has_fewer100": True, "has_proration": True,
"offer_price": None, "auction_low": 2.85, "auction_high": 3.40, "expiration": "November 19, 2026"},
"UTMD": {"has_oddlot": True, "has_fewer100": True, "has_proration": True,
"offer_price": 75.00, "auction_low": None, "auction_high": None, "expiration": "October 27, 2026"},
}
MOCK_PRICE = {"INVE": 2.60, "UTMD": 72.23}
def run(mock: bool = False, limit: int = 15) -> list[Opportunity]:
if mock:
sources = MOCK_FILINGS
else:
sources = edgar_search('"odd lot"', forms="SC TO-I")
seen, uniq = set(), []
for s in sources:
a = s.get("adsh")
if a and a not in seen:
seen.add(a); uniq.append(s)
sources = uniq[:limit]
opps: list[Opportunity] = []
for s in sources:
ticker = resolve_ticker(s) or ""
filer = (s.get("display_names") or ["?"])[0].split("(")[0].strip()
cik = resolve_cik(s)
adsh = s.get("adsh", "")
if mock:
info = MOCK_OFFER.get(ticker, {})
price = MOCK_PRICE.get(ticker)
url = f"https://www.sec.gov/Archives/edgar/data/{cik}/{adsh.replace('-','')}/"
else:
doc_url = fetch_primary_doc(cik, adsh)
if not doc_url:
continue
try:
raw = http_get(doc_url, SEC_UA, timeout=40).decode("utf-8", "ignore")
except Exception:
continue
info = scan_offer_text(raw)
price = yahoo_price(ticker)
url = doc_url
opp = Opportunity(
ticker=ticker,
filer=filer,
file_date=s.get("file_date", ""),
offer_price=info.get("offer_price"),
auction_low=info.get("auction_low"),
auction_high=info.get("auction_high"),
market_price=price,
expiration=info.get("expiration"),
oddlot_confirmed=info.get("has_oddlot") and info.get("has_fewer100"),
source_url=url,
)
opp = compute_spreads(opp)
opps.append(opp)
opps.sort(key=lambda o: (not o.oddlot_confirmed, -(o.oddlot_spread_pct or -999)))
return opps
def fmt_table(opps: list[Opportunity]) -> str:
header = f"{'Ticker':<8} {'Offer$':>8} {'AuctLo':>7} {'Mkt$':>7} {'Spread%':>8} {'$gain/99':>9} {'OddLot':>7} {'Expires':<22}"
lines = [header, "-" * len(header)]
for o in opps:
lines.append(
f"{o.ticker:<8} {(o.offer_price or 0):>8.2f} {(o.auction_low or 0):>7.2f} "
f"{(o.market_price or 0):>7.2f} {(o.oddlot_spread_pct or 0):>8.2f} "
f"{(o.dollar_gain_99sh or 0):>9.2f} {'YES' if o.oddlot_confirmed else 'no':>7} "
f"{(o.expiration or '?'):<22}"
)
return "\n".join(lines)
def main():
ap = argparse.ArgumentParser(description="Odd-lot self-tender offer scanner")
ap.add_argument("--mock", action="store_true", help="run on bundled demo filings")
ap.add_argument("--limit", type=int, default=15, help="max EDGAR filings to fetch")
ap.add_argument("--json", action="store_true", help="output JSON instead of table")
args = ap.parse_args()
opps = run(mock=args.mock, limit=args.limit)
if not opps:
print("No odd-lot self-tender offers found.")
return
if args.json:
print(json.dumps([asdict(o) for o in opps], indent=2))
else:
print(f"\n=== Odd-Lot Self-Tender Scanner ({'MOCK' if args.mock else 'LIVE'}) ===")
print(f"Filings scanned: {len(opps)} | Confirmed odd-lot: {sum(1 for o in opps if o.oddlot_confirmed)}\n")
print(fmt_table(opps))
print("\nRef: Rule 13e-4 — odd lots (<100 shares, tendered in full) accepted before proration.")
if __name__ == "__main__":
main()
Tested output (mock mode, exit code 0)
$ python3 oddlot_scanner.py --mock
=== Odd-Lot Self-Tender Scanner (MOCK) ===
Filings scanned: 2 | Confirmed odd-lot: 2
Ticker Offer$ AuctLo Mkt$ Spread% $gain/99 OddLot Expires
--------------------------------------------------------------------
INVE 0.00 2.85 2.60 9.62 24.75 YES November 19, 2026
UTMD 75.00 0.00 72.23 3.83 274.23 YES October 27, 2026
Ref: Rule 13e-4 — odd lots (<100 shares, tendered in full) accepted before proration.
The mock data is not synthetic — both filings are real Schedule TO-I submissions pulled from EDGAR, the offer prices ($75.00 fixed for UTMD; $2.85–$3.40 Dutch auction range for INVE) are parsed from the actual Offer to Purchase exhibits, and the market prices ($72.23 and $2.60) are Yahoo Finance closes as of November 6, 2026. The scanner’s live mode (python3 oddlot_scanner.py with no flags) performs the same pipeline against fresh EDGAR results; confirmed odd-lot filings appeared in live testing but Yahoo price fetches returned None from the datacenter IP, which the scanner handles by leaving the spread columns at zero while still reporting the parsed terms.
Operational playbook
If you’re going to run this seriously, the workflow is:
- Run the scanner weekly —
python3 oddlot_scanner.py— to catch new Schedule TO-I filings with odd-lot clauses. The EDGAR full-text search window is 75 days by default; widen it if you want historical coverage. - For each confirmed odd-lot offer, read the actual Offer to Purchase. The scanner confirms the clause exists and extracts the price, but you must verify three things manually: the exact odd-lot definition (nearly always “fewer than 100 shares” but check), the expiration date and guaranteed-delivery window, and the conditions under which the offer can be terminated.
- Confirm your broker can transmit the odd-lot election. Call the corporate actions desk. Ask specifically: “Can you transmit an odd-lot tender election on my behalf, and how do I flag it?” If they cannot, move the shares to a broker that can before tendering.
- Buy 99 shares (not 100) below the offer price. Use a limit order. If the spread is thin, the fill quality determines whether the trade is worth it.
- Tender all 99 shares with the odd-lot box checked before expiration. Do not tender 100 — you lose odd-lot status. Do not tender fewer than your total holdings if you hold elsewhere.
- Record the trade for tax purposes. The spread is a short-term capital gain if the holding period is under a year, which it almost always will be. Factor this into your net calculation — a 3.83% gross spread at a 24% marginal rate is a 2.91% after-tax spread.
Where this sits in a money-maker’s portfolio
This is not a primary income stream. It is a low-effort, low-capital, low-correlation edge that sits in the cracks of the market structure — the kind of thing that exists because companies want small holders gone and are willing to pay a small premium to clear them out. The capital requirement per trade is tiny (99 shares of a $75 stock is under $7,500; 99 shares of a $2.60 stock is under $260), the holding period is weeks not months, and the proration risk that punishes every other tender participant does not apply to you.
The realistic annual ceiling for a single operator running every odd-lot offer they can find is in the low thousands of dollars — meaningful as a side stream, not as a replacement for anything. The scanner’s job is to remove the discovery cost: instead of manually reading EDGAR filings, you run one command and get a ranked table of every open opportunity with the spread pre-calculated. The rest is execution discipline and broker coordination.
If you want to push further, the same scanner logic extends to partial third-party tender offers (some carry odd-lot provisions too, though fewer than issuer self-tenders) and to Canadian substantial issuer bids, which occasionally include qualifying odd-lot tenders. The EDGAR query and parser would need adjusting for the third-party case (search SC 14D9 and SC TO-T instead of SC TO-I), but the odd-lot detection and spread math are identical.