Build a List of Funded Startups That Are Hiring on Wellfound

Sales teams, recruiters and startup scouts all want the same list: startups that have raised money and are hiring right now. The hiring says they are growing, and the funding says there is budget. Wellfound puts both on every job, but a job board is organized by job, not by company. The same startup turns up three times in one search, and its funding sits on a separate page from the listing.

Try it live: Wellfound Jobs Scraper: Startup Salary, Equity and Funding. Pay per result delivered. Failed and empty results are never charged.

The Wellfound Jobs Scraper reads each job’s page for the startup’s website and funding, so one run of a few role lists becomes a company list once you collapse the rows by company_id.

What you get and who it is for

Field	What it holds
company_id	Wellfound’s startup id, the key to dedupe on
company_name, company_website, company_url	Who they are, their own site and their Wellfound page
company_size, company_stage	Employee band and Wellfound’s stage label
funding_total, funding_rounds	Total raised and the number of rounds
funding_last_round, funding_last_round_date, funding_last_round_amount	The latest round, as Wellfound shows it
yc_funded, top_investors	Two badges Wellfound sets on the profile
title, primary_role, posted_at	What they are hiring for, and since when

This is for SDRs who sell to startups (a company hiring engineers is a company buying developer tools), agency recruiters looking for clients, investors tracking who is scaling, and vendors building a territory list.

The input

{
  "roles": ["software engineer", "account executive"],
  "locations": ["new york", "san francisco", "austin"],
  "includeCompanyDetails": true,
  "maxJobsPerSearch": 100
}

• includeCompanyDetails is the switch this job depends on. The website, industries, company type and every funding field come from each job’s own page. With it off, rows still carry size, stage and badges, but no funding and no website.
• roles should match what you sell. Engineering roles point at companies building product, and account executive points at companies scaling a sales team.
• locations multiplies the roles: two roles in three cities is six searches. Use city names the way Wellfound lists them.
• maxJobsPerSearch counts jobs, not companies. Wellfound lists 20 startups a page with up to three of their jobs each, so 100 jobs means far fewer companies: our 100-job run came from 54 startups.

What the output looks like

[
  {
    "company_id": "8824130",
    "company_name": "PermitFlow",
    "company_website": "https://www.permitflow.com",
    "company_url": "https://wellfound.com/company/permitflow",
    "company_size": "51-200",
    "company_stage": "Growth Stage",
    "yc_funded": true,
    "top_investors": true,
    "funding_total": "$90.5M",
    "funding_rounds": 3,
    "funding_last_round": "Series B",
    "funding_last_round_date": "Dec 2025",
    "funding_last_round_amount": "$54000000"
  },
  {
    "company_id": "78720",
    "company_name": "Gusto",
    "company_website": "https://www.gusto.com/",
    "company_size": "501-1000",
    "company_stage": "Scale Stage",
    "yc_funded": true,
    "funding_total": "$276.1M",
    "funding_rounds": 5,
    "funding_last_round": "Series C",
    "funding_last_round_date": "Jul 2018",
    "funding_last_round_amount": "$140000000"
  },
  {
    "company_id": "71791",
    "company_name": "Countly",
    "company_website": "https://countly.com",
    "company_size": "11-50",
    "company_stage": "Early Stage",
    "funding_total": "Undisclosed amount",
    "funding_rounds": 1,
    "funding_last_round": "Seed",
    "funding_last_round_date": "Jun 2013",
    "funding_last_round_amount": "Undisclosed amount"
  }
]

These rows come from our run of Wellfound’s remote software engineer list on October 7, 2026, trimmed to the company fields. That run returned 100 jobs from 54 startups: 27 had one job in it, 8 had two and 19 had three. All 54 had a website, 31 had a funding round on Wellfound, 23 had none, and 5 of the 31 showed Undisclosed amount for the total.

Read the dates with care. Of the 31 last rounds, 29 were dated 2023 or earlier, and the oldest was Countly’s seed round in June 2013. Only PermitFlow (December 2025) and Confident LIMS (December 2024) were recent. The field is what Wellfound shows, which is whatever the startup entered; a company may well have raised since without updating its profile. One profile in the same run listed a total of $120K next to a Series A. Use the funding fields to sort and filter, and check the latest round against company funding and investor records before you quote it to anyone.

Run it in Apify Console

