DEV Community: Michalis Solomou

Five SEC Form D Filings This Week, Worth $984M Combined

Michalis Solomou — Fri, 07 Aug 2026 13:21:39 +0000

Five companies filed SEC Form D paperwork this week — public record, days to weeks before any funding announcement hits the press.

Company	Industry	Raised	Score
Integrated Biosciences	Biotech	$68.4M	98
Jasper Therapeutics	Biotech	$132.0M	98
Oxide Computer Co	Hardware/Infra	$445.0M	97
Mariana Minerals	Energy	$310.5M	93
Proactive AI Lab	AI	$28.3M	93

Total: ~$984M in newly-raised capital, all public before the press release.

Why this matters if you sell B2B

A company that just raised has two things it didn't have last month: cash and a mandate to spend it. New hires, new tools, new vendors — the buying window is widest in the weeks right after a raise, before the funding news is even public.

Form D filings go public on SEC EDGAR the moment they're filed — legally, for free, no scraping required. Almost nobody checks them manually, because the raw filings are unstructured and unscored.

We built Funding Signals to do that automatically: poll EDGAR daily, filter out amendments and investment funds, and score what's left 0-100 on "likely to buy soon" — company, industry, funding amount, resolved domain.

Free API key, no card required, 1,500 calls/month on the free tier.

Five SEC Form D filings this week, worth $1.8B combined — here's what's public and free

Michalis Solomou — Thu, 06 Aug 2026 15:40:38 +0000

This week five companies quietly filed SEC Form D notices — the public record every company has to file within 15 days of closing a private funding round. None of these have hit TechCrunch yet.

Groq — $672.2M
DriveNets — $410.25M
Antares Nuclear — $320M
Sila Nanotechnologies — $309.6M
General Fusion — $107.7M

That's $1.8B combined, sitting in EDGAR right now, free for anyone to read.

Why this matters if you sell B2B

A funding round is one of the strongest buying-intent signals that exists — new budget, new headcount, new tools to evaluate. Sales and marketing teams already know this, which is why "funding alerts" are a whole category of paid tools. What most people don't realize is that the underlying data (SEC Form D) is public and free, and it's available before the press release, not after.

By the time a raise is on TechCrunch, every vendor in the space has already sent a cold email. The Form D filing itself is the earlier signal.

What I built

Funding Signals pulls new Form D filings from EDGAR, scores them (dedupes funds/amendments, filters noise), and enriches the real ones with company domain + contacts. Free tier, no card required.

Happy to answer questions about how the EDGAR full-text search / filing pipeline works if anyone's curious — it's a fun, messy dataset.

Four SEC Form D filings this week, worth $753M combined — here's why that matters for B2B sales

Michalis Solomou — Tue, 04 Aug 2026 13:38:36 +0000

This week alone, four companies filed SEC Form D notices totaling $753M: Emerald AI ($90.2M), Core Automation ($432.1M), ThreatLocker ($189.2M), and Valoros ($31.4M).

Most sales and marketing teams never see these. Form D filings are public, factual, and filed days-to-weeks before a funding round hits TechCrunch or a company's own press release — which means the budget signal is available before your competitors are even looking for it.

Why this matters for outbound:

A funded company has fresh budget and a mandate to spend it (headcount, tools, vendors).
Form D data is free and public — no scraping paywalled news sites.
Timing beats targeting: reaching out in the first two weeks after a raise gets a materially different response than six months later.

We built Funding Signals to turn raw EDGAR filings into a scored, enriched lead feed — company, industry, amount, and contact-ready enrichment, updated as filings land: https://fundingsignals.net/?utm_source=devto&utm_medium=article

Free tier available if you want to see this week's list for your own niche.

This week in Form D filings: $427M+ across 3 raises, pulled with a Python one-liner

Michalis Solomou — Mon, 03 Aug 2026 19:43:29 +0000

Three SEC Form D filings crossed my scored feed this week: Sila Nanotechnologies ($309.6M), Core Automation ($432.1M), and Invoq Health ($58.8M). All public record days to weeks before any of it hits tech press.

