# Fresh Funding Signals - SEC Form D Scraper & Sales Triggers (`publimoov/fresh-funding-signals`) Actor

Companies that just raised money, as a clean JSON feed. Parses SEC Form D and Form C filings, separates operating companies from investment funds, resolves company domains and scores each deal as a sales trigger. Public-domain US government data - no login, no personal data.

- **URL**: https://apify.com/publimoov/fresh-funding-signals.md
- **Developed by:** [Nacho Bustos](https://apify.com/publimoov) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $80.00 / 1,000 enriched company rows

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Fresh Funding Signals — SEC Form D funding alerts & B2B sales triggers

**Find companies that just raised money, before anyone announces it.**

Every US company that closes a private funding round must file a **Form D** with the SEC, usually within 15 days of the first sale — often weeks before a press release, a Crunchbase entry or a LinkedIn post. That filing is public. It is also an unusable XML blob with no website, no readable industry, duplicated amendments, and two different "amount" fields that most people confuse.

This Actor turns it into a clean, scored row you can drop straight into a CRM, an enrichment pipeline or an AI agent.

### What you get

```json
{
  "entity_name": "Castelion Corp",
  "domain": "castelion.com",
  "domain_confidence": 0.85,
  "domain_method": "dns_http_probe",
  "total_sold_usd": 647000679,
  "total_offering_usd": 647000679,
  "industry": "technology",
  "entity_class": "operating_company",
  "state_or_country": "CA",
  "city": "El Segundo",
  "date_of_first_sale": "2026-08-14",
  "date_filed": "2026-08-28",
  "security_types": ["equity"],
  "investors_already_invested": 24,
  "signal_score": 0.82,
  "freshness_score": 0.82,
  "confidence": 0.95,
  "amendment_count": 0,
  "form_type": "D",
  "cik": "1922418",
  "sources": ["https://www.sec.gov/Archives/edgar/data/..."],
  "generated_at": "2026-08-30T01:12:44Z",
  "schema_version": "1.0.0"
}
```

### Why this instead of the raw SEC feed

**It separates companies from funds.** This is the big one. On a typical day the SEC receives around 250 Form D filings, and in a measured sample of 120 of them, **63 were investment funds and only 49 were operating companies**. If you are prospecting, more than half of the raw feed is noise. Set `entityClasses` to `operating_company` and it disappears.

**It finds the website.** Form D does not contain one. This Actor derives candidate domains from the legal entity name and verifies each by DNS and HTTP before returning it — and returns `null` with a confidence of `0` rather than guessing. Every domain comes with `domain_confidence` and `domain_method`, so you always know what you are trusting.

**It deduplicates amendments.** One offering can generate several filings. You get one row per offering, with the latest numbers and an `amendment_count`.

**It gets the amounts right.** `total_offering_usd` is what the company is authorised to raise; `total_sold_usd` is what actually landed. `"Indefinite"` becomes `null`, never `0`.

**It scores each row.** `signal_score` blends recency, amount raised, company type and whether a website was confirmed, so the best leads sort to the top.

### Use cases

- **Sales triggers** — a company that just closed a round is buying software, hiring, and choosing vendors.
- **Recruiting** — freshly funded companies are freshly hiring.
- **Venture and market research** — private-round deal flow before it hits the press.
- **AI agents** — a stable, schema-versioned JSON feed with source URLs and confidence on every row, so an agent can cite and verify what it used.

### Input

| Field | Default | What it does |
|---|---|---|
| `daysBack` | `5` | Business days of filings to cover |
| `entityClasses` | `["operating_company"]` | Filter out funds and real estate |
| `minSoldUsd` | `0` | Skip small or unclosed rounds |
| `includeFormC` | `false` | Add Reg CF equity-crowdfunding raises |
| `resolveDomains` | `true` | Find and verify the company website |
| `includeDigest` | `false` | Append one aggregate row for the period |
| `maxResults` | `200` | Hard cap, so a run can never surprise you |

### Data source, legality and privacy

Data comes from **SEC EDGAR**, the US Securities and Exchange Commission's public filing system. It is US government work in the public domain, and the SEC explicitly permits programmatic access. This Actor identifies itself with a declared User-Agent and stays well under the published rate limit. There is no login, no session, no paywall and no scraping of any private surface.

**No personal data.** Form D filings list officers and directors with home addresses. **This Actor never emits a natural person's name or address** — only the company. You get `related_person_count` and their roles, nothing else. There is an automated test that fails the build if a single personal field ever leaks into the output.

### Notes

- Filings are immutable once submitted, so results are cached and repeated runs over the same period are fast and cheap.
- The SEC publishes on business days; weekends and federal holidays return nothing.
- Roughly 250 Form D filings arrive per business day, so `daysBack: 5` covers around 1,200 filings before filtering.

***

Built and maintained by **PubliMoov LLC**. Issues and feature requests are welcome on the Actor's issues tab.

# Actor input Schema

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

How many business days of SEC filings to cover, counting back from the most recent one. 1 = today's new filings only. Around 250 Form D filings are submitted every business day.

## `entityClasses` (type: `array`):

Most Form D filings are investment funds raising capital, not companies that just received it. Leave only 'operating\_company' if you want sales leads.

## `minSoldUsd` (type: `integer`):

Skip filings where the amount actually sold is below this. 0 keeps everything, including offerings that have not closed yet.

## `includeFormC` (type: `boolean`):

Adds equity-crowdfunding raises on top of Reg D private placements.

## `resolveDomains` (type: `boolean`):

Finds and verifies the company's domain. This is the 'enriched' tier and is what makes a row usable for outreach or enrichment. Slower and priced higher.

## `includeDigest` (type: `boolean`):

Appends one aggregate row: totals by industry, state and company type for the whole period.

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

Hard cap on rows returned, so a run can never cost more than you expect.

## Actor input object example

```json
{
  "daysBack": 5,
  "entityClasses": [
    "operating_company"
  ],
  "minSoldUsd": 0,
  "includeFormC": false,
  "resolveDomains": true,
  "includeDigest": false,
  "maxResults": 200
}
```

# Actor output Schema

## `fundingSignals` (type: `string`):

One row per offering: company, resolved domain, amount raised, normalized industry, company type and signal score. Includes the period digest when requested.

## `telemetry` (type: `string`):

Rows returned and charged, SEC requests made, cache hit rate, runtime and recoverable errors for this run.

# 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("publimoov/fresh-funding-signals").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("publimoov/fresh-funding-signals").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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 publimoov/fresh-funding-signals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publimoov/fresh-funding-signals"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Hr0bb3401fQCrFDx0/builds/Odm6m9BL36Jiwlbe8/openapi.json