# Startup Funding & Investor Intel - Form D Rounds, Investors (`seibs.co/startup-funding-intel`) Actor

Fresh startup funding rounds and investor intel synthesized from SEC Form D filings, EDGAR full-text search, and press coverage. A Crunchbase-style feed rebuilt from primary sources. For VC/PE deal sourcing, B2B sales (a fresh raise = budget), and recruiters. Public data only.

- **URL**: https://apify.com/seibs.co/startup-funding-intel.md
- **Developed by:** [Seibs.co](https://apify.com/seibs.co) (community)
- **Categories:** Business, Lead generation, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.00 / 1,000 company records

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 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 & Investor Intel

> **TL;DR for VC/PE deal sourcing, B2B sales, and recruiters:** A Crunchbase-style funding feed rebuilt from PRIMARY sources - SEC Form D filings (the Regulation D exempt-offering notice almost every priced VC round files), EDGAR full-text search, and press coverage - not a Crunchbase scrape. Pull every fresh Form D in the last two weeks, look up a specific company's raise history, or map the companies a person sits on the board of. Each round comes parsed: issuer, offering amount, industry, the disclosed officers/directors/promoters, and any matching news story. Crunchbase killed its free API in 2025; this rebuilds its inputs from public, government-source data. Logged-out, public-data only. Free Apify plan covers exploration runs on your $5 platform credit.

### Run it in 30 seconds

```python
## Via the Apify Python SDK
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("seibs.co/startup-funding-intel").call(run_input={
    "mode": "recent_rounds",
    "lookback_days": 14,
    "industry_groups": ["Technology"],
    "states": ["CA", "NY"],
    "user_agent_contact": "you@company.com"
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
````

Or via curl:

```bash
curl -X POST "https://api.apify.com/v2/acts/seibs.co~startup-funding-intel/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode": "recent_rounds", "lookback_days": 14, "user_agent_contact": "you@company.com"}'
```

Or click "Try for free" on this page if you prefer the no-code UI. You must set a real `user_agent_contact` email - the SEC requires it.

### What you get

Each run produces:

- A clean dataset, filterable in the Apify console and downloadable as CSV or JSON
- An OUTPUT.html dashboard preview of your top records
- A sample-output preview at [`.actor/sample-output.json`](./.actor/sample-output.json)

Three record types:

- `funding_round_record` - one parsed Form D filing (issuer, offering amount, industry, exemptions, related persons, press)
- `company_record` - a per-issuer rollup (total disclosed raised, round count, latest round)
- `investor_graph_enrichment` - one searched person mapped to the companies they are a related person on, with co-investors

### Live example output

Sample shapes are in [`.actor/sample-output.json`](./.actor/sample-output.json) (the same records demo mode pushes when inputs are missing). A live `recent_rounds` run over the last 14 days returns the newest Form D filings parsed into the schema above, one `funding_round_record` per filing and one `company_record` per distinct issuer, with press mentions attached where a recent news story matches the issuer name.

### What does Startup Funding Intel do?

It treats SEC Form D as the primary-source funding feed it effectively is. When a startup closes a priced equity round under Regulation D, it files a Form D within 15 days disclosing the issuer, the offering amount (total / sold / remaining), the industry, the securities type, and the related persons (executive officers, directors, promoters). This actor:

1. **Finds** the filings - either all of them in a lookback window (`recent_rounds`), or the ones matching a company or person name via EDGAR full-text search.
2. **Parses** each `primary_doc.xml` defensively into a clean record - handling the real-world quirks (offering amounts reported as "Indefinite", first sales "yet to occur", multi-relationship people).
3. **Corroborates** with press - a Google News RSS lookup, fuzzy-matched to the issuer name, attaches recent funding stories. Press files *before* Form D, so a fresh mention confirms the round is real and recent.
4. **Resolves entities** with `rapidfuzz` so "Acme Robotics, Inc." in a filing, "Acme Robotics" in a headline, and the EDGAR display name link up - and weak matches are flagged with a `match_confidence` field rather than silently merged.

### Responsible use / data scope

This actor is a **public-data tool** built on government open data. SEC EDGAR is public-by-law with no adverse platform owner - the safest class of source. It reads only logged-out, publicly-served endpoints (EDGAR full-text search, the EDGAR archives, Google News RSS) - no accounts, no cookies, no paywalls. It minimizes PII: it surfaces the issuer's disclosed related persons (a public-record field that the filer chose to put on a federal form) and firmographics; it never enriches into private contact data or resells personal contact lists. You are responsible for lawful use of the outputs (GDPR / CCPA apply to personal data even when public). This is the synthesis path - we rebuild Crunchbase's inputs from primary sources, we do not scrape Crunchbase.

### AI / RAG / Agent

A turn-key funding feed for deal-sourcing AI, sales copilots, and recruiting bots. Records arrive pre-parsed with `total_offering_amount_usd`, `industry_group`, `filing_date`, `related_persons`, and `press_mentions`, so an agent can answer "which California tech companies filed a Form D over $10M this week, and which have press confirming a Series B?" without parsing XML. Compatible with **LangChain**, **LlamaIndex**, **Pinecone**, **Weaviate**, **Chroma**, and any **MCP**-aware agent runtime (a sibling `mcp-startup-funding-intel` actor is planned for direct tool-call wiring with agentic payments).

### Features

- **Four modes** - recent-rounds firehose, per-company history, investor graph, and a scheduled watchlist monitor.
- **Defensive Form D parser** - offering amounts (total / sold / remaining, with non-numeric "Indefinite" preserved), industry group, federal exemptions, date of first sale, issuer (name / CIK / state / incorporation year), entity type, related persons with normalized relationships, minimum investment, revenue range.
- **Press corroboration** - up to 5 recent (180-day) news mentions per company from Google News RSS, fuzzy-matched to the issuer name. Soft-fail (press errors never abort the run).
- **Entity resolution** - rapidfuzz `token_set_ratio` with documented accept / weak / reject thresholds; weak matches carry a `match_confidence` caveat.
- **Investor graph** - companies a person is a related person on, co-investors seen on the same filings, total disclosed amounts, date range.
- **SEC fair-access compliant** - required contact email in the User-Agent, <= 8 req/s throttle, retry/backoff on 429/503, and a browse-edgar fallback when full-text search is unavailable.
- **Honest framing** - every round carries a `data_lag_note`; the investor graph carries a `graph_note` explaining Form D does not name LP/VC funds.
- **Cost-control** - per-run budget guard + demo-mode soft-fail so runs finish SUCCEEDED.

### Use cases

- **VC / PE deal sourcing** - a fresh Form D is an early signal of a closing round. Watch `recent_rounds` filtered to your thesis (industry + state + minimum amount).
- **B2B sales triggers** - a fresh raise = budget. Route newly-funded companies to the AE who owns the territory. Pairs with the [b2b-sales-triggers](https://apify.com/seibs.co/b2b-sales-triggers) actor.
- **Recruiting** - newly-funded scale-ups are hiring; combine with [hiring-signal-intel](https://apify.com/seibs.co/hiring-signal-intel) for the open-roles side.
- **Investor relationship mapping** - `investor_search` shows which companies a person is a disclosed director/officer on and who they file alongside.
- **Watchlist monitoring** - `funding_monitor` on a schedule alerts you when a target company files a new round.

### Modes

| Mode | What it returns |
|---|---|
| `recent_rounds` | Every Form D / D/A filing in a lookback window (default 14 days), optionally filtered by industry group, state, and minimum offering amount. One `funding_round_record` per filing; one `company_record` per distinct issuer. |
| `company_funding` | For each named company: its Form D history (resolved by name via EDGAR full-text search + fuzzy matching) plus press corroboration. Emits rounds + a company rollup. |
| `investor_search` | For each named person: the Form D filings where they appear as a related person, rolled up into an `investor_graph_enrichment` (companies backed, co-investors, totals, date range). |
| `funding_monitor` | A company watchlist intended for Apify Schedules. Monitor-mode delta digest of NEW rounds since the last run. |

### Input

See [`.actor/input_schema.json`](./.actor/input_schema.json) for the full form. Key fields:

```json
{
    "mode": "recent_rounds",
    "user_agent_contact": "you@company.com",
    "lookback_days": 14,
    "industry_groups": ["Technology", "Biotechnology"],
    "states": ["CA", "NY", "MA"],
    "min_offering_amount_usd": 1000000,
    "include_press": true
}
```

For `company_funding` / `funding_monitor`, set `companies` (e.g. `["Acme Robotics", "Northwind AI"]`). For `investor_search`, set `investors` (e.g. `["Jane Smith"]`). The `user_agent_contact` email is required by the SEC and is intentionally not prefilled - a missing or placeholder value runs in demo mode instead of sending a fake identity to the SEC.

### Output

One `company_record` per issuer (the headline rollup) followed by the `funding_round_record` rows, then any `investor_graph_enrichment` records.

```json
{
    "record_type": "funding_round_record",
    "issuer_name": "Northwind AI, Inc.",
    "issuer_state": "CA",
    "form_type": "D",
    "is_amendment": false,
    "filing_date": "2026-05-22",
    "date_of_first_sale": "2026-05-15",
    "total_offering_amount_usd": 40000000.0,
    "amount_sold_usd": 40000000.0,
    "industry_group": "Technology",
    "federal_exemptions": ["06b", "3C"],
    "related_persons": [
        {"name": "Maria Delgado", "relationship": "Executive Officer"},
        {"name": "Priya Raman", "relationship": "Director"}
    ],
    "press_mentions": [
        {"title": "Northwind AI raises $40M Series B led by Meridian Ventures", "source": "TechCrunch", "match_confidence": 97.0}
    ],
    "edgar_filing_url": "https://www.sec.gov/Archives/edgar/data/1999001/.../...-index.htm",
    "data_lag_note": "Form D often files days-to-weeks after the press announcement..."
}
```

Filings that cannot be resolved or fetched still emit a `fetch_error` record with a human `reason` for a complete audit trail.

### Pricing

Pay-per-event:

| Event | Price | When charged |
|---|---|---|
| `company_record` | $0.006 | Per per-issuer rollup (total disclosed raised, round count, latest round). |
| `funding_round_record` | $0.010 | Per parsed Form D filing returned (the base unit). |
| `investor_graph_enrichment` | $0.012 | Per searched person rolled up into an investor graph. |
| `scheduled_delta_run` | $0.050 | Once per scheduled monitor-mode run. |

A run that returns nothing costs nothing. A typical `recent_rounds` run over 14 days that returns ~80 filings across ~60 issuers costs roughly $0.80 (rounds) + $0.36 (companies) = about $1.16. Narrow the lookback, industry, state, or minimum-amount filters to control volume.

### FAQ

**Q: Why is a round missing?**
A: Only Regulation D *exempt* offerings file Form D. Priced VC equity rounds (Series Seed/A/B...) almost always do, because they rely on the Rule 506(b)/506(c) exemption - so most venture rounds show up. But a round done under a different exemption (for example certain Reg A+ or Reg CF crowdfunding raises, or a fully registered offering) may not file a Form D, and so will not appear here. There is also a filing lag: the issuer has up to 15 days after the first sale to file, and amendments (D/A) follow later - so a round announced in the press today may not file for a week or two. That lag is exactly why this actor attaches press corroboration and stamps every record with a `data_lag_note`.

**Q: Is this Crunchbase data?**
A: No. This is the synthesis path - it rebuilds the *inputs* Crunchbase aggregates from public, government-source primary data (SEC Form D filings) plus public press, and never scrapes Crunchbase. Crunchbase killed its free API in 2025; rather than pay or scrape it, this actor goes to the source the filings come from. The trade-off is honest: Form D gives you the issuer, the offering size, the industry, the exemptions, and the disclosed officers/directors - but it does not name the venture funds or label the round "Series B" (the press mentions help fill that gap). It is a primary-source funding feed, not a re-sold commercial database.

**Q: What does match\_confidence mean?**
A: Linking the same company or person across SEC filings and news headlines is fuzzy - "Acme Robotics, Inc.", "Acme Robotics", and a padded headline like "Acme Robotics raises $40M" are the same entity, but a naive comparison would miss it. The actor uses `rapidfuzz` `token_set_ratio` (0-100) after normalizing the names (uppercasing, stripping punctuation and legal suffixes like Inc/LLC/Corp). A score of 90+ is accepted as a confident match with no caveat. A score of 75-89 is a *weak* match: the record is still returned, but it carries a `match_confidence` object with the score and a "verify before relying on it" note, so you decide rather than the actor silently merging two entities. Below 75 is treated as a different entity. Press headline matching uses a slightly lower floor plus a required funding-keyword filter to cut noise.

**Q: Do I have to provide a contact email?**
A: Yes. The SEC fair-access policy requires every automated request to identify itself with a real contact email or the IP gets banned. The actor sends it in the User-Agent header. It is intentionally not prefilled, because a placeholder would send a fake identity to the SEC - so a missing or `example.com` value runs in demo mode instead.

**Q: Can I schedule this?**
A: Yes. `funding_monitor` (or any mode under an Apify Schedule) gives you a hands-off feed. Pair it with monitor mode (below) so you only get the delta of new rounds. A daily `recent_rounds` over your thesis, or a weekly `funding_monitor` over a target-company watchlist, are the two common setups.

### Save your input as an Apify Task

Apify Tasks let you save a configured input once and re-run it with one click - the foundation for schedules and monitor mode.

1. Click `Run` with your input configured (mode, contact email, filters).
2. Click `Save as task`.
3. Name it (e.g. `seed-stage CA tech - daily`).
4. Reload the task page and click `Start` anytime.

### Run this on a schedule with Apify Schedules

1. Save your input as a Task (above).
2. Go to https://console.apify.com/schedules and `Create new schedule`.
3. Pick your Task and set a cron expression (daily 8am: `0 8 * * *`; weekly Mondays 9am: `0 9 * * 1`).
4. Save. Each run surfaces the newest filings for your thesis or watchlist.

### Monitor mode

When this actor runs under an Apify Schedule, or in `funding_monitor` mode, it emits a change digest of new rounds since the last run instead of repeating the full set, with a digest record at the top. Provide `monitor_webhook_url` and the digest also fires to your Slack channel. Cost: one `scheduled_delta_run` event ($0.05) per scheduled run plus standard PPE on the emitted records.

### Related Actors

- [sec-edgar-intel](https://apify.com/seibs.co/sec-edgar-intel) - the broader SEC actor (8-K triggers, Form 4 insider trades, 13F positions, full-text search). This actor specializes its Form D leg into a funding feed.
- [b2b-sales-triggers](https://apify.com/seibs.co/b2b-sales-triggers) - turn a fresh raise into an outbound sales trigger for your AE/SDR team.
- [hiring-signal-intel](https://apify.com/seibs.co/hiring-signal-intel) - pair a raise with a hiring surge for a full "this company is scaling" picture.

### Support

Open an issue via the Apify Store contact link. Include the run ID and input config so the issue is reproducible.

### Changelog

See [CHANGELOG.md](./CHANGELOG.md).

### Found this useful?

If this actor saved you time or money, please leave a quick review on the Apify Store. Reviews help other buyers find work that solves their problem: https://apify.com/seibs.co/startup-funding-intel#reviews

# Actor input Schema

## `mode` (type: `string`):

recent\_rounds = all Form D / D/A filings in a lookback window (optionally filtered by industry, state, min offering). company\_funding = named companies -> their Form D history + press corroboration. investor\_search = investor/person names -> Form D filings where they appear as related persons, rolled into an investor graph. funding\_monitor = a company watchlist for Apify Schedules (monitor-mode delta of NEW rounds since last run).

## `user_agent_contact` (type: `string`):

A real contact email. The SEC fair-access policy requires every automated request to identify itself with a contact email or the IP gets banned. We send it in the User-Agent header. This is intentionally NOT prefilled - a placeholder would send a fake identity to the SEC, so a missing or example.com value triggers demo mode instead. Example: 'you@company.com'.

## `companies` (type: `array`):

Company legal or common names to look up in Form D filings, e.g. \['Acme Robotics', 'Northwind AI']. The actor resolves each to an SEC issuer via full-text search and fuzzy name matching (rapidfuzz). Names that match weakly are still returned but carry a match\_confidence caveat. Hard cap of 50.

## `investors` (type: `array`):

Investor or person names to search Form D 'related persons' for (executive officers, directors, promoters), e.g. \['Jane Smith', 'Reid Hoffman']. Builds an investor graph per name: companies backed, co-investors seen on the same filings, total disclosed amounts, date range. Form D does NOT name LP/VC funds, so this finds disclosed control persons, not fund investors. Hard cap of 25.

## `lookback_days` (type: `integer`):

How far back to pull Form D filings in recent\_rounds mode. Default 14 (the last two weeks of fresh raises). Hard cap of 365.

## `industry_groups` (type: `array`):

Keep only filings whose Form D industry group contains one of these (case-insensitive substring), e.g. \['Technology', 'Pooled Investment Fund', 'Biotechnology', 'Health Care']. Form D uses a fixed industry-group vocabulary. Leave empty for all. Hard cap of 15.

## `states` (type: `array`):

Keep only filings whose issuer business state matches one of these 2-letter codes, e.g. \['CA', 'NY', 'TX', 'DE']. Leave empty for all states. Hard cap of 50.

## `min_offering_amount_usd` (type: `integer`):

Keep only rounds whose disclosed total offering amount is at least this many dollars. Default 0 (no floor). Note: many Form D filings report 'Indefinite' (no numeric amount); when a floor > 0 is set, Indefinite-amount filings are excluded.

## `max_rounds` (type: `integer`):

Hard cap on the number of Form D filings fetched and parsed in a run (recent\_rounds and per-name searches). Default 200. Hard cap of 1000.

## `include_press` (type: `boolean`):

Attach up to 5 recent (within 180 days) press mentions per company from Google News RSS, fuzzy-matched to the company name. Press files BEFORE Form D, so a fresh mention corroborates the round. Press errors never kill the run (soft-fail). No extra charge.

## `monitor_webhook_url` (type: `string`):

When this actor runs under an Apify Schedule (monitor mode) or in funding\_monitor mode, post the change digest of new rounds to this Slack-compatible webhook URL.

## `use_apify_proxy` (type: `boolean`):

Route SEC and news requests through Apify Proxy. DATACENTER is sufficient - the SEC is a government source with a fair-access throttle, not anti-bot.

## `apify_proxy_groups` (type: `array`):

Apify Proxy groups. DATACENTER is fine for SEC and Google News endpoints.

## `concurrency` (type: `integer`):

Parallel SEC requests. The SEC fair-access ceiling is 10 req/sec; this is capped at 8 with polite spacing. Default 4.

## Actor input object example

```json
{
  "mode": "recent_rounds",
  "user_agent_contact": "",
  "companies": [],
  "investors": [],
  "lookback_days": 14,
  "industry_groups": [],
  "states": [],
  "min_offering_amount_usd": 0,
  "max_rounds": 50,
  "include_press": true,
  "monitor_webhook_url": "",
  "use_apify_proxy": true,
  "apify_proxy_groups": [
    "DATACENTER"
  ],
  "concurrency": 4
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

Narrow, token-efficient slice of every record. Consumer: LLM agents (Claude, GPT, LangChain tools), MCP hosts, deal-sourcing dashboards.

## `datasetItemsRounds` (type: `string`):

All parsed Form D filings with full fields. Consumer: humans browsing, RAG ingest, CRM export, VC deal pipelines.

## `datasetItemsInvestors` (type: `string`):

One row per searched investor/person: companies backed, co-investors, total disclosed, date range. Consumer: VC/PE relationship mapping, recruiting.

## `datasetItemsMcp` (type: `string`):

First 50 overview records as a clean JSON array. Wrap on the agent side in an MCP tool-call envelope. Consumer: MCP servers, Claude Desktop, Cursor, OpenAI Assistants tool calls.

## `datasetItemsCsv` (type: `string`):

Spreadsheet-friendly export of the overview view. Consumer: deal-sourcing teams, Excel / Google Sheets users.

# 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 = {
    "mode": "recent_rounds",
    "lookback_days": 14,
    "max_rounds": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("seibs.co/startup-funding-intel").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 = {
    "mode": "recent_rounds",
    "lookback_days": 14,
    "max_rounds": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("seibs.co/startup-funding-intel").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 '{
  "mode": "recent_rounds",
  "lookback_days": 14,
  "max_rounds": 50
}' |
apify call seibs.co/startup-funding-intel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Startup Funding & Investor Intel - Form D Rounds, Investors",
        "description": "Fresh startup funding rounds and investor intel synthesized from SEC Form D filings, EDGAR full-text search, and press coverage. A Crunchbase-style feed rebuilt from primary sources. For VC/PE deal sourcing, B2B sales (a fresh raise = budget), and recruiters. Public data only.",
        "version": "0.1",
        "x-build-id": "fCnaBaEGX6QBAaS4a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/seibs.co~startup-funding-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-seibs.co-startup-funding-intel",
                "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/seibs.co~startup-funding-intel/runs": {
            "post": {
                "operationId": "runs-sync-seibs.co-startup-funding-intel",
                "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/seibs.co~startup-funding-intel/run-sync": {
            "post": {
                "operationId": "run-sync-seibs.co-startup-funding-intel",
                "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",
                "required": [
                    "mode",
                    "user_agent_contact"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "recent_rounds",
                            "company_funding",
                            "investor_search",
                            "funding_monitor"
                        ],
                        "type": "string",
                        "description": "recent_rounds = all Form D / D/A filings in a lookback window (optionally filtered by industry, state, min offering). company_funding = named companies -> their Form D history + press corroboration. investor_search = investor/person names -> Form D filings where they appear as related persons, rolled into an investor graph. funding_monitor = a company watchlist for Apify Schedules (monitor-mode delta of NEW rounds since last run).",
                        "default": "recent_rounds"
                    },
                    "user_agent_contact": {
                        "title": "Contact email (REQUIRED - SEC fair-access)",
                        "type": "string",
                        "description": "A real contact email. The SEC fair-access policy requires every automated request to identify itself with a contact email or the IP gets banned. We send it in the User-Agent header. This is intentionally NOT prefilled - a placeholder would send a fake identity to the SEC, so a missing or example.com value triggers demo mode instead. Example: 'you@company.com'.",
                        "default": ""
                    },
                    "companies": {
                        "title": "Companies (for company_funding / funding_monitor)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Company legal or common names to look up in Form D filings, e.g. ['Acme Robotics', 'Northwind AI']. The actor resolves each to an SEC issuer via full-text search and fuzzy name matching (rapidfuzz). Names that match weakly are still returned but carry a match_confidence caveat. Hard cap of 50.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "investors": {
                        "title": "Investors / people (for investor_search)",
                        "maxItems": 25,
                        "type": "array",
                        "description": "Investor or person names to search Form D 'related persons' for (executive officers, directors, promoters), e.g. ['Jane Smith', 'Reid Hoffman']. Builds an investor graph per name: companies backed, co-investors seen on the same filings, total disclosed amounts, date range. Form D does NOT name LP/VC funds, so this finds disclosed control persons, not fund investors. Hard cap of 25.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "lookback_days": {
                        "title": "Lookback window (days) for recent_rounds",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "How far back to pull Form D filings in recent_rounds mode. Default 14 (the last two weeks of fresh raises). Hard cap of 365.",
                        "default": 14
                    },
                    "industry_groups": {
                        "title": "Industry-group filter (Form D categories)",
                        "maxItems": 15,
                        "type": "array",
                        "description": "Keep only filings whose Form D industry group contains one of these (case-insensitive substring), e.g. ['Technology', 'Pooled Investment Fund', 'Biotechnology', 'Health Care']. Form D uses a fixed industry-group vocabulary. Leave empty for all. Hard cap of 15.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "states": {
                        "title": "State filter (2-letter issuer state)",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Keep only filings whose issuer business state matches one of these 2-letter codes, e.g. ['CA', 'NY', 'TX', 'DE']. Leave empty for all states. Hard cap of 50.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "min_offering_amount_usd": {
                        "title": "Minimum total offering amount (USD)",
                        "minimum": 0,
                        "maximum": 100000000000,
                        "type": "integer",
                        "description": "Keep only rounds whose disclosed total offering amount is at least this many dollars. Default 0 (no floor). Note: many Form D filings report 'Indefinite' (no numeric amount); when a floor > 0 is set, Indefinite-amount filings are excluded.",
                        "default": 0
                    },
                    "max_rounds": {
                        "title": "Max filings to process",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on the number of Form D filings fetched and parsed in a run (recent_rounds and per-name searches). Default 200. Hard cap of 1000.",
                        "default": 200
                    },
                    "include_press": {
                        "title": "Include press corroboration",
                        "type": "boolean",
                        "description": "Attach up to 5 recent (within 180 days) press mentions per company from Google News RSS, fuzzy-matched to the company name. Press files BEFORE Form D, so a fresh mention corroborates the round. Press errors never kill the run (soft-fail). No extra charge.",
                        "default": true
                    },
                    "monitor_webhook_url": {
                        "title": "Monitor webhook URL (Slack / email, optional)",
                        "type": "string",
                        "description": "When this actor runs under an Apify Schedule (monitor mode) or in funding_monitor mode, post the change digest of new rounds to this Slack-compatible webhook URL.",
                        "default": ""
                    },
                    "use_apify_proxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route SEC and news requests through Apify Proxy. DATACENTER is sufficient - the SEC is a government source with a fair-access throttle, not anti-bot.",
                        "default": true
                    },
                    "apify_proxy_groups": {
                        "title": "Proxy groups",
                        "type": "array",
                        "description": "Apify Proxy groups. DATACENTER is fine for SEC and Google News endpoints.",
                        "default": [
                            "DATACENTER"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "concurrency": {
                        "title": "Max concurrent SEC requests",
                        "minimum": 1,
                        "maximum": 8,
                        "type": "integer",
                        "description": "Parallel SEC requests. The SEC fair-access ceiling is 10 req/sec; this is capped at 8 with polite spacing. Default 4.",
                        "default": 4
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
