From SEC Form D to Cold Outreach: Automating Fresh-Funded Lead Generation

If you sell anything to startups — observability, payroll, infrastructure, sales tools, fractional services — fresh-funded companies are the highest-converting cold-outbound cohort you'll ever target. The conversion-rate math is well-documented internally at most B2B SaaS companies and roughly consistent across categories: a company within 60 days of closing a Series A or B converts at 4-7x the rate of a comparable un-funded company.

The intuitive reason: fresh capital creates short-window buying intent. Founders who just raised $5M have an 18-month runway and a hiring + tooling list to burn through; they're actively evaluating vendors. The window closes within ~6 months as the capital becomes routine. Hit them in week 2 post-raise and you're in their early evaluation set; hit them in week 30 and they've already standardized on your competitor.

The problem most outbound teams have isn't knowing this — it's operationalizing it. By the time a round hits Crunchbase Pro or Owler or Apollo's funded-companies filter, the high-intent window is half over. Your competitors have already sequenced these accounts.

The fix is direct ingestion of SEC Form D filings into your outbound workflow, with a 24-72 hour latency from the actual filing. This post is the playbook.

Why Form D Beats Crunchbase For This Workflow

Crunchbase's funded-companies data has roughly an 11-day median lag from the actual round closing. For a tool whose competitive advantage is "be the first vendor to email the new VP Engineering," 11 days is fatal — that's 35% of your high-intent window already burned.

SEC Form D is the legal record of the round. Companies have 15 days to file post-first-sale. EDGAR makes filings searchable within 24-72 hours of submission. Net latency from "money changed hands" to "in your CRM" is typically 7-14 days — half of Crunchbase's lag.

Form D also has a data point Crunchbase doesn't: the Related Persons list. Every Form D filing names executive officers, directors, and (often) the lead investor's representative. That's exactly the contact list you want to outbound — and it's hyper-fresh because the same names had to be on the filing.

The Pipeline

The architecture has four stages:

