# Wellfound AI Job Scraper (`marklp/wellfound-ai-job-scraper`) Actor

Extract Wellfound startup jobs with pay, equity, locations and company info. Enable optional AI: skills, seniority, summaries, grit scores & match ranking via Candidate Profile. Filter by remote, salary and keywords. Uses public listings—no Wellfound login required for search.

- **URL**: https://apify.com/marklp/wellfound-ai-job-scraper.md
- **Developed by:** [ML Data Solutions](https://apify.com/marklp) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 11 total users, 8 monthly users, 94.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Jobs Scraper + AI Analysis

**Find startup jobs on [Wellfound.com](https://wellfound.com)** with salary, equity, remote policy, and company details — plus optional **AI screening and match scores**. Run on Apify to schedule searches, export to Excel/CSV, or connect via API.

### What does this Actor do?

Enter a **job role**, **location**, and/or **keyword filter** (e.g. Software Engineer in New York, or keyword `machine learning` alone). The Actor collects matching listings from public Wellfound search pages and saves them to a dataset you can browse or download. **No Wellfound account needed.**

Each result includes pay range, equity (when listed), work arrangement, full description, and company info (logo, size, funding, badges).

Optionally turn on **Enable AI Analysis** (on by default) to enrich every job with summaries, scores, and red flags — including **inferred tech skills** from the posting text. Add a **Candidate Profile** to rank jobs against your background — results are **sorted highest match first** in the output when a profile is provided.

The Actor uses a **residential proxy** and an anti-bot browser to access Wellfound reliably on the Apify platform. AI enrichment runs **after scraping finishes** (browser is closed first), so pagination stays fast.

### Why use it?

- **Startup jobs with equity** — not just salary
- **Smart filters** — remote only, salary band, keywords, company whitelist/blacklist
- **AI screening (optional)** — one-line pitches, role-intensity scores, authenticity labels, and warning flags
- **Match ranking** — paste your background once; best-fit jobs appear at the top
- **Apify platform** — schedule runs, monitor jobs, integrate with other tools, pay only for what you use

### How to use it

1. Open the **Input** tab in [Apify Console](https://console.apify.com).
2. Leave **Enable AI Analysis** on for summaries and scores, or turn it off for scrape-only runs (faster, lower cost).
3. Optionally paste your **Candidate Profile** for match scoring — jobs will be ordered **highest match % first** in the dataset.
4. Set **Job Title** (e.g. `software-engineer`), **Job Location**, and/or **Keyword Filter** — at least one is required.
5. Optionally add **Keyword Filter** words (e.g. `python`, `machine learning`) to narrow by title or description.
6. Set **Job Location** if you want a geographic filter (e.g. `new-york`). Leave blank for a global search.
7. Set **Maximum Number of Jobs** and any other filters you need.
8. Click **Start** — results appear under **Output** (Jobs, Companies, and AI Analysis tabs).

**Tip:** Job title and location use Wellfound’s URL style (`software-engineer`, `san-francisco`). Plain English usually works — the Actor converts it automatically.

### Input

See the **Input** tab in Apify Console for all fields. Main fields in display order:

| Field | What it does |
|---|---|
| **Enable AI Analysis** | Add AI summaries, scores, and flags to each job (on by default) |
| **Candidate Profile** | Your background — adds match score, reasons, and gaps; enables match sorting |
| **Job Title / Role** | Role to search, e.g. `software-engineer` (optional if Location or Keywords set) |
| **Keyword Filter** | Keep jobs whose title **or description** contains a keyword, e.g. `python`, `machine learning` — can be used alone |
| **Job Location** | City, region, or country, e.g. `new-york`, `united-states` (optional if Title or Keywords set) |
| **Maximum Number of Jobs** | Stop after this many accepted results |
| **Maximum Pages to Scrape** | How many search pages to load (~40–50 jobs per page) |
| **Remote Jobs Only** | Only fully remote roles |
| **Job Type** | Full-time, part-time, contract, internship, or all |
| **Posted Within (days)** | Only recent listings (0 = no limit) |
| **Minimum / Maximum Salary** | Filter by listed salary (USD/year) |
| **Include Jobs Without Salary** | When salary filters are on, also keep jobs with no salary listed |
| **Include / Exclude Companies** | Whitelist or blacklist company slugs from Wellfound URLs |

Example input:

```json
{
  "aiAnalysis": true,
  "candidateProfile": "8 yrs Python/FastAPI, AWS. Remote-first, $160k+ target.",
  "jobTitle": "software-engineer",
  "keywords": ["python", "backend"],
  "jobLocation": "new-york",
  "maxItems": 50,
  "fullyRemote": false
}
````

Keyword-only example:

```json
{
  "aiAnalysis": false,
  "jobTitle": "",
  "keywords": ["machine learning"],
  "maxItems": 20
}
```

### Output

Each row is one job. Download as **JSON**, **CSV**, or **Excel** from the Dataset tab.

Dataset rows are **ordered with the most useful fields first** (title, company, pay, location, remote, links, then description). Empty text fields are `""` and empty lists are `[]` — not `null`.

#### Output tabs

The **Output** tab in Apify Console has three views — same dataset, different columns:

| Tab | Best for |
|---|---|
| **Jobs** | Main list — title, company, pay, location, remote, experience, links |
| **Companies** | Company logos, size, location, badges, funding |
| **AI Analysis** | AI enrichment — summaries, role intensity, match details (**only when Enable AI Analysis was on**) |

When **Candidate Profile** is set and AI Analysis is on, jobs in the dataset are saved **sorted by match score (highest first)**. Open the **AI Analysis** tab and sort by **Match %** to review the best fits quickly.

#### Example job record (core fields)

```json
{
  "job_title": "Software Engineer",
  "company": {
    "name": "Example Co",
    "logo_url": "https://photos.wellfound.com/...",
    "size": "51-200",
    "badges": ["Actively Hiring"]
  },
  "job_compensation": "$150k – $230k",
  "job_pay_range": "$150k – $230k",
  "job_location": ["San Francisco"],
  "remote_work_policy": "Hybrid",
  "job_url": "https://wellfound.com/jobs/3324973-software-engineer",
  "job_application_url": "https://wellfound.com/jobs/3324973-software-engineer?autoOpenApplication=true"
}
```

### AI Analysis (optional)

When **Enable AI Analysis** is turned on, the Actor analyzes each collected job after scraping completes and adds structured AI fields. These appear in the dataset and in the **AI Analysis** output tab.

If you also fill in **Candidate Profile**, each job gets a match score plus reasons and gaps compared to your background. The final dataset is ordered **highest `ai_match_score` first**.

AI Analysis adds **extra run time** (all jobs are processed in one batch after the browser closes). On the Apify Store, it is a **paid add-on** — see the **Pricing** section on this Actor’s page for current rates and billing details.

#### AI fields

| Field | Meaning |
|---|---|
| `one_line_pitch` | Ultra-short cheat sheet about the role (≤15 words) |
| `ai_summary` | 2–3 sentence objective summary of the posting |
| `ai_skills` | Technologies and tools mentioned in the job |
| `ai_culture_tags` | Short labels for work environment (e.g. fast-paced, remote) |
| `ai_seniority` | Inferred level: junior, mid, senior, staff, principal, executive |
| `technical_grit` | 0–100 — how big and intense the job feels (see below) |
| `stability` | 0–100 — company stability and predictability |
| `ai_authenticity` | Whether the company builds real AI products vs marketing AI |
| `red_flags` | Possible concerns inferred from the posting (empty if none) |
| `ai_match_score` | 0–100 fit vs your Candidate Profile (only when profile is set) |
| `ai_match_reasons` | Up to 3 reasons the job matches your profile |
| `ai_gaps` | Up to 3 gaps between the role and your profile |

#### Role intensity explained (`technical_grit`)

**Role intensity** answers: *How much of the product or problem will you own?*

It is **not** about how difficult the coding is. It is about **scope, pace, and responsibility**.

**High scores (70–100)** — build new things, wear many hats, make decisions with less hand-holding, typical of early-stage or founding-style roles.

**Low scores (0–40)** — focused tasks, clearer boundaries, more maintenance or structured work, typical of larger or more stable teams.

#### Stability explained

**Stability** estimates how predictable the company and role are — funding runway, team maturity, and scope clarity. **High scores** suggest later-stage companies and clear scope; **low scores** suggest early-stage startups or evolving roles.

#### AI authenticity explained

**AI authenticity** tries to distinguish companies that truly build AI products from companies that mainly use “AI” as marketing.

| Label | Meaning |
|---|---|
| `true_agentic_ai` | AI agents or autonomous systems are core to the product |
| `llm_wrapper` | Product is mostly a wrapper around an LLM API |
| `ai_enabled_saas` | SaaS product with meaningful AI features built in |
| `traditional_saas_using_ai` | Traditional software that mentions AI but it’s not central |
| `non_ai_company` | No meaningful AI focus |
| `unclear` | Posting is too vague to classify |

#### Example AI output

```json
{
  "job_title": "Staff Software Engineer (Agents)",
  "one_line_pitch": "Series B — build agent systems for supply chain ops",
  "ai_summary": "Design and deploy agentic platforms for industrial workflows. Python backend, LLM integration, customer-facing deployments.",
  "technical_grit": 84,
  "stability": 38,
  "ai_authenticity": "true_agentic_ai",
  "ai_seniority": "staff",
  "ai_skills": ["Python", "FastAPI", "LLMs", "AWS"],
  "ai_culture_tags": ["fast-paced", "high ownership", "customer-facing"],
  "red_flags": ["Broad stack expectations"],
  "ai_match_score": 81,
  "ai_match_reasons": [
    "Strong Python and FastAPI alignment",
    "AI infrastructure focus matches your target",
    "Remote-friendly policy"
  ],
  "ai_gaps": [
    "Limited agent-systems experience mentioned",
    "Salary at upper edge of your range"
  ]
}
```

### Data table

| Field | Description |
|---|---|
| `job_title`, `job_type`, `job_compensation` | Basics from the listing |
| `job_pay_range`, `job_min_salary`, `job_max_salary` | Pay where listed |
| `job_equity` | Equity range text when listed |
| `job_location`, `remote_work_policy` | Where and how you work |
| `job_experience` | Experience requirement when listed on the search page |
| `job_description`, `job_url` | Full text and link |
| `company` | Name, logo, size, badges, funding, Wellfound profile |
| AI fields (`ai_*`, `one_line_pitch`, etc.) | Present when AI Analysis is enabled |

**Note:** Wellfound search pages do not expose structured skills or visa fields — use **AI Analysis** for inferred skills from the job description.

### Tips

- Use **Keyword Filter** right below **Job Title** to narrow broad role searches (e.g. `backend`, `python`).
- Use **Keyword Filter** alone to scan all jobs on Wellfound (e.g. `machine learning`) without a role slug.
- Turn off **Enable AI Analysis** when you only need raw listings — faster and cheaper.
- Fill in **Candidate Profile** for match scores and automatic **highest-match-first** ordering in the dataset.
- Company filters use Wellfound URL slugs (e.g. `openai`, `stripe`) — check a company’s Wellfound page URL for the slug.

### FAQ, disclaimers, and support

**Is this legal?**\
Job listings on Wellfound are public. Use the data responsibly and comply with privacy laws and Wellfound’s terms in your region.

**No results?**\
Check that your job title and location exist on Wellfound — try opening `wellfound.com/role/your-title` or `wellfound.com/role/l/your-title/your-location` in a browser first. You can also leave title/location empty and use **Keyword Filter** alone (e.g. `machine learning`) to scan all jobs. Very strict filters (keywords + salary + remote) can eliminate all matches.

**Run ended with a status message but no jobs?**\
If required input was missing, the run finishes with **Succeeded** and a clear message — not Failed. Provide at least one of Job Title, Job Location, or Keyword Filter.

**AI fields are empty?**\
Make sure **Enable AI Analysis** is turned on. If AI still doesn’t run, check the run log for errors or contact the Actor owner via the **Issues** tab.

**Match score missing?**\
`ai_match_score`, `ai_match_reasons`, and `ai_gaps` appear only when **Candidate Profile** is filled in. Without a profile, other AI fields still run but jobs are not match-sorted.

**Why did my run scrape fewer jobs than maxItems?**\
Filters (keywords, salary, remote, company lists) apply after fetch. A **maximum cost per run** limit can also reduce the effective cap when AI Analysis is enabled.

**How accurate is AI Analysis?**\
AI summaries and scores are estimates based on each posting — useful for screening, not a substitute for reading the full listing and doing your own research.

**Need help or a custom integration?**\
Use the **Issues** tab on this Actor in Apify Console.

# Actor input Schema

## `aiAnalysis` (type: `boolean`):

Add AI summaries, inferred skills, seniority, role intensity, stability, authenticity, and red flags to each job. Results appear in the AI Analysis tab and in the dataset JSON (for API use).

## `candidateProfile` (type: `string`):

Optional. Your background in plain text. When AI Analysis is on, jobs are ranked by fit and include match score, reasons, and gaps. Example: 8 yrs Python/FastAPI, some React, AWS certified. Targeting remote-first roles paying $160k+, ideally AI infra or developer tools.

## `jobTitle` (type: `string`):

The job role to search for. Use Wellfound's URL slug format or plain text – slugified automatically.

Examples: 'software-engineer', 'product-manager', 'data-scientist'.

Optional if Job Location or Keyword Filter is set. Leave empty to search all jobs (Keyword Filter still applies).

## `keywords` (type: `array`):

Only keep jobs whose title or description contains at least one of these keywords (case-insensitive). Example: \['python', 'machine learning', 'backend'].

Can be used alone (without Job Title or Location) to scan all Wellfound jobs at wellfound.com/jobs and filter results. Leave empty to keep all jobs from the search page.

## `jobLocation` (type: `string`):

City, region, or country to filter by.

Examples: 'new-york', 'san-francisco', 'united-states', 'london'. Leave blank to search globally.

Optional if Job Title or Keyword Filter is set.

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

Maximum number of job listings to output (after all filters are applied).

## `maxPages` (type: `integer`):

Limit how many search-result pages to fetch. Each page returns ~40–50 jobs. Set to 1 for a quick test.

## `fullyRemote` (type: `boolean`):

If enabled, only return jobs with a remote work policy. Jobs marked 'In office' or 'Hybrid' are excluded.

## `jobType` (type: `string`):

Filter by employment type. 'all' returns every type.

## `lastXDays` (type: `integer`):

Only include jobs posted within the last N days. Set to 0 to disable the date filter.

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

Only include jobs where the listed minimum salary is at or above this value. Set to 0 to disable.

## `maxSalary` (type: `integer`):

Only include jobs where the listed maximum salary is at or below this value. Set to 0 to disable.

## `includeNoSalary` (type: `boolean`):

When salary filters are active, also keep jobs that have no salary listed. Disable to show only jobs with explicit salary data.

## `includeCompany` (type: `array`):

Only return jobs from these companies. Use the company slug as it appears in the Wellfound URL (e.g. 'openai', 'stripe'). Leave empty to include all companies.

## `excludeCompany` (type: `array`):

Skip jobs from these companies. Use the company slug as it appears in the Wellfound URL (e.g. 'openai', 'stripe').

## Actor input object example

```json
{
  "aiAnalysis": true,
  "candidateProfile": "",
  "jobTitle": "software-engineer",
  "keywords": [],
  "jobLocation": "",
  "maxItems": 100,
  "maxPages": 50,
  "fullyRemote": false,
  "jobType": "all",
  "lastXDays": 0,
  "minSalary": 0,
  "maxSalary": 0,
  "includeNoSalary": true,
  "includeCompany": [],
  "excludeCompany": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "jobTitle": "software-engineer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("marklp/wellfound-ai-job-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 = { "jobTitle": "software-engineer" }

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

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

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

```

## CLI example

```bash
echo '{
  "jobTitle": "software-engineer"
}' |
apify call marklp/wellfound-ai-job-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=marklp/wellfound-ai-job-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wellfound AI Job Scraper",
        "description": "Extract Wellfound startup jobs with pay, equity, locations and company info. Enable optional AI: skills, seniority, summaries, grit scores & match ranking via Candidate Profile. Filter by remote, salary and keywords. Uses public listings—no Wellfound login required for search.",
        "version": "1.1",
        "x-build-id": "lEfHTWQXBJLck3H6q"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/marklp~wellfound-ai-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-marklp-wellfound-ai-job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/marklp~wellfound-ai-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-marklp-wellfound-ai-job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/marklp~wellfound-ai-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-marklp-wellfound-ai-job-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "aiAnalysis": {
                        "title": "Enable AI Analysis",
                        "type": "boolean",
                        "description": "Add AI summaries, inferred skills, seniority, role intensity, stability, authenticity, and red flags to each job. Results appear in the AI Analysis tab and in the dataset JSON (for API use).",
                        "default": true
                    },
                    "candidateProfile": {
                        "title": "Candidate Profile (for AI match scoring)",
                        "type": "string",
                        "description": "Optional. Your background in plain text. When AI Analysis is on, jobs are ranked by fit and include match score, reasons, and gaps. Example: 8 yrs Python/FastAPI, some React, AWS certified. Targeting remote-first roles paying $160k+, ideally AI infra or developer tools.",
                        "default": ""
                    },
                    "jobTitle": {
                        "title": "Job Title / Role",
                        "type": "string",
                        "description": "The job role to search for. Use Wellfound's URL slug format or plain text – slugified automatically.\n\nExamples: 'software-engineer', 'product-manager', 'data-scientist'.\n\nOptional if Job Location or Keyword Filter is set. Leave empty to search all jobs (Keyword Filter still applies).",
                        "default": ""
                    },
                    "keywords": {
                        "title": "Keyword Filter",
                        "type": "array",
                        "description": "Only keep jobs whose title or description contains at least one of these keywords (case-insensitive). Example: ['python', 'machine learning', 'backend'].\n\nCan be used alone (without Job Title or Location) to scan all Wellfound jobs at wellfound.com/jobs and filter results. Leave empty to keep all jobs from the search page.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobLocation": {
                        "title": "Job Location",
                        "type": "string",
                        "description": "City, region, or country to filter by.\n\nExamples: 'new-york', 'san-francisco', 'united-states', 'london'. Leave blank to search globally.\n\nOptional if Job Title or Keyword Filter is set.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Maximum Number of Jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to output (after all filters are applied).",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Maximum Pages to Scrape",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Limit how many search-result pages to fetch. Each page returns ~40–50 jobs. Set to 1 for a quick test.",
                        "default": 50
                    },
                    "fullyRemote": {
                        "title": "Remote Jobs Only",
                        "type": "boolean",
                        "description": "If enabled, only return jobs with a remote work policy. Jobs marked 'In office' or 'Hybrid' are excluded.",
                        "default": false
                    },
                    "jobType": {
                        "title": "Job Type",
                        "enum": [
                            "all",
                            "full-time",
                            "part-time",
                            "contract",
                            "internship"
                        ],
                        "type": "string",
                        "description": "Filter by employment type. 'all' returns every type.",
                        "default": "all"
                    },
                    "lastXDays": {
                        "title": "Posted Within (days)",
                        "minimum": 0,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "Only include jobs posted within the last N days. Set to 0 to disable the date filter.",
                        "default": 0
                    },
                    "minSalary": {
                        "title": "Minimum Salary (USD/year)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include jobs where the listed minimum salary is at or above this value. Set to 0 to disable.",
                        "default": 0
                    },
                    "maxSalary": {
                        "title": "Maximum Salary (USD/year)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include jobs where the listed maximum salary is at or below this value. Set to 0 to disable.",
                        "default": 0
                    },
                    "includeNoSalary": {
                        "title": "Include Jobs Without Salary",
                        "type": "boolean",
                        "description": "When salary filters are active, also keep jobs that have no salary listed. Disable to show only jobs with explicit salary data.",
                        "default": true
                    },
                    "includeCompany": {
                        "title": "Include Companies (whitelist)",
                        "type": "array",
                        "description": "Only return jobs from these companies. Use the company slug as it appears in the Wellfound URL (e.g. 'openai', 'stripe'). Leave empty to include all companies.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "excludeCompany": {
                        "title": "Exclude Companies (blacklist)",
                        "type": "array",
                        "description": "Skip jobs from these companies. Use the company slug as it appears in the Wellfound URL (e.g. 'openai', 'stripe').",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```