# Y Combinator Jobs Scraper (`scrapers-hub/workatastartup-jobs-scraper`) Actor

Y Combinator Jobs Scraper extracts Work at a Startup roles - title, company, YC batch, tagline, job type, role category, salary and equity ranges, location, remote flag and apply URL. 🚀 For startup job boards and talent research.

- **URL**: https://apify.com/scrapers-hub/workatastartup-jobs-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

# README

## 💼 Y Combinator Jobs Scraper – Startup Job Listings, Salary Data & Company Intelligence

The **Y Combinator Jobs Scraper** extracts job listings from workatastartup.com and returns them as structured JSON — role details, parsed salary and equity ranges, location and remote status, full job descriptions, and a deep block of company intelligence covering the YC batch, team size, founding year, tech stack, industry and founders. One search produces a dataset that would otherwise take hours of manual browsing to assemble.

Work at a Startup is the official job board for Y Combinator companies, which makes it an unusually concentrated source of early-stage hiring data. Every listing belongs to a funded startup with a known batch, a known team size and a public trajectory. This Y Combinator jobs scraper turns that board into recruitment data you can filter, join and analyse — whether you are a candidate tracking the market, a recruiter mapping talent demand, or an analyst studying startup hiring trends.

***

### 📊 What Data Can You Extract with This Y Combinator Jobs Scraper?

Each dataset item is one job listing enriched with the company behind it. The fields group into seven categories.

| Category | Fields | What it gives you |
|---|---|---|
| 🆔 Job identity | `jobId`, `title`, `url`, `applyUrl`, `postedAgo`, `scrapedAt` | The listing's identifier, title, canonical and application URLs, how long ago it was posted, and when the record was captured |
| 💰 Compensation | `salaryRange`, `salaryMin`, `salaryMax`, `salaryCurrency`, `equity`, `equityMin`, `equityMax` | The advertised salary as displayed plus parsed numeric bounds and currency, and the same treatment for equity |
| 🗺️ Location and work mode | `location`, `isRemote`, `visaSponsorship` | Where the role is based, whether it is remote, and what the listing says about visa sponsorship |
| 🏷️ Role classification | `jobType`, `roleCategory`, `roleSubcategory`, `experience`, `skills` | Employment type, role category and subcategory, required experience, and the listed skills |
| 📄 Job content | `description`, `descriptionHtml`, `interviewProcess` | The full job description in plain text and HTML, plus the interview process where published |
| 🏢 Company profile | `companyName`, `companySlug`, `companyUrl`, `companyTagline`, `companyDescription`, `companyHiringDescription`, `companyWebsite`, `companyLogo` | Everything the board publishes about the hiring company |
| 📈 Company signals | `ycBatch`, `companyFounded`, `companyTeamSize`, `companyStatus`, `companyLocation`, `companyIndustry`, `companyTechStack`, `founders` | The YC batch, founding year, headcount, status, HQ, industry, technology stack and founder details |

The standout is the parsed salary trio — `salaryMin`, `salaryMax` and `salaryCurrency`. Job boards publish compensation as free text like `$124K - $188K CAD`, which is unusable for analysis. Having the numeric bounds and the currency as separate fields means you can filter, sort and benchmark salary data directly, without writing a parser of your own.

***

### 🌟 Key Features of the Y Combinator Jobs Scraper

| Feature | Description |
|---|---|
| 🔍 Free-text search | `searchQuery` matches the same way as the search box on workatastartup.com/jobs |
| 🗂️ Role category filtering | Restrict results to engineering, design, product, sales, marketing, operations, recruiting, science, legal or finance |
| 📍 Location filtering | `locationFilter` does a case-insensitive substring match on the listing's location text, including values like "Remote" |
| 💵 Parsed salary data | Salary is returned both as displayed text and as numeric `salaryMin`, `salaryMax` and `salaryCurrency` fields |
| 📊 Parsed equity data | Equity ranges are similarly split into `equityMin` and `equityMax` alongside the raw `equity` string |
| 🏢 Deep company enrichment | Every job carries the company's YC batch, team size, founding year, industry, tech stack, status and founders |
| 📝 Description in two formats | `description` for text analysis and `descriptionHtml` when you need the original formatting preserved |
| 🎓 Interview process capture | `interviewProcess` returns what the company publishes about how it hires, where available |
| 🎯 Result cap | `maxResults` keeps runs predictable, defaulting to a modest 25 listings |

