I need a funding API that will return me a list of investors and the exact amount they invested. Not just a scraped list of news headlines. Most people googling for this would find Apify scrapers for SEC Form D filings or TechCrunch articles. That is not an API. It's a hack. And if you are building a product that needs funding data, you cannot rely on a scraper that breaks every time the website changes. You need a structured data source.
I ran the search on NinjaPear, filtered to Seed and Series A rounds since 1 October 2026. On 14 November 2026, I got five companies back. TechCrunch alone has more seed rounds in a week than that.
A real funding endpoint is one call per company. It returns the date, round type, amount (in USD and local currency), and investor list with specific amounts. A call for openai.com will return a 31 March 2026 round totaling $122,000,000,000. It breaks it down to SoftBank at $30B, Amazon $50B, NVIDIA $30B, ARK Invest $3B, and Andreessen Horowitz as undisclosed. This level of detail is what makes funding data useful.
By the end of this piece, you can filter companies by last funding date and round type in one call, then fetch each company's full funding history with investors in another call.
What does a startup funding API actually return?
In plain English, a funding API takes a company domain and turns it into a chronological list of investment rounds for a company. Each entry in this list represents a snapshot of an event: date that round was closed, type of round, total amount raised, names of investors involved.
Take openai.com as the example. A call to the endpoint will return a round from 31 March 2026 for a total of $122,000,000,000. The data does not just give you a total. It breaks down the participants. You see SoftBank at $30B, Amazon at $50B, NVIDIA at $30B, ARK Invest at $3B and Andreessen Horowitz listed as undisclosed.
Sometimes companies keep their numbers private. In which case, the API returns null for the amount instead of guessing. For anthropic.com, you get round types and dates such as Series E in June 2024, Series F in December 2024, Series G in March 2025. However, investors are marked Undisclosed and amounts are null. This is not a failure of data. It is an honest reflection of what the company has disclosed.
How do you find companies that just raised, not one at a time?
If you're looking for a list of new targets, use the search call: GET /api/v1/company/search. You can filter by last funding date range and last funding type. The types include PRE_SEED, SEED, SERIES_A to SERIES_G, VENTURE_DEBT, GRANT. You can also layer on filters for total funding raised, industry, country, headcount, founded year, revenue. This costs 2 credits per page with results, free if nothing matches. Funding is one slice of the record; if you want the whole enrichment stack, I compared the best company data enrichment tools side by side.
I did this myself. On 14 November 2026, I set the filters to last_funding_date_min=2026-10-01 and last_funding_type=SEED,SERIES_A. I got exactly five companies back: Ambio Life Sciences, Baba, Malama Health, Project Lucid, Rosie.
That coverage of new seed rounds is thin on the ground. If you need every American seed round as it happens in a week's time, then an SEC Form D filing feed is currently the better source for discovery. What you get here that a filing feed does not provide is the full funding history, per-investor amounts and the rest of the company record all on one key.
What does the funding data look like: rounds, amounts, investors?
A funding response is a structured array of rounds. Here is the shape of the data for openai.com:
[
{
"date": "2026-03-31",
"round_type": "UNKNOWN",
"amount": 122000000000,
"amount_usd": 122000000000,
"currency": "USD",
"investors": [
{
"name": "SoftBank",
"type": "company",
"website": "https://www.softbank.group",
"amount": 30000000000,
"amount_usd": 30000000000,
"currency": "USD"
},
{
"name": "Amazon.com, Inc.",
"type": "company",
"website": "https://www.amazon.com",
"amount": 50000000000,
"amount_usd": 50000000000,
"currency": "USD"
},
{
"name": "NVIDIA Corporation",
"type": "company",
"website": "https://www.nvidia.com",
"amount": 30000000000,
"amount_usd": 30000000000,
"currency": "USD"
},
{
"name": "ARK Invest",
"type": "company",
"website": "https://ark.com",
"amount": 3000000000,
"amount_usd": 3000000000,
"currency": "USD"
},
{
"name": "Andreessen Horowitz",
"type": "company",
"website": "https://a16z.com",
"amount": null,
"amount_usd": null,
"currency": "USD"
}
]
}
]
Per-investor amounts are the most valuable part of this record. They let you do allocation analysis, track specific syndicates, and detect repeat investors across your entire pipeline. Without the breakdown, you only have a headline number.
You must build your pipeline to handle nulls. Not every company discloses every detail. For anthropic.com, the API returns the round types and dates, SERIES_E on 2024-06-01, SERIES_F on 2024-12-01, and SERIES_G on 2025-03-01. But the amount_usd fields are null and the investors are marked as Undisclosed. Do not assume every field is populated.
Why the cheap SERP options (Form D and news scrapers) break at scale
Most developers start with what they find on page one of Google that is cheap. Usually Apify actors scraping SEC Form D filings or news sites like TechCrunch.
SEC Form D is a regulatory filing US companies are required to file within 15 days after selling securities. It captures many private rounds, but only for US companies. The data is messy. Fields are unstructured, filer names often differ from the actual operating company, and amounts are often reported as ranges or estimates.
News scrapers are even worse because they only catch rounds that make it into the press. This biases the dataset towards well-known companies and over-reports large rounds. Small, quiet seed rounds are often missed entirely.
Neither of these sources provides you with per-investor amounts reliably. Neither provides the rest of the company record such as headcount, customers, or competitors. If you use them, you have to build and maintain the deduplication and company-matching layer yourself. For a wider view of what developers actually pay for, the company data APIs that come up on Reddit are a decent signal.
There is a fair tradeoff here. If all you need is week-one US seed discovery, filing feeds win. For everything after discovery, a structured API wins.
Pricing, rate limits and caching, in numbers
Company search costs 2 credits per page with results, free if nothing matches. The funding endpoint, GET /api/v1/company/funding, costs 2 credits plus 1 credit per unique investor returned in the result. Paid endpoints are rate-limited to 50 requests per minute.
You should budget for latency. Most calls take 30 to 60 seconds, but the funding endpoint can take up to five minutes on a cold company. Endpoints have a 30-day deprecation notice guarantee, so a pipeline you build today will not break silently.
Repeat cache hits are free. Operationally, this is significant for weekly jobs. If you do a search and enrich the same set of companies every Monday, then the second run of the week on the same set of companies will cost you nothing on cached endpoints.
To see it in action, look at my earlier search. Finding those five companies cost 2 credits. Enriching all five with their full funding history would cost 10 credits plus 1 credit for every unique investor found across these records.
Build it: a two-call workflow in Python
Here is a sketch of the pipeline using the requests library.
import requests
from urllib.parse import urlparse, parse_qs, unquote
API_KEY = "YOUR_API_KEY"
headers = {"Authorization": f"Bearer {API_KEY}"}
# 1. Find recently funded companies
search = requests.get(
"https://nubela.co/api/v1/company/search",
params={"last_funding_date_min": "2026-10-01",
"last_funding_type": "SEED,SERIES_A"},
headers=headers).json()
# 2. Pull full funding history for each
for company in search["data"]["companies"]:
domain = parse_qs(urlparse(company["company_details_url"]).query)["website"][0]
funding = requests.get(
"https://nubela.co/api/v1/company/funding",
params={"website": unquote(domain)}, headers=headers).json()
print(company["name"], funding["data"]["funding_rounds"])
If you prefer not to code, you can use the MCP route. NinjaPear exposes 29 MCP tools including the funding and search tools, so an agent can run this entire workflow for you. If you are moving off a per-seat tool, the Apollo API guide covers that tradeoff.
The scraper question is settled. These two calls are the entire pipeline. The one thing that matters is null handling, and you have a production-ready funding feed.