Here's the whole pull, no auth required for the sample endpoint:

import httpx

r = httpx.get("https://fundingsignals.net/v1/sample")
for company in r.json():
    print(f"{company['company_name']} — ${company['amount_usd']:,} ({company['industry']})")

That's it. No scraping, no API key for the sample. The full feed (paginated, scored 0-100, enriched with domain + contacts) needs a free key.

Why this matters for anyone doing outbound: a funding round is one of the most reliable "budget just got approved" signals that exists, and it's public information — SEC EDGAR publishes Form D within 15 days of the first sale of securities. Most tools infer buying intent from indirect signals (hiring, tech stack changes). This one is just... the filing.

fundingsignals.net/?utm_source=devto&utm_medium=post

How to Track SEC Form D Filings in Real Time

Michalis Solomou — Sun, 02 Aug 2026 09:05:16 +0000

If you sell to startups — SaaS tools, recruiting, PR, dev shops, anything B2B — the moment a company raises funding is one of the best buying-intent signals you'll ever get. Fresh budget, new headcount plans, a founder actively looking for vendors. The problem is that funding announcements (TechCrunch, press releases) lag the actual event by days or weeks.

The underlying event is public before the press writes about it: a Form D filing with the SEC. Here's how to pull it yourself.

What is a Form D?

Form D is the filing a company makes with the SEC when it raises money in a private offering (the overwhelming majority of VC/angel rounds in the US). It's short, structured, and — unlike an 8-K or 10-K — filed within 15 days of the first sale of securities, often well before any public announcement. It includes:

Company name, address, and industry (primarySICCode)
Amount raised (totalOfferingAmount)
Date of first sale
Related persons (executives, sometimes directors)

All of it is public, free, and structured XML.

Where the data lives

SEC EDGAR exposes two useful surfaces:

Full-text search API — https://efts.sec.gov/LATEST/search-index?q=...&forms=D lets you query recent Form D filings.
The daily/quarterly index files — https://www.sec.gov/Archives/edgar/full-index/ list every filing by date, which you can filter to form.idx entries starting with D.
Per-filing XML — each Form D filing has a primary_doc.xml with the structured data above, at a predictable URL once you have the accession number.

A minimal polling script

import requests
import time

HEADERS = {"User-Agent": "YourCompany research@yourcompany.com"}  # SEC requires this

def get_recent_form_d(days_back=1):
    url = "https://www.sec.gov/cgi-bin/browse-edgar"
    params = {
        "action": "getcompany",
        "type": "D",
        "dateb": "",
        "owner": "include",
        "count": "100",
        "output": "atom",
    }
    resp = requests.get(url, params=params, headers=HEADERS)
    resp.raise_for_status()
    return resp.text  # parse the Atom feed for entries

def poll_loop():
    while True:
        feed = get_recent_form_d()
        # parse feed, diff against last-seen accession numbers, fetch primary_doc.xml
        # for each new filing, extract company name / amount / industry
        time.sleep(60 * 15)  # SEC rate limit: stay well under 10 req/sec, this is generous

The full-text search endpoint (efts.sec.gov) is faster to filter by form type and date range if you want something closer to real time than the daily index files, which only update once EDGAR finishes processing the day's batch.

Things that bite people building this

Rate limits. SEC asks for a descriptive User-Agent header and caps you around 10 requests/second — polling every filing individually will get you blocked fast. Batch via the index files where you can.
Amount parsing. totalOfferingAmount is sometimes "Indefinite" — handle it, don't crash your parser on it.
Deduplication. Companies amend Form D filings (Form D/A). Decide up front whether you want the latest amendment or the original filing as your "signal" — they can have meaningfully different amounts.
Industry codes. SIC codes are coarse and sometimes wrong/generic ("Other Technology" when the company is clearly biotech, for example) — don't rely on them alone if you need clean industry categorization.
No contact info. Form D gives you the company and sometimes executive names — it does not give you emails or phone numbers. That's a separate enrichment step, and one worth doing carefully — see the compliance note below.