***

### 🚀 Why Choose This Y Combinator Jobs Scraper?

**Compensation data you can actually compute on.** Most job scrapers hand back a salary string and leave the parsing to you. This one returns `salaryMin`, `salaryMax` and `salaryCurrency` as separate typed fields, so median-by-role queries and cross-currency comparisons are a single aggregation rather than a regex project.

**Company context arrives with every listing.** You do not need a second lookup to know who is hiring. `ycBatch`, `companyTeamSize`, `companyFounded`, `companyIndustry`, `companyTechStack` and `founders` come attached to each job, which makes cohort analysis — "what are S21 companies hiring for now?" — trivial.

**Equity is treated as first-class data.** Early-stage compensation is not just salary. `equity`, `equityMin` and `equityMax` let you compare the full offer shape across companies and stages, something almost no aggregated job dataset supports.

**Filters mirror the source board.** `searchQuery`, `roleFilter` and `locationFilter` behave the way the site's own filters behave, so what you see when browsing manually is what you get in the dataset. No surprises between preview and export.

***

### 📥 Input

```json
{
  "searchQuery": "software engineer",
  "roleFilter": "engineering",
  "locationFilter": "Remote",
  "maxResults": 100
}
```

#### 🔧 Y Combinator Jobs Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchQuery` | string | No | `""` | Free-text search term, matched the same way as the search box on workatastartup.com/jobs (e.g. "software engineer") |
| `roleFilter` | string | No | `""` | Restrict results to one role category |
| `locationFilter` | string | No | `""` | Only keep jobs whose location text contains this string (e.g. "San Francisco", "Remote"). Case-insensitive substring match |
| `maxResults` | integer | No | `25` | Maximum number of job listings to scrape |

**Role category options for `roleFilter`**

| Value | Label |
|---|---|
| `""` | Any |
| `engineering` | Engineering |
| `design` | Design |
| `recruiting` | Recruiting |
| `science` | Science |
| `product` | Product |
| `operations` | Operations |
| `sales` | Sales |
| `marketing` | Marketing |
| `legal` | Legal |
| `finance` | Finance |

#### 💡 Input Examples

**Remote engineering roles**

```json
{
  "roleFilter": "engineering",
  "locationFilter": "Remote",
  "maxResults": 200
}
```

**Specific role search in one city**

```json
{
  "searchQuery": "machine learning engineer",
  "locationFilter": "San Francisco",
  "maxResults": 50
}
```

**Full board sweep for market analysis**

```json
{
  "searchQuery": "",
  "roleFilter": "",
  "locationFilter": "",
  "maxResults": 500
}
```

***

### 📤 Output

A real job listing from an actual run:

```json
{
  "jobId": "93806",
  "title": "Senior Software Developer",
  "url": "https://www.workatastartup.com/jobs/93806",
  "companyName": "Hive",
  "companySlug": "hive",
  "companyUrl": "https://www.workatastartup.com/companies/hive",
  "companyTagline": "Marketing automation for event promoters (email, sms, ads, CRM)",
  "ycBatch": "S14",
  "jobType": "Full-time",
  "roleCategory": "Engineering",
  "roleSubcategory": "Full stack",
  "salaryRange": "$124K - $188K CAD",
  "salaryMin": 124000,
  "salaryMax": 188000,
  "salaryCurrency": "CAD",
  "equity": "",
  "equityMin": null,
  "equityMax": null,
  "location": "Remote",
  "isRemote": true,
  "postedAgo": ""
}
```

#### 🧾 Y Combinator Jobs Output Fields — Job Data