1. Ingest — pull recent Form D filings from EDGAR
2. Enrich — match the issuer to a domain (Form D doesn't disclose websites)
3. Score — apply ICP filters (round size, industry, geography)
4. Sequence — push qualifying accounts into your outbound tool

Stage 1: Ingest

EDGAR's full-text search index is at efts.sec.gov/LATEST/search-index. Filter by forms=D and a date range. This returns 80-200 results per business day for US filings.

import httpx
from datetime import date, timedelta

HEADERS = {"User-Agent": "your-name [e-mail]"}

async def fetch_recent_form_d(days_back: int = 1) -> list[dict]:
    today = date.today()
    start = today - timedelta(days=days_back)
    params = {
        "q": "",
        "dateRange": "custom",
        "startdt": start.isoformat(),
        "enddt": today.isoformat(),
        "forms": "D",
    }
    async with httpx.AsyncClient(headers=HEADERS, timeout=30) as client:
        r = await client.get("https://efts.sec.gov/LATEST/search-index", params=params)
        r.raise_for_status()
        return r.json().get("hits", {}).get("hits", [])

For each hit, pull the actual XML filing to get the round amount and Related Persons list:

async def fetch_filing_details(cik: str, accession: str) -> dict:
    accession_clean = accession.replace("-", "")
    url = f"https://www.sec.gov/Archives/edgar/data/{cik}/{accession_clean}/primary_doc.xml"
    async with httpx.AsyncClient(headers=HEADERS) as client:
        r = await client.get(url)
        # parse XML for offeringData.totalAmountSold and relatedPersonsList
        return parse_form_d_xml(r.text)

Be polite. EDGAR enforces a 10-requests-per-second rate limit. Add a 0.15s sleep between requests; back off exponentially on any 429.

Stage 2: Enrich (Form D → Domain)

Form D doesn't include the company website. The most reliable enrichment path:

1. Search the company name + city on Bing (Google's results are spammier)
2. Pick the top result that matches [company name].com or has the company name as the title
3. Fall back to LinkedIn search for the executive officer named in Related Persons

A pragmatic shortcut: if the issuer has a Delaware C-corp filing, the registered agent often points to the formation service (Stripe Atlas, Carta, Clerky), and the formation service often hosts a redirect to the company's website. This isn't always the case but it's free signal.

For high-volume operations, the NexGenData Lead List Enricher actor handles this enrichment step at scale — feed in company names, get back domain + tech stack + employee estimates.

Stage 3: Score

Filter the daily Form D batch by your ICP:

def is_icp(filing: dict, config: dict) -> bool:
    amount = filing["totalAmountSold"]
    if not (config["min_round"] <= amount <= config["max_round"]):
        return False

    # Industry: SEC EDGAR lacks industry tags. Either enrich via the company
    # website (HTTP headers, robots.txt patterns), or use the company's SIC
    # code from the registration filing (slow, but free).

    if config["us_only"] and filing["issuer_state"] not in US_STATES:
        return False

    # Optional: filter by exec-officer count (proxy for team size at filing time)
    if filing["related_persons_count"] < config["min_team_size"]:
        return False

    return True

Typical ICP filters for a B2B SaaS outbound team:

• Round size: $2M-$50M (Series A through Series B sweet spot)
• US-incorporated (Delaware or California — easier deliverability)
• Industry inferred from website (filter for tech/SaaS, exclude crypto/cannabis)
• Team size 5-200 (small enough to be evaluating tools, big enough to have buying authority)

A typical day produces 80-150 Form D filings; ICP filtering retains 15-25.

Stage 4: Sequence

The last step is pushing qualifying accounts into your outbound tool. Apollo, Outreach, Salesloft, and HubSpot all have CRUD APIs for adding contacts and triggering sequences. The pseudocode:

async def push_to_apollo(filing: dict, sequence_id: str):
    contacts = filing["related_persons"]  # list of names + titles
    domain = filing["enriched_domain"]

    for person in contacts:
        # Apollo's API auto-enriches the person if you provide first/last/domain
        contact = await apollo.create_contact(
            first_name=person["first_name"],
            last_name=person["last_name"],
            organization=domain,
            title=person["title"],
        )
        await apollo.add_to_sequence(contact["id"], sequence_id)

Personalization tip: the cold email's first line should reference the round itself. "Saw [Company] just raised $4M — congrats. You're probably evaluating [vendor category] right now; here's why teams in your stage tend to choose us..." has 2-3x the reply rate of generic outbound.

Costs

The pipeline is essentially free if you build it yourself: SEC EDGAR has no API fees, and the compute footprint is small (under $5/month). The cost is engineering time — typically 3-5 days of an SDR-tooling engineer's time to build, plus ongoing maintenance as Apollo/Outreach APIs change.

If you'd rather buy than build, the NexGenData Startup Funding Tracker actor handles stages 1 and 2 (ingest + enrich) at $0.01/record. Stages 3 and 4 are usually 50-100 lines of Python tying the actor's output into your CRM. Total monthly cost for a typical SDR team running 30 enriched filings/day is roughly $30-40.

What This Replaces

Most outbound teams rely on one of three paid sources for fresh-funded lead generation: Crunchbase Pro ($588/seat/month), Apollo's Funding Filter ($199/month/seat plus their core platform fee), or a custom feed from Cobalt/Clay/Smartlead ($500-2000/month).

A Form-D-direct pipeline replaces all of these for one specific use case (US-only, post-Series-A): same data, 11 days faster, 90%+ cost reduction. It does not replace Crunchbase/Apollo for international rounds, debt rounds, or pre-Form-D signals — for those you still need a paid source or a different pipeline (covered in pre-seed sourcing post).

The Math On Why This Wins

A typical fresh-funded company sees 30-60 cold outbound emails in week 1 post-Crunchbase listing. That number drops to 5-10/week by week 8. The Crunchbase-derived outbound traffic is a saturated, low-conversion channel.

Hitting the same companies 7-10 days earlier (Form D direct) puts you in week 1 of inbox saturation, when the founder is still reading every cold email because the round is fresh news. Same email, 4x the reply rate.

That's the whole game.

---

NexGenData publishes 195+ actors for B2B sales workflows: SEC filings, lead enrichment, company data, contact discovery, and competitive intelligence. All pay-per-result.