Wellfound Jobs Scraper Guide: Extracting AngelList Startup Data

Direct Answer: How to Extract Wellfound Job Listings

To extract public startup job postings from Wellfound, you can run the Wellfound (AngelList) Jobs Scraper. The actor operates HTTP-only and requires no user login credentials or cookie setup. By providing standard target URLs such as https://wellfound.com/jobs or filtered parameter strings into the startUrls input array, the actor fetches raw HTML using curl_cffi configured with a Chrome TLS fingerprint. It parses the Apollo Client cache stored inside the NEXT_DATA script block to extract structured JSON data for each listing. For protected endpoints like deep-filter URLs (/role/l//), the actor automatically routes requests through an Apify RESIDENTIAL US proxy pool, handling edge security checks without requiring manual proxy configuration.

Key Technical Factors Before Executing Your First Run

Before launching an extraction run against Wellfound, plan your query strategy and feed scope to collect relevant records while staying within platform constraints.

Target URLs and parameter strings: Wellfound's primary feed accepts base paths alongside search query parameters such as ?remote=true. If your goal is to extract specific categories or locations, collect these URLs before configuring the input payload.
Post-fetch client filtering: The actor includes built-in filters to refine collected items. Decide whether to filter records by job title, location, general keywords, remote flags, employment type, or minimum and maximum salary thresholds.
Compensation data handling: Determine whether listings lacking explicit salary details should be kept or removed. By default, the actor retains listings without salary data, but you can configure it to exclude un-salaried positions if downstream applications require compensation metrics.
Dataset volume limits: The standard /jobs feed serves a single landing page with approximately 47 listings and does not provide client-side pagination. To retrieve larger volumes, supply multiple targeted startUrls rather than relying on a single feed URL.

Practical use cases

Use case 1: Build a focused startup-job watchlist

Outcome: A compact list of current opportunities that satisfy a job seeker's non-negotiable constraints.

Question to answer: Which listings match the target role, location, remote preference, employment type, and compensation requirements closely enough to review?

Configure: Start with targeted startUrls, then apply jobTitle, location, remoteOnly, jobType, and a small maxItems value. Use minSalary, maxSalary, and includeNoSalary only when compensation is part of the actual acceptance rule.

Working method: Separate hard constraints from preferences before collecting records. Reject clear mismatches first, place incomplete listings in a research-needed group, and compare similar roles instead of ranking unrelated titles together. Preserve jobUrl so every decision remains traceable.

Deliverable: Produce an opportunity watchlist grouped into strong fit, possible fit, and missing-information review, with a short reason beside every classification.

Stop condition: Pause when critical constraints are unavailable, titles are being used as a substitute for full job detail, or stale and current listings cannot be distinguished.

Use case 2: Compare startup hiring demand by segment

Outcome: A comparison of visible hiring activity across defined role, location, or company-category cohorts.

Question to answer: Which comparable segments show different mixes of roles, remote options, locations, or stated compensation?

Configure: Create a controlled set of startUrls and apply one cohort definition at a time using keyword, location, companyCategories, or includeCompanies. Keep sort and maxItems consistent across cohorts.

Working method: Define cohorts before collection, deduplicate overlapping results by jobId, and preserve missing compensation rather than converting it to zero. Compare record composition and coverage before calculating summaries, and keep non-comparable cohorts out of the same ranking.

Deliverable: Create a hiring-market matrix containing cohort definitions, listing counts, role and location mix, compensation coverage, and notable exceptions that need interpretation.

Stop condition: Stop when cohort inputs overlap heavily, one cohort has materially different coverage, or missing values drive the apparent comparison.

Use case 3: Track additions and removals at target startups

Outcome: A dated change log for a bounded list of companies or search configurations.

Question to answer: Which listings appeared, changed, or disappeared since the previous collection, and which differences warrant attention?

Configure: Keep includeCompanies, excludeCompanies, startUrls, filters, and maxItems stable between runs. Select newest sorting when recent ordering helps review, but do not treat ordering alone as proof that a listing is new.