| Field | Type | Description |
|---|---|---|
| `jobId` | string | Identifier of the job |
| `title` | string | Job title |
| `url` | string | Canonical URL of the listing |
| `applyUrl` | string | URL to apply for this job |
| `jobType` | string | Employment type of the job |
| `roleCategory` | string | Role category of the listing |
| `roleSubcategory` | string | Role subcategory of the listing |
| `salaryRange` | string | Salary range as displayed on the board |
| `salaryMin` | integer | Lower bound of the advertised salary range |
| `salaryMax` | integer | Upper bound of the advertised salary range |
| `salaryCurrency` | string | Currency of the advertised salary |
| `equity` | string | Equity range as displayed |
| `equityMin` | number | Lower bound of the advertised equity range |
| `equityMax` | integer | Upper bound of the advertised equity range |
| `location` | string | Location of the role |
| `isRemote` | boolean | Whether the role is remote |
| `postedAgo` | string | How long ago the listing was posted |
| `experience` | string | Required experience |
| `visaSponsorship` | string | What the listing says about visa sponsorship |
| `skills` | array | Skills required or listed |
| `description` | string | Full job description in plain text |
| `descriptionHtml` | string | Job description with original HTML formatting |
| `interviewProcess` | string | The company's published interview process |
| `scrapedAt` | string | When this record was scraped |

#### 🧾 Y Combinator Jobs Output Fields — Company Data

| Field | Type | Description |
|---|---|---|
| `companyName` | string | Company name |
| `companySlug` | string | Company slug used in URLs |
| `companyUrl` | string | Company page on the board |
| `companyTagline` | string | One-line description of what the company does |
| `companyDescription` | string | Longer company description |
| `companyHiringDescription` | string | What the company says about hiring |
| `companyTechStack` | string | Technologies the company uses |
| `companyFounded` | integer | Year the company was founded |
| `companyTeamSize` | integer | Number of people at the company |
| `companyStatus` | string | Company status |
| `companyLocation` | string | Company headquarters location |
| `companyIndustry` | string | Industry the company operates in |
| `companyLogo` | string | Company logo URL |
| `companyWebsite` | string | Company website |
| `ycBatch` | string | Y Combinator batch, e.g. `S14` |
| `founders` | array | Founder details collected for the company |

***

### 💻 How to Use the Y Combinator Jobs Scraper (Step by Step)

#### Step 1: Decide what you are searching for

Start by deciding whether you want a targeted search or a broad sweep. A targeted search uses `searchQuery` with a specific role phrase — "backend engineer", "product designer", "technical recruiter" — and returns closely matching listings. A broad sweep leaves `searchQuery` empty and relies on `roleFilter` and `maxResults` to define the scope, which is what you want for market analysis rather than job hunting.

#### Step 2: Apply a role category filter

`roleFilter` restricts results to one of ten categories: engineering, design, recruiting, science, product, operations, sales, marketing, legal or finance. Leave it empty for all categories. It is more reliable than a free-text search for category-level work, because it uses the board's own classification rather than keyword matching against titles that may be phrased in unexpected ways.

#### Step 3: Filter by location

`locationFilter` performs a case-insensitive substring match against the listing's location text. That makes it flexible: "San Francisco" matches listings written as "San Francisco, CA", and "Remote" matches any listing whose location text mentions remote work. Because it is a substring match, keep the value short — a long, precisely formatted string will match fewer listings than you expect.

#### Step 4: Set the result cap

`maxResults` defaults to 25, which is deliberately small so a first run completes quickly and shows you the record shape. Raise it once you have confirmed the filters return what you want. For serious market analysis you will typically want several hundred listings; for a candidate's weekly job search, a few dozen filtered results is usually more useful than a large unfiltered dump.

#### Step 5: Run and monitor

Start the run from the Apify Console or via the API. The scraper works directly against workatastartup.com without needing a browser or proxy configuration, so runs are straightforward. Watch the log to see listings being collected and to catch any filter that is unexpectedly returning nothing.

