# Startup Funding Signal Scraper — EU & US (`actorpilot/startup-funding-signal-scraper`) Actor

Track recently funded startups from EU-Startups & TechCrunch. Returns company, amount, round type, investors and sector as B2B signals.

- **URL**: https://apify.com/actorpilot/startup-funding-signal-scraper.md
- **Developed by:** [S. Klein](https://apify.com/actorpilot) (community)
- **Categories:** Lead generation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Startup Funding Signal Scraper

**Track recently funded startups as B2B sales intelligence signals.** Scrapes [EU-Startups.com](https://www.eu-startups.com) and [TechCrunch Venture](https://techcrunch.com/category/venture/) for fresh funding announcements and extracts structured data: company name, funding amount, round type, country, sectors, and investors — all in one clean JSON dataset.

No API keys required. Runs on demand or on a schedule. Ready to plug into your CRM, sales pipeline, or market intelligence workflow.

### Why Use Startup Funding Signal Scraper?

Every week, hundreds of startups close funding rounds — and every one of them is a warm sales signal. Newly funded companies are **actively hiring**, **buying tools**, and **scaling operations**. Reaching them within days of their announcement dramatically improves conversion rates.

This Actor does the grunt work of monitoring two of the best funding news sources — EU-Startups (European coverage) and TechCrunch (US and global) — so you never miss a signal:

- **Sales prospecting**: Find startups that just raised and are likely buying SaaS, recruiting, marketing, or infrastructure tools
- **Market intelligence**: Track which sectors attract investment, which round types dominate, and how funding volumes shift over time
- **Lead generation**: Build targeted lists of funded companies in your vertical, filtered by amount, round type, or region
- **Competitive monitoring**: Watch when companies in your space or adjacent niches raise — know before your competitors do
- **Investor research**: Track deal flow from specific VCs or emerging fund activity in a sector
- **Content and PR**: Identify newly funded startups for partnership pitches, press outreach, or ecosystem mapping

### How to Use Startup Funding Signal Scraper

1. Go to the Actor page on [Apify Store](https://apify.com) and click **Try for free**
2. Choose your **sources**: `eu-startups`, `techcrunch`, or `both`
3. Set `daysBack` to define how far back to look (e.g. `7` for last week's signals)
4. Optionally filter by `minAmountM` (minimum round size in millions) and `roundType`
5. Set `maxResults` — default is 30, max is 200
6. Click **Start** — results appear in the **Output** tab within seconds
7. Download as JSON, CSV, or Excel — or trigger runs via the Apify API on a schedule

### Input Reference

| Field | Type | Default | Description |
|---|---|---|---|
| `sources` | string | `both` | Which sources to scrape: `eu-startups`, `techcrunch`, or `both` |
| `maxResults` | integer | `30` | Maximum signals to return (1–200) |
| `daysBack` | integer | `30` | How many days back to look (1–90) |
| `minAmountM` | number | `0` | Minimum round size in millions (e.g. `5` for Series A+ only) |
| `roundType` | string | _(all)_ | Filter by round: `Seed`, `Series A`, `Series B`, `Series C`, `Growth`, `Pre-Seed`, `Bridge`, `IPO` |

#### Example Input — European Seed Rounds This Week

```json
{
  "sources": "eu-startups",
  "daysBack": 7,
  "minAmountM": 1,
  "roundType": "Seed",
  "maxResults": 50
}
````

#### Example Input — All Recent US Raises Above $10M

```json
{
  "sources": "techcrunch",
  "daysBack": 14,
  "minAmountM": 10,
  "maxResults": 100
}
```

### Output

Each funding signal includes the following fields:

| Field | Type | Description |
|---|---|---|
| `startupName` | string | Company that received funding |
| `title` | string | Original article headline |
| `fundingAmountRaw` | string | Raw amount as written in the article (e.g. "€2.1 million") |
| `fundingAmountM` | number | Normalized amount in millions for filtering and sorting |
| `currency` | string | `EUR`, `USD`, or `GBP` |
| `roundType` | string | `Pre-Seed`, `Seed`, `Series A`–`E`, `Growth`, `Bridge`, `IPO`, or `null` |
| `country` | string | Country of the startup (from EU-Startups tags) |
| `sectors` | array | Industry tags (e.g. `["AI", "HealthTech", "B2B SaaS"]`) |
| `investors` | array | Named investors/VCs mentioned in the article |
| `source` | string | `eu-startups` or `techcrunch` |
| `publishedAt` | string | ISO 8601 publication date |
| `articleUrl` | string | Link to the original article |
| `summary` | string | First 300 characters of the article description |

You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel** from the Output tab or via the Apify API.

#### Example Output

```json
{
  "startupName": "OurMind",
  "title": "Amsterdam's OurMind raises €2.1 million in seed funding",
  "fundingAmountRaw": "€2.1 million",
  "fundingAmountM": 2.1,
  "currency": "EUR",
  "roundType": "Seed",
  "country": "Netherlands",
  "sectors": ["AI", "HealthTech"],
  "investors": ["Gradient Ventures"],
  "source": "eu-startups",
  "publishedAt": "2026-06-11T08:00:00.000Z",
  "articleUrl": "https://www.eu-startups.com/2026/06/...",
  "summary": "OurMind, the Amsterdam-based AI platform for mental health practitioners, has raised €2.1 million..."
}
```

### Source Coverage

| Source | Geography | Typical Round Size | Strengths |
|---|---|---|---|
| **EU-Startups** | Europe (primary) | €500K–€100M+ | Country detection, sector tags, early-stage EU coverage |
| **TechCrunch** | US + Global | $5M+ | High-profile rounds, US unicorns, global tech coverage |

**EU-Startups** is the strongest source for European funding rounds across all stages. It covers Germany, Netherlands, France, UK, Spain, Poland, and other EU markets with detailed category tagging.

**TechCrunch** focuses on larger rounds and US-based companies. The Actor applies strict filtering to exclude editorial content and VC fund announcements — only startup funding news passes through.

### How Much Does It Cost?

Apify provides a **free tier** with $5 of platform credits per month — enough for dozens of daily runs.

| Run configuration | Approximate time | Estimated cost |
|---|---|---|
| 30 results, 1 source | ~5–10 seconds | <$0.01 |
| 100 results, both sources | ~15–30 seconds | ~$0.01 |
| 200 results, both sources | ~30–60 seconds | ~$0.02 |

This Actor uses RSS feed parsing — extremely fast and lightweight, no browser automation needed.

### Tips for Best Results

- **Schedule daily runs** at 8am to get fresh signals every morning before your sales team starts their day
- **Use `daysBack: 3`** for high-frequency monitoring to catch signals within 72 hours of announcement
- **Combine `minAmountM: 5` with `roundType: "Series A"`** to target companies with meaningful budgets but not yet enterprise-locked
- **Export to Google Sheets** or pipe results directly into your CRM via the Apify API or Zapier integration
- **Filter by `country`** in your downstream processing to target specific markets — EU-Startups tags include Germany, Netherlands, France, and 15+ other countries
- **Round type is null** when the article doesn't clearly name the round — check `fundingAmountM` to infer stage

### Use With the Apify API and MCP

Trigger runs programmatically and retrieve results via the REST API:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/actorpilot~startup-funding-signal-scraper/runs" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"sources":"eu-startups","daysBack":7,"minAmountM":1,"maxResults":50}'
```

The Actor works with the **Apify MCP server** — connect it to Claude, GPT-4, or any MCP-compatible AI assistant to query funding data conversationally:

> "Show me all European AI startups that raised a Series A in the last 7 days"

### FAQ

**How accurate is the funding amount extraction?**
Amounts are extracted via regex from article text and headlines. Well-written announcements (e.g. "raises €5 million Series A") parse cleanly. Vague articles ("raises significant funding") will have `null` for the amount fields.

**Why is `roundType` null for some entries?**
The round type is extracted from text patterns like "Series A" or "seed round". If the article doesn't mention the round type explicitly, it will be `null`.

**Why is `country` only populated for EU-Startups results?**
EU-Startups.com uses category tags like "German Startups" or "Dutch Startups" that allow reliable country detection. TechCrunch does not use equivalent geographic tags.

**Can I get investor names for all articles?**
Investor extraction uses named entity patterns (VC firm names, "led by", "backed by" phrases). Not all articles mention investors explicitly — roughly 30–60% will have investor data.

**Is the data real-time?**
The Actor fetches from live RSS feeds at run time. For maximum freshness, schedule it to run multiple times per day.

**I need custom filtering or integration with my CRM — can you help?**
Open a ticket via the **Issues** tab on the Actor page. Custom solutions and enterprise integrations are available on request.

# Actor input Schema

## `sources` (type: `string`):

Which news sources to scrape for funding signals.

## `maxResults` (type: `integer`):

Maximum number of funding signals to return.

## `daysBack` (type: `integer`):

How many days back to look for funding rounds.

## `minAmountM` (type: `number`):

Only return rounds of at least this size (in millions). 0 = all sizes.

## `roundType` (type: `string`):

Filter by specific funding round type.

## Actor input object example

```json
{
  "sources": "both",
  "maxResults": 30,
  "daysBack": 30,
  "minAmountM": 0,
  "roundType": ""
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("actorpilot/startup-funding-signal-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("actorpilot/startup-funding-signal-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call actorpilot/startup-funding-signal-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=actorpilot/startup-funding-signal-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Startup Funding Signal Scraper — EU & US",
        "description": "Track recently funded startups from EU-Startups & TechCrunch. Returns company, amount, round type, investors and sector as B2B signals.",
        "version": "1.0",
        "x-build-id": "ej2X2Ojv8tSy0em1l"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/actorpilot~startup-funding-signal-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-actorpilot-startup-funding-signal-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/actorpilot~startup-funding-signal-scraper/runs": {
            "post": {
                "operationId": "runs-sync-actorpilot-startup-funding-signal-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/actorpilot~startup-funding-signal-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-actorpilot-startup-funding-signal-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "sources": {
                        "title": "Data sources",
                        "enum": [
                            "both",
                            "eu-startups",
                            "techcrunch"
                        ],
                        "type": "string",
                        "description": "Which news sources to scrape for funding signals.",
                        "default": "both"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of funding signals to return.",
                        "default": 30
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 90,
                        "type": "integer",
                        "description": "How many days back to look for funding rounds.",
                        "default": 30
                    },
                    "minAmountM": {
                        "title": "Minimum amount (million)",
                        "minimum": 0,
                        "type": "number",
                        "description": "Only return rounds of at least this size (in millions). 0 = all sizes.",
                        "default": 0
                    },
                    "roundType": {
                        "title": "Round type filter",
                        "enum": [
                            "",
                            "Pre-Seed",
                            "Seed",
                            "Series A",
                            "Series B",
                            "Series C",
                            "Series D",
                            "Growth",
                            "IPO"
                        ],
                        "type": "string",
                        "description": "Filter by specific funding round type.",
                        "default": ""
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