A note on compliance

Form D is public record, so scraping it is fine. Be careful with what you build on top of it: don't scrape personal emails, don't skip an unsubscribe/opt-out mechanism if you're sending outreach off this signal, and keep enrichment to company-level data (domain, generic role emails) rather than harvesting personal information you don't have a lawful basis to hold.

If you'd rather not build the pipeline

I built exactly this — a daily-updating feed of companies that just filed a Form D (plus funding-news signals), scored 0–100 as sales leads, with company domain and generic contact emails attached. Free tier, no card required: fundingsignals.net

But if you just need the raw filings for your own pipeline, everything above is enough to get you a working poller in an afternoon.

I built a free API that turns SEC Form D filings into scored B2B leads

Michalis Solomou — Sun, 26 Jul 2026 09:59:45 +0000

The problem

If you do B2B outbound, a company that just raised funding is one of the warmest leads you can get -- fresh budget, actively evaluating vendors. The catch: press coverage of a raise typically lags the actual event by days or weeks, so by the time it's on TechCrunch or Crunchbase, other people have already reached out.

What I built

Funding Signals is a small API that watches the SEC's daily EDGAR Form D index directly -- the raw regulatory filing, not the press release. Every new filing gets:

Scored 0-100 based on size, recency, and industry
Enriched with the company's domain and a contact email
Made available same-day (paid) or with a short delay (free tier)

Try it

No card required for the free tier: fundingsignals.net

Feedback wanted

Genuinely curious from other devs/founders here: is "reach them right after they raise" a signal you'd actually use for prospecting, or is it weaker than good firmographic/intent data? Would love to hear how you currently find fresh leads.

SEC Form D as a free, factual "buying intent" signal for B2B

Michalis Solomou — Sat, 25 Jul 2026 13:16:56 +0000

Most "intent data" in B2B sales is inferred: web visits, job-post scraping, hiring signals. Useful, but noisy — you're guessing at a company's internal state from the outside.

SEC Form D filings are different. Any US company raising a private round (equity, debt, or fund interests) has to file one with the SEC — and it becomes public days to weeks before the funding gets a press release or a TechCrunch writeup. It's not an inference, it's a legal fact, and it's free to read on EDGAR.

The catch: EDGAR's full-text search is built for compliance people, not for a sales team trying to build a Monday-morning target list. Raw filings mix in real operating companies with investment funds, SPVs, and amendments that aren't real "someone just got money" events.

So I built a small pipeline that:

pulls new Form D filings + funding-news RSS daily
filters out funds/SPVs/amendments (the noise)
scores what's left 0-100 on "how sales-ready is this raise"
optionally enriches with company domain, industry, and generic contact emails

It ships as a plain REST API with a free tier (delayed signals, no card required) and a small dashboard to browse the freshest raises without writing any code: https://fundingsignals.net

Also just added: a free embeddable JS widget (one script tag → live "recently funded" list for VC blogs/directories) and permanent monthly archive pages for anyone who wants the historical data without hitting the API.

Curious if anyone else here is using public filings (Form D, 10-K/10-Q 8-Ks, etc.) as a signal source instead of the usual scraped/inferred stuff — what have you built with it?

Two ES module script tags, same src, only one runs: a debugging story

Michalis Solomou — Sat, 25 Jul 2026 06:50:37 +0000

I migrated a landing page to a new domain and left the old analytics beacon tag in place "temporarily," alongside the new one. Two <script type="module" src="https://static.cloudflareinsights.com/beacon.min.js"> tags, identical src, different data-cf-beacon token attribute.

Traffic on the new domain's analytics property stayed at exactly zero for days. Not low — zero.

Here's the part that isn't obvious: browsers deduplicate ES module fetches by URL, per document. A type="module" script isn't like a classic <script> tag that each instance executes independently — the module graph is built once per unique specifier and cached. Two tags, same src, means one fetch and one execution, using whichever tag's attributes got resolved first.

So the second tag's token was never read. All the traffic was still being recorded — just under the OLD analytics property, silently.