#### Step 6: Analyse compensation and company signals

Once the dataset is populated, the parsed fields are where the value is. Filter on `salaryMin` to set a floor, group by `roleCategory` to compare bands, and check `salaryCurrency` before comparing figures across countries — a CAD range and a USD range are not directly comparable. Cross-reference `ycBatch`, `companyTeamSize` and `companyFounded` to understand what stage of company each offer comes from.

#### Step 7: Export or automate

Export the dataset as CSV for spreadsheet analysis, or JSON to preserve the `skills` and `founders` arrays. For ongoing tracking, schedule the actor to run daily or weekly with the same input and diff on `jobId` to detect newly posted roles. Pair that with a webhook and you have an alerting pipeline for the roles you care about.

***

### 🔌 API Access & Integrations

Run the Y Combinator jobs scraper over HTTP and get the dataset items back in the same request:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~workatastartup-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "software engineer",
    "roleFilter": "engineering",
    "locationFilter": "Remote",
    "maxResults": 100
  }'
```

With the Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/workatastartup-jobs-scraper").call(run_input={
    "roleFilter": "engineering",
    "locationFilter": "Remote",
    "maxResults": 250,
})

rows = list(client.dataset(run["defaultDatasetId"]).iterate_items())

usd = [r for r in rows if r.get("salaryCurrency") == "USD" and r.get("salaryMin")]
usd.sort(key=lambda r: r["salaryMax"] or 0, reverse=True)

for job in usd[:10]:
    print(f"{job['title']} @ {job['companyName']} ({job['ycBatch']}) "
          f"{job['salaryMin']}-{job['salaryMax']} {job['salaryCurrency']}")
```

Results can also be pushed into Zapier, Make, Google Sheets or Slack, or delivered to your own service with an Apify webhook on run completion.

***

### 💡 Best Use Cases for Y Combinator Jobs Data

#### 🎯 Startup Job Hunting and Application Tracking

Candidates can filter the entire YC board by `roleCategory`, `locationFilter` and a salary floor on `salaryMin`, then work from a single ranked list instead of scrolling the site. `applyUrl` takes you straight to the application, `interviewProcess` tells you what to prepare for, and `visaSponsorship` answers the question that otherwise costs an email exchange to resolve.

#### 💰 Compensation Benchmarking

With `salaryMin`, `salaryMax` and `salaryCurrency` parsed out, you can compute real salary bands by `roleCategory`, `roleSubcategory` and `companyTeamSize`. Adding `equityMin` and `equityMax` gives the full compensation picture, which matters enormously at seed and Series A stage where equity is a large share of the offer.

#### 🧲 Recruitment Market Intelligence

Recruiters and talent teams can track which roles YC companies are hiring for and how they are pricing them. Grouping by `ycBatch` and `companyFounded` shows which cohorts are actively scaling, while `companyTechStack` reveals which technologies are in demand — useful both for sourcing strategy and for advising candidates.

#### 📊 Startup Ecosystem Research

Analysts studying the early-stage ecosystem can use `ycBatch`, `companyTeamSize`, `companyIndustry` and `companyStatus` across a large sweep to measure hiring velocity by cohort and sector. Because `scrapedAt` timestamps every record, repeated runs build a time series showing which industries are expanding and which have stalled.

#### 🛠️ Technology Trend Analysis

`companyTechStack` and `skills` together form a demand signal for specific technologies. Aggregating them across hundreds of listings shows which frameworks, languages and tools early-stage companies are actually betting on — typically a leading indicator relative to enterprise adoption surveys.

#### 🤝 Sales Prospecting into Startups

Companies selling to startups can use hiring activity as a buying signal. A company with a growing `companyTeamSize` posting multiple engineering roles is scaling infrastructure; one hiring across sales and marketing is scaling go-to-market. `companyWebsite`, `companyIndustry` and `founders` give the context needed to write a relevant approach.

#### 🌍 Remote Work and Location Analysis