Working method: Store each dated collection, match records using jobId, and classify them as new, still present, changed, or no longer returned. Treat a missing record as uncertain until input scope and collection completeness are confirmed.

Deliverable: Produce a hiring-change digest with company, title, job URL, observed status, relevant fields, and the previous collection used for comparison.

Stop condition: Pause when the input scope changed, the source feed returned unexpectedly few records, or a collection failure could be mistaken for widespread job removal.

Step-by-Step Workflow for a Controlled First Extraction

Running an initial extraction in a controlled environment allows you to verify schema compatibility, observe proxy escalation logic, and confirm filter accuracy before executing large-scale runs.

Define target URLs in the input configuration: Start with a small, predictable set of URLs. Enter https://wellfound.com/jobs inside the startUrls input list.
Set a low maxItems threshold: Set the maxItems parameter to 5 for your initial validation run. This guarantees rapid execution and avoids unnecessary compute usage during output verification.
Apply initial filter criteria: If you want to test specific matching rules, configure parameters such as remoteOnly: true or enter a target string inside jobTitle.
Execute the extraction run: Start the actor using the Apify Console or API client.
Inspect output records: Check the generated dataset to verify fields such as jobId, title, companyName, compensation, locations, and scrapedAt.
Scale input volume: After verifying schema field alignment, adjust maxItems up to the maximum limit of 500 and expand your array of startUrls to cover additional locations or roles.

Documented Input Configuration Options

The actor accepts a defined set of input parameters according to its input schema:

startUrls: Array of Wellfound URLs to process. The default value is https://wellfound.com/jobs. Accepts standard query strings such as ?remote=true, location paths, and custom search filters. Deep-filter URLs matching /role/l/ are automatically escalated to residential proxies.
jobTitle: String value representing a client-side filter. Retains only jobs whose title contains the specified substring (case-insensitive).
keyword: String value for client-side filtering across job title, company name, and location fields simultaneously (case-insensitive).
location: String value representing a client-side location filter. Matches any location name string on a case-insensitive basis.
remoteOnly: Boolean flag. When set to true, filters results to remote-only listings and appends ?remote=true to default URLs. Default is false.
jobType: Enum selection to filter by employment type based on job metadata or description matching. Supported values are any, full-time, part-time, contract, and internship. Default is any.
experience: Enum selection to filter by experience level based on job title or description keywords. Supported values are any, junior, mid, senior, and executive. Default is any.
minSalary: Integer value specifying minimum annual compensation in USD per year, parsed from the job compensation field. Minimum is 0, maximum is 1000000, and default is 0.
maxSalary: Integer value specifying maximum annual compensation in USD per year. A value of 0 indicates no upper salary limit. Minimum is 0, maximum is 1000000, and default is 0.
includeNoSalary: Boolean flag controlling compensation filtering. When set to false, job postings without a compensation field are filtered out. Default is true.
companyCategories: Array of company category strings (for example, 'saas' or 'fintech'). Filters startups using case-insensitive substring matching on startup name or slug.
includeCompanies: Allow-list array of company names or slugs (case-insensitive).
excludeCompanies: Block-list array of company names or slugs (case-insensitive).
sort: Enum selection ordering records by posted date when available. Options are newest (Newest First), oldest (Oldest First), and none (As Returned). Default is none.
maxItems: Integer specifying the maximum number of job records returned after filtering. Minimum is 1, default is 50, prefill is 5, and maximum hard cap is 500.

Documented Dataset Output Fields

Each record output to the Apify dataset contains standard key-value pairs per job listing:

type: Entity descriptor string.
jobId: Unique identifier string for the job listing.
title: Title of the open position.
slug: URL slug string associated with the job listing.
jobUrl: Full web link pointing to the individual job posting page.
compensation: Stated compensation details string or parsed representation.
remote: Boolean flag indicating whether the position is remote.
locations: List or array of geographic location strings tied to the posting.
companyId: Unique platform identifier for the hiring startup.
companyName: Display name of the startup.
companySlug: URL identifier string for the startup profile.
companyUrl: Direct link to the startup platform profile.
companyLogo: Image URL pointing to the startup logo asset.
postedAt: Date string or timestamp indicating when the job was posted (when available).
scrapedAt: ISO timestamp recording when the item was extracted.

