De-SPAC Events API for Post-Merger Research

Query completed de-SPAC transactions by disclosure date, preserve the actual closing and trading dates, then freeze a point-in-time cohort before measuring post-merger outcomes.

A de-SPAC events API should identify completed business combinations, not announced SPAC deals that may never close. Alphanume's De-SPAC Events dataset records confirmed completions derived from SEC filings, usually the closing 8-K and its related filing trail. Each row supplies a post-combination ticker, source filing, completion evidence, identity fields, listing dates, and transaction economics when the filings explicitly support them.

That contract makes the dataset useful for post-merger research, but the event is not a trade signal. A completed combination can lead to positive, negative, or flat returns. The API gives the cohort and timing evidence needed to test a hypothesis without starting from today's surviving de-SPAC names.

Choose the correct event clock

These dates can differ. The served date can occur shortly after trading begins because it reflects the filing date of the closing disclosure. A post-close return window should use a rule written before prices are loaded, such as the first complete session after trading_commencement_date. If that field is null, route the row to manual review rather than inventing a date from the filing.

Retrieve completed transactions by date range

The endpoint is GET /v1/de-spac-events. It accepts an exact date or the standard range filters. The example below requests one fixed quarter and reads credentials from the environment.

import os
import requests

response = requests.get(
    "https://api.alphanume.com/v1/de-spac-events",
    headers={"X-API-Key": os.environ["ALPHANUME_API_KEY"]},
    params={
        "date_gte": "2026-01-01",
        "date_lte": "2026-03-31",
    },
    timeout=30,
)
response.raise_for_status()
events = response.json()["data"]

The response envelope contains count and data. Results are ordered by date descending. The De-SPAC Events guide covers practical applications, while the API field reference defines the enriched identity and economics fields. Any enriched field can be null when no source filing explicitly supported it. Null is not zero.

Join point-in-time size without moving the event

A size-conditioned study can join each post-combination ticker to Historical Market Cap, though the new ticker should never search backward into dates before the combined company traded. Start on the later of the disclosure filing date and trading_commencement_date, then choose the earliest supported observation inside a bounded post-start window. Retain the source dates and every failed match.

from datetime import timedelta
import pandas as pd

event_rows = []
for event in events:
    filing_date = event.get("date")
    first_trade = event.get("trading_commencement_date")
    ticker = event.get("ticker")

    if filing_date is None or first_trade is None or ticker is None:
        event_rows.append({
            "event": event,
            "market_cap_row": None,
            "match_status": "missing filing date, first trade, or ticker",
        })
        continue

    search_start = max(pd.Timestamp(filing_date), pd.Timestamp(first_trade))
    search_end = search_start + timedelta(days=10)

    cap_response = requests.get(
        "https://api.alphanume.com/v1/historical-market-cap",
        headers={"X-API-Key": os.environ["ALPHANUME_API_KEY"]},
        params={
            "ticker": ticker,
            "date_gte": search_start.date().isoformat(),
            "date_lte": search_end.date().isoformat(),
        },
        timeout=30,
    )
    cap_response.raise_for_status()
    cap_rows = sorted(cap_response.json()["data"], key=lambda row: row["date"])
    market_cap_row = cap_rows[0] if cap_rows else None
    event_rows.append({
        "event": event,
        "market_cap_row": market_cap_row,
        "match_status": "matched" if market_cap_row else "no supported row in window",
    })

The 10-calendar-day request is a bounded retrieval window, and the code selects its earliest supported observation. Validate that the returned date is on or after the declared start, then keep unmatched events as a missing-size cohort. Broader market-cap cohort analysis belongs in a separate research specification so the API cohort remains centered on completed transactions and their identity clocks.

Define the post-close outcome separately

De-SPAC Events does not include subsequent stock returns, bid-ask spreads, borrow availability, delisting returns, or execution costs. Obtain prices from a separately timed source and write the outcome window explicitly. A useful first design can measure close-to-close returns over 1, 5, 20, and 60 sessions after the first eligible trading session, while retaining delisted names and documenting corporate-action adjustments.

Transaction fields such as redemption_shares, trust_remaining_usd, pipe_amount_usd, and pro_forma_shares_outstanding can support conditioning variables. They cannot be assumed complete. A complete-case filter can become a disclosure-quality screen, so report the null rate for each field before comparing returns.

Avoid the common cohort failures

• Announcement leakage. Include completed combinations only, and do not anchor the cohort to an earlier rumor or definitive-agreement date unless that is a separate study.
• Ticker leakage. Preserve the post-combination ticker and source identity fields rather than rebuilding history from a current ticker list.
• Date collapse. Keep filing, closing, effective, and trading-commencement dates distinct.
• Missing economics. Do not fill undisclosed redemption or PIPE values with zero.
• Universal-return claims. Report the observed sample and window instead of asserting that every SPAC underperforms.

Free access supplies the trailing 20 trading sessions after a one-trading-session delay. That window is enough to validate a current query but not a long post-merger study. Sparse completion periods can also produce few rows without indicating an outage.

Freeze one quarter before scaling

Export one quarter of raw event responses, an as-of market-cap match table, an exclusions report, and a cohort file with the chosen post-close anchor. Manually verify five filing URLs and every row with conflicting dates. Only then attach the predefined return windows. The existing de-SPAC research framework provides related context, but the API cohort should remain neutral until the measured outcomes are complete.