# 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:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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, skills, visa info, 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** and optional **location** (e.g. Software Engineer in New York). 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, skills, work arrangement, full description, and company info (logo, stage, funding, links).

Optionally turn on **Enable AI Analysis** (on by default) to enrich every job with summaries, scores, and red flags. 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, grit/stability 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`) and/or **Job Location** — at least one is required.
5. Optionally add **Keyword Filter** words (e.g. `python`, `backend`) to narrow titles.
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` (at least one of Title or Location) |
| **Keyword Filter** | Keep jobs whose title contains at least one word, e.g. `python`, `react` |
| **Job Location** | City, region, or country, e.g. `new-york`, `united-states` |
| **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
}
````

### Output

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

#### Output tabs

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

| Tab | Best for |
|---|---|
| **Jobs** | Main list — title, pay, location, remote policy, key AI scores |
| **Companies** | Company logos, stage, funding, badges, social links |
| **AI Analysis** | Full AI enrichment — summaries, grit, authenticity, match details |

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",
  "job_pay_range": "$150k – $230k",
  "skills": ["TypeScript", "React"],
  "remote_work_policy": "Hybrid",
  "job_url": "https://wellfound.com/jobs/3324973-software-engineer",
  "company": {
    "name": "Example Co",
    "logo_url": "https://photos.wellfound.com/...",
    "stage": ["Series B"],
    "size": "51-200"
  }
}
```

### 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 demanding and ownership-heavy the role is |
| `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 |

#### Technical grit explained

**Technical grit** estimates how demanding and ownership-heavy a role is — not how “hard” the coding is.

**High scores (e.g. 70–100)** usually mean early-stage or founding-style work, building new systems, broad ownership, and fast pace. **Low scores (e.g. 0–40)** usually mean maintenance work, structured enterprise environments, or narrow responsibilities.

#### 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, type, compensation | Basics from the listing |
| Salary & equity ranges | Numeric min/max where listed |
| Skills, experience | Requirements from the posting |
| Visa, relocation, remote policy | Work arrangement |
| Job description & URL | Full text and link |
| Company name, logo, stage, funding | Employer details |
| AI fields (`ai_*`, `one_line_pitch`, etc.) | Present when AI Analysis is enabled |

### Tips

- Use **Keyword Filter** right below **Job Title** to narrow broad role searches (e.g. `backend`, `python`).
- 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. Very strict filters (keywords + salary + remote) can eliminate all matches.

**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`):

If enabled, each job gets AI-generated fields:
• one\_line\_pitch – ultra-short cheat sheet
• ai\_summary – 2-3 sentence description
• ai\_skills – technologies mentioned
• ai\_culture\_tags – work-environment labels
• ai\_seniority – inferred level
• technical\_grit – 0-100 ownership score
• stability – 0-100 company stability score
• ai\_authenticity – how AI-focused the company product is
• red\_flags – warnings (empty if none)

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

Optional. Your background in plain text. When set and AI Analysis is enabled, each job also gets:
• ai\_match\_score (0-100)
• ai\_match\_reasons (why it fits)
• ai\_gaps (requirements you don't meet)

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'.

Provide at least one of Job Title or Job Location.

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

Only keep jobs whose title contains at least one of these keywords (case-insensitive). Example: \['python', 'react', 'backend']. Leave empty to keep all.

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

City, region, or country to filter by.

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

Provide at least one of Job Title or Job Location.

## `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.0",
        "x-build-id": "1rcktFnk8YR5WfwQM"
    },
    "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": "If enabled, each job gets AI-generated fields:\n• one_line_pitch – ultra-short cheat sheet\n• ai_summary – 2-3 sentence description\n• ai_skills – technologies mentioned\n• ai_culture_tags – work-environment labels\n• ai_seniority – inferred level\n• technical_grit – 0-100 ownership score\n• stability – 0-100 company stability score\n• ai_authenticity – how AI-focused the company product is\n• red_flags – warnings (empty if none)",
                        "default": true
                    },
                    "candidateProfile": {
                        "title": "Candidate Profile (for AI match scoring)",
                        "type": "string",
                        "description": "Optional. Your background in plain text. When set and AI Analysis is enabled, each job also gets:\n• ai_match_score (0-100)\n• ai_match_reasons (why it fits)\n• ai_gaps (requirements you don't meet)\n\nExample: '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\nProvide at least one of Job Title or Job Location."
                    },
                    "keywords": {
                        "title": "Keyword Filter",
                        "type": "array",
                        "description": "Only keep jobs whose title contains at least one of these keywords (case-insensitive). Example: ['python', 'react', 'backend']. Leave empty to keep all.",
                        "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\nProvide at least one of Job Title or Job Location.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```