// how I actually found it — not by staring at the dashboard,
// but by checking what fired
performance.getEntriesByType('resource')
  .filter(r => r.name.includes('cloudflareinsights'))
// only ONE beacon.min.js entry, despite two script tags

The fix was deleting the stale tag. The lesson was: a metric reading exactly zero for longer than plausible is a signal to check the instrumentation, not just the dashboard.

I ran into this building fundingsignals.net (a small API for SEC funding-filing data) — happy to go deeper on the module-dedup behavior if useful to anyone else debugging analytics gaps.

This week in Form D filings: 3 raises, pulled with 4 lines of Python

Michalis Solomou — Thu, 23 Jul 2026 19:44:08 +0000

A quick one — this week's fresh Form D filings, pulled straight from the public sample endpoint (no API key needed):

import requests
r = requests.get("https://fundingsignals.net/v1/sample?limit=3")
for c in r.json():
    print(c["company_name"], c["amount_usd"], c["score"])

Output today:

Venice AI — $65,030,636 — score 99
GT Medical Technologies — $50,056,676 — score 97
Qolab — $44,147,466 — score 92

No scraping, no auth wall for the sample. The full feed (with domain + contact enrichment) needs a free key: fundingsignals.net/docs

Curious what other devs are building on top of Form D data — link your projects below.

I Built a Free Tool to Search Any Company's SEC Form D Funding History

Michalis Solomou — Sat, 18 Jul 2026 11:55:43 +0000

A few weeks ago I wrote about Form D filings as a funding-data source. The most common question I got back was some version of "cool, but does it cover [my specific company]?"

So I shipped a small search tool that answers that directly.

What it does

funding-signals-api.onrender.com/lookup — type a company name, get every matching Form D filing in the free-tier window: raise size, industry, and a 0-100 lead score. No signup, no API key, just a search box.

How it's built

It reuses the same public teaser query the /this-week and /industry/{slug} pages already use — a case-insensitive LIKE match on company_name, filtered through the same free-tier freshness delay so the public page never leaks real-time data:

@app.get("/lookup", include_in_schema=False)
def lookup(q: str | None = Query(None), conn=Depends(get_conn)) -> HTMLResponse:
    term = (q or "").strip()
    rows = _public_teaser_rows(
        conn, " AND lower(company_name) LIKE ?", (f"%{term.lower()}%",), limit=25
    ) if term else []
    ...

_public_teaser_rows pulls a top-500-by-score candidate pool first, then filters by parsed filing date in Python — the underlying filed_at column mixes YYYYMMDD (EDGAR) and RFC-822 (RSS-sourced) date formats, so a raw SQL string comparison on dates would silently sort wrong. Same pattern as everywhere else this API does date filtering.

Why bother with a search box instead of just the API

Most people evaluating a data API don't want to read docs first — they want to type one company name they actually care about and see if it's there. A search box answers "is this any good" in five seconds; a Swagger page doesn't.

Free tier, no card: docs.

Form D Filings: The Funding Data TechCrunch Misses

Michalis Solomou — Fri, 17 Jul 2026 20:45:23 +0000

Ask most developers where funding data comes from and they'll say "Crunchbase" or "TechCrunch." Neither is actually the source — they're both downstream of a much less glamorous document: the SEC Form D.

This is a technical walkthrough of what a Form D filing actually contains, why most of them never become a press release, and how to pull the raw structured data yourself in Python.

What Form D actually is

Form D is a notice private companies file with the SEC within 15 days of the first sale of securities in an exempt offering — most commonly a Regulation D private placement. It exists so the SEC has a record of who's raising private capital without going through a full public registration.

It's a legal filing, not a marketing document. Companies file it because they have to, not because they want press. That's exactly why it's a better data source than funding news: it doesn't depend on anyone deciding the round is newsworthy.

Where to actually find it

SEC EDGAR publishes every filing at sec.gov/cgi-bin/browse-edgar and a daily full-text index. A raw Form D filing is XML, and looks roughly like this (trimmed):

