# Job Search Scraper — Live Jobs Direct from Company Career Pages (`spool/job-search`) Actor

Live jobs read straight from 768 employers' career pages on 17 ATS platforms (Greenhouse, Workday, Lever, Ashby, SuccessFactors, Oracle). No reposts, no ghost jobs. Filter by title, keyword, category, location, remote, salary, experience and visa.

- **URL**: https://apify.com/spool/job-search.md
- **Developed by:** [Spool](https://apify.com/spool) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 9 total users, 4 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 job postings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Search live job listings read straight from company career pages**, across 1,129 verified employers on 17 ATS platforms: Greenhouse, Workday, Lever, Ashby, SmartRecruiters, SAP SuccessFactors, Oracle Cloud HCM, Phenom, Eightfold and more. Powered by the spool job engine. **No job-board reposts, no expired or ghost jobs, no proxies, no login.**

```
Senior Software Engineer, Payments     Stripe        Remote, US        $180,000–$260,000   Software Engineering · senior   greenhouse
Staff Machine Learning Engineer        Databricks    San Francisco     $190,000–$285,000   AI & Machine Learning · lead    greenhouse
Lead, Systems Engineering              L3Harris      Ottawa, CA        $126,500–$176,500   Manufacturing & Hardware        successfactors
Security Engineer, Cloud               Ramp          New York (HQ)     $175,000–$220,000   Security · mid                  ashby
```

### Why this scraper instead of scraping LinkedIn or Indeed?

- **Direct from the source.** Every posting comes from the employer's own career page, read at query time. What you get is what the employer shows today, with the real posting date and the direct application link.
- **No expired or ghost jobs.** Nothing is served from a stale database. A posting that is gone from the career page cannot appear in your results.
- **No duplicate spam.** One canonical listing per role. Set the deduplication mode to collapse an employer's multi-location copies into one row.
- **Enriched fields on every row.** Job category (30), employment type, experience level and years asked, visa sponsorship, education, 190 technologies as skills, salary annualised in USD, parsed city, region and country, remote or hybrid or on-site.
- **No proxies.** The boards publish public JSON meant for exactly this, so runs are cheap and start fast: the first rows land within seconds, the 300 largest employers finish in about four minutes, the whole list of 1,129 in about twelve.

### What you can filter by

| Filter | Examples |
|---|---|
| Job titles | Software Engineer, Account Executive, Data Analyst (phrase or every word in the title) |
| Keywords | Python, Kubernetes, HIPAA, Salesforce — in the title, skills or posting text, any of them |
| Job categories | 30 categories, from Software Engineering and AI & Machine Learning to Healthcare and Skilled Trades |
| Workplace type | Remote, hybrid, on-site |
| Location | New York · Texas · London · Germany, matched against the employer's label and the parsed city, region, country |
| Countries | Two-letter codes: US, CA, GB, DE, IN |
| Employment type | Full-time, part-time, contract, internship, temporary |
| Experience | junior → executive, plus minimum and maximum years of experience asked |
| Posted | Within the last N days |
| ATS platform | Greenhouse, Workday, Lever, Ashby and 13 more |
| Salary | Only postings with a stated salary; a USD floor, annualised |
| Visa sponsorship | Only postings whose text says sponsorship is available |
| Technologies | Only postings naming any of these (190 recognised) |
| Companies | Add your own employers by name, domain or careers URL; they are found through their careers page if needed |
| Extras | Deduplicate by company and title, only new since last run, up to 5,000 results per run |

### Output

Each result carries: job title, company and website, direct application link, ATS platform and board URL, a stable `jobSlug` for syncing, posting date and days since posting, location with parsed city, region, country and workplace type, employment type, job category, department, experience level and years of experience, education level, visa sponsorship (true, false or not stated), salary as stated and annualised in USD, skills and skill categories, the employer's own description as clean text, and the title or keyword that matched.

```json
{
  "jobTitle": "Senior Software Engineer, Data Infrastructure",
  "company": "Stripe",
  "companyWebsite": "stripe.com",
  "applicationLink": "https://stripe.com/jobs/listing/senior-software-engineer-data-infrastructure/6198542",
  "jobBoard": "greenhouse",
  "datePosted": "2026-10-03",
  "location": "Toronto, Canada",
  "locationType": "hybrid",
  "country": "CA",
  "employmentType": "fulltime",
  "jobCategory": "Software Engineering",
  "experienceLevel": "senior",
  "yearsExperienceMin": 5,
  "visaSponsorship": null,
  "salaryMinUsd": 164000,
  "salaryMaxUsd": 246000,
  "skills": ["Python", "Kafka", "Kubernetes", "AWS"]
}
```

Export to JSON, CSV or Excel, or feed it into Make, n8n, Zapier, Google Sheets or the Apify API. The *Jobs*, *Salaries in USD* and *Experience, visa, education* views on the Output tab each show their own columns.

### Example searches

**Job seeker, a daily remote digest.** Job titles `Software Engineer`, workplace type `remote`, experience level `senior`, minimum salary 150000, posted within 7 days. Run it on an Apify Schedule every morning with *Only new since last run* on and add the Gmail or Slack integration: new matches arrive in your inbox, nothing twice.

```json
{ "jobTitles": ["software engineer"], "workplaceType": ["remote"], "experienceLevel": ["senior"], "minSalaryUsd": 150000, "postedWithinDays": 7, "onlyNew": true }
```

**Recruiter, map a niche talent market.** Job category `Sales`, keywords `fintech`, employer pool 800. Export to Excel and you have every live sales opening at the verified employers that mention fintech, with salaries where stated.

```json
{ "jobCategories": ["Sales"], "keywords": ["fintech"], "employerPool": 800 }
```

**Sponsorship search.** Keywords `Kubernetes`, visa sponsorship on, countries `US`. Only postings whose text says sponsorship is available.

```json
{ "keywords": ["Kubernetes"], "visaSponsorship": true, "countries": ["US"] }
```

**Data team, keep a job board fresh.** One category per scheduled run, `maxResults` 5000, deduplicate by company and title, only new since last run. Insert by `jobSlug`; a posting that disappears from a career page simply stops coming back.

```json
{ "jobCategories": ["Data & Analytics"], "maxResults": 5000, "dedupeMode": "companyTitle", "onlyNew": true, "employerPool": 800 }
```

**Your own watch-list, searched the same way.** Add companies by name, domain or careers URL; they are found through their careers page when the name alone is not enough.

```json
{ "jobTitles": ["account executive"], "companies": ["Datadog", "stripe.com", "https://jobs.ashbyhq.com/ramp"], "employerPool": 0 }
```

**Measured on the platform, 11 October 2026 (builds 1.0.6 to 1.0.8).** Every row below is one real run; costs are the per-posting charge, before the Actor start.

| Search | Boards | Postings scanned | Delivered | First rows | Done | Cost |
|---|---|---|---|---|---|---|
| Default: remote software engineers, last 30 days | 300 | 60,818 | 285 (217 with salary, 261 with description) | 1.8 s | 3 min 45 s | $0.86 |
| Three named companies, account executive and SDR titles | 3 | 1,328 | 100 | 1.8 s | 2.2 s | $0.30 |
| Keyword `Kubernetes`, stated salary only | 32 | 18,777 | 150 | 98 s | 98 s | $0.45 |
| US tech roles offering visa sponsorship (cap 60) | 250 | 272,781 listed | 57, all with the sponsorship sentence | 78 s | 7 min 24 s | $0.17 |
| Remote roles posted in the last 24 hours (cap 60) | 250 | 285,419 listed | 7, all dated today or yesterday | 12 s | 2 min 22 s | $0.02 |
| Software, data and AI internships (cap 60) | 250 | 18,106 | 60, all internships | 6 s | 2 min 35 s | $0.18 |
| Entry-level software engineers, two years or less (cap 60) | 250 | 18,506 | 60 | 3.5 s | 80 s | $0.18 |
| Workday employers only (cap 60) | 82 | 6,400 | 60, all Workday | 4.7 s | 32 s | $0.18 |
| Tech roles paying $200k or more (cap 60) | 250 | 28,481 | 65, every one at or above the floor | 58 s | 5 min 14 s | $0.20 |

Searches that depend on the posting text (keywords, visa sponsorship, salary floors, years of experience) read every candidate's description and take longer; title, category, location, platform and date searches are answered from the listings and start within seconds.

### Ready-made searches

Each of these is a public task with its own page and schedule button. Open one, press Start, or save it as your own and change the filters.

| Search | What it returns |
|---|---|
| [Remote senior software engineer jobs](https://apify.com/spool/remote-senior-software-engineer-jobs) | Remote, senior, posted in the last 7 days |
| [Remote jobs posted today](https://apify.com/spool/remote-jobs-posted-today) | Every remote role published in the last 24 hours, the whole list |
| [Visa sponsorship tech jobs USA](https://apify.com/spool/visa-sponsorship-tech-jobs-usa) | US tech roles whose text says sponsorship is available |
| [Tech jobs paying over $200k](https://apify.com/spool/tech-jobs-over-200k-salary) | Stated pay of $200,000 a year or more, annualised in USD |
| [Entry-level software engineer jobs](https://apify.com/spool/entry-level-software-engineer-jobs) | Junior roles asking for two years of experience or less |
| [Software engineering internships](https://apify.com/spool/software-engineering-internships) | Internships and co-ops in software, data and AI |
| [Remote data engineer jobs](https://apify.com/spool/remote-data-engineer-jobs) | Data and analytics engineers, posted in 14 days |
| [Machine learning engineer jobs](https://apify.com/spool/machine-learning-engineer-jobs) | The AI and machine learning category, 30 days |
| [Product manager jobs](https://apify.com/spool/product-manager-jobs-live) | Product management roles, 30 days |
| [Workday jobs](https://apify.com/spool/workday-jobs-live) | Every Workday employer in the verified list |

### Input

| Field | Type | What it does |
|---|---|---|
| `jobTitles` | list | Keep postings whose title contains the phrase or every word of it |
| `keywords` | list | Keep postings naming any of these in the title, skills or text |
| `jobCategories` | list | One or more of the 30 categories |
| `workplaceType` | list | `remote`, `hybrid`, `onsite` |
| `location` | text | Location label, city, region or country contains this text |
| `countries` | list | Two-letter codes |
| `employmentType` | list | `fulltime`, `parttime`, `contract`, `internship`, `temporary` |
| `experienceLevel` | list | `junior`, `mid`, `senior`, `manager`, `director`, `executive` |
| `minYearsExperience`, `maxYearsExperience` | number | Against the years the posting asks for; postings stating no number are kept |
| `postedWithinDays` | number | Employer's posting or update date within N days |
| `atsPlatforms` | list | Only employers on these systems |
| `requireSalary`, `minSalaryUsd` | flag, number | Stated salary only; USD floor, annualised |
| `visaSponsorship` | flag | Only postings whose text says sponsorship is available |
| `requireTech` | list | Only postings naming any of these technologies |
| `companies` | list | Extra employers by name, domain or careers URL, up to 100 |
| `employerPool` | number | How many verified employers to search, largest first (default 300, up to the whole list) |
| `maxResults` | number | Stop after this many postings (default 500, up to 5,000) |
| `dedupeMode` | choice | `location` (default), `companyTitle`, `none` |
| `maxDescriptionsPerBoard` | number | Descriptions per Workday, Oracle, SuccessFactors, Phenom or Eightfold board |
| `onlyNew`, `monitorName` | flag, text | Only postings not delivered before; the memory record's name |

### Output fields

| Field | Meaning |
|---|---|
| `jobTitle`, `company`, `companyWebsite`, `companyIndustry`, `companySize` | The posting's title and the employer, with industry and team size where the verified list knows them |
| `applicationLink`, `jobBoard`, `boardUrl`, `jobId`, `jobSlug` | Direct apply link, the ATS platform, the board, the platform's id, and a stable key for syncing |
| `datePosted`, `postedDaysAgo` | The employer's own date |
| `location`, `city`, `region`, `country`, `locationType`, `isRemote` | As stated, then parsed; `remote`, `hybrid` or `onsite` |
| `employmentType`, `jobCategory`, `department`, `experienceLevel` | From the platform's field where it has one, otherwise from the title and text |
| `yearsExperienceMin`, `yearsExperienceMax`, `educationLevel`, `visaSponsorship` | Read from the posting text; `visaSponsorship` is true, false or null |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryMinUsd`, `salaryMaxUsd`, `salarySource`, `hasSalary` | As stated, then annualised in USD; `ats` or `description` |
| `skills`, `skillCategories` | Technologies named in the posting, 190 recognised |
| `descriptionText`, `descriptionChars`, `matchedOn`, `dedupeKey`, `firstSeenAt` | The employer's text, what matched, and the only-new bookkeeping |

### Live search or jobs database?

| | This Actor | A jobs database API |
|---|---|---|
| Where results come from | The employer's career page, read when you run it | A crawl stored hours or days ago |
| Expired and ghost jobs | Cannot appear | Removed when the next re-check finds them gone |
| Coverage | 1,129 verified employers plus any company you name | Whatever the database crawled |
| Time to results | First rows in seconds; 300 employers in about four minutes | Seconds |
| Proxies | None | Not your concern |
| Best for | Feeds that must be exact, watch-lists, company-level signals | Broad keyword search across the whole market |

### Where the jobs come from

The search runs live over a bundled, verified list of 1,129 employers whose public boards answered when the list was built: Ashby (474), Greenhouse (293), Workday (82), Lever (72), Phenom (30), SAP SuccessFactors (30), Breezy (24), Oracle Cloud HCM (21), Rippling (20), Eightfold (16), Pinpoint (16), Personio (15), Teamtailor (13), SmartRecruiters (12), BambooHR, Recruitee and Amazon. Together they hold about 68,000 open roles on any given day, and 610 of the companies carry their industry and team size from the YC company data, from Stripe, Databricks, OpenAI and Anthropic to Lockheed Martin, Capital One, JPMorgan Chase, Nvidia, ExxonMobil and L3Harris. `employerPool` sets how many of them to search, largest first; `companies` adds any employer you name.

The list is rebuilt from benchmarks of the S\&P 500 and 2,000 YC companies and grows with every pass. Companies you add are resolved by the same engine: name → board slug on every platform at once → the company's careers page and the system behind it, within six requests and ten seconds.

### Pricing

**$3.00 per 1,000 postings, on every plan.** Pay per result: you are charged for postings actually delivered, up to 5,000 per run, plus Apify's small Actor-start fee. Duplicates, postings removed by your filters and postings already delivered in only-new mode cost nothing.

| Search | Postings | Cost |
|---|---|---|
| Default run (remote software engineers, last 30 days, 300 employers) | 285 | $0.86 |
| 1,000 postings | 1,000 | $3.00 |
| A category across the whole list, 5,000 cap | up to 5,000 | up to $15.00 |
| Daily only-new feed on a quiet day | 0 | the Actor start |

The free plan's $5 monthly credit covers about 1,600 postings.

### Use it from an AI agent, the API or an integration

**MCP.** Add the Apify MCP server to Claude, Cursor or any MCP client and the agent can call this Actor as a tool: *"Find remote senior data engineering roles posted this week that pay over $180k and mention Snowflake."*

```
https://mcp.apify.com/?tools=spool/job-search
```

**API.** `POST https://api.apify.com/v2/acts/spool~job-search/run-sync-get-dataset-items?token=…` with the filters as JSON returns the rows in one call; an empty body runs the default search. **Python and JavaScript:** `client.actor("spool/job-search").call(run_input={...})` with `apify-client`. **Schedules and integrations:** run daily with `onlyNew` and push rows to Google Sheets, Airtable, Slack, HubSpot or a webhook from the Integrations tab.

### FAQ

**Do I need an account or API key for the job boards?** No. The boards publish public listings; the Actor reads them directly. You pay per result through Apify only.

**How is this different from a jobs database API?** A database serves what it crawled hours or days ago and must re-check listings to remove the expired ones. This Actor reads the career pages when you run it, so the results are the employer's live board. The trade-off is time: rows start within seconds, but a search over the 300 largest employers takes about four minutes to finish and the whole list about twelve.

**Why do I sometimes see the same job more than once?** Some employers publish one posting per location. Set *Deduplicate results* to `companyTitle` to collapse them; skipped duplicates are not billed.

**Can I run it on a schedule and get only new jobs?** Yes. Turn on *Only new since last run*: the search remembers every posting it delivered, in a key-value store in your own account, and returns only new ones next time. The first run returns normal results and records the starting point. Changing the filters starts a fresh memory unless you set a `monitorName`.

**What does "visa sponsorship" mean here?** `true` when the posting text says sponsorship is available, `false` when it says it is not, `null` when it says nothing. The filter keeps only `true`.

**How fresh are the dates?** `datePosted` is the employer's own posting or last-update date. Where a platform gives no date, the field is empty and the posting is kept by the date filter rather than silently dropped.

**A company I added was not found.** `RUN_SUMMARY.companies.notFound` says why: the careers page uses a system the engine cannot read yet (iCIMS, Paradox, Taleo, Avature, ADP, UKG are recognised and named), the website did not answer, or no careers page was found. Paste the careers URL and the engine reads what is behind it.

**Is this legal?** The data comes from job listings employers publish openly on their own career pages through public endpoints intended for exactly this. No login, no candidate data, no paywall bypass. Handle any personal data a description happens to contain according to the law that applies to you.

### Changelog

**1.1.0 — 2026-10-11.** The verified list grows to 1,129 employers (68,000 open roles) after a pass over 1,475 more YC companies; 610 of them carry industry and team size, now on every row as `companyIndustry` and `companySize`. Employment type comes from the platform's own field on Ashby, Lever, Workday and SmartRecruiters. Category, seniority, employment and date filters now run before descriptions are fetched, so filter-only searches finish in a fraction of the time; filters that need the posting text (keywords, visa sponsorship, years, salary floor, technologies) read every candidate's description. Date filters only return dated postings; Workday roles get their date from the listing. Live progress messages during the run.

**1.0.0 — 2026-10-11.** First release: live search over 768 verified employers on 17 ATS platforms plus any company you name; filters for titles, keywords, 30 categories, workplace type, location and country, employment type, experience level and years, posting date, platform, salary, visa sponsorship and technologies; deduplication modes; only-new mode; rows delivered in waves as boards answer.

### More from spool

- **[Career Page Scraper & ATS Jobs API — 17 ATS Platforms, No Proxy](https://apify.com/spool/career-page-jobs-api)** — whole boards for the companies you name, with hiring profiles per company
- **[Job Board API — LinkedIn, Indeed, Glassdoor, Workday + 28 More](https://apify.com/spool/job-board-api)** — one search across 33 sources with the employer's posting attached
- **[Company Tech Stack API — Detected from Job Postings](https://apify.com/spool/company-tech-stack-api)** — a company's technologies read from its own job board

# Actor input Schema

## `jobTitles` (type: `array`):

Roles to look for, one per line: `Software Engineer`, `Account Executive`, `Data Analyst`. A posting matches when the whole phrase appears in its title or every word of it does (`machine learning engineer` matches *Senior Engineer, Machine Learning*). Leave empty to search by keywords or category alone.

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

Skills, technologies or words that must appear in the title or the posting text: `Python`, `Kubernetes`, `HIPAA`, `Salesforce`. Any keyword matching is enough (OR). Used together with job titles, a posting must satisfy both.

## `jobCategories` (type: `array`):

Keep postings filed under these categories (30 categories, derived from the title and the employer's department label).

## `workplaceType` (type: `array`):

Remote, hybrid or on-site, read from the employer's own location label and the posting text. Leave empty for all.

## `location` (type: `string`):

Keep postings whose location mentions this text: `New York`, `London`, `Texas`, `Germany`. Matched against the employer's location label and the parsed city, region and country.

## `countries` (type: `array`):

Two-letter country codes to keep: `US`, `GB`, `DE`, `IN`. Parsed from the location label or a known city. Postings with no recognisable country are kept unless you also set a location.

## `employmentType` (type: `array`):

Full-time, part-time, contract, internship or temporary. Leave empty for all.

## `experienceLevel` (type: `array`):

Seniority read from the title: junior, mid, senior, manager, director, executive.

## `minYearsExperience` (type: `integer`):

Keep postings asking for at least this many years (`5+ years of experience`). Postings that state no number are kept.

## `maxYearsExperience` (type: `integer`):

Keep postings whose minimum requirement is at most this many years. `2` keeps entry-level and early-career roles. Postings that state no number are kept.

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

Keep postings the employer published or updated within this many days. Postings that carry no date are left out when this is set (Rippling and Breezy boards publish none; Workday-type boards only for the roles whose details were read). Empty = all open roles.

## `atsPlatforms` (type: `array`):

Only search employers on these systems. Leave empty for all 17.

## `requireSalary` (type: `boolean`):

Keep rows with a salary from the employer's structured fields or from a pay range stated in the posting text.

## `minSalaryUsd` (type: `integer`):

Compared against the annualised USD figure, so an hourly US wage and a monthly EUR salary are judged on one scale. Postings with no salary are dropped when this is set.

## `visaSponsorship` (type: `boolean`):

Keep postings whose text says sponsorship is available (`visa sponsorship available`, `H-1B transfers welcome`). Needs the posting text, so descriptions are read for every candidate. Postings that say sponsorship is not offered are marked `visaSponsorship: false` in the output.

## `requireTech` (type: `array`):

Keep rows whose text names any of these: `Kubernetes`, `Snowflake`, `Salesforce`, `React`… 190 technologies are recognised; spell them as in the `skills` output field.

## `companies` (type: `array`):

Employer names, domains or careers URLs, one per line (`Stripe`, `ramp.com`, `https://jobs.ashbyhq.com/openai`). Each is resolved to its public board, through its careers page if needed, and searched with the same filters. Up to 100.

## `employerPool` (type: `integer`):

How many boards from the verified list of 1,129 to search, largest first. Rows start arriving within seconds; 300 covers the biggest employers in about four minutes, the whole list in about twelve. 0 searches only the companies you list.

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

Stop after this many postings. Rows arrive as boards answer, so the first results land within seconds.

## `dedupeMode` (type: `string`):

`location` keeps one row per company, title and city (default). `companyTitle` collapses an employer's multi-location postings into one row. `none` keeps every posting.

## `maxDescriptionsPerBoard` (type: `integer`):

Those platforms need one request per posting for its description; Greenhouse, Ashby and Lever send every description in the listing. Lower is faster.

## `onlyNew` (type: `boolean`):

Remember every posting this search has delivered and return only the ones not seen before. Memory is one record per search in a key-value store named `job-search-monitor` in your own account; postings not seen for 60 days are forgotten. Nothing delivered earlier is charged again.

## `monitorName` (type: `string`):

Name of the memory record. Leave empty and it is derived from the filters, so the same search always shares one memory. Set a name to share memory between searches, or change it to start fresh. It is a label, not a credential.

## Actor input object example

```json
{
  "jobTitles": [
    "data engineer",
    "product manager"
  ],
  "keywords": [
    "Python",
    "Kubernetes"
  ],
  "workplaceType": [
    "remote"
  ],
  "countries": [
    "US",
    "CA"
  ],
  "postedWithinDays": 30,
  "requireSalary": false,
  "visaSponsorship": false,
  "companies": [
    "Anthropic",
    "nvidia.com"
  ],
  "employerPool": 300,
  "maxResults": 500,
  "dedupeMode": "location",
  "maxDescriptionsPerBoard": 30,
  "onlyNew": false
}
```

# Actor output Schema

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

Every posting delivered: title, company, location, category, experience, employment type, salary in USD, platform, apply link.

## `salaries` (type: `string`):

Postings with a stated salary, as stated and annualised in USD.

## `requirements` (type: `string`):

Years of experience, education level, visa sponsorship and skills per posting.

## `runSummary` (type: `string`):

Boards searched and answered, postings scanned and matched, what each filter removed, delivery waves and timing.

# 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 = {
    "jobTitles": [
        "software engineer"
    ],
    "workplaceType": [
        "remote"
    ],
    "postedWithinDays": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("spool/job-search").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 = {
    "jobTitles": ["software engineer"],
    "workplaceType": ["remote"],
    "postedWithinDays": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("spool/job-search").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 '{
  "jobTitles": [
    "software engineer"
  ],
  "workplaceType": [
    "remote"
  ],
  "postedWithinDays": 30
}' |
apify call spool/job-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,spool/job-search"
        }
    }
}
```

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/LtdNwd9d7xjW2CLUg/builds/Zczm8eIQsgep63S1T/openapi.json