Wellfound Scraper — Startup Jobs, Salary, Equity & Funding

Wellfound (AngelList) Scraper — Startup Jobs, Salary, Equity & Funding Signals

Scrape startup job listings from Wellfound — formerly AngelList Talent — at scale, with no login and no coding required. This Wellfound scraper extracts complete, structured career opportunities from any role category: job title, parsed salary min/max, equity percentage min/max, remote policy, accepted locations, and experience requirements — joined directly to the hiring startup's employee headcount, stage, valuation, and investor funding signals (YC Funded, Top Investors, Growing Fast, Actively Hiring, B2B).

Export everything to JSON, CSV, Excel, XML, or API.

Built for tech recruiters, talent sourcers, VC intelligence analysts, startup job seekers, and B2B SDR teams targeting high-growth venture-backed companies.

---

⚡ At a glance

Feature	Description
Data Source	Wellfound (formerly AngelList Talent) — the world's premier startup hiring marketplace
Search Modes	Role slugs (roles), direct role URLs (startUrls), and remote-only filtering (remoteOnly)
Output Formats	JSON, CSV, Excel (XLSX), XML, HTML table
Key Job Fields	Job title, role category, compensation string, salaryMin, salaryMax, equityMin, equityMax, remote configuration, locations, description, ATS source
Startup Intelligence	Company name, employee size, tagline, stage (Early/Growth/Scale), valuation tier, YC Funded badge, Top Investors badge
Speed & Scale	Pure HTTP Next.js Apollo cache parsing with rotating datacenter proxy sessions; collects 35–40 jobs per page, scaling to 1,000+ records

---

🔎 Why scrape Wellfound?

Wellfound is the primary hiring network for early-stage and venture-backed tech startups worldwide. Unlike legacy job boards such as LinkedIn, Indeed, or Monster, Wellfound listings feature structured equity compensation, explicit remote geographic policies, and verified company funding tiers.

However, Wellfound restricts bulk data exports and paginates listings behind dynamic client-side rendering. Manually copying salary ranges, equity splits, and funding badges across hundreds of engineering, product, or sales openings is time-consuming and difficult to automate. This Wellfound scraper bypasses UI friction by parsing the underlying Apollo state, returning structured rows ready for immediate analysis.

Common use cases for Wellfound scraping:

• 💰 Compensation Benchmarking: Analyze tech salary bands and equity stakes across funding stages (Seed, Series A, Growth) and job roles.
• 🦄 VC & Talent Intelligence: Track hiring velocity and talent migration across Y Combinator cohorts and top-tier venture portfolio companies.
• 🧑‍💻 Technical Recruiting & Sourcing: Generate targeted candidate pipelines matching specific role titles, experience requirements, and remote policies.
• 🎯 B2B Lead Generation: Identify high-growth startups that are actively hiring and recently funded for SaaS and developer tooling sales.
• 📊 Hiring Market Trends: Monitor demand surges in artificial intelligence, machine learning, data engineering, and product design.

---

✨ Key scraper capabilities

• 🔎 Flexible Role Targeting: Input standard role handles (software-engineer, data-scientist, product-manager, product-designer, marketing, devops, sales-development-representative).
• 🔗 Direct URL Ingestion: Paste specific Wellfound search URLs directly into startUrls to capture custom role combinations.
• 🔁 Unlocked Deep Pagination (1,000+ items): Automatically cycles through sequential page indexes (?page=1, ?page=2, …). Setting maxPagesPerSearch: 0 allows extraction up to your target maxItems.
• 💵 Parsed Numeric Compensation: Automatically converts raw compensation strings (e.g. $120k – $160k • 0.1% – 0.5%) into clean numeric fields (salaryMin, salaryMax, equityMin, equityMax).
• 🏠 Remote Policy Identification: Flags whether roles are fully remote, hybrid, or on-site, capturing accepted remote countries and cities.
• 🏢 Integrated Company Funding Signals: Joins each job to its hiring startup, attaching metadata including company stage, valuation, and investor pedigree.
• ⚡ Pure HTTP Execution: Lightweight and resource-efficient, operating reliably over standard Apify Datacenter proxies.

---

📥 Input parameters