1. Open https://apify.com/themineworks/wellfound-jobs-scraper and click Try for free.
2. In Roles or keywords, enter one role per line.
3. In Cities, enter one city per line, or leave it empty to search everywhere.
4. Leave Include company and job page details ticked.
5. Set Max jobs per search, then click Start and watch the Output tab.
6. Click Export and choose CSV, JSON or Excel. The export has one row per job; the script below folds it into one row per company.

Run it from Python

pip install apify-client

import csv
from datetime import datetime
from pathlib import Path
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("themineworks/wellfound-jobs-scraper").call(run_input={
    "roles": ["software engineer", "account executive"],
    "locations": ["new york", "san francisco", "austin"],
    "includeCompanyDetails": True,
    "maxJobsPerSearch": 100,
})

companies = {}
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("record_type") != "job":
        continue  # free status rows, such as an unknown city
    cid = item["company_id"]
    if cid not in companies:
        companies[cid] = {k: item.get(k) for k in (
            "company_id", "company_name", "company_website", "company_url",
            "company_size", "company_stage", "yc_funded", "top_investors",
            "funding_total", "funding_rounds", "funding_last_round",
            "funding_last_round_date", "funding_last_round_amount")}
        companies[cid]["open_jobs"] = 0
        companies[cid]["job_titles"] = []
    companies[cid]["open_jobs"] += 1
    companies[cid]["job_titles"].append(item.get("title", ""))

def round_year(text):
    try:
        return datetime.strptime(text, "%b %Y").year
    except (TypeError, ValueError):
        return None

seen_path = Path("seen_company_ids.txt")
seen = set(seen_path.read_text().split()) if seen_path.exists() else set()

rows = []
for c in companies.values():
    if not c["funding_last_round"]:
        continue  # no funding on Wellfound
    c["last_round_year"] = round_year(c["funding_last_round_date"])
    c["job_titles"] = "; ".join(c["job_titles"][:5])
    c["new_this_run"] = c["company_id"] not in seen
    rows.append(c)

rows.sort(key=lambda c: c["last_round_year"] or 0, reverse=True)
if rows:
    with open("funded_startups_hiring.csv", "w", newline="", encoding="utf-8") as f:
        writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
        writer.writeheader()
        writer.writerows(rows)

seen_path.write_text("\n".join(sorted(seen | set(companies))))
new = sum(1 for c in rows if c["new_this_run"])
print(f"{len(companies)} companies, {len(rows)} with a funding round, {new} new since last run")

The CSV is sorted by the year of the last round, so the most recently funded startups come first, with the number of open jobs and up to five titles next to each. The new_this_run column marks companies the script has not seen in an earlier run.

Run it every week

Save the input as a task in Apify Console, open Schedules, create a schedule with a cron expression such as 0 7 * * 1 (Mondays at 07:00) and add the task. The actor has no only-new option, so keep the list of company_id values you have already worked, as the script does, and pass on only the new ones.

Send each run’s dataset to a Google Sheet with Apify’s Google Sheets integration, push new companies into a CRM through Make, Zapier or n8n, or have a webhook call your endpoint when the run finishes.

What it costs

Billing is per job delivered, not per company: $2.09 per 1,000 jobs on the Bronze plan, $1.79 on Silver, and $1.49 on Gold, Platinum and Diamond, plus a flat $0.005 start fee per run. Company details cost nothing extra.

Our 100-job run cost about $0.21 on Bronze plus $0.005, and gave 54 companies, 31 of them with a funding round: under one cent per funded company. The weekly input above is six searches of up to 100 jobs, so at most 600 jobs a run and 2,400 a month, about $5.02 on Bronze plus $0.02 in start fees. A job found by two searches in one run is charged once, and jobs Wellfound has taken down are dropped without a charge.

Limits worth knowing

• Funding is self-reported and often old. 29 of the 31 last-round dates in our run were from 2023 or earlier. The field tells you what Wellfound shows, not what happened since.
• Many startups have no funding block. 23 of 54 companies in our run had none, and some show Undisclosed amount.
• No investor names and no contacts. You get badges, totals and the latest round, plus the company website, but no investors, founders or emails.
• Some jobs have been open a long time. Check posted_at: one Gusto job in our run had been live since March 22, 2025. A reposted job shows its repost time.
• Coverage follows Wellfound’s lists. A role or city Wellfound does not know returns a free status row, and a startup that does not post on Wellfound will not appear at all.

Related

• Compare Startup Salary and Equity Ranges by Role on Wellfound
• B2B Lead Generation Tools Compared
• Sourcing Without a Recruiter Seat
• Wellfound Jobs Scraper