I built the Pre-IPO Intelligence API because I needed this data for my own trading systems and couldn’t find it in one place. If you’re building fintech applications, trading bots, or investment research tools, you know the pain: pre-IPO data is fragmented across dozens of SEC filing pages, paywalled databases, and stale spreadsheets. The Pre-IPO Intelligence API solves this by delivering real-time SEC filings, SPAC tracking, lockup expiration calendars, and M&A intelligence through a single, developer-friendly REST API — available now on RapidAPI with a free tier to get started.
In this deep dive, we’ll cover what the API offers across its 42 endpoints, walk through practical code examples in both cURL and Python, and explore real-world use cases for developers and quant engineers. Whether you’re building the next algorithmic trading system or a portfolio intelligence dashboard, this guide will get you up and running in minutes.
What Is the Pre-IPO Intelligence API?
📌 TL;DR: If you’re building fintech applications, trading bots, or investment research tools, you know the pain: pre-IPO data is fragmented across dozens of SEC filing pages, paywalled databases, and stale spreadsheets.
🎯 Quick Answer
If you’re building fintech applications, trading bots, or investment research tools, you know the pain: pre-IPO data is fragmented across dozens of SEC filing pages, paywalled databases, and stale spreadsheets.
The Pre-IPO Intelligence API (v3.0.1) is a thorough financial data service that aggregates, normalizes, and serves pre-IPO market intelligence through 42 RESTful endpoints. It covers the full lifecycle of companies going public — from early-stage private valuations and S-1 filings through SPAC mergers, IPO pricing, lockup expirations, and post-IPO M&A activity.
Unlike scraping SEC.gov yourself or paying five-figure annual fees for enterprise terminals, this API gives you structured, machine-readable JSON data with sub-second response times. It’s designed for developers who need to integrate pre-IPO intelligence into their applications without building an entire data pipeline from scratch.
Key Capabilities at a Glance
- Company Intelligence: Search and retrieve detailed profiles on pre-IPO companies, including valuation history, funding rounds, and sector classification
- SEC Filing Monitoring: Real-time tracking of S-1, S-1/A, F-1, and prospectus filings with parsed key data points
- Lockup Expiration Calendar: Know exactly when insider selling restrictions expire — one of the most predictable catalysts for post-IPO price movement
- SPAC Tracking: Monitor active SPACs, merger targets, trust values, redemption rates, and deal timelines
- M&A Intelligence: Track merger and acquisition activity involving pre-IPO and recently-public companies
- Market Overview: Aggregate statistics on IPO pipeline health, sector trends, and market sentiment indicators
Getting Started: Subscribe on RapidAPI
The fastest way to start using the API is through RapidAPI. The freemium model lets you explore endpoints with generous rate limits before committing to a paid plan. Here’s how to get set up:
- Visit the Pre-IPO Intelligence API page on RapidAPI
- Click “Subscribe to Test” and select the free tier
- Copy your
X-RapidAPI-Key from the dashboard
- Start making requests immediately — no credit card required for the free plan
Once subscribed, you’ll have access to all 42 endpoints. The free tier includes enough requests for development and testing, while paid tiers unlock higher rate limits and priority support for production workloads.
Core Endpoint Reference
Let’s walk through the five core endpoint groups with practical examples. All endpoints return JSON and accept standard query parameters for filtering, pagination, and sorting.
1. Company Search & Profiles
The /api/companies/search endpoint is your entry point for finding pre-IPO companies. It supports full-text search across company names, tickers, sectors, and descriptions.
cURL Example
curl -X GET "https://pre-ipo-intelligence.p.rapidapi.com/api/companies/search?q=artificial+intelligence§or=technology&limit=10" \
-H "X-RapidAPI-Key: YOUR_RAPIDAPI_KEY" \
-H "X-RapidAPI-Host: pre-ipo-intelligence.p.rapidapi.com"
Python Example
import requests
url = "https://pre-ipo-intelligence.p.rapidapi.com/api/companies/search"
params = {
"q": "artificial intelligence",
"sector": "technology",
"limit": 10
}
headers = {
"X-RapidAPI-Key": "YOUR_RAPIDAPI_KEY",
"X-RapidAPI-Host": "pre-ipo-intelligence.p.rapidapi.com"
}
response = requests.get(url, headers=headers, params=params)
companies = response.json()
for company in companies.get("results", []):
print(f"{company['name']} — Valuation: ${company.get('valuation', 'N/A')}")
print(f" Sector: {company.get('sector')} | Stage: {company.get('stage')}")
print()
The response includes rich metadata: company name, latest valuation estimate, funding stage, sector, key executives, and links to relevant SEC filings. This is the same data that powers our Pre-IPO Valuation Tracker for companies like SpaceX, OpenAI, and Anthropic.
2. SEC Filing Monitoring
The /api/filings/recent endpoint delivers newly published SEC filings relevant to IPO-track companies. Stop polling EDGAR manually — let the API push structured filing data to your application.
curl -X GET "https://pre-ipo-intelligence.p.rapidapi.com/api/filings/recent?type=S-1&days=7&limit=20" \
-H "X-RapidAPI-Key: YOUR_RAPIDAPI_KEY" \
-H "X-RapidAPI-Host: pre-ipo-intelligence.p.rapidapi.com"
import requests
url = "https://pre-ipo-intelligence.p.rapidapi.com/api/filings/recent"
params = {"type": "S-1", "days": 7, "limit": 20}
headers = {
"X-RapidAPI-Key": "YOUR_RAPIDAPI_KEY",
"X-RapidAPI-Host": "pre-ipo-intelligence.p.rapidapi.com"
}
response = requests.get(url, headers=headers, params=params)
filings = response.json()
for filing in filings.get("results", []):
print(f"[{filing['filed_date']}] {filing['company_name']}")
print(f" Type: {filing['filing_type']} | URL: {filing['sec_url']}")
print()
Each filing record includes the company name, filing type (S-1, S-1/A, F-1, 424B, etc.), filing date, SEC URL, and extracted financial highlights such as proposed share price range, shares offered, and underwriters. This is invaluable for building IPO alert systems or AI-driven market signal pipelines.
3. Lockup Expiration Calendar
The /api/lockup/calendar endpoint is a hidden gem for swing traders and quant funds. Lockup expirations — when insiders are first allowed to sell shares after an IPO — are among the most statistically significant and predictable events in equity markets. Studies consistently show that stocks decline an average of 1–3% around lockup expiry dates due to increased supply pressure.
import requests
from datetime import datetime, timedelta
url = "https://pre-ipo-intelligence.p.rapidapi.com/api/lockup/calendar"
params = {
"start_date": datetime.now().strftime("%Y-%m-%d"),
"end_date": (datetime.now() + timedelta(days=30)).strftime("%Y-%m-%d"),
}
headers = {
"X-RapidAPI-Key": "YOUR_RAPIDAPI_KEY",
"X-RapidAPI-Host": "pre-ipo-intelligence.p.rapidapi.com"
}
response = requests.get(url, headers=headers, params=params)
lockups = response.json()
for event in lockups.get("results", []):
shares_pct = event.get("shares_percent", "N/A")
print(f"{event['expiry_date']} — {event['company_name']} ({event['ticker']})")
print(f" Shares unlocking: {shares_pct}% of float")
print(f" IPO Price: ${event.get('ipo_price')} | Current: ${event.get('current_price')}")
print()
This data pairs perfectly with a disciplined risk management framework. You can build automated alerts, backtest lockup-expiration strategies, or feed the calendar into a portfolio hedging system.
4. SPAC Tracking
SPACs (Special Purpose Acquisition Companies) remain an important vehicle for companies going public, especially in sectors like clean energy, fintech, and AI. The /api/spac/active endpoint provides real-time tracking of active SPACs and their merger pipelines.
curl -X GET "https://pre-ipo-intelligence.p.rapidapi.com/api/spac/active?status=searching&min_trust_value=100000000" \
-H "X-RapidAPI-Key: YOUR_RAPIDAPI_KEY" \
-H "X-RapidAPI-Host: pre-ipo-intelligence.p.rapidapi.com"
The response includes trust value, redemption rates, target acquisition sector, deadline dates, sponsor information, and merger status. For SPACs that have announced targets, you also get the target company profile, deal terms, and projected timeline to close.
5. Market Overview & Pipeline Health
The /api/market/overview endpoint provides a bird’s-eye view of the IPO market, including pipeline statistics, sector breakdowns, pricing trends, and sentiment indicators.
import requests
url = "https://pre-ipo-intelligence.p.rapidapi.com/api/market/overview"
headers = {
"X-RapidAPI-Key": "YOUR_RAPIDAPI_KEY",
"X-RapidAPI-Host": "pre-ipo-intelligence.p.rapidapi.com"
}
response = requests.get(url, headers=headers)
market = response.json()
print(f"IPO Pipeline: {market.get('pipeline_count')} companies")
print(f"Avg First-Day Return: {market.get('avg_first_day_return')}%")
print(f"Market Sentiment: {market.get('sentiment')}")
print(f"Most Active Sector: {market.get('top_sector')}")
print(f"YTD IPOs: {market.get('ytd_ipo_count')}")
This endpoint is especially useful for macro-level dashboards and for timing IPO-related strategies based on overall market appetite for new listings.
Real-World Use Cases
The Pre-IPO Intelligence API is built for developers and engineers who want to integrate financial intelligence into their applications. Here are four high-impact use cases we’ve seen from early adopters.
Fintech & Investment Apps
If you’re building a consumer investment app or brokerage platform, the API can power an entire “IPO Center” feature. Show users upcoming IPOs, lockup calendars, and filing alerts — the kind of data that was previously locked behind Bloomberg terminals. The company search and market overview endpoints give you everything needed to build a compelling IPO discovery experience.
Algorithmic Trading Bots
For quant developers building algorithmic trading systems, the lockup expiration calendar and filing endpoints provide structured event data that can be fed directly into signal generation engines. Lockup expirations, in particular, offer a well-documented statistical edge — the combination of pre-IPO data APIs can give your models a significant informational advantage.
# Lockup Expiration Trading Signal Generator
import requests
from datetime import datetime, timedelta
def get_lockup_signals(api_key, lookahead_days=14):
"""Fetch upcoming lockup expirations and generate trading signals."""
url = "https://pre-ipo-intelligence.p.rapidapi.com/api/lockup/calendar"
headers = {
"X-RapidAPI-Key": api_key,
"X-RapidAPI-Host": "pre-ipo-intelligence.p.rapidapi.com"
}
params = {
"start_date": datetime.now().strftime("%Y-%m-%d"),
"end_date": (datetime.now() + timedelta(days=lookahead_days)).strftime("%Y-%m-%d"),
}
response = requests.get(url, headers=headers, params=params)
lockups = response.json().get("results", [])
signals = []
for lockup in lockups:
shares_pct = lockup.get("shares_percent", 0)
days_to_expiry = (
datetime.strptime(lockup["expiry_date"], "%Y-%m-%d") - datetime.now()
).days
# High-conviction signal: large unlock + near expiry
if shares_pct > 20 and days_to_expiry <= 5:
signals.append({
"ticker": lockup["ticker"],
"action": "MONITOR",
"conviction": "HIGH",
"expiry_date": lockup["expiry_date"],
"shares_unlocking_pct": shares_pct,
"rationale": f"{shares_pct}% float unlock in {days_to_expiry} days"
})
return signals
# Usage
signals = get_lockup_signals("YOUR_RAPIDAPI_KEY")
for s in signals:
print(f"[{s['conviction']}] {s['action']} {s['ticker']} — {s['rationale']}")
Equity research teams and data-driven newsletters can use the API to automate IPO screening and filing analysis. Instead of manually checking EDGAR every morning, pipe the filings endpoint into a Slack alert or email digest. The company search endpoint lets analysts quickly pull structured profiles for due diligence workflows.
Portfolio Monitoring Dashboards
If you manage a portfolio with exposure to recently-IPO’d stocks, the lockup calendar and SPAC endpoints are essential monitoring tools. Build a dashboard that surfaces upcoming lockup expirations for your holdings, tracks SPAC deal timelines, and alerts you to new SEC filings for companies on your watchlist. Combined with the market overview, you get a complete situational awareness layer for IPO-adjacent positions.
API Architecture & Technical Details
For developers who care about what’s under the hood, the Pre-IPO Intelligence API (v3.0.1) is built with the following characteristics:
- Response Format: All endpoints return JSON with consistent envelope structure (
results, meta, pagination)
- Authentication: Via RapidAPI proxy — a single
X-RapidAPI-Key header handles auth, rate limiting, and billing
- Rate Limiting: Tier-based through RapidAPI. Free tier includes generous allowances for development. Paid tiers scale to thousands of requests per minute
- Latency: Median response time under 200ms for search endpoints, under 500ms for aggregate endpoints
- Pagination: Standard
limit and offset parameters across all list endpoints
- Error Handling: RESTful HTTP status codes with descriptive error messages in JSON
- Uptime: 99.9% availability SLA on paid tiers
The API is served through RapidAPI’s global edge network, which means low-latency access from anywhere. The underlying data is refreshed continuously from SEC EDGAR, exchange feeds, and proprietary data sources.
Pricing: Start Free, Scale as Needed
The API follows a freemium model on RapidAPI, making it accessible to solo developers and enterprise teams alike:
- Free Tier: Perfect for development, testing, and personal projects. Includes enough monthly requests to build and prototype your application
- Pro Tier: Higher rate limits and priority support for production applications. Ideal for startups and small teams shipping real products
- Enterprise: Custom rate limits, dedicated support, and SLA guarantees for high-volume production workloads
Check the Pre-IPO Intelligence API pricing page on RapidAPI for current rates and included quotas. The free tier requires no credit card — just sign up and start calling endpoints.
Quick-Start Integration Guide
🔧 From my experience: The endpoint I use most in my own trading pipeline is /lockup-expirations. Lockup expiry dates create predictable selling pressure that’s visible days in advance. I pair this data with options flow analysis to find asymmetric setups around insider unlock dates.
Here’s a complete, copy-paste-ready Python script that connects to the API and pulls a summary of the current IPO market with upcoming lockup events:
#!/usr/bin/env python3
"""Pre-IPO Intelligence API — Quick Start Demo"""
import requests
from datetime import datetime, timedelta
API_KEY = "YOUR_RAPIDAPI_KEY"
BASE_URL = "https://pre-ipo-intelligence.p.rapidapi.com"
HEADERS = {
"X-RapidAPI-Key": API_KEY,
"X-RapidAPI-Host": "pre-ipo-intelligence.p.rapidapi.com"
}
def get_market_overview():
"""Get current IPO market conditions."""
resp = requests.get(f"{BASE_URL}/api/market/overview", headers=HEADERS)
resp.raise_for_status()
return resp.json()
def get_recent_filings(days=7):
"""Get SEC filings from the past N days."""
resp = requests.get(
f"{BASE_URL}/api/filings/recent",
headers=HEADERS,
params={"days": days, "limit": 5}
)
resp.raise_for_status()
return resp.json()
def get_upcoming_lockups(days=30):
"""Get lockup expirations in the next N days."""
now = datetime.now()
resp = requests.get(
f"{BASE_URL}/api/lockup/calendar",
headers=HEADERS,
params={
"start_date": now.strftime("%Y-%m-%d"),
"end_date": (now + timedelta(days=days)).strftime("%Y-%m-%d"),
}
)
resp.raise_for_status()
return resp.json()
def search_companies(query):
"""Search for pre-IPO companies."""
resp = requests.get(
f"{BASE_URL}/api/companies/search",
headers=HEADERS,
params={"q": query, "limit": 5}
)
resp.raise_for_status()
return resp.json()
if __name__ == "__main__":
# 1. Market Overview
print("=== IPO Market Overview ===")
market = get_market_overview()
for key, val in market.items():
if key != "meta":
print(f" {key}: {val}")
# 2. Recent Filings
print("\n=== Recent SEC Filings (7 days) ===")
filings = get_recent_filings()
for f in filings.get("results", []):
print(f" [{f['filed_date']}] {f['company_name']} — {f['filing_type']}")
# 3. Upcoming Lockups
print("\n=== Upcoming Lockup Expirations (30 days) ===")
lockups = get_upcoming_lockups()
for l in lockups.get("results", []):
print(f" {l['expiry_date']} — {l['company_name']} ({l.get('shares_percent', '?')}% unlock)")
# 4. Company Search
print("\n=== AI Companies in Pre-IPO Stage ===")
results = search_companies("artificial intelligence")
for c in results.get("results", []):
print(f" {c['name']} — {c.get('sector', 'N/A')} — Est. Valuation: ${c.get('valuation', 'N/A')}")
Recommended Reading
If you’re serious about building quantitative trading systems or financial applications, I highly recommend Python for Finance by Yves Hilpisch. It’s the definitive guide to using Python for financial analysis, algorithmic trading, and computational finance — and it pairs perfectly with the kind of data the Pre-IPO Intelligence API provides. For a deeper dive into systematic strategy development, Quantitative Trading by Ernest Chan is another essential read for quant-minded developers.
Why Choose Pre-IPO Intelligence Over Alternatives?
We’ve compared the landscape of finance APIs for pre-IPO data, and here’s what sets this API apart:
- Breadth: 42 endpoints covering the full pre-IPO lifecycle, from private company intelligence to post-IPO lockup tracking. Most competitors focus on a single slice
- Freshness: Data is refreshed continuously, not on daily or weekly batch cycles. SEC filings appear within minutes of publication
- Developer Experience: Clean JSON responses, consistent pagination, proper error codes. No XML parsing, no SOAP, no proprietary SDKs required
- Pricing Transparency: Freemium through RapidAPI with clear tier pricing. No sales calls required, no hidden fees, no annual commitments for basic plans
- Integration Speed: From signup to first API call in under 2 minutes via RapidAPI
Start Building Today
The Pre-IPO Intelligence API is live and ready for integration. Whether you’re prototyping a weekend project or architecting a production trading system, the free tier gives you everything needed to evaluate the data quality and build your proof of concept.
👉 Subscribe to the Pre-IPO Intelligence API on RapidAPI →
Already using the API? We’d love to hear what you’re building. Drop a comment below or reach out through the RapidAPI discussion page.
Related reading on Orthogonal:
Frequently Asked Questions
What data does the Pre-IPO API provide?
The Pre-IPO API delivers structured SEC filing data including S-1 and S-4 documents, SPAC merger details, and lockup expiration dates. It helps developers and analysts programmatically track companies approaching their public debut with real-time filing updates.
How can I use SEC filing data to track upcoming IPOs?
By monitoring S-1 filings and amendments through the API, you can identify companies in the IPO pipeline and track their progress. The API normalizes raw SEC EDGAR data into clean JSON endpoints, making it easy to integrate into dashboards or trading systems.
What is a SPAC lockup period and why does it matter?
A SPAC lockup period is a contractual restriction preventing insiders from selling shares for a set time after a merger closes, typically 6-12 months. When lockups expire, increased selling pressure can cause significant price drops, making these dates critical for investors.
Is the Pre-IPO API free to use?
The API offers a free tier with rate-limited access to basic filing data. Premium tiers provide higher rate limits, real-time webhook notifications, and access to advanced analytics like valuation estimates and insider transaction tracking.
References
- RapidAPI — “Pre-IPO Intelligence API Documentation”
- U.S. Securities and Exchange Commission (SEC) — “EDGAR – Search and Access SEC Filings”
- GitHub — “Pre-IPO Intelligence API Python SDK”
- RapidAPI Blog — “How to Use the Pre-IPO Intelligence API for Financial Data”
- Crunchbase — “SPAC Tracking and Pre-IPO Data Overview”