Field	Type	Default	Description
roles	Array	["software-engineer"]	Role slugs to scrape (e.g. ["software-engineer", "data-scientist", "product-manager"]).
startUrls	Array	[]	Optional direct Wellfound role URLs (e.g. https://wellfound.com/role/r/data-scientist).
remoteOnly	Boolean	false	When true, only positions verified as remote are returned.
maxItems	Integer	0	Overall maximum number of jobs to collect across all roles. 0 = unlimited.
maxPagesPerSearch	Integer	0	Number of result pages per role (~38 jobs/page). 0 = auto/unlimited (governed by maxItems).
proxyConfiguration	Object	Datacenter	Apify Proxy Datacenter is enabled by default for fast, cost-effective runs.

Example input — engineering and data roles

{
  "roles": ["software-engineer", "data-scientist"],
  "remoteOnly": true,
  "maxItems": 250,
  "maxPagesPerSearch": 0,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}

Example input — product & design roles

{
  "roles": ["product-manager", "product-designer"],
  "remoteOnly": false,
  "maxItems": 150,
  "maxPagesPerSearch": 0
}

---

📊 Extracted fields

Every scraped job listing produces structured fields across 4 main domains:

💼 Job specifications & compensation

Field	Type	Coverage	Description
id	String	🟢 High	Unique Wellfound listing identifier (de-duplication key)
url	String	🟢 High	Canonical job listing URL
title	String	🟢 High	Full job title (e.g. Senior Full-Stack Engineer)
roleTitle	String	🟢 High	Normalized primary role category
compensation	String	🟡 Conditional	Raw compensation summary string as displayed on the site
salaryMin	Number	🟡 Conditional	Minimum annual salary in USD
salaryMax	Number	🟡 Conditional	Maximum annual salary in USD
equityMin	Number	🟡 Conditional	Minimum equity grant percentage (e.g. 0.1 for 0.1%)
equityMax	Number	🟡 Conditional	Maximum equity grant percentage (e.g. 0.5 for 0.5%)
jobType	String	🟢 High	Employment type (e.g. Full Time, Contract, Internship)

🌍 Remote configuration & requirements

Field	Type	Coverage	Description
remote	Boolean	🟢 High	Whether the position supports remote work
remoteKind	String	🟡 Conditional	Specific policy (REMOTE, ONSITE, ONSITE_OR_REMOTE)
remoteLocations	Array	🟡 Conditional	List of accepted geographic locations for remote staff
locations	Array	🟢 High	Physical company office locations or regional hubs
yearsExperienceMin	Number	🟡 Conditional	Minimum required professional experience in years
yearsExperienceMax	Number	🟡 Conditional	Maximum required professional experience in years
atsSource	String	🟡 Conditional	External applicant tracking system (Ashby, Greenhouse, Lever)
postedAt	String	🟢 High	ISO 8601 publication timestamp
description	String	🟢 High	Full job description text converted from HTML

🏢 Hiring company intelligence

Field	Type	Coverage	Description
company.id	String	🟢 High	Unique Wellfound startup identifier
company.name	String	🟢 High	Official startup or company name
company.slug	String	🟢 High	URL handle for company profile
company.url	String	🟢 High	Direct link to company profile page on Wellfound
company.size	String	🟢 High	Headcount band (e.g. 11-50, 51-200, 500+)
company.highConcept	String	🟢 High	Company elevator pitch / tagline
company.logoUrl	String	🟢 High	Direct URL to company logo graphic

🦄 Startup funding & investor badges

Field	Type	Coverage	Description
company.stage	String	🟡 Conditional	Funding maturity stage (Early, Growth, Scale, Public)
company.valuation	String	🟡 Conditional	Company valuation tier ($500M+, $1B+)
company.ycFunded	Boolean	🟢 High	Whether the company graduated from Y Combinator
company.topInvestors	Boolean	🟢 High	Backed by tier-one venture capital firms
company.growingFast	Boolean	🟢 High	Flagged by Wellfound as rapidly growing headcount
company.activelyHiring	Boolean	🟢 High	Flagged as actively hiring across multiple departments
company.b2b	Boolean	🟢 High	Verified B2B business model

---

💻 Sample output record

{
  "id": "2918234",
  "url": "https://wellfound.com/jobs/2918234",
  "title": "Senior Backend Engineer (Distributed Systems)",
  "roleTitle": "Software Engineer",
  "compensation": "$150k – $190k • 0.1% – 0.25%",
  "salaryMin": 150000,
  "salaryMax": 190000,
  "equityMin": 0.1,
  "equityMax": 0.25,
  "jobType": "Full Time",
  "remote": true,
  "remoteKind": "REMOTE",
  "remoteLocations": ["United States", "Canada"],
  "locations": ["San Francisco", "New York City"],
  "yearsExperienceMin": 4,
  "yearsExperienceMax": 8,
  "description": "We are looking for a Senior Backend Engineer to scale our core distributed event processing engine...",
  "postedAt": "2026-11-08T14:22:00.000Z",
  "atsSource": "Ashby",
  "company": {
    "id": "847291",
    "name": "HyperScale AI",
    "slug": "hyperscale-ai",
    "url": "https://wellfound.com/company/hyperscale-ai",
    "size": "11-50",
    "highConcept": "Real-time vector inference infrastructure for generative models",
    "logoUrl": "https://photos.wellfound.com/startups/i/847291-abc123_logo.png",
    "stage": "Growth",
    "valuation": "$500M+",
    "ycFunded": true,
    "topInvestors": true,
    "growingFast": true,
    "activelyHiring": true,
    "b2b": true
  },
  "searchRole": "software-engineer",
  "scrapedAt": "2026-11-10T13:00:00.000Z"
}

---

🔁 Deep pagination & scale

Wellfound lists between 35 and 40 jobs per page.

• 1,000+ Items Pagination: Setting maxPagesPerSearch: 0 removes per-role page caps. The scraper paginates continuously until your maxItems target is reached or all available jobs for the role are harvested.
• Deduplication: Jobs are tracked in memory by unique id, guaranteeing zero duplicate records across overlapping role searches.
• Polite Network Handling: Employs subtle request jitter and rotating proxy sessions to respect target platform infrastructure.

---

⚙️ How to integrate via API

Trigger runs and consume startup job feeds directly in Python or Node.js:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run_input = {
    "roles": ["software-engineer"],
    "remoteOnly": True,
    "maxItems": 100,
    "maxPagesPerSearch": 0
}
run = client.actor("haketa/wellfound-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    company = item.get("company", {})
    print(f"{item['title']} @ {company.get('name')} | Salary: ${item.get('salaryMin')}-${item.get('salaryMax')} | YC: {company.get('ycFunded')}")

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('haketa/wellfound-scraper').call({
    roles: ['product-manager', 'data-scientist'],
    maxItems: 150,
    maxPagesPerSearch: 0,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Successfully scraped ${items.length} startup jobs.`);

---

🏢 VC talent mapping & portfolio monitoring

Venture capital talent partners and investment teams use this scraper to track hiring velocity and organizational growth across their own portfolio companies and rival syndicates:

• Growth Velocity Scoring: Track monthly job posting volume by startup slug (company.slug). A sudden 3× spike in engineering and go-to-market roles typically indicates a fresh funding round or product breakout.
• Stage Progression Audits: Compare employee size bands (company.size) against active hiring targets to detect inflection points where startups transition from Seed to Growth stage.
• Competitor Syndicate Monitoring: Filter on company.topInvestors: true and company.ycFunded: true to identify competitive investments made by peer venture firms before PR announcements.

---

🧭 Popular role slugs directory

Wellfound organizes job listings into standard URL slugs. You can supply any of these directly to the roles input:

Functional Area	Role Slug	Common Sub-Disciplines Included
Software Engineering	software-engineer	Full-stack, backend, frontend, systems, distributed systems
Frontend Development	frontend-engineer	React, Vue, Next.js, TypeScript, UI architecture
Backend Development	backend-engineer	Python, Go, Node.js, Java, microservices, cloud
Data & AI / ML	data-scientist	Machine learning, LLM fine-tuning, computer vision, NLP
Data Engineering	data-engineer	ETL pipelines, Snowflake, dbt, Spark, vector stores
DevOps & Infrastructure	devops	Kubernetes, AWS, Terraform, CI/CD, site reliability
Product Management	product-manager	Technical PM, growth PM, enterprise B2B PM
Product Design	product-designer	UI/UX design, design systems, user research
Sales & Growth	sales-development-representative	SDR, outbound sales, account executive
Marketing	marketing	Growth marketing, product marketing, content, SEO
Operations & Finance	operations	BizOps, Chief of Staff, strategy, financial analysis

---

📈 Equity valuation modeling & analysis

One of the unique strengths of Wellfound data is pairing equity percentages with startup valuation badges:

• Early-Stage Valuation Estimate: A 0.25% equity grant at an Early stage startup ($10M-$20M post-money) represents an unvested paper value of approximately $25,000–$50,000.
• Growth-Stage Valuation Estimate: A 0.05% equity grant at a $500M+ valuation startup represents $250,000+ in potential asset value.

You can calculate estimated equity grant value directly in Python:

def estimate_equity_value(equity_pct, valuation_str):
    if not equity_pct or not valuation_str:
        return None
    val_map = {
        "$500M+": 500_000_000,
        "$1B+": 1_000_000_000,
        "$2B+": 2_000_000_000,
        "$5B+": 5_000_000_000
    }
    val = val_map.get(valuation_str)
    if val:
        return (equity_pct / 100.0) * val
    return None

---

💡 Practical sourcing & recruiting tips

• YC & Tier-One Backing: Filter dataset exports on company.ycFunded: true or company.topInvestors: true to identify candidates at pedigree venture-backed firms.
• Compensation Analysis: Group by company.size or company.stage to benchmark how cash and equity compensation scale from Seed to Series C.
• ATS Identification: Leverage atsSource to direct candidate referrals through appropriate applicant tracking systems (e.g. Greenhouse, Ashby, Lever).

---

❓ Frequently Asked Questions

Do I need a Wellfound account or recruiter subscription? No. The scraper gathers publicly viewable startup jobs without requiring personal credentials or paid recruiter accounts.

Why do some listings lack salary or equity figures? In certain jurisdictions, publishing exact salary ranges is not legally mandatory, and some startups omit compensation figures from initial listings. All available figures are parsed into numeric fields.

Can I filter only for remote positions? Yes. Enabling remoteOnly: true automatically filters out on-site-only positions, delivering exclusively remote-friendly opportunities.

What proxy settings are recommended? Standard Apify Datacenter proxies are enabled by default and perform reliably. Switch to Residential (US) only if specific IP-level blocks are encountered.

What is the value of the atsSource field? Many venture-backed startups host their official job postings on dedicated Applicant Tracking Systems (e.g. Ashby, Greenhouse, Lever). When atsSource is populated, candidates and recruiting agencies can locate the direct ATS application link, bypassing marketplace application queues.

Can I filter listings by years of experience? Yes. You can filter the returned dataset using yearsExperienceMin and yearsExperienceMax to isolate entry-level, mid-level, or staff/lead engineering roles.

How do I export Wellfound jobs to Google Sheets or Notion? From the Apify platform Dataset tab, select Export and choose Google Sheets or JSON. You can also configure automated synchronization via Apify's native Google Sheets integration.

How often should I run the scraper to capture new startup jobs? Startups typically post new openings throughout the business week. We recommend scheduling a daily run in the morning to capture newly created roles and funding badge updates.

Can I run this actor from within my own Python or Node.js microservice? Yes. You can use the official apify-client package in Python or JavaScript to trigger jobs asynchronously or synchronously, streaming the results directly into memory or your internal data pipelines.

Does this scraper support webhook notifications? Yes. You can attach Apify Webhooks to trigger on SUCCEEDED events, notifying your Slack channel, Discord, or downstream server endpoint immediately when new jobs are harvested.

---

🔗 Related hiring scrapers

• Seek Scraper — Australian & Asia-Pacific job market listings.
• H1B Visa Database Scraper — US visa sponsorship and salary records.
• ZipRecruiter Scraper — US job postings and salary ranges.
• Workana Scraper — Freelance projects and tech talent directory.

---

📋 Changelog

v1.2 — 2026-11

• Unlocked 1,000+ Deep Pagination: Updated maxPagesPerSearch default to 0 (auto/unlimited), enabling deep pagination runs up to 1,000+ jobs governed by maxItems.
• Enhanced Compensation Normalizer: Improved regex parsing for varied international compensation formats and equity splits.
• Optimized Prefill Execution: Fine-tuned initial role extraction for fast prefill runs (<45s).
• Apollo Cache Join Refinement: Strengthened mapping between JobListingSearchResult and StartupResult objects.

v1.1 — 2026-09

• Initial public release featuring pure-HTTP Apollo cache extraction.
• Automatic extraction of company funding signals (YC Funded, Top Investors, Stage, Valuation).
• Support for role slugs and Start URLs with deduplication.