# Wellfound (AngelList) Jobs Scraper: Startup Jobs & Salaries (`localwire/wellfound-jobs`) Actor Startup jobs from Wellfound (formerly AngelList Talent) by role and location: company size and badges, locations, remote policy, pay and equity, experience and description, in the same schema as Career Site Jobs API. Keyword, country, remote and date filters; monitor mode returns only new jobs. - **URL**: https://apify.com/localwire/wellfound-jobs.md - **Developed by:** [Local Wire](https://apify.com/localwire) (community) - **Categories:** Jobs, Business - **Features:** Limited permissions - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing $2.00 / 1,000 jobs 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? An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes. 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. Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md. ## 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. Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run. For examples already wired to this Actor's own input schema, see the [API](#api) section below. Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`). # README ## Wellfound Jobs Scraper: startup jobs by role and location Get **startup jobs from Wellfound** (formerly AngelList Talent) as structured JSON for **$2 per 1,000 jobs** ($0.002 per job, no start fee). Pick roles and locations, and this Wellfound jobs scraper reads Wellfound's public role and location pages and returns one record per job: title, startup (with size, pitch and badges such as *Actively Hiring* or *YC Funded*), locations and country codes, remote policy, **pay range as numbers**, equity, years of experience, posting date, the full description and the job link. Records use the **same schema as our [Career Site Jobs API](https://apify.com/localwire/ats-jobs)**, so startup jobs and company career-site jobs can share one dataset. Filter by keywords, countries, remote, employment type and date. In **monitor mode** a scheduled run returns only the jobs that are new since last time. It reads the pages Wellfound publishes for search engines (`wellfound.com/role/l//` and friends) without logging in: one ordinary request every 1.5 seconds, no proxies, no browser automation. Company pages and the logged-in search are not read. ### What you get One record per job: - **Identity:** a stable `id` (`wellfound:companySlug:jobId`), Wellfound's `jobId` and the `jobUrl`. - **The role:** `title`, `primaryRole` (Wellfound's role category), `employmentType`, and `yearsExperienceMin` / `yearsExperienceMax` where given. - **The startup:** `company`, `companyUrl`, `companySize` ("11-50", "1000-5000", "5000+"), `companyTagline`, `companyBadges` and `companyLogoUrl`. - **Where:** `location`, `locations`, ISO codes in `country` and `countries`, a `remote` flag, Wellfound's own policy in `remoteKind` and, for remote roles, `acceptedRemoteLocations`. - **Pay and equity:** `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod` parsed from Wellfound's range, the original in `salaryText`, and the equity part in `equityText`. - **The posting:** `descriptionText` (optionally `descriptionHtml`), `postedAt` and `scrapedAt`. - **Monitor fields:** `changeType` and `firstSeenAt` in monitor mode. A full record looks like this: ```json { "id": "wellfound:humaans-1:2563805", "ats": "wellfound", "atsName": "Wellfound", "source": "wellfound.com", "company": "Humaans", "companySlug": "humaans-1", "jobId": "2563805", "title": "Senior Software Engineer (Full Stack)", "department": null, "team": "Software Engineer", "employmentType": "full-time", "employmentTypeRaw": "full-time", "location": "London", "locations": ["London"], "country": "GB", "countries": ["GB"], "remote": true, "workplaceType": null, "salaryMin": 66000, "salaryMax": 80000, "salaryCurrency": "USD", "salaryPeriod": "year", "salaryText": "$66k – $80k • No equity", "descriptionText": "About us\n\nHumaans is building the next generation of infrastructure for the workplace…", "descriptionHtml": null, "jobUrl": "https://wellfound.com/jobs/2563805-senior-software-engineer-full-stack", "applyUrl": "https://wellfound.com/jobs/2563805-senior-software-engineer-full-stack", "postedAt": "2026-11-04T12:21:51.000Z", "updatedAt": null, "changeType": null, "firstSeenAt": null, "input": "software-engineer | london", "detectedBy": "search", "scrapedAt": "2026-11-07T22:40:00.000Z", "companyUrl": "https://wellfound.com/company/humaans-1", "companySize": "11-50", "companyTagline": "Humaans is the fastest way for companies to onboard and manage employees", "companyBadges": ["Actively Hiring", "Top 10% of responders", "Early Stage", "Top Investors", "YC Funded", "Growing fast"], "companyLogoUrl": "https://photos.wellfound.com/startups/i/8383274-….jpg", "equityText": "No equity", "yearsExperienceMin": null, "yearsExperienceMax": null, "remoteKind": "ONSITE_OR_REMOTE", "acceptedRemoteLocations": ["United Kingdom"], "primaryRole": "Software Engineer" } ``` - `id` is stable, so you can de-duplicate or upsert, and merge with Career Site Jobs API datasets. - `remoteKind` is Wellfound's own policy: `REMOTE`, `ONSITE` or `ONSITE_OR_REMOTE`. `remote` is true for the first and last, and `workplaceType` is set only when the policy is one thing. - `salaryMin` and `salaryMax` are yearly figures parsed from Wellfound's range ("$180k – $300k"). `salaryText` keeps the original, including the equity part, and `equityText` holds the equity on its own. - `countries` are read from the city names. `acceptedRemoteLocations` lists where a remote role can be done from. - `postedAt` is when the listing went live. - `team` repeats `primaryRole`, and `department` is always empty: both exist so the record matches the shared job schema. - Descriptions are cut at 20,000 characters. The dataset has three table views: **Overview**, **Pay and equity** and **Startups**. The run's key-value store also gets an `OUTPUT` record with one entry per search: the page URL, Wellfound's own job count, pages read, jobs listed, matched and returned, and any role/location combination that has no page. ### Quick start Give `roles`, `locations` or both. This input returns up to 50 software-engineering jobs at London startups and costs at most $0.10: ```json { "roles": ["software-engineer"], "locations": ["london"], "maxResults": 50 } ``` In Apify Console the form opens with these values already filled in, so you can press **Start** straight away. When you call the Actor from the API and leave `maxResults` out, it defaults to 500 jobs. New engineering roles in London or remote, posted this week, every day: ```json { "roles": ["software-engineer", "backend-engineer"], "locations": ["london"], "remote": true, "postedWithinDays": 7, "onlyNew": true, "monitorKey": "london-remote-eng" } ``` Save the input as a **Task**, add a daily **Schedule**, and each run returns only the new jobs. ### Input reference | Field | Type | Default | What it does | |---|---|---|---| | `roles` | list of text | none | Wellfound role names or slugs, e.g. `software-engineer` or `Product Manager`. Each role is combined with each location. | | `locations` | list of text | none | Cities or countries as Wellfound names them, e.g. `london`, `new-york`, `united-kingdom`. | | `remote` | true/false | `false` | Also read each role's remote page (`/role/r/`). Needs at least one role. | | `urls` | list of text | none | Wellfound role or location page URLs, instead of or as well as roles and locations. | | `keywords` | list of text | none | Keep jobs whose title or primary role contains ANY of these. | | `searchDescriptions` | true/false | `false` | Also match `keywords` against the description. | | `excludeKeywords` | list of text | none | Drop jobs whose title contains ANY of these. | | `countries` | list of text | none | Keep jobs in ANY of these countries (ISO codes or names), read from the job's locations. | | `remoteOnly` | true/false | `false` | Keep only jobs Wellfound marks as remote or onsite-or-remote. | | `employmentTypes` | list | none | `full-time`, `part-time`, `contract`, `temporary`, `internship`, `apprenticeship`, `other` (which includes cofounder posts). | | `postedWithinDays` | number 1-365 | none | Keep jobs that went live in this many days. | | `postedSince` | date | none | Keep jobs that went live on or after this date. Overrides `postedWithinDays`. | | `includeDescriptions` | true/false | `true` | Include the description as plain text. It comes with the listing, so it costs no extra requests. | | `includeHtml` | true/false | `false` | Also return the description as HTML with the exact posting date, read from each job's own page (one request per job). | | `maxPagesPerSearch` | number 1-50 | `5` | Pages to read per role/location combination. Each page lists about 20 startups. | | `maxResults` | number 1-20,000 | `500` | Stop the run after this many jobs in total. | | `onlyNew` | true/false | `false` | Monitor mode: return only jobs that earlier runs have not returned. | | `monitorKey` | text | automatic | A name for the monitor's memory. Without one, each set of searches and filters gets its own. | A run needs at least one role, location or URL, and at most 200 role/location combinations. Invalid input fails at once with a message that lists every problem. #### Which pages are read | You give | Page read | |---|---| | a role and a location | `wellfound.com/role/l//` | | a role and `remote: true` | `wellfound.com/role/r/` | | a role only | `wellfound.com/role/` (worldwide) | | a location only | `wellfound.com/location/` | Roles that have pages include software-engineer, frontend-engineer, backend-engineer, full-stack-engineer, mobile-engineer, devops-engineer, data-scientist, data-engineer, machine-learning-engineer, product-manager, designer, product-designer, sales, account-executive, marketing, growth, customer-success, recruiter, operations-manager and finance. Locations are cities (london, new-york, san-francisco, berlin, paris, bangalore…) and countries (united-kingdom, germany, india…). Wellfound's own [role](https://wellfound.com/role) and [location](https://wellfound.com/location) indexes list them all. A combination without a page is reported in `OUTPUT` and costs nothing. ### Monitor mode: only new startup jobs With `onlyNew` on, the Actor remembers the jobs it has returned for this set of searches and filters (or under your `monitorKey`) in a key-value store called `wellfound-jobs-monitor` in your account. Each run returns, and charges for, only jobs it has not returned before, and stops paging a search as soon as a page holds nothing new. Changing roles, locations or filters starts a new memory unless you give the same `monitorKey`. Date windows and limits are not part of the memory, so a rolling `postedWithinDays` does not reset it. ### Use cases - **Startup hiring signals.** Which startups in a city are hiring for which roles, how big they are and what they pay. - **Job boards and newsletters.** A daily feed of new startup roles for a role, a city or remote. - **Salary and equity research.** Published ranges and equity by role, city and company size. - **Recruiting and sales.** Spot growing startups (badges, open roles) early. - **AI agents.** A small, predictable JSON schema that an agent can call as a tool through Apify's MCP server. ### Pricing **$0.002 per job returned, which is $2 per 1,000 jobs.** There is no start fee and no monthly rental. You pay for each job the Actor returns. You pay nothing for jobs that your filters drop, for jobs already returned in monitor mode, or for role/location pages that do not exist. Descriptions cost nothing extra. | What you run | Jobs returned | Cost | |---|---|---| | The pre-filled first run | 50 | $0.10 | | One role in one city, all 5 pages | about 200 | about $0.40 | | The default API limit | 500 | $1.00 | | Ten roles in three cities | up to about 6,000 | up to about $12.00 | | A daily monitor of six searches that finds 25 new jobs a day | about 750 a month | about $1.50 a month | To cap spending, set **Max cost per run** in the run options, or lower `maxResults`. The Actor stops cleanly at the limit and says so in its status message. ### Use it from the API Run the Actor and get the jobs back in one request: ```bash curl -X POST "https://api.apify.com/v2/acts/localwire~wellfound-jobs/run-sync-get-dataset-items" \ -H "Authorization: Bearer " \ -H "Content-Type: application/json" \ -d '{"roles": ["data-scientist"], "locations": ["berlin"], "maxPagesPerSearch": 2, "maxResults": 50}' ``` That endpoint waits up to five minutes. For a long run, such as many combinations or `includeHtml`, start it with `POST /v2/acts/localwire~wellfound-jobs/runs` and read the run's dataset when it has finished. With the Apify client for JavaScript: ```js import { ApifyClient } from "apify-client"; const client = new ApifyClient({ token: process.env.APIFY_TOKEN }); const run = await client.actor("localwire/wellfound-jobs").call({ roles: ["product-manager"], locations: ["new-york", "san-francisco"], maxResults: 200, }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); ``` With the Apify client for Python: ```python from apify_client import ApifyClient client = ApifyClient("") run = client.actor("localwire/wellfound-jobs").call(run_input={ "roles": ["backend-engineer"], "remote": True, "remoteOnly": True, "maxResults": 100, }) jobs = list(client.dataset(run["defaultDatasetId"]).iterate_items()) ``` Results can be downloaded from the dataset as JSON, CSV, Excel, XML or JSON Lines. ### Use it from an AI agent (MCP) Apify's hosted MCP server is at `https://mcp.apify.com`. Add it to any MCP client that supports remote servers and sign in with your Apify account when the browser opens (or send an `Authorization: Bearer ` header). To give the agent only this Actor as a tool, use this server URL: ``` https://mcp.apify.com?tools=localwire/wellfound-jobs ``` ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com?tools=localwire/wellfound-jobs" } } } ``` The agent then sees the Actor's input fields with their descriptions and defaults. It needs to send `roles`, `locations` or `urls`, using Wellfound's slugs (`software-engineer`, `london`). Tell it to set `maxResults` (for example 50), because the default is 500 jobs. Questions that work well: - "Which London startups are hiring backend engineers, and what salary ranges do they publish?" - "Find remote product-manager roles at startups with fewer than 50 people." - "What equity do early-stage startups in Berlin offer data scientists?" ### Integrations Runs can be started on a schedule or by another system, and results can be sent on: - **Make, n8n and Zapier** have Apify integrations that run an Actor and pass its dataset to the next step, for example to a spreadsheet, a CRM, email or a chat channel. - **Webhooks** call your endpoint when a run succeeds or fails. - **LangChain** and other agent frameworks can use Apify Actors as tools. - **The Apify API** and the JavaScript and Python clients cover everything else. ### FAQ #### Is there a Wellfound API for jobs? We know of no public Wellfound jobs API. Wellfound does publish role and location pages that anyone can open without an account, and this Actor reads those and returns the jobs on them as structured data. #### How do I scrape startup jobs from Wellfound? Put a role in `roles` and a city in `locations`, written the way Wellfound writes them in its page addresses (`software-engineer`, `london`), and start the run. Each job listed on the matching Wellfound page becomes one record. #### Is this an AngelList jobs scraper? Yes. AngelList Talent was renamed Wellfound, and the jobs that used to be on angel.co are on wellfound.com. Old `angel.co` role and location links are accepted in `urls`. #### Does it return salary and equity? Where the startup published them. The pay range is parsed into `salaryMin`, `salaryMax` and `salaryCurrency` as yearly figures, and equity is kept as text in `equityText` ("0.1% – 0.5%", "No equity"). Jobs without a published range have empty salary fields. #### Can I filter Wellfound jobs by salary? There is no salary filter in the input. Run the search, then filter the dataset on `salaryMin` or `salaryMax`, which are plain numbers. #### Can I get every job at one startup? No. Company pages sit behind Wellfound's security check and the Actor never requests them. You get the jobs each startup has highlighted on the role and location pages, which for a startup with many openings may not be all of them. #### How do I get only new startup jobs each day? Turn on `onlyNew` and schedule the Actor daily. Each run returns, and charges for, only jobs it has not returned before. #### How many jobs does one search return? About 35 to 45 per page (roughly 20 startups and their highlighted jobs), and Wellfound shows up to 5 pages per role/location combination, so around 200. Add more roles or locations to cover more. #### How much does it cost to scrape 1,000 Wellfound jobs? $2.00. The price is $0.002 per job returned. #### Does it need proxies or a login? No. It makes plain requests with one ordinary browser User-Agent, and never logs in. #### Is it legal to scrape Wellfound? This is not legal advice. The Actor reads only public job listings and returns company and job data, never applicant, recruiter or founder profiles. You are responsible for how you use the data, including Wellfound's terms and the employers' rights. ### Limitations - **What is read.** Wellfound's public role and location pages: about 20 startups a page with each startup's highlighted jobs, up to 5 pages per combination as Wellfound shows them. - **What is not read.** Company pages (`/company//jobs`), the logged-in job search, and applicant or founder profiles. Those sit behind Wellfound's security check or a login, and the Actor does not try to get past either. - **If Wellfound stops serving pages, the run stops.** On an HTTP 403, a 429, a bot challenge or Wellfound's "Security Check" page the Actor waits once and tries one more time. If it is still refused, the run stops, keeps the jobs it already has and says so in the status message. It does not use proxies, rotate headers or solve challenges. - **robots.txt.** The Actor reads Wellfound's robots.txt at the start of each run, honours any crawl delay, and lists in the `OUTPUT` record any requested path that robots.txt disallows. - **Roles and locations must exist as Wellfound pages.** The Actor cannot run a free-text search. Use `urls` for any role or location page you find on the site. - **Pay** appears only where the startup published a range. Figures are yearly, and the currency comes from the symbol Wellfound shows. - **Countries** come from city names. Unusual places leave `country` empty, and regions such as "Europe" always do. - **Keywords** match anywhere in the title, so `java` also matches "JavaScript". - **No removed-job tracking.** Monitor mode reports new jobs only. ### Data, privacy and terms Job listings are published by startups for anyone to read. This Actor reads Wellfound's public pages only, never logs in, and does not try to get around any access control or rate limit. It returns company and job data, never applicant, recruiter or founder profiles, and has no fields for people's names or contact details. Email addresses and phone numbers in descriptions are replaced with `[email removed]` and `[phone removed]`. Names that a startup wrote into its own description can remain. You are responsible for how you use the data, including Wellfound's terms and the employers' rights. This Actor is not affiliated with or endorsed by Wellfound or AngelList. ### More from this developer Jobs: - [Career Site Jobs API](https://apify.com/localwire/ats-jobs): jobs straight from company career sites on Workday, Greenhouse, Lever and eight more platforms, in the same schema. - [Workday Jobs API](https://apify.com/localwire/workday-jobs): every job from a Workday career site. - [Reed.co.uk Jobs Scraper](https://apify.com/localwire/reed-jobs): UK job-board search in the same schema. - [Hacker News API](https://apify.com/localwire/hacker-news): stories, comments and structured "Who is hiring?" jobs. Other data: - [Public Tenders API](https://apify.com/localwire/uk-public-tenders): UK and EU tenders and contract awards. - [Google Trends Trending Now](https://apify.com/localwire/google-trends-trending-now): trending searches for 125 countries. - [App Store Reviews](https://apify.com/localwire/app-store-reviews): reviews, app details and top charts. - [Telegram Channel Scraper](https://apify.com/localwire/telegram-channels): posts from public channels. - [ESPN Sports Data](https://apify.com/localwire/espn-sports) and [Flashscore Results & Fixtures](https://apify.com/localwire/flashscore-sports): scores, standings and fixtures. - [Eventbrite Scraper](https://apify.com/localwire/eventbrite-events) and [Meetup Scraper](https://apify.com/localwire/meetup-events): events by place and topic. - [Gumtree Scraper](https://apify.com/localwire/gumtree-listings): UK classified listings. ### Feedback Found a page that does not work, or need a field we do not return? Open an issue on the Actor's **Issues** tab and we will reply within a few days. # Actor input Schema ## `roles` (type: `array`): Wellfound role names or slugs, one per line, e.g. software-engineer, Product Manager, data-scientist, designer, devops-engineer, sales, marketing. Names are turned into slugs ("Product Manager" becomes product-manager). Each role is combined with each location; a role with no location reads the role's worldwide page. See wellfound.com/role for the roles that have pages. ## `locations` (type: `array`): Cities or countries as Wellfound names them, e.g. london, new-york, san-francisco, berlin, united-kingdom. Leave empty to read the role's worldwide page. A location with no role reads every job on that location's page. See wellfound.com/location for the ones that have pages. ## `remote` (type: `boolean`): Adds wellfound.com/role/r/ (remote jobs for the role) to the searches. ## `urls` (type: `array`): Instead of (or as well as) roles and locations: Wellfound role or location page URLs, e.g. https://wellfound.com/role/l/software-engineer/london, https://wellfound.com/role/r/designer, https://wellfound.com/location/berlin. Company pages can't be read. ## `keywords` (type: `array`): Keep jobs whose title (or primary role) contains ANY of these, e.g. python, "machine learning", staff. ## `searchDescriptions` (type: `boolean`): Match keywords against the full job description too (e.g. a technology like Kubernetes). ## `excludeKeywords` (type: `array`): Drop jobs whose title contains ANY of these, e.g. intern, senior. ## `countries` (type: `array`): Keep jobs in ANY of these countries (ISO codes or names), read from the job's locations. ## `remoteOnly` (type: `boolean`): Keep only jobs Wellfound marks as remote or onsite-or-remote. ## `employmentTypes` (type: `array`): Keep only these types (Wellfound posts are mostly full-time; contract, internship and cofounder posts exist). ## `postedWithinDays` (type: `integer`): Keep jobs that went live in this many days. ## `postedSince` (type: `string`): Keep jobs that went live on or after this date, e.g. 2026-11-01. Overrides 'Posted in the last N days'. ## `includeDescriptions` (type: `boolean`): Include each job's description as plain text (from the listing, no extra requests). ## `includeHtml` (type: `boolean`): Also return the description as HTML (descriptionHtml) with the exact posting date, read from each job's own page (one request per job, so slower). ## `maxPagesPerSearch` (type: `integer`): Each page lists about 20 startups and their highlighted jobs (roughly 35-45 jobs). Wellfound shows up to 5 pages per combination. ## `maxResults` (type: `integer`): Stop the run after this many jobs in total. Each job returned is charged once, so this is also the cost cap. 500 when left out; the form starts at 50 so that a first run is small. You can also cap spending with the run's maximum cost. ## `onlyNew` (type: `boolean`): Remember the jobs returned by earlier runs of the same searches and filters, and return (and charge for) only new ones. Schedule the Actor daily to get a feed of new startup openings. ## `monitorKey` (type: `string`): Optional name for this monitor's memory, e.g. london-engineering. Leave empty and each set of searches and filters gets its own memory automatically. ## Actor input object example ```json { "roles": [ "software-engineer" ], "locations": [ "london" ], "remote": false, "searchDescriptions": false, "remoteOnly": false, "includeDescriptions": true, "includeHtml": false, "maxPagesPerSearch": 5, "maxResults": 50, "onlyNew": false } ``` # Actor output Schema ## `overview` (type: `string`): The key facts for each job. ## `pay` (type: `string`): Jobs with a published pay range, as numbers. ## `startups` (type: `string`): The company behind each job: size, pitch, badges and page. ## `allResults` (type: `string`): Every record in the run's default dataset, all fields. # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "roles": [ "software-engineer" ], "locations": [ "london" ], "maxResults": 50 }; // Run the Actor and wait for it to finish const run = await client.actor("localwire/wellfound-jobs").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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "roles": ["software-engineer"], "locations": ["london"], "maxResults": 50, } # Run the Actor and wait for it to finish run = client.actor("localwire/wellfound-jobs").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" ], "locations": [ "london" ], "maxResults": 50 }' | apify call localwire/wellfound-jobs --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "type": "http", "url": "https://mcp.apify.com/?tools=fetch-actor-details,localwire/wellfound-jobs" } } } ``` 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 ` 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/GdaCur5Y1rHam0jMM/builds/c2NoR1WipVhgYpjKs/openapi.json