How Next.js and Apollo Cache Parsing Function

Wellfound builds its /jobs landing feed as a Next.js web application. When a client requests a page, the server embeds an Apollo Client cache state directly inside the page HTML within a NEXT_DATA script block.

Rather than instantiating headless browsers that consume high memory resources, the actor issues lightweight HTTP calls using curl_cffi with a Chrome TLS fingerprint. Upon receiving the HTML response, the scraper extracts the JSON payload from NEXT_DATA and navigates the Apollo Client object graph. Within this graph, up to approximately 47 JobListing entries and their connected Startup entities are parsed per page request.

When deep-filter URLs (/role/l//) are supplied, Wellfound applies DataDome security protection. The actor detects these protected routes and automatically routes requests through Apify RESIDENTIAL US proxy IPs, ensuring consistent access without requiring manual proxy configuration.

Operational Limitations and Rate Boundaries

To build stable downstream pipelines, take into account these documented operational limitations:

Single page feed constraints: The primary /jobs feed serves a single page with approximately 47 listings and lacks client-side pagination. To extract broader datasets, you must supply multiple startUrls covering different search filters or locations.
Item cap enforcement: The maxItems parameter enforces a hard upper cap of 500 items per execution run.
Deep page detail isolation: Summary records extracted from the landing feed contain core metadata including job ID, title, company, compensation, remote status, and location. Comprehensive job details such as full text job descriptions, listed skill requirements, and employee benefits reside on individual job pages (/jobs/-). These individual detail pages are protected by DataDome and may require fallback to the residential proxy pool.

Practical Quality Checklist for Pipeline Engineers

Follow these practices to ensure consistent data quality and operational reliability in production environment setups:

Validate salary thresholds: If your data ingestion pipeline requires guaranteed financial data, set includeNoSalary to false and set explicit minSalary or maxSalary values.
Verify residential proxy access: Ensure your Apify account has active residential proxy permissions when targeting deep-filter URLs (/role/l/), as these endpoints rely on automatic proxy escalation.
Deduplicate by job identifier: Because different startUrls or search filters can yield overlapping company listings, index records downstream by jobId to maintain dataset uniqueness.
Monitor extraction timestamps: Rely on the scrapedAt field to track data freshness, as postedAt metadata is included only when available on the source feed.
Test text matching filters: Evaluate jobTitle, location, and keyword filters on sample runs to verify case-insensitive substring matching rules without accidentally dropping valid target listings.

Frequently Asked Questions

Do I need cookies or a login to run the scraper?

No. The Wellfound (AngelList) Jobs Scraper operates HTTP-only and extracts public job listings without requiring user account credentials or session cookies.

Do I need to configure a proxy manually?

No. Residential proxy routing is hardcoded specifically for URLs that require it (such as deep-filter routes), while standard page requests are executed directly.

Why does the number of returned listings differ from maxItems?

The standard /jobs feed returns a single page with around 47 listings. If maxItems is set higher than the available listings on the provided URLs, or if client-side filters (such as jobTitle or minSalary) exclude non-matching listings, the final dataset count reflects only the matching results.

How are deep job descriptions extracted?

The landing feed cache contains summary fields such as job ID, position title, company info, compensation, remote flag, and locations. Detailed job descriptions, required skills, and specific benefits are hosted on individual /jobs/- pages, which are DataDome-protected and require individual detail page fetches.

What happens when includeNoSalary is set to false?

When includeNoSalary is configured to false, any job posting that lacks a compensation field is filtered out of the final dataset output.

What is the maximum number of items the scraper can return in one run?

The actor enforces a maximum hard cap of 500 items per execution run, with a default maxItems setting of 50.

Resources

Wellfound (AngelList) Jobs Scraper Actor Page: Official actor page on the Apify platform for configuration and execution.