<edgarSubmission>
  <primaryIssuer>
    <entityName>Acme Robotics, Inc.</entityName>
    <jurisdictionOfInc>DE</jurisdictionOfInc>
  </primaryIssuer>
  <offeringData>
    <industryGroup>
      <industryGroupType>Technology</industryGroupType>
    </industryGroup>
    <offeringSalesAmounts>
      <totalAmountSold>12000000</totalAmountSold>
    </offeringSalesAmounts>
    <typeOfFiling>
      <newOrAmendment>New Notice</newOrAmendment>
    </typeOfFiling>
  </offeringData>
</edgarSubmission>

The fields that matter for lead-scoring purposes:

entityName — the legal company name (not always the brand name — "Acme Robotics, Inc." vs. the product name "AcmeBot")
industryGroupType — SEC's own classification, a controlled vocabulary (~30 categories)
totalAmountSold — how much was actually raised in this offering
newOrAmendment — "New Notice" vs. "D/A" (amendment) — this distinction matters more than it looks, see below

The two things that make raw Form D data noisy

If you pull the raw daily index and expect a clean list of "companies that just raised," you'll hit two problems immediately.

1. Amendments look like new filings. A company files an initial Form D, then amends it weeks or months later as the offering progresses (more investors close, the total changes). Each amendment is its own filing in the index. Naively counting filings roughly triples your apparent "new raises" — most of what you're counting is the same round being updated, not a new one.

2. A large fraction of filings aren't operating companies at all. VC funds, hedge funds, and special-purpose vehicles (SPVs) file Form D too — they're also raising private capital, just from their own LPs, not customers with a product budget. SEC's own industryGroupType catches some of these (there's a literal "Pooled Investment Fund" category), but plenty get filed under "Investing" or even "Other" instead. A more reliable tell, if you want to build this filter yourself: fund/SPV legal names very often combine an investment-vehicle noun (Fund, Partners, Capital, Ventures) with a roman-numeral vintage (II, III) — a pattern real operating companies essentially never have. "Acme Ventures III, LP" is a fund. "Acme Robotics, Inc." is not.

Pulling it with Python

The full daily index is public and free — no API key needed to fetch it:

import requests

# SEC requires a descriptive User-Agent identifying your app/contact —
# generic or missing UAs get blocked.
headers = {"User-Agent": "YourApp research@yourdomain.com"}resp = requests.get(
    "https://www.sec.gov/cgi-bin/browse-edgar",
    params={"action": "getcompany", "type": "D", "dateb": "", "owner": "include", "count": 40},
    headers=headers,
)

In practice you'll want the daily full-text index rather than scraping the browse UI — it's more reliable for a scheduled job. Either way, once you have a batch of filings you still need to: parse the XML, drop amendments, filter funds/SPVs by industry + name pattern, and turn totalAmountSold + filing recency into something you can actually rank leads by.

Skipping the parsing

That pipeline (fetch → parse → dedupe → fund-filter → score) is exactly what Funding Signals does — it runs daily and exposes the result as a scored REST endpoint:

import requests

resp = requests.get("https://funding-signals-api.onrender.com/v1/sample?limit=5")
for company in resp.json():
    print(f"{company['score']:>3}  {company['company_name']:<28} "
          f"${company['amount_usd']:,}  ({company['industry']})")

No XML parsing, no amendment/fund filtering to write yourself — same underlying SEC data, already cleaned up. Free tier, no card required: docs.

Why this matters more than "another funding API"

The reason Form D is worth building on directly, instead of just consuming a funding-news aggregator: most Form D filings never get press coverage at all. Smaller rounds, non-VC-backed companies, and anything outside the SF/NY startup press cycle mostly go unreported. If your data only comes from funding news, you're seeing a minority of actual raises — and competing with everyone else reading the same newsletter for the ones you do see.

Reading the primary filing means seeing the raise the day (or days) it becomes public record, whether or not anyone ever writes about it.

Build a Slack Bot That Pings You the Moment a Prospect Raises Funding