Filtering on `isRemote` and grouping by `location` and `companyLocation` shows how remote-friendly the YC portfolio is and where the concentrations sit. Comparing `salaryMin` between remote and location-specific listings for the same `roleCategory` quantifies whether remote roles are priced differently.

***

### ⚙️ Tips for Better Y Combinator Jobs Scraping Results

- **Prefer `roleFilter` over keyword search for category work.** The board's own classification is more consistent than matching free text against job titles that vary widely in phrasing.
- **Keep `locationFilter` short.** It is a case-insensitive substring match, so "San Francisco" works well while a fully formatted address string will match almost nothing.
- **Always check `salaryCurrency` before comparing salaries.** The board carries USD, CAD and other currencies. Comparing raw `salaryMin` values across currencies produces nonsense.
- **Start with the default `maxResults` of 25.** Confirm your filters return the right kind of listing before scaling to hundreds of records.
- **Handle empty compensation fields.** Not every listing publishes salary or equity — `equity`, `equityMin` and `equityMax` can be empty or null. Filter those out before aggregating rather than treating them as zero.
- **Diff on `jobId` across scheduled runs.** It is the stable identifier, so comparing `jobId` sets between runs is the cleanest way to detect newly posted and removed roles.

***

### 🛠️ Troubleshooting

**My search returned no jobs.**
Check the filters in combination. `searchQuery`, `roleFilter` and `locationFilter` all apply together, so a narrow query plus a narrow location can eliminate everything. Clear `locationFilter` first, since substring matching is the most common cause of an unexpectedly empty result.

**I got fewer results than `maxResults`.**
`maxResults` is a ceiling, not a quota. The board simply may not have that many listings matching your filters at the moment you run. Broaden the search or remove a filter.

**Salary fields are empty on some listings.**
Not every company publishes compensation. When the board shows no range, `salaryRange` is empty and `salaryMin`, `salaryMax` and `salaryCurrency` cannot be parsed. The same applies to equity. Exclude these rows from compensation aggregations.

**`locationFilter` set to "Remote" is missing jobs I expected.**
The match runs against the listing's location text. A role advertised as "San Francisco or remote" will match, but one advertised only as "Distributed" will not, because the substring differs. Try a broader run with no location filter and inspect the `location` and `isRemote` values yourself.

**`postedAgo` is empty for some jobs.**
The board does not always publish a posting age. When it is absent the field is returned empty rather than guessed at. Use `scrapedAt` to establish when you observed the listing, and compare across scheduled runs if you need genuine recency tracking.

***

### ❓ Frequently Asked Questions About Y Combinator Jobs Scraping

**What does the Y Combinator Jobs Scraper extract?**
Job listings from workatastartup.com, including title, role category, location, remote status, parsed salary and equity ranges, full descriptions, required skills, visa sponsorship, interview process, and detailed company data such as YC batch, team size, founding year, industry, tech stack and founders.

**Do I need an account on workatastartup.com?**
No. The scraper reads publicly accessible listing pages. Note that `applyUrl` typically leads to an authenticated application flow, so you will need your own account to actually apply.

**How many job listings can I scrape at once?**
`maxResults` sets the maximum and defaults to 25. Raise it for larger sweeps; the practical limit is how many listings match your filters on the board.

**Can I filter by role category?**
Yes. `roleFilter` accepts engineering, design, recruiting, science, product, operations, sales, marketing, legal or finance, or an empty string for all categories.

**How does the location filter work?**
`locationFilter` is a case-insensitive substring match against the listing's location text. "Remote" matches any listing whose location mentions remote work; "San Francisco" matches "San Francisco, CA".

**Is salary data included in the output?**
Yes, when the company publishes it. You get the displayed `salaryRange` plus parsed `salaryMin`, `salaryMax` and `salaryCurrency`, which is what makes numeric analysis possible.

**Does it capture equity as well as salary?**
Yes. `equity` holds the displayed range and `equityMin` and `equityMax` hold the parsed bounds, where the listing publishes them.

