Notion is the collaborative AI workspace where teams and agents β¦",
"sections": [],
"customFields": {},
"applicationQuestions": [],
"companyEmails": [],
"companyPhones": [],
"companySocialLinks": [],
"matchedKeywords": [],
"sourceInput": "ashby:notion",
"scrapedAt": "2026-10-21T22:58:00.128Z"
}
```
You can download the dataset in various formats such as JSON, HTML, CSV or Excel. The Output tab also has a **salaries** view.
#### All 79 fields
| Fields | What you get |
| --- | --- |
| `id`, `globalId` | the job's ID on its ATS, and `ats:companySlug:id` β unique across every ATS and company, the key to merge runs: `ashby:notion:1fc309c8-β¦` |
| `url`, `applyUrl` | the job page and the application form |
| `status` | `open`, `updated` (delivered before and changed since) or `closed` (taken down from its board) |
| `ats`, `companySlug`, `boardUrl`, `sourceApiUrl` | `ashby`, `notion`, `https://jobs.ashbyhq.com/notion`, and the address the job was read from |
| `companyName`, `hiringOrganization`, `companyOpenJobs` | **Company**: `Notion`, the hiring entity when named apart (Personio; Workday with **Extract job details**), `137` open jobs on the whole board, before your filters |
| `companyWebsite`, `companyDomain`, `companyLogoUrl`, `companyDescription` | website and domain (the domain you typed, Ashby's company profile with **Company contact e-mails**, or the careers page linked by Greenhouse or Recruitee), logo (not filled yet: always empty), about-the-company text (SmartRecruiters and Rippling, with **Extract job details**) |
| `title` | `Software Engineer, AI Connections (Developer Platform)` |
| `department`, `departments`, `team`, `jobFunction`, `industry` | **Team**: `Engineering`, every department (parent first), team, job function or category, industry (SmartRecruiters) |
| `location`, `locations`, `city`, `region`, `postalCode` | **Location**: `San Francisco, California`, every location of the job, `San Francisco`, `California`, postal code |
| `country`, `countryCode`, `countryCodes`, `latitude`, `longitude` | `United States`, `US`, the codes of every location, coordinates (SmartRecruiters) |
| `workplaceType`, `isRemote` | `remote`, `hybrid` or `onsite`; `true` when the job can be done fully remote |
| `employmentType`, `employmentTypeRaw` | `full-time`, `part-time`, `contract`, `temporary`, `internship`, `apprenticeship` or `volunteer`; as published: `FullTime` |
| `seniority`, `experienceLevelRaw` | `intern`, `junior`, `mid`, `senior`, `lead`, `manager`, `director` or `executive`; the level as published |
| `minYearsExperience`, `maxYearsExperience`, `educationLevel` | **Profile asked**: `10`, `10` (`3-5 years` gives 3 and 5), `master` (`high-school`, `bachelor`, `master` or `phd`) |
| `skills` | `["TypeScript", "LLM"]`, from a fixed list of common skills |
| `visaSponsorship`, `securityClearance` | `true`, `false`, or `null` when the job says nothing |
| `recruiterName` | the recruiter who published the job (SmartRecruiters) |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | **Salary**: `272000`, `304000`, `USD`, `year` (or `month`, `week`, `day`, `hour`) |
| `salaryMinYearly`, `salaryMaxYearly` | converted to a year (hour Γ 2,080, day Γ 260, week Γ 52, month Γ 12): `$33.65 - $38.70 per hour` gives `69992` and `80496` |
| `salaryText`, `salarySource`, `salaryRanges`, `offersEquity` | `$272,000 β $304,000 per year`; `ats`, `pay-transparency` or `description`; every pay range (by location or tier); equity (Ashby) |
| `publishedAt`, `updatedAt`, `postedOnText`, `postedDaysAgo` | **Dates**: `2026-08-24T14:44:49.699Z` (the day alone, `2026-09-21`, when the ATS gives no time: Workable, BambooHR, Workday), last update (Greenhouse and Recruitee), `Posted 30+ Days Ago` (Workday), `58` |
| `applicationDeadline`, `requisitionId`, `internalJobId` | last day to apply, as written by the job (`2026-11-30`; Greenhouse and Recruitee), the company's reference of the opening, its internal ID |
| `language` | `en` |
| `description`, `descriptionHtml` | **Text**: the full description, plain text and HTML (HTML up to 200,000 characters) |
| `requirements`, `benefits`, `sections` | requirements and benefits when the ATS publishes them apart, the titled sections of the description |
| `customFields` | the fields the company added on its ATS, name β value |
| `applicationQuestions` | with **Application form questions**: label, type, required, choices |
| `companyEmails`, `companyPhones`, `companySocialLinks` | with **Company contact e-mails**: public e-mails, phone numbers, LinkedIn, X, Facebook⦠pages |
| `matchedKeywords`, `sourceInput` | the keywords the job matched; the company or link you typed (`directory` for the directory) |
| `firstSeenAt`, `lastSeenAt`, `closedAt` | with **Only new jobs**: first delivered, last run that found it, taken down at |
| `scrapedAt` | ISO timestamp of the extraction |
### π‘ Tips
#### Search the whole directory
Tick **Search all companies in our directory** to read the career pages of 17,463 companies checked on 21-22 October 2026 (about 1,009,000 open jobs between them when they were checked), the largest boards first, up to **Max companies from the directory** (500 by default, 0 = all). Narrow them down with **ATS platforms**, **Only these companies** and **Exclude companies**, then keep the jobs you want with keywords and filters.
| ATS | Companies | Open jobs when checked |
| --- | --- | --- |
| Workable | 3,684 | 65,934 |
| Greenhouse | 3,548 | 145,226 |
| BambooHR | 2,556 | 18,496 |
| Workday | 1,962 | 498,730 |
| Ashby | 1,783 | 42,813 |
| Personio | 1,619 | 15,302 |
| Teamtailor | 634 | 7,784 |
| SmartRecruiters | 611 | 185,711 |
| Rippling | 400 | 5,239 |
| Recruitee | 372 | 8,006 |
| Lever | 294 | 15,690 |
#### How to get more results
Set `maxItems` to `0`, leave `maxItemsPerQuery` at `0`, and use broad keywords. Big Workday boards are read past 2,000 jobs, nothing to set. With `searchInDescription`, a keyword written only in the description is found too.
#### How to reduce costs
The price is per job, so the levers are `maxItems`, `maxItemsPerQuery`, the filters (a job a filter drops costs only the small filter fee) and `onlyNew` for recurring runs (you never pay twice for the same job, unless it changed and you ticked `includeUpdatedJobs`). Leave the paid options off unless you need them: Greenhouse, Lever, Ashby, Recruitee, Personio and Teamtailor already give the full description.
#### Several keywords and places in one run
Fill `searchQueries` and / or `locations`, up to 100 each (plus the single `query` and `location`): a job is kept when it matches any keyword and any place, and is saved β and charged β once, with the keywords it matched in `matchedKeywords`. The single `query` and `location` fields still work and are added to the lists. Set `maxItemsPerQuery` to give every company board its own cap: without it, the first big boards can use up the whole `maxItems` budget.
#### Monitoring: new, updated and taken-down jobs
Tick **Only new jobs** (`onlyNew`) and schedule the Actor. The first run returns everything; each later run skips the jobs already delivered: they are not saved and not charged. The memory lives in a named key-value store of your account (`ats-jobs-scraper-seen`, up to 150,000 listings per key) and is only updated with jobs that really reached the dataset, so a failed run never hides anything. Give each schedule its own `stateKey` (two schedules sharing a key would hide each other's jobs), and tick `resetState` once to start over.
Add **Also report updated jobs** to get a job again when its title, locations, salary, description or dates changed (`status` = `updated`), and **Report jobs taken down** to get, once, each delivered job that is no longer on its company board (`status` = `closed`, with `closedAt`). Tick them from the first run of the schedule: jobs are followed from a run that has one of them ticked. A board is judged only when the run read it in full: a board that failed, was cut by a cap, was searched for a keyword on the ATS itself, or is a Workday board of 2,000 jobs or more reports no job taken down. Up to 4,000 jobs are followed in each of 32 records (a company board always in the same one): past that, the next jobs of a full record are not reported as updated or taken down.
#### Salary filters
`minSalary` and `maxSalary` compare the yearly amount (hour Γ 2,080, day Γ 260, week Γ 52, month Γ 12) in `salaryCurrency` (USD by default). There is no currency conversion: a job paid in another currency is dropped, and so is a job without a salary unless you tick `keepJobsWithoutSalary`. The salary comes from the ATS's pay fields, from the pay ranges Greenhouse publishes (with `includeApplicationQuestions`), or from an amount written in the description β `salarySource` tells which.
#### Filter by publication date
`postedAfter` and `postedBefore` take a date (`2026-09-01`, the whole day is included) or a period before now (`7 days`, `2 weeks`, `24 hours`). They read `publishedAt`; on Workday without **Extract job details**, that is the day computed from "Posted 3 Days Ago" ("30+ Days Ago" counts as 30 days) β unless one of your date bounds is more than 30 days ago: then the page of each "30+ Days Ago" job is opened to read its exact date (one more request per such job, not charged as **Extract job details**). A job without a date is dropped as soon as a date bound is set. `updatedAfter` reads `updatedAt`, or `publishedAt` when the ATS gives no update date. Filtered-out jobs are not saved and do not count in `maxItems`.
### π Integrations and API
Call the Actor via the Apify API, the JavaScript or Python clients, or connect it with integrations and webhooks (Make, Zapier, n8n, Google Sheets, Slack, Airtableβ¦). The dataset can be fetched as JSON or CSV from any tool.
### π€ Use with AI agents (MCP)
AI agents and assistants (any MCP client) can find and run this Actor through the [Apify MCP server](https://mcp.apify.com), billed to their Apify account like any run. It returns one item per job posting. Actor id: `nice_dev/ats-jobs-scraper`; MCP server with this Actor only: `https://mcp.apify.com/?tools=fetch-actor-details,nice_dev/ats-jobs-scraper`.
Smallest input, for a cheap first call:
```json
{
"companies": ["stripe"],
"maxItems": 10
}
```
Key output fields: `title`, `companyName`, `url`, `location`, `workplaceType`, `salaryMinYearly`, `publishedAt`, `description`.
Cost: pay per event β see the pricing section above and the **Pricing** tab. Cap each call with `maxItems` and, through the API, with the run option `maxTotalChargeUsd`.
### β FAQ
#### Is it legal to scrape job postings from career pages?
The Actor only reads the job postings that companies publish on their public career pages for anyone to see. It logs in to nothing and solves no captcha. Results can contain personal data β the name of a recruiter (SmartRecruiters) and, with **Company contact e-mails**, the public e-mails and phone numbers of a company β which is protected by GDPR: do not store it without a legitimate reason. You are responsible for using the data in compliance with the Terms of Use of each career site and ATS and with applicable law. This Actor is not affiliated with Greenhouse, Lever, Ashby, Workday, SmartRecruiters, Recruitee, Workable, Personio, BambooHR, Rippling, Teamtailor or the companies whose jobs it reads.
#### Does it need a login or a proxy?
No login, and no proxy by default. A request a site turns away is retried after a pause of 5 seconds, doubled at each retry up to 150 seconds. If your runs are rate-limited (many companies, frequent schedules), add a proxy in **Proxy configuration**: a refused request is then retried at once on a new proxy session, up to 10 times on top of the retries.
#### Is the data safe to open in Excel or to show on a web page?
Titles and descriptions are the companies' own words, copied as they are. A text can begin with `-`, `+`, `=` or `@`: Excel and Google Sheets may read such a cell of a CSV file as a formula or as a number. The Actor leaves the text as it is, so that the JSON and the API give the real value: when you open a CSV, import these columns as text. `descriptionHtml` is the HTML the ATS publishes, left as it is by the Actor (only cut past 200,000 characters): sanitize it before showing it on a web page, and escape every other field like any text written by a stranger.
#### Known limitations
- **Workday** shows at most 2,000 jobs per search: past that, the Actor splits the board by country, then by job family. If the pieces cannot cover the whole board, the log says that some jobs may be missing. On such a board, a run capped at 20 jobs or fewer without filters gets the first jobs of the career page; with a higher cap or filters, the jobs come from the pieces in no fixed order.
- **Workable** limits each IP to a few hundred requests a day. If a Workable board is still refused, the run goes on with the other boards and its log tells you to add a proxy or to run again the next day.
- With a single keyword, Workday, SmartRecruiters and Workable boards are searched for it on the ATS itself, and `companyOpenJobs` is then empty for them. Set `minOpenJobs` and the whole board is read so that it can be counted.
- **Workday** companies are found by name only when they are in the built-in directory: for another one, give its career page link.
- **Updated and taken-down jobs** are followed in 32 records of up to 4,000 jobs each, a company board always in the same record. Once a record is full, the next jobs put in it are not followed: they are never reported as updated or taken down, and the log warns once.
- `descriptionMaxLength` = 0 gives the full text up to 32,000 characters: a longer description is cut there.
- Fields detected from the job text are empty when the text does not say it: a job that names no degree has no `educationLevel`.
- `onlyNew` remembers job IDs: a job that changed comes back only with `includeUpdatedJobs`.
- Two runs sharing the same `stateKey` at the same time may both return the same new job.
**A run that reaches its timeout** stops itself about 45 seconds before it: no new page is asked, what it read is saved and, with **Only new jobs**, remembered, and the run ends *Succeeded* with "Stopped before the run's timeout". Resurrect it to go on from there, or give the next run a longer timeout (Run options).
**A run the platform stops without warning** (out of memory)
- Resurrect it: it goes on from where it stood at most a minute before the stop. What it had read since is read again, and the jobs already saved are skipped: none is delivered or charged twice, and `maxItems` still counts them.
- With `onlyNew`, the memory is saved after each write (at most once every 2 seconds): resurrect the stopped run and the jobs it had saved meanwhile join the memory; leave it stopped for good, and the next run may return the jobs of its last 2 seconds once more.
#### Something doesn't work?
The last line of the log counts the jobs saved and the requests that failed after every retry. Those requests, and the company names found on no ATS, are listed with the reason in the `FAILED_REQUESTS` record of the run's key-value store. A run that saved nothing and had failed requests fails, and its last message gives the cause.
If an ATS changes its job pages, you are told instead of paying for blank rows. If the first 20 listings read all lack their title, or their publication date on the nine ATS whose job list shows it (all but BambooHR and Rippling), the run saves nothing more, stops and fails, and its last message names the missing field: at most those first jobs are charged. A job that `postedAfter` / `postedBefore` drops because it has no date at all counts among those 20. A run of fewer jobs (a scheduled **Only new jobs** run that finds a few new ones, a small **Max jobs**) is checked at its end, from 5 listings: its jobs are already saved, and the run fails with the missing field instead of ending green.
### π Support
Open an issue in the **Issues** tab with a link to your run: the run log and the `FAILED_REQUESTS` record of the key-value store show exactly which companies or URLs failed and why.
# Actor input Schema
## `companies` (type: `array`):
Company names, ATS slugs or website domains, one per line (e.g. `stripe`, `ramp`, `spotify`, `notion.so`). The Actor finds which ATS hosts each company (one quick check per ATS, see **ATS platforms**). Force the ATS with a prefix: `greenhouse:airbnb`, `lever:spotify`, `ashby:ramp`, `smartrecruiters:BoschGroup`, `workday:nvidia.wd5/NVIDIAExternalCareerSite`. A career page link works here too, with or without https://. A Workday company is found by name only when it is in our directory: otherwise give its career page link. Max 5 000.
## `startUrls` (type: `array`):
Career pages or job pages of any supported ATS, e.g. `https://job-boards.greenhouse.io/airbnb`, `https://jobs.lever.co/spotify`, `https://jobs.ashbyhq.com/ramp`, `https://nvidia.wd5.myworkdayjobs.com/NVIDIAExternalCareerSite`, `https://jobs.smartrecruiters.com/BoschGroup`, `https://bunq.recruitee.com`, `https://apply.workable.com/huggingface`. A job URL returns the whole company board. Workday needs the full URL (tenant + site): the way to read a Workday company that is not in our directory. Max 5 000.
## `searchAllCompanies` (type: `boolean`):
Also read the companies of our built-in directory (thousands of career sites found on the public web, filtered by **ATS platforms**, **Only these companies** and **Exclude companies**) and keep the jobs that match your keywords and filters. Use it to find jobs without knowing which companies hire. Capped by **Max companies from the directory**.
## `maxCompanies` (type: `integer`):
With **Search all companies**: how many directory companies to read, the largest boards first. 0 = the whole directory.
## `atsPlatforms` (type: `array`):
Only use these ATS: to detect the ATS of a company name, and to pick directory companies. Empty = all eleven.
## `query` (type: `string`):
Keep only the jobs whose title (or department / team) contains this word or phrase, e.g. `engineer`, `data scientist` (case and accents ignored). Tick **Search in description too** to also match the description. Empty = all jobs.
## `searchQueries` (type: `array`):
Several keywords in one run: a job is kept when it matches ANY of them (and **Job keyword**). Up to 100 here, plus **Job keyword**. Each job is saved once, with the keywords it matched in `matchedKeywords`.
## `searchInDescription` (type: `boolean`):
Match the keywords against the job description as well as the title. Needs the description: free for Greenhouse, Lever, Ashby, Recruitee, Personio and Teamtailor; for the other ATS it turns **Extract job details** on.
## `location` (type: `string`):
Keep only the jobs whose location (any of their locations) contains this text, e.g. `London`, `Germany`, `Remote` (case and accents ignored). Empty = everywhere.
## `locations` (type: `array`):
Several locations: a job is kept when it matches ANY of them (and **Location**). Up to 100 here, plus **Location**.
## `maxItems` (type: `integer`):
Maximum number of jobs to save for the whole run (after deduplication and filters). 0 = no limit.
## `maxItemsPerQuery` (type: `integer`):
Cap for EACH company board, so that one big employer cannot use up the whole **Max jobs** budget. 0 = no per-company cap.
## `extractDetails` (type: `boolean`):
Open each job page (1 extra request per job) on the ATS whose job list has no description: Workday (description, exact posting date, country code, extra locations), SmartRecruiters (description, qualifications), Workable (description, requirements, benefits), BambooHR and Rippling. Greenhouse, Lever, Ashby, Recruitee, Personio and Teamtailor always come with the full description. Charged as a job with details (see Pricing).
## `includeApplicationQuestions` (type: `boolean`):
Greenhouse, Ashby, Recruitee, Rippling and BambooHR: add the questions of the application form (label, type, required, choices) in `applicationQuestions`, plus the Greenhouse pay ranges. 1 extra request per Greenhouse, Ashby, Rippling or BambooHR job; charged per job that has questions (see Pricing).
## `descriptionFormat` (type: `string`):
Which description fields to save: plain text (`description`), the HTML of the ATS (`descriptionHtml`), both, or none (lighter dataset).
## `descriptionMaxLength` (type: `integer`):
Cut the plain-text `description` to this many characters (ending with `β¦`); `descriptionHtml` is not cut by this setting, only past 200 000 characters. 0 = the full text, up to 32 000 characters.
## `includeCompanySummary` (type: `boolean`):
Also write one summary per company with jobs in the results, counted on the jobs this run delivered (after the filters, Max jobs and Only new jobs; only the open jobs of the whole board are counted before the filters): open jobs, jobs per department, country, workplace type, seniority and contract type, share of remote jobs, jobs posted in the last 7 / 30 days, new and closed since the last run (with **Only new jobs**), salary range. Saved in the key-value store record `COMPANY_SUMMARIES` (linked in the Output tab). Charged per company summary written (see Pricing). If the maximum cost of the run is reached by the jobs, some summaries can be left out; the end message says how many.
## `enrichEmails` (type: `boolean`):
For each company whose website is known (the domain you typed in **Companies**, Ashby's company profile, or the company's own careers page linked by Greenhouse / Recruitee), read its contact / about pages and add the public e-mail addresses (`companyEmails`), phone numbers (`companyPhones`) and social links such as LinkedIn (`companySocialLinks`) found there. Charged once per company with at least one e-mail found (see Pricing); phone numbers and social links alone are free.
## `workplaceTypes` (type: `array`):
Keep only remote, hybrid and / or on-site jobs, read from the ATS field when there is one, otherwise from the location and title (`workplaceType`). Empty = all.
## `remoteOnly` (type: `boolean`):
Adds Remote to **Workplace type**: alone, it keeps the remote jobs only; with Hybrid or On-site ticked there too, it keeps those as well.
## `employmentTypes` (type: `array`):
Keep only these contract types (normalized from the ATS value, otherwise read in the title, see `employmentType`). Jobs whose type is found neither on their ATS nor in their title are dropped when this list is not empty. Empty = all.
## `seniority` (type: `array`):
Keep only the jobs of these levels, from the ATS experience level when there is one, otherwise from the job title (see `seniority`). Jobs with no level are dropped when this list is not empty. Empty = all.
## `departments` (type: `array`):
Keep only the jobs whose department, team or job function contains one of these words, e.g. `Engineering`, `Sales` (case ignored). Workday gives no department: its jobs are dropped once this list is set. Empty = all.
## `countries` (type: `array`):
Keep only the jobs located in these countries: ISO codes (`US`, `GB`, `DE`) or English names. A job with several locations is kept when one of them matches. Jobs whose country cannot be read are dropped when this list is not empty.
## `excludeLocations` (type: `array`):
Drop the jobs whose every location contains one of these words (case and accents ignored). On Workday, SmartRecruiters, Workable, BambooHR and Rippling, a job whose list entry shows no location is checked on its job page (1 extra request; charged as a filter check only if the job is dropped).
## `includeCompanies` (type: `array`):
Keep only the jobs of companies whose name or slug contains one of these words (case ignored). Most useful with **Search all companies**.
## `excludeCompanies` (type: `array`):
Drop the jobs of companies whose name or slug contains one of these words (e.g. staffing agencies).
## `skills` (type: `array`):
Keep only the jobs that name at least one of these skills in the title or description (e.g. `Python`, `Salesforce`, `Kubernetes`; case ignored, whole words). Read from `skills` and the description.
## `languages` (type: `array`):
Keep only the jobs written in these languages, ISO 639-1 codes (`en`, `de`, `fr`β¦): from the ATS field when there is one, otherwise detected from the description (`language`). Empty = all.
## `maxYearsExperience` (type: `integer`):
Keep only the jobs that ask at most this many years of experience (`minYearsExperience`, read from the description); jobs that write no number are kept. On Workday, SmartRecruiters, Workable, BambooHR and Rippling, whose job list has no description, the job page of each job is read for it (1 extra request; charged as a filter check only if the job is dropped). 0 = no limit.
## `minOpenJobs` (type: `integer`):
Keep only the jobs of companies that have at least this many open jobs on their board (`companyOpenJobs`, counted before your filters). 0 = all companies.
## `visaSponsorshipOnly` (type: `boolean`):
Keep only the jobs that say they sponsor visas (`visaSponsorship` = true).
## `onlyWithSalary` (type: `boolean`):
Keep only the jobs that show a salary: the pay range of the ATS, or an amount written in the description.
## `minSalary` (type: `integer`):
Keep only the jobs whose yearly salary (top of the range, hourly / monthly pay converted to a year) reaches this amount in **Salary currency**. Jobs in another currency, or without a salary, are dropped. 0 = no minimum.
## `salaryCurrency` (type: `string`):
Currency of **Minimum yearly salary**, ISO code (`USD`, `EUR`, `GBP`β¦).
## `maxSalary` (type: `integer`):
Keep only the jobs whose yearly salary (bottom of the range, converted to a year) is at most this amount in **Salary currency**. Jobs in another currency, or without a salary, are dropped (unless **Keep jobs without a salary**). 0 = no maximum.
## `keepJobsWithoutSalary` (type: `boolean`):
With **Minimum yearly salary**: also keep the jobs that publish no salary (only the jobs whose published salary is too low, or in another currency, are dropped).
## `postedAfter` (type: `string`):
Only jobs published on or after this date: `2026-09-01`, or a period before now such as `7 days`, `24 hours`, `2 weeks`. The date read is `publishedAt` (Workday without details: the day shown as `Posted N Days Ago`; `30+ Days Ago` counts as 30 days, unless a date bound is more than 30 days ago: then the page of each such job is opened for its exact date, 1 extra request per job, not charged as **Extract job details**). Jobs without a date are dropped.
## `postedBefore` (type: `string`):
Only jobs published on or before this date (the whole day is included), or older than a period such as `30 days`.
## `updatedAfter` (type: `string`):
Only jobs updated on their ATS on or after this date, or within a period such as `3 days` (`updatedAt`; jobs whose ATS gives no update date are compared on `publishedAt`).
## `excludeKeywords` (type: `array`):
Drop the jobs whose title contains one of these whole words (case and accents ignored), e.g. `intern`, `sales`; the description is checked too with **Search in description too**.
## `onlyNew` (type: `boolean`):
Skip the jobs that a previous run (same **Memory key**) already delivered: they are not saved and not charged. First run = everything is new.
## `includeClosedJobs` (type: `boolean`):
With **Only new jobs**: also save, once, each job delivered by a previous run (same **Memory key**, with this box ticked) that is no longer on its company board, with `status` = `closed` and `closedAt`. Charged as a closed job, not as a job. Nothing is reported for a company board the run could not read in full.
## `includeUpdatedJobs` (type: `boolean`):
With **Only new jobs**: also save again a job already delivered when its content changed since (title, locations, salary, description, dates...), with `status` = `updated`. Charged as a job.
## `stateKey` (type: `string`):
Name of the memory used by **Only new jobs**. Give each schedule / task its own key (e.g. `fintech-engineers`) so that they do not share their memory. Letters, digits, `-` and `_`.
## `resetState` (type: `boolean`):
Forget everything remembered under this **Memory key** before the run: this run returns (and charges) every job again. Untick it afterwards.
## `proxyConfiguration` (type: `object`):
Optional. Leave empty: the Actor reads the public job APIs directly. Add a proxy if your runs are rate-limited.
## `maxConcurrency` (type: `integer`):
Maximum number of requests processed in parallel (all ATS together).
## `maxRequestsPerMinute` (type: `integer`):
Most requests in any 60 seconds, all ATS counted. Lever is always kept at 1 request per second at most. Lower it if the log shows HTTP 429.
## `minRequestIntervalMs` (type: `integer`):
Smallest gap between two requests, in milliseconds. 0 = no gap.
## `maxRequestRetries` (type: `integer`):
Retries per request before it is marked as failed.
## `debugLog` (type: `boolean`):
Include debug messages in the run log.
## Actor input object example
```json
{
"companies": [
"stripe",
"ramp",
"spotify"
],
"startUrls": [],
"searchAllCompanies": false,
"maxCompanies": 500,
"atsPlatforms": [],
"searchQueries": [],
"searchInDescription": false,
"locations": [],
"maxItems": 100,
"maxItemsPerQuery": 0,
"extractDetails": false,
"includeApplicationQuestions": false,
"descriptionFormat": "both",
"descriptionMaxLength": 0,
"includeCompanySummary": false,
"enrichEmails": false,
"workplaceTypes": [],
"remoteOnly": false,
"employmentTypes": [],
"seniority": [],
"departments": [],
"countries": [],
"excludeLocations": [],
"includeCompanies": [],
"excludeCompanies": [],
"skills": [],
"languages": [],
"maxYearsExperience": 0,
"minOpenJobs": 0,
"visaSponsorshipOnly": false,
"onlyWithSalary": false,
"minSalary": 0,
"salaryCurrency": "USD",
"maxSalary": 0,
"keepJobsWithoutSalary": false,
"excludeKeywords": [],
"onlyNew": false,
"includeClosedJobs": false,
"includeUpdatedJobs": false,
"stateKey": "default",
"resetState": false,
"proxyConfiguration": {
"useApifyProxy": false
},
"maxConcurrency": 10,
"maxRequestsPerMinute": 600,
"minRequestIntervalMs": 0,
"maxRequestRetries": 5,
"debugLog": false
}
```
# Actor output Schema
## `results` (type: `string`):
No description
## `companySummaries` (type: `string`):
One summary per company read (open jobs, departments, locations, salary ranges), filled when includeCompanySummary is on.
# 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 '