Michalis Solomou — Fri, 17 Jul 2026 20:41:15 +0000

The first thing most SDRs do with a funding alert is... nothing, because it
lands in an email digest three weeks after the fact and 40 other companies
in that digest already got pitched by five other vendors.

This is a ~40 line Python script that checks for new funding signals every
morning and posts the ones that match your ICP straight into a Slack
channel — so the "just raised money" alert actually arrives while it's
still useful.

What you need

A free Funding Signals API key (self-serve, no card).
A Slack Incoming Webhook URL for the channel you want alerts in (Slack → your workspace → Apps → search "Incoming Webhooks" → Add to Slack → pick a channel → copy the webhook URL).
requests installed (pip install requests).

The script

import requests
import os

FS_API_KEY = os.environ["FUNDING_SIGNALS_KEY"]
SLACK_WEBHOOK = os.environ["SLACK_WEBHOOK_URL"]

# tune this to your ICP
PARAMS = {
    "min_score": 80,
    "min_raise": 3_000_000,
    "industry": "technology",
    "has_contact": "true",
    "limit": 10,
}

def fetch_signals():
    resp = requests.get(
        "https://funding-signals-api.onrender.com/v1/signals",
        headers={"X-API-Key": FS_API_KEY},
        params=PARAMS,
    )
    resp.raise_for_status()
    return resp.json()

def post_to_slack(signal):
    text = (
        f"*{signal['company_name']}* just raised "
        f"${signal['amount_usd']:,} ({signal['industry']}) — score "
        f"{signal['score']}/100\n"
        f"<https://funding-signals-api.onrender.com/v1/signals/{signal['id']}/lead"
        f"?utm_source=slackbot|View enriched lead>"
    )
    requests.post(SLACK_WEBHOOK, json={"text": text})

def main():
    for signal in fetch_signals():
        post_to_slack(signal)

if __name__ == "__main__":
    main()

Set the two environment variables and run it once to sanity-check the
output, then point it at a scheduler.

Making it run daily

Simplest option: a GitHub Actions workflow in the same repo as the script
(no server to babysit).

# .github/workflows/funding-alerts.yml
name: funding-alerts
on:
  schedule:
    - cron: "0 13 * * 1-5"  # 9am ET, weekdays
  workflow_dispatch: {}

jobs:
  alert:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4      - uses: actions/setup-python@v5        with:
          python-version: "3.12"
      - run: pip install requests
      - run: python alert.py
        env:
          FUNDING_SIGNALS_KEY: ${{ secrets.FUNDING_SIGNALS_KEY }}
          SLACK_WEBHOOK_URL: ${{ secrets.SLACK_WEBHOOK_URL }}

Add the two secrets in the repo's Settings → Secrets → Actions, and that's
the whole pipeline: SEC filing → scored signal → Slack message, with no
server and no cron box to maintain.

Avoiding duplicate alerts

The API doesn't track what you've already seen, so on a fresh run every
signal in the current window will post again. Cheapest fix: keep a small
JSON file of seen IDs, commit it back after each run.

import json
from pathlib import Path

SEEN_FILE = Path("seen_ids.json")

def load_seen():
    if SEEN_FILE.exists():
        return set(json.loads(SEEN_FILE.read_text()))
    return set()

def save_seen(ids):
    SEEN_FILE.write_text(json.dumps(sorted(ids)))

def main():
    seen = load_seen()
    signals = fetch_signals()
    new = [s for s in signals if s["id"] not in seen]
    for signal in new:
        post_to_slack(signal)
    save_seen(seen | {s["id"] for s in new})

If you're running this in GitHub Actions, add a commit-and-push step at the
end of the job so seen_ids.json persists between runs.

Where to take it from here

Same pattern works for a Discord webhook, a CRM sync (dump straight into
HubSpot/Airtable instead of Slack), or per-rep channels filtered by
industry. The API call is the same either way — only post_to_slack
changes.

Docs: funding-signals-api.onrender.com/docs

Prefer no code at all? Grab the free lead tracker template instead.