**What company information comes with each job?**
`companyName`, `companySlug`, `companyUrl`, `companyTagline`, `companyDescription`, `companyHiringDescription`, `companyWebsite`, `companyLogo`, `companyIndustry`, `companyLocation`, `companyStatus`, `companyTechStack`, `companyFounded`, `companyTeamSize`, `ycBatch` and `founders`.

**Can I find only remote startup jobs?**
Yes. Set `locationFilter` to "Remote", or scrape more broadly and filter on the boolean `isRemote` field afterwards, which is the more reliable of the two approaches.

**Does the scraper tell me about visa sponsorship?**
The `visaSponsorship` field returns whatever the listing publishes on the subject. Not every company states a position, so the field can be empty.

**Can I see a company's interview process?**
Where the company publishes it, `interviewProcess` returns that text. It is one of the more useful fields for candidates preparing applications.

**Do I need a proxy to run this scraper?**
No. The actor works directly against the source site and does not require proxy configuration.

**Can I schedule recurring scrapes of the YC job board?**
Yes. Use Apify's Scheduler with saved input and compare `jobId` values between runs to spot new listings. Combined with a webhook, this makes an effective new-job alerting system.

**What export formats are supported?**
JSON, CSV, Excel and XML from the Apify Console, or the items directly in the API response via `run-sync-get-dataset-items`. JSON preserves the `skills` and `founders` arrays; CSV flattens them.

**Why do `description` and `descriptionHtml` both exist?**
`description` is plain text, which is what you want for keyword analysis, embeddings or LLM processing. `descriptionHtml` preserves the original markup, which is what you want if you are rendering the listing in your own interface.

***

### 🆘 Support & Feedback

Hit a bug, a parsing problem, or a filter behaving unexpectedly? Open a ticket in the **Issues** tab on the actor page and include the run ID and your input so it can be reproduced.

Need a custom build — additional fields, a different filtering model, or direct delivery into your ATS or data warehouse? Email **scraperhubapi@gmail.com** with your requirements.

If the Y Combinator jobs scraper is useful to you, please leave a rating and a short review on the actor page. Feedback directly shapes what gets improved next.

***

### ⚖️ Disclaimer

This Y Combinator jobs scraper collects only publicly available job listing data from workatastartup.com — the same information any visitor to the board can see. It does not authenticate, does not access private employer dashboards, and does not retrieve applicant data of any kind.

You are responsible for how you use this actor and the data it produces, including compliance with workatastartup.com's terms of service and Y Combinator's policies. Scraped job data should be used for legitimate purposes such as job searching, market research, recruitment intelligence and analysis — not for spamming employers or republishing listings as if they were your own.

Some fields, notably `founders` and company profile text, may contain personal data. Under GDPR, CCPA and comparable privacy regimes you act as the data controller for anything you store: keep only what you need, secure it appropriately, and honour access and deletion requests. Using founder or company contact information for unsolicited outreach is subject to marketing and anti-spam law in your jurisdiction.

Job listing content, descriptions and company logos remain the property of the respective companies. If you believe data collected through this actor should be removed, contact **scraperhubapi@gmail.com** with the details and the request will be handled.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text search term, matched the same way as the search box on workatastartup.com/jobs (e.g. "software engineer").

## `roleFilter` (type: `string`):

Restrict results to one role category.

## `locationFilter` (type: `string`):

Only keep jobs whose location text contains this string (e.g. "San Francisco", "Remote"). Case-insensitive substring match.

## `maxResults` (type: `integer`):

Maximum number of job listings to scrape.

## Actor input object example

```json
{
  "searchQuery": "",
  "roleFilter": "",
  "locationFilter": "",
  "maxResults": 25
}
```

# Actor output Schema

## `results` (type: `string`):

Records scraped by Y Combinator Jobs Scraper, stored in the run's default dataset.

# 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 = {};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {}

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

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

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

```

## CLI example

```bash
echo '{}' |
apify call scrapers-hub/workatastartup-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

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

## OpenAPI specification

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