Ramp is buildingβ¦",
"changeType": "new",
"firstSeenAt": "2026-10-07T00:00:12.000Z",
"input": "https://jobs.ashbyhq.com/ramp",
"scrapedAt": "2026-10-07T00:00:12.000Z"
}
```
The dataset has ready-made views: **Jobs** (overview table), **Jobs with salary**, **Changes (monitoring)** and **All fields**.
#### Run summary (key-value store β `OUTPUT`)
For every input you get the detected platform and board, how it was detected (`input`, `website`, `name-search`, `domain-name-guess`), a `confidence`, the number of jobs on the board / matching your filters / saved, new / changed / removed counts, other candidate boards, and a clear error for anything not found (e.g. *"No Greenhouse/Lever/Ashby/SmartRecruiters/Workable board found⦠The company may use another ATS (e.g. Workday)"*).
### Output fields
| Field | Description |
|---|---|
| `id` | Stable unique ID `platform:board:jobId` (use it to dedupe across runs) |
| `platform`, `boardToken`, `jobId` | Source ATS, board slug and the platform's job ID |
| `title`, `company` | Job title and company name |
| `location`, `locations` | Primary location and all listed locations |
| `city`, `region`, `country`, `countryCode` | Structured location where the ATS provides it (country also inferred from location text) |
| `isRemote`, `workplaceType` | `true/false/null` and `remote / hybrid / onsite / null` |
| `department`, `team` | Department and team / function |
| `employmentType`, `employmentTypeRaw` | Normalised type and the original value |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryInterval`, `salaryText`, `salarySource` | Pay range when published (`ats`) or found in the description (`description`) |
| `postedAt`, `updatedAt` | First published / last updated (ISO 8601) |
| `jobUrl`, `applyUrl` | Job page and application URL on the employer's board |
| `requisitionId` | Internal requisition / reference number when public |
| `descriptionText`, `descriptionHtml` | Full description as clean text and original HTML |
| `changeType`, `firstSeenAt` | Monitoring only: `new`, `changed` or `removed`, and when this job was first seen |
| `input`, `scrapedAt` | Which input produced the row, and when |
### How much does it cost?
**Pay per event: $2.50 per 1,000 jobs saved** ($0.0025 per job), plus Apify's tiny per-run start fee.
- 100 jobs β **$0.25**; 10,000 jobs β **$25**.
- **Monitoring mode:** you only pay for jobs returned (new or changed). Unchanged jobs are free, and so are "removed" rows.
- Boards that fail, inputs that aren't found, and jobs excluded by your filters are **not charged**.
- Set **Max jobs in total** or the run's **maximum cost** to cap spending. The Actor stops cleanly at the limit and remembers unsaved new jobs for the next monitored run.
### Platforms and data sources
| Platform | Public endpoint used | Notes |
|---|---|---|
| Greenhouse | Job Board API `boards-api.greenhouse.io/v1/boards/{token}/jobs` | Docs: "Job Board data is publicly available, so authentication is not required for any GET endpoints." Pay ranges from the per-job pay-transparency field |
| Lever | Postings API `api.lever.co/v0/postings/{site}` (and `api.eu.lever.co`) | Public postings API documented by Lever on GitHub |
| Ashby | Public Job Posting API `api.ashbyhq.com/posting-api/job-board/{name}` | Includes compensation when the company publishes it |
| SmartRecruiters | Posting API `api.smartrecruiters.com/v1/companies/{id}/postings` | Public, no authentication. Description via the posting-details endpoint |
| Workable | Public published-jobs endpoint `www.workable.com/api/accounts/{subdomain}` | Documented in Workable Help; fetched gently (one request at a time) |
Not supported on purpose: **Workday** and other ATSs without a documented public jobs API, and LinkedIn/Indeed/Glassdoor.
### FAQ
**Is it legal to scrape these job boards?**
This Actor only calls the job-board endpoints that Greenhouse, Lever, Ashby, SmartRecruiters and Workable publish so that employers' jobs can be shown on careers sites and job boards. It doesn't log in, bypass anything, or collect personal data about candidates. When it scans a company website to detect the ATS, it respects robots.txt. Job descriptions remain the employer's content; if you republish them, link back via `jobUrl`/`applyUrl` and follow the laws that apply to you.
**How does company-name detection work?**
It turns the name into likely board slugs (e.g. `Hugging Face` β `huggingface`, `hugging-face`) and asks each platform's public API whether that board exists. When the platform reports a company name (Greenhouse, SmartRecruiters, Workable), it's compared with yours (`confidence: high`). Lever and Ashby don't publish names (`confidence: medium`). For 100% accuracy, use the careers page URL or the board URL.
**A company isn't found. Why?**
It probably uses another ATS (e.g. Workday, iCIMS, Taleo, SuccessFactors) or a custom careers site. The run summary lists what was checked. If you know the board URL, paste it directly.
**How does monitoring work with filters?**
State is tracked per board (every open job, regardless of filters), so a job counts as "new" when it first appears on the board. If you later widen your filters, older jobs aren't re-sent; use a new **Monitor ID** to start fresh.
**Can I monitor hundreds of companies?**
Yes. Add them all (up to 2,000 inputs per run) and schedule the run; boards are fetched in parallel within each platform's rate limits. For very large lists, use board URLs or `platform:token` inputs to skip detection.
**Can I use it from my code, Make, Zapier, n8n or an AI agent?**
Yes. Use the Apify API/SDKs, the official integrations, or the Apify MCP server. Each run returns a dataset you can fetch as JSON/CSV.
### Other tools from the same developer
- [Sitemap URL Extractor](https://apify.com/pinkish_armada/sitemap-url-extractor)
- [Broken Link Checker](https://apify.com/pinkish_armada/broken-link-checker)
- [PDF to Markdown](https://apify.com/pinkish_armada/pdf-to-markdown)
Found a bug or need another ATS? Open an issue on the Actor's **Issues** tab.
# Actor input Schema
## `companies` (type: `array`):
One per line. Accepts:
β’ ATS board URLs: https://job-boards.greenhouse.io/airbnb, https://jobs.lever.co/palantir, https://jobs.ashbyhq.com/ramp, https://jobs.smartrecruiters.com/BoschGroup, https://apply.workable.com/huggingface
β’ platform:token: greenhouse:airbnb, lever:palantir, ashby:ramp, smartrecruiters:BoschGroup, workable:huggingface (lever-eu: for Lever EU)
β’ Careers page or website URL: https://stripe.com/jobs: the page is scanned for an embedded ATS board (robots.txt respected)
β’ Company name: Palantir: probes each platform for a matching board (best effort; check confidence in the run summary).
## `keywords` (type: `array`):
Keep jobs whose title contains ANY of these (case-insensitive). Acronyms and 1β2 letter terms like AI, QA, iOS, SRE match whole words only. Use /regex/ for patterns, e.g. /senior|staff/. Leave empty for all jobs.
## `keywordsMatchDescription` (type: `boolean`):
Search the full job description as well as the title (e.g. to find all jobs mentioning Kubernetes).
## `excludeKeywords` (type: `array`):
Drop jobs whose title contains ANY of these, e.g. intern, /principal|director/.
## `locations` (type: `array`):
Keep jobs whose location (any listed location, city, region or country) contains ANY of these, e.g. London, Australia, NY. Two-letter country codes such as AU also match the country code. Remote matches remote jobs.
## `remote` (type: `string`):
Filter by remote / hybrid / on-site. Greenhouse doesn't publish a workplace field, so for Greenhouse it is inferred from the location text and custom fields (unknown counts as on-site).
## `departments` (type: `array`):
Keep jobs whose department or team contains ANY of these, e.g. Engineering, Sales.
## `employmentTypes` (type: `array`):
Keep only these types. Jobs whose platform doesn't state a type (common on Greenhouse) are kept.
## `postedWithinDays` (type: `integer`):
Keep only jobs first published in the last N days. 0 = any date.
## `monitorMode` (type: `string`):
Off: return every matching job on each run.
New jobs only: return only jobs that weren't on the board at the previous run (ideal for schedules and alerts).
New + changed: also return jobs whose title, location, department, type, salary, apply URL or description changed.
State is kept per board in a named key-value store in your account, so it survives between runs and schedules.
## `monitorId` (type: `string`):
Separate monitors (e.g. one per client or task) by giving each a different ID. Change it to start from scratch.
## `stateStoreName` (type: `string`):
Name of the key-value store (in your account) that remembers which jobs were already seen.
## `firstRunEmitsAll` (type: `boolean`):
On the first monitored run of a board, return all matching jobs (on) or just record them silently as a baseline (off) so that only future new jobs are returned.
## `reportRemovedJobs` (type: `boolean`):
In monitoring mode, also add a row with changeType: "removed" for each job that disappeared from the board since the last run. Removed-job rows are free.
## `descriptionFormat` (type: `string`):
Include the description as plain text, HTML, both, or not at all (smaller output). Descriptions are always read internally so salary ranges written in the text can still be extracted.
## `fetchSalaryDetails` (type: `boolean`):
Greenhouse publishes pay-transparency ranges on each job's detail endpoint. When on, one extra lightweight request is made per saved Greenhouse job to get structured salary min/max/currency.
## `maxJobsPerCompany` (type: `integer`):
Newest jobs first. 0 = no limit.
## `maxJobs` (type: `integer`):
Stop after saving this many jobs. 0 = no limit. You can also cap spending with the run's maximum cost setting.
## `platforms` (type: `array`):
Which ATS platforms to probe when an input is a company name or a website without an embedded board. Explicit board URLs and platform:token inputs are always fetched.
## `nameMatchMode` (type: `string`):
When a company name or website matches boards on more than one platform: keep the best match (name match + most jobs) or fetch all of them.
## `detectFromWebsites` (type: `boolean`):
For website / careers page URLs, fetch the page (and up to 5 careers-looking pages on the same site) to find an embedded or linked ATS board. robots.txt is respected. If off or nothing is found, the domain name is tried as a board slug.
## `maxConcurrency` (type: `integer`):
Boards fetched in parallel. Per-platform rate limits are always respected (e.g. Workable is fetched one request at a time).
## Actor input object example
```json
{
"companies": [
"https://jobs.ashbyhq.com/ramp",
"greenhouse:airbnb",
"Palantir"
],
"keywords": [
"engineer",
"data"
],
"keywordsMatchDescription": false,
"remote": "any",
"postedWithinDays": 0,
"monitorMode": "off",
"monitorId": "default",
"stateStoreName": "ats-jobs-monitor",
"firstRunEmitsAll": true,
"reportRemovedJobs": false,
"descriptionFormat": "both",
"fetchSalaryDetails": true,
"maxJobsPerCompany": 0,
"maxJobs": 0,
"platforms": [
"greenhouse",
"lever",
"ashby",
"smartrecruiters",
"workable"
],
"nameMatchMode": "best",
"detectFromWebsites": true,
"maxConcurrency": 5
}
```
# Actor output Schema
## `results` (type: `string`):
Normalised job postings (title, company, location, remote, department, type, salary, dates, URLs, description).
## `summary` (type: `string`):
Per input: detected platform and board token, confidence, jobs on board / matched / saved, new / changed / removed counts and any errors.
# 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 '