Every week, over €2 billion flows into European startups. But finding who got funded -- and how much -- means scrolling press releases, parsing LinkedIn posts, and paying for paywalled databases.
If you're building an investor dashboard, a CRM for venture capital, or a market intelligence tool, you need this data structured and accessible. Not in PDFs. Not in HTML. In JSON, via an API, ready to plug into your application.
This post shows you two ways to get there: the hard way (building your own scraper) and the smart way (using a structured API). By the end, you'll have working Python code and a clear decision on which path fits your project.
1. The Hard Way: Building Your Own Scraper
Most developers start here. I did too.
You find a site that lists funding rounds -- TechCrunch, local news, industry blogs. You open Chrome DevTools, find the CSS selectors, and write a scraper:
import requests
from lxml import html
def scrape_funding(url):
response = requests.get(url, headers={"User-Agent": "Mozilla/5.0"})
tree = html.fromstring(response.content)
# These selectors work... until the site redesigns
companies = tree.xpath("//h2[@class='company-name']/text()")
amounts = tree.xpath("//span[@class='funding-amount']/text()")
return [{"company": c, "amount": a} for c, a in zip(companies, amounts)]
It works for a week. Then:
- The site adds a paywall
- Cloudflare blocks your IP
- A redesign changes every selector
- You discover the amounts are inconsistent ("€5M", "5 million euros", "Series A of undisclosed size")
- You need to deduplicate the same round from three sources
Three months in, you've spent more time maintaining the scraper than building your actual product.
This is the hidden cost of DIY data collection: it's not the first script that kills you. It's the 4 AM alerts when a site changes its HTML.
2. The Smart Way: Using a Funding API
After maintaining scrapers for too long, I built ParheliaWeb -- a structured API that handles the messy work for you.
Here's how to get funding data in 5 lines of Python:
import requests
API_KEY = "your_api_key_here" # Get one at parheliaweb.com
response = requests.get(
"https://parheliaweb.com/v1/funding",
headers={"x-api-key": API_KEY},
params={
"max_age_days": 30,
"max_records": 10
}
)
data = response.json()
for round in data["results"]:
print(f"{round['company_name']} raised {round['funding_amount']} "
f"in {round['round_type']} ({round['announcement_date']})")
What you get back:
{
"user_tier": "pro",
"count": 10,
"max_age_days": 30,
"last_crawled": "2026-07-03T10:30:00Z",
"results": [
{
"company_name": "Acme AI",
"funding_amount": "$5 million",
"round_type": "Series A",
"announcement_date": "2026-06-15",
"source_url": "https://techcrunch.com/...",
"source_status": "active",
"sector": "Artificial Intelligence",
"currency": "USD",
"country": "US",
"lead_investor": "Sequoia Capital",
"is_extension": false,
"investor_count": "5"
}
]
}
No parsing. No deduplication. No 4 AM alerts.
3. Build vs. Buy: The Real Math
| Factor | Build Yourself | Use ParheliaWeb API |
|---|---|---|
| Time to first result | 2-4 weeks | 5 minutes |
| Ongoing maintenance | 5-10 hours/week | 0 |
| Data quality | Variable | AI-verified & structured |
| Coverage gaps | Your problem | Handled |
| Compliance (GDPR, etc.) | Your risk | Our responsibility |
| Cost | Engineering salary | €29/month |
The rule: If your core business is data collection, build it. If your core business is using the data, buy it.
4. Getting Started
Start with 100 free API calls -- no credit card required. Test your integration, validate the data quality, and upgrade when you're ready.
Pro tier: Full dataset access for €29/month. Launch promo: 20% off (€23/month).
5. Questions?
I'm Andy, the founder. I read every email.
Top comments (1)
I've definitely been down this road trying to aggregate data from external sources for market intelligence or competitive analysis. It always starts with a few seemingly simple scrapes or free APIs, then quickly devolves into a game of whack-a-mole with schema changes, rate limits, and outright data discrepancies. The "losing your mind" part resonates deeply; we once tried to build a comprehensive industry mapping for a B2B SaaS product, pulling in company info from various public registries and news sites, and the initial excitement quickly faded into a backlog of parsing issues.
The biggest trap we fell into was underestimating the maintenance burden. What looks like a stable XPath today might vanish tomorrow, or a "free" API tier becomes cripplingly slow once you hit production scale. We ended up investing heavily in a robust data validation layer, using fuzzy matching algorithms for company names and cross-referencing against multiple sources before accepting an update. It's a constant battle against stale data where "eventual consistency" sometimes feels more like "eventual chaos." The legal and ethical side of continuous web scraping also needs careful consideration; often, a targeted API partnership, even if paid, offers far more stability and reliability than trying to outsmart a website's anti-bot measures.
One pattern that helped us was to treat each data source as a distinct service with its own health checks and circuit breakers. If a scraper fails, it shouldn't block the entire data pipeline. Also, prioritizing data freshness versus absolute completeness is a critical trade-off. For funding rounds, getting most of the data quickly might be more valuable than waiting for 100% accuracy from every single source. It's about finding that sweet spot where the data is "good enough" for the intended use case without breaking the bank on engineering effort or accumulating unnecessary legal risk.