# Wellfound Jobs Scraper — Salary, Stage, Investors & Ratings (`scrapersdelight/wellfound-jobs-scraper`) Actor

Scrape Wellfound (AngelList) startup jobs by role, location or URL. Each row carries salary min/max, equity, remote policy, ATS source and the full description, plus the startup's size, stage, YC / top-investor / recently-funded flags and Glassdoor rating. Detail mode adds funding raised and geo.

- **URL**: https://apify.com/scrapersdelight/wellfound-jobs-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 per job returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Wellfound (AngelList) Jobs Scraper

Startup jobs from [Wellfound](https://wellfound.com) — formerly AngelList Talent — as **one row per
job with the hiring startup already joined onto it**: salary and equity ranges as numbers, the
company's size and stage, its YC / top-investor / recently-funded badges, its Glassdoor rating, and
optionally the **funding it has raised** and the **startup's own website domain**.

The incumbent Wellfound actors ship about seven fields (job id, title, compensation string, remote
flag, location, company name, company logo). This one ships **69 fields with no extra requests**,
and **107 with detail enrichment on**.

***

### What you get

One record per job posting. Every number below is **measured from real runs on the Apify platform
on 2026-09-03**, not estimated — the run ids are in the fill tables.

```json
{
  "jobId": "4579450",
  "title": "Software Engineer",
  "jobUrl": "https://wellfound.com/jobs/4579450-software-engineer",
  "jobType": "full-time",
  "compensation": "$110k – $200k",
  "salaryMin": 110000,
  "salaryMax": 200000,
  "salaryCurrency": "USD",
  "salaryPeriod": "YEAR",
  "salarySource": "detail-jsonld",
  "equityText": "0.1% – 0.5%",
  "equityMin": 0.1,
  "equityMax": 0.5,
  "locationNames": ["Santa Clara"],
  "remote": true,
  "acceptedRemoteLocationNames": ["United States"],
  "postedAt": "2026-08-12T16:29:14.000Z",
  "postedDaysAgo": 21,
  "atsSource": "AtsIntegration::Greenhouse::Listing",
  "atsVendor": "Greenhouse",
  "yearsExperienceMin": 5,
  "description": "Join us in pioneering the next generation of nuclear reactors! …",

  "companyName": "Oklo",
  "companySlug": "oklo",
  "companySize": "201-500",
  "companyHighConcept": "Making reactors people want",
  "companyStage": "growth_stage",
  "companyStageLabel": "Growth Stage",
  "businessModel": "B2B",
  "isYcFunded": true,
  "hasTopInvestors": true,
  "isRecentlyFunded": false,
  "isGrowingFast": true,
  "isActivelyHiring": true,
  "glassdoorRating": 4.2,

  "companyWebsiteUrl": "https://www.oklo.com",
  "companyTotalRaisedText": "$333.2M",
  "companyTotalRaisedUsd": 333200000,
  "companyFundingRoundsCount": 5,
  "companyLatestRoundName": "Series G",
  "companyLatestRoundDate": "May 2019",
  "companyLatestRoundAmountUsd": 123000000,
  "visaSponsorship": "Not Available",
  "relocation": "Not Allowed",
  "jobLat": 37.3541,
  "jobLon": -121.955,

  "searchTotalJobCount": 4964,
  "searchPageCount": 90,
  "sourceUrl": "https://wellfound.com/role/software-engineer",
  "page": 1
}
```

#### The four fields worth the price on their own

1. **`salaryMin` / `salaryMax` as integers.** Wellfound prints `"$170k – $200k • 0.2% – 0.4%"`. That
   string is parsed into salary numbers **and** an equity range — including `€`, `₹` (lakh/crore) and
   `Up to $170k` forms — so you can sort and filter without writing a parser.
2. **`companyWebsiteUrl`** — the startup's **own domain** (`https://www.oklo.com`), not a
   wellfound.com URL. That is the join key to your CRM, an enrichment API, or a domain-based
   email-pattern finder. 100% filled on the 60-row detail run.
3. **`companyTotalRaisedUsd` + `companyLatestRoundName` + `companyLatestRoundDate`.** Real funding
   numbers, from the job page itself.
4. **`glassdoorRating`, `leadershipRating`, `workLifeBalanceRating`** — cross-site employer quality,
   already on the row.

***

### Input

| Field | What it does |
| --- | --- |
| `roles` | Wellfound role slugs, e.g. `software-engineer`, `product-manager`, `data-scientist` |
| `locations` | Location slugs, e.g. `san-francisco`, `new-york`, `austin`. Crossed with `roles` |
| `remoteOnly` | Use the remote-only landing page (`/role/r/<slug>`) for role-only searches |
| `startUrls` | Paste Wellfound landing-page URLs directly. `?page=` is stripped; pagination is handled |
| `maxItems` | Stop after this many **unique** jobs. Default 200 |
| `maxPagesPerSeed` | Depth cap per seed. 20 jobs/page. 0 = crawl to the seed's own last page |
| `fetchJobDetails` | Adds one request per job for funding, geo, benefits, visa, structured salary |
| `detailConcurrency` | Parallel detail requests (default 5) |
| `includeDescription` | The full markdown job description ships by default at no extra request |
| `postedWithinDays` · `minSalary` · `onlyWithSalary` | Freshness and pay filters |
| `remoteFilter` · `companyStage` · `onlyRecentlyFunded` · `onlyYcFunded` | Row filters on the company signals |
| `proxyConfiguration` | **RESIDENTIAL + US by default.** See "Proxies" below — this one matters |

Role slug sizes measured live on 2026-09-02: `software-engineer` 4,964 jobs · `product-manager`
4,434 · `sales-manager` 2,849 · `operations-manager` 2,527 · `account-manager` 1,830 · `data-analyst`
1,022 · `product-designer` 754 · `hr-manager` 455 · `growth-marketer` 301 · `financial-analyst` 299 ·
`ui-ux-designer` 290 · `graphic-designer` 189. Location slugs work the same way (`san-francisco`
alone: 2,955 jobs). Every row also carries `searchTotalJobCount` and `searchPageCount`, so the first
run tells you exactly how big the next one can be.

***

### Measured output — the default path (no detail requests)

Run `Zweeuazw4l6X0nHMa`, 2026-09-03: `product-manager` × `san-francisco`, **150 rows across 4 pages
in 9 seconds**, 5 requests, 0 blocks, 11 cross-page duplicates removed before billing. 69 fields per
row, **41 of them 100% filled**.

| Field | Fill |
| --- | --- |
| `jobId` `title` `jobSlug` `jobUrl` `primaryRoleTitle` `jobType` `employmentType` | **100%** |
| `remote` `liveStartAt` `postedAt` `postedDaysAgo` `autoPosted` `description` `descriptionLength` | **100%** |
| `locationNames` `locationsText` | **100%** |
| `companyId` `companyName` `companySlug` `companyUrl` `companySize` `companySizeRaw` `companyLogoUrl` | **100%** |
| `isActivelyHiring` `isGrowingFast` `isRecentlyFunded` `hasTopInvestors` `isYcFunded` `isTopResponder` | **100%** (booleans, always decided) |
| `searchRole` `searchLocation` `searchRemote` `roleDisplayName` `locationDisplayName` `searchTotalJobCount` `searchTotalStartupCount` `searchPageCount` `sourceUrl` `page` `scrapedAt` | **100%** |
| `companyHighConcept` | 99% |
| `badges` (raw array of every company badge) | 98% |
| `compensation` | 85% |
| `salaryMin` `salaryMax` `salaryCurrency` `salarySource` | 84% |
| `companyOtherJobIds` (other open roles at the same startup) | 81% |
| `atsSource` `atsVendor` (Greenhouse / Ashby / Workable / Lever) | 77% |
| `companyStage` `companyStageLabel` | 70% |
| `businessModel` (B2B / B2C / B2B/B2C) | 61% |
| `responseSpeed` (how fast the company replies to applicants) | 26% |
| `remoteKind` `remoteWfhFlexible` | 27% |
| `valuationTier` (`1B+` / `500M+`) | 27% |
| `acceptedRemoteLocationNames` | 25% |
| `equityText` `hasEquity` | 15% |
| `yearsExperienceMin` | 14% |
| `glassdoorRating` | 13% |
| `equityMin` `equityMax` | 11% |
| `leadershipRating` | 9% |
| `workLifeBalanceRating` | 8% |
| `salaryPeriod` | **0% on this path — by design.** The list route prints a range with no period. Detail enrichment fills it |
| `yearsExperienceMax` | **0%.** Wellfound exposes the field and left it empty on all 210 platform rows and 381 offline rows audited |

The badge-derived percentages are **facts about the market, not gaps in the scraper**: only 13% of
these startups have a Glassdoor rating on Wellfound, and only 15% publish equity. Where the signal
exists it is on the row.

### Measured output — with `fetchJobDetails` on

Run `ZGmVf8iMiSrsuMNfi`, 2026-09-03: `software-engineer`, **60 rows, 60/60 detail pages fetched
successfully, 62 requests, 0 blocks, 0 rate limits, 60 seconds**. 107 fields per row, 50 at 100%.

| Detail field | Fill | What it is |
| --- | --- | --- |
| `companyWebsiteUrl` | **100%** | the startup's own domain — the CRM/enrichment join key |
| `datePostedIso` | **100%** | exact ISO timestamp (the list route gives a unix epoch) |
| `employmentTypeNormalized` | **100%** | schema.org `FULL_TIME` / `INTERN` / `CONTRACTOR` |
| `industry` · `companyMarkets[]` | **100%** | "Clean Energy, Renewable Energies, Nuclear Energy" → array |
| `descriptionHtml` · `canonicalUrl` · `directApply` | **100%** | |
| `visaSponsorship` · `relocation` | **100%** | "Not Available" / "Allowed" — the two questions every candidate list needs |
| `companyEmployeesText` | **100%** | "501-1000 Employees" |
| `companyHqLat` `companyHqLon` `companyHqCountry` | 98% | |
| `companyHqRegion` | 97% | |
| `salaryMin` `salaryMax` `salaryCurrency` `salaryPeriod` | 95% | structured integers + `YEAR`, from the JSON-LD |
| `companyHqCity` | 93% | |
| `jobLat` `jobLon` `jobCountry` | 92% | |
| `jobRegion` | 85% | |
| `companyTotalRaisedText` · `companyFundingRoundsCount` · `companyFundingUrl` | 73% | "$333.2M", "5 rounds" |
| `jobBenefits` · `companyPerks[]` | 70% | benefit list with the company's own blurb per perk |
| `companyTotalRaisedUsd` | 67% | 333200000 — parsed integer, null when "Undisclosed amount" |
| `jobCity` | 65% | |
| `companyLatestRoundName` `companyLatestRoundLetter` `companyLatestRoundDate` `companyEarlierRoundsShown` | 65% | "Series G", "G", "May 2019", 4 |
| `postedAgoText` | 62% | "2 weeks ago" |
| `companyLatestRoundAmountUsd` | 58% | 123000000 |
| `recruiterActivity` | 47% | "Recruiter recently active" |
| `hiresRemotelyIn` | 40% | |
| `jobLocationType` | 37% | `TELECOMMUTE` |
| `applicantLocationRequirement` | 28% | |
| `validThrough` | **0%** | schema.org field Wellfound leaves empty; shipped for completeness |

**Funding is a real number, not a badge.** 40 of the 60 rows carried a dollar amount raised
(`$678.5M` Klaviyo, `$492M` YipitData, `$333.2M` Nextdoor, `$85M` Mirage…). The remaining rows are
companies Wellfound shows as "Undisclosed amount" or with no funding card at all — those come back
`null`, never guessed.

***

### Coverage, pagination and duplicates — read this before setting `maxItems`

Wellfound paginates with `?page=N`, 20 jobs per page, and **the page payload reports its own page
count** — which this actor reads, so it stops at the last real page instead of guessing. Past the
end Wellfound *wraps back to page 1* rather than 404ing; the payload echoes the page it actually
served, so the wrap is detected and the seed ends cleanly.

**Contiguous pages overlap.** Measured across the four multi-page platform runs: 45 duplicate job
rows out of 505 raw rows (**8.9%**, per-run 4.8% / 6.8% / 10.3% / 13.8%). Every duplicate is dropped by job id
**before** the row is delivered, so **you are never charged for a job twice** — not within a page,
not across pages, not across seeds in the same run.

Coverage comes from fanning out: `roles` × `locations` builds one seed per pair, `remoteOnly`
switches to the remote-only corpus, and `startUrls` takes any landing page you build in the browser.

***

### Proxies — the honest version

**Datacenter proxies do not work on Wellfound. Residential does.** Measured 2026-09-02 across 12
fresh sessions against one identical URL:

```
Apify BUYPROXIES94952 (datacenter)   3/12 clean   — 75% Cloudflare 403
Apify RESIDENTIAL-US                10/12 clean   — 0 Cloudflare 403s; both misses were
                                                    proxy transport errors, not blocks
```

A three-URL smoke test on datacenter came back 200/200/200 and would have looked fine — and then
failed three quarters of its pages in production. So `RESIDENTIAL` + `US` is the **default** here,
the actor **rotates its proxy session on every block or error** and retries, and the five platform
runs behind this README recorded **0 Cloudflare 403s and 0 rate limits across 106 requests** (2 proxy
transport errors, both recovered by the retry).

Two more things you should know rather than discover:

- **Rate limiting is real on a single IP.** Six concurrent detail fetches from one residential IP
  earned HTTP 429 within seconds. The actor backs off up to 20s on a 429 (not just rotating — a
  rate limit needs time as well as a new IP) and jitters detail requests.
- **A block is never reported as "no results".** If a run cannot read a page, it says so — with the
  request count, the 403 count and the 429 count — and exits cleanly. An empty dataset from this
  actor means the filters matched nothing, and it will say that instead.

***

### Pricing

Pay per event, no platform-usage pass-through, no actor-start fee.

| Event | Price | When |
| --- | --- | --- |
| `job-scraped` | **$0.0015** per job | each unique job delivered to your dataset |
| `job-detail-enriched` | **$0.0008** per job | only when `fetchJobDetails` is on, only on a successful detail fetch |

1,000 jobs with the full company card = **$1.50**. The same 1,000 with funding, geo and structured
salary = **$2.30**. Duplicates are never billed, and rows are delivered with the budget-aware push,
so **delivered always equals billed** — verified on run `D1s2jquAGrcfqUSdd`: 30 dataset items,
`chargedEventCounts` `{job-scraped: 30, job-detail-enriched: 30}`.

***

### Honest limits

- **No recruiter names, emails or phone numbers.** Wellfound does not publish them on these pages
  and this actor does not invent them. What you get is the company's own domain, which is the
  correct input to an email-pattern or enrichment step.
- **`/company/<slug>` is Cloudflare-walled** (403 on home IP, three residential sessions and a
  datacenter session on 2026-09-02), so the company *profile* route is not used. Everything company-
  related here — including funding — comes from the job pages, which are open.
- **Funding is what Wellfound shows on the job page.** Total raised, round count and the latest
  round name/date/amount, at 58-73% fill. Full round-by-round history and investor names live behind
  the walled profile route and are **not** promised here.
- **`salaryPeriod` is only asserted when detail enrichment is on.** The list route prints
  `"₹15,000 – ₹17,000"` and `"$110k – $200k"` in the same slot with no period, so it is left `null`
  rather than guessed. `salarySource` always tells you where a salary number came from.
- **`yearsExperienceMax` and `validThrough` measured 0%.** They exist in Wellfound's own payloads
  and were empty on every row measured. They ship as `null` columns rather than being silently
  dropped.
- **Company signals reflect the market.** 13% Glassdoor rating, 15% equity, 70% stage — those are
  the real fill rates on Wellfound, not scraper misses.
- **`isBookmarked` is deliberately not emitted.** It is viewer-scoped and always `false` for an
  anonymous crawler; shipping it would be a fake column.

### Legal / fair use

`https://wellfound.com/robots.txt` (fetched 2026-09-02, 964 bytes) **allows every route this actor
touches**. Its `Disallow` list is account, embed and form paths:

```
Disallow: /_jobs/          Disallow: /auth/            Disallow: /cdn-cgi/
Disallow: /documents/      Disallow: /embed/           Disallow: /jobs/applications
Disallow: /jobs/signup     Disallow: /onboarding       Disallow: /profile/edit
Disallow: /profile/resume  Disallow: /projects/        Disallow: /re/
Disallow: /recruit/dashboard   Disallow: /search       Disallow: /social/share_modal
Disallow: /u/              Disallow: /*?role=*         Disallow: /*?jobId=*   (query-parameter forms)
```

This actor reads `/role/<slug>`, `/role/r/<slug>`, `/role/l/<role>/<location>`, `/location/<slug>`
and `/jobs/<id>-<slug>` — none of which appear above. Note `Disallow: /*?role=*` is the
**query-parameter** form (`?role=`); the path form `/role/…` is a different URL and is not matched.
`/jobs/applications` and `/jobs/signup` are disallowed and are never touched; individual job pages
`/jobs/<id>-<slug>` are not.

Only public, logged-out pages are read. No login, no cookies from the target site, no CAPTCHA
solving, no personal candidate data. Job postings are employer-published listings. You are
responsible for how you use the output, including under GDPR/CCPA where applicable.

### FAQ

**Do I need a Wellfound account or API key?** No. Everything comes from public pages.

**How many jobs can I get?** The 12 role slugs linked from Wellfound's own footer sum to ~19,900 job
slots, plus 10+ location slugs and role × location combinations. Every row reports
`searchTotalJobCount` for its seed so you can size the next run exactly.

**Is the description included?** Yes — the complete markdown description, on the default path, at no
extra request (100% fill, typically 2-4 KB per job).

**What does `salarySource` mean?** `listing-display` = parsed from Wellfound's displayed range.
`detail-jsonld` = taken from the job page's schema.org `baseSalary`, which is authoritative and
carries the period. Detail enrichment upgrades a row from the first to the second.

**Can I monitor new postings?** Yes — schedule the actor with `postedWithinDays: 1` and a role or
location seed. `postedAt` and `postedDaysAgo` are on every row.

**Why is Wellfound also called AngelList?** Wellfound is the renamed AngelList Talent. Same jobs,
same companies, `wellfound.com` URLs.

# Actor input Schema

## `roles` (type: `array`):

Wellfound role slugs, e.g. `software-engineer`, `product-manager`, `data-scientist`, `sales-manager`, `growth-marketer`. These are the URL segments from wellfound.com/role/<slug>. Live sizes measured 2026-09-02: software-engineer 4,964 jobs · product-manager 4,434 · sales-manager 2,849 · operations-manager 2,527 · account-manager 1,830 · data-analyst 1,022 · product-designer 754 · hr-manager 455 · growth-marketer 301 · financial-analyst 299 · ui-ux-designer 290 · graphic-designer 189. Slugs outside that list work too (`data-scientist`, `frontend-engineer`).

## `locations` (type: `array`):

Wellfound location slugs, e.g. `san-francisco`, `new-york`, `austin`, `boston`, `seattle`, `denver`, `chicago`, `district-of-columbia`, `india`, `united-states`. Combined with the roles above as a cross product: 3 roles x 4 locations = 12 searches. Leave empty to scrape a role across every location.

## `remoteOnly` (type: `boolean`):

Use Wellfound's remote-only landing page (`/role/r/<slug>`) instead of the all-locations one. Applies only when a role is given without a location. The remote route is a smaller corpus — 1,913 remote software-engineer jobs versus 4,964 overall.

## `startUrls` (type: `array`):

Paste Wellfound landing-page URLs directly — `/role/<role>`, `/role/r/<role>`, `/role/l/<role>/<location>` or `/location/<location>`. Use this for combinations the fields above do not build. Any `?page=` is stripped; pagination is handled for you.

## `maxItems` (type: `integer`):

Stop after this many unique jobs across all seeds. Duplicates removed across pages are never counted or charged. 0 = no limit (a single role slug can hold ~5,000 jobs, so set this deliberately).

## `maxPagesPerSeed` (type: `integer`):

Cap how deep each seed is crawled. 20 jobs per page. 0 = crawl to the seed's own last page, which the page payload reports (90 pages for /role/software-engineer, 37 for /location/san-francisco).

## `fetchJobDetails` (type: `boolean`):

Adds one request per job to open its detail page, which carries the startup's FUNDING card (total raised, number of rounds, latest round name/date/amount), the company's own website URL, structured salary min/max with its period, the exact ISO posting date, industry, perks, visa-sponsorship and relocation policy and geo coordinates. Billed as a separate cheaper event. Off by default because it multiplies the request count.

## `detailConcurrency` (type: `integer`):

Parallel detail-page requests. Only used when detail fetching is on. Higher is faster but leans harder on the proxy pool.

## `includeDescription` (type: `boolean`):

Wellfound ships the complete markdown job description on the list route at no extra request — typically 2-4 KB per job. Switch off for a lean dataset.

## `postedWithinDays` (type: `integer`):

Only jobs whose live-start date is inside the last N days. 0 = any age.

## `minSalary` (type: `integer`):

Only jobs whose top-of-range salary is at least this. Compared in the currency Wellfound printed (most listings are USD; some are EUR or INR), so use it on single-currency searches. 0 = no minimum.

## `onlyWithSalary` (type: `boolean`):

Drop listings with no compensation range. About 91% of listings publish one.

## `remoteFilter` (type: `string`):

Filter the returned rows by the job's own remote flag. Independent of the remote-only landing page above.

## `companyStage` (type: `string`):

Wellfound's own stage badge on the hiring startup. Measured fill: 85% of jobs carry a stage.

## `onlyRecentlyFunded` (type: `boolean`):

Keep only jobs at companies carrying Wellfound's `Recently funded` badge — 'raised funding in the past six months'. A hiring trigger for GTM lists.

## `onlyYcFunded` (type: `boolean`):

Keep only jobs at companies carrying the `YC Funded` badge.

## `proxyConfiguration` (type: `object`):

RESIDENTIAL + US is the default and is the measured-correct choice: over 12 fresh sessions on one URL, datacenter proxies came back clean 3 times out of 12 (75% Cloudflare 403) while residential came back clean 10 out of 12 with zero 403s. Datacenter or no proxy will mostly be blocked. Your own proxy URLs work too.

## Actor input object example

```json
{
  "roles": [
    "software-engineer"
  ],
  "locations": [],
  "remoteOnly": false,
  "startUrls": [],
  "maxItems": 50,
  "maxPagesPerSeed": 0,
  "fetchJobDetails": false,
  "detailConcurrency": 5,
  "includeDescription": true,
  "postedWithinDays": 0,
  "minSalary": 0,
  "onlyWithSalary": false,
  "remoteFilter": "any",
  "companyStage": "any",
  "onlyRecentlyFunded": false,
  "onlyYcFunded": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

The dataset of scraped Wellfound jobs (one item per job posting).

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "roles": [
        "software-engineer"
    ],
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/wellfound-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "roles": ["software-engineer"],
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/wellfound-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "roles": [
    "software-engineer"
  ],
  "maxItems": 50
}' |
apify call scrapersdelight/wellfound-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapersdelight/wellfound-jobs-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/IcG2jClE70Y32JVcn/builds/RAc8WOPWKKwPWVv5b/openapi.json