# Oracle, Taleo, BambooHR & Rippling Jobs Scraper (+5 more ATS) (`kadi_bence/ats-plus-jobs-scraper`) Actor

Get open jobs from companies on Oracle Recruiting, Taleo, BambooHR, Rippling, Teamtailor, Breezy, JazzHR, Jobvite or Gem. Input: company names or career-site URLs; optional title and location filters. Returns per job: title, company, location, salary, posted date, URL. Default: 20 jobs per company.

- **URL**: https://apify.com/kadi_bence/ats-plus-jobs-scraper.md
- **Developed by:** [Bence Kadi](https://apify.com/kadi_bence) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.25 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## Oracle, Taleo, BambooHR & Rippling Jobs Scraper: export jobs from 9 ATS career sites

### What is Oracle, Taleo, BambooHR & Rippling Jobs Scraper?

This Actor collects job postings from company career sites on nine applicant tracking systems (ATS): **Oracle Recruiting Cloud** (Oracle Fusion HCM), **Oracle Taleo**, **BambooHR**, **Rippling**, **Teamtailor**, **Breezy HR**, **JazzHR**, **Jobvite** and **Gem**. You type company names, websites or career-site URLs and get every open job as JSON, CSV or Excel, with title, locations, work mode, department, posting date, salary and description.

It detects each company's ATS and reads the public job feed that the ATS publishes. No browser, no login, no API key.

**What makes it different**

- **Auto-detects the ATS.** Type `Polestar`, `fly.io` or `Nutanix`; all 9 platforms are checked.
- **Finds Oracle tenants for you.** Oracle career sites hide behind codes like `hdjq.fa.us2.oraclecloud.com`. Type the company's domain (e.g. `emerson.com`) and the Actor follows the careers links on its website to the right career site. Backup and "FOR REFERENCE ONLY" sites are skipped.
- **No 10,000-job wall.** Oracle's search stops at 10,000 results. Big boards are split by job category, so you get them all (Marriott: 12,900+ of 12,973).
- **Same schema as our other job scrapers.** With our Greenhouse/Lever/Ashby and Workday Actors that is 16 ATSs in one format.
- **Salary included.** Pay fields from Rippling, BambooHR and Oracle, and ranges like "$120,000 – $150,000" parsed from descriptions.
- **Only new jobs.** Monitoring mode outputs, and charges for, only postings you haven't seen before.
- **GDPR-friendly.** Recruiter contact fields are never read; e-mails and phone numbers are removed from descriptions.

**Use cases:** Generate leads (build B2B prospect lists, lead enrichment & validation) · Research markets & competitors (track competitors, build market datasets, track trends, profile companies & due diligence) · Developer tools (monitor & alert on website changes).

#### Use cases

- **Sales and lead generation (hiring signals):** large employers on Oracle and Taleo, and growing SMBs on BambooHR, Rippling and Teamtailor.
- **Recruiting and staffing agencies:** watch target accounts and react to new openings the same day.
- **Job boards and aggregators:** fill your board with direct-from-employer postings.
- **Market and labour research:** track headcount growth, locations and pay ranges across companies.
- **Job alerts:** send a daily Slack message, e-mail or Google Sheet of new postings at your target companies.
- **AI agents and RAG apps:** give an LLM fresh, structured job data through the API or the Apify MCP server.

#### Data fields you get

| Field | Description | Example |
|---|---|---|
| `title` | Job title | `Finance Manager` |
| `company` | What you typed | `Polestar` |
| `companyName` | Employer or business unit, when published | `Commercial & Investment Bank` |
| `ats` | Platform the job came from | `oracle` |
| `jobId` | Job ID on the ATS | `210795927` |
| `url` / `applyUrl` | Job page / application form | `https://jobs.jobvite.com/nutanix/job/oUQKAfwO` |
| `location` | Primary location | `Cologne, Germany` |
| `locations` | All locations | `["Cologne, Germany"]` |
| `country` / `countryCode` | Country and ISO code, when known | `United States` / `US` |
| `workMode` | `remote`, `hybrid`, `onsite` or empty | `hybrid` |
| `employmentType` | As published | `Full time` |
| `department` / `team` | As published | `Global Sales` |
| `seniority` | Job level, when published | `null` |
| `postedDate` / `updatedDate` | ISO dates (UTC), when published | `2026-10-05T00:03:48Z` |
| `salaryMin` / `salaryMax` | Parsed pay range | `156750` / `215000` |
| `salaryCurrency` / `salaryPeriod` | Currency, `YEAR`/`MONTH`/`HOUR`... | `USD` / `YEAR` |
| `salaryText` | Original pay text | `$156,750.00-$215,000.00` |
| `description` / `descriptionHtml` | Plain text and/or HTML | `We have an opportunity...` |
| `boardUrl` | Job board | `https://polestar.teamtailor.com/jobs` |
| `isNew` | `true` in monitoring mode | `true` |
| `scrapedAt` | Scrape time (UTC) | `2026-10-05T02:12:15Z` |

### How to use Oracle, Taleo, BambooHR & Rippling Jobs Scraper

1. Open the Actor and enter **company names, websites or career-site URLs**, one per line. The prefill is Polestar (Teamtailor), Nutanix (Jobvite) and a JPMorgan Chase Oracle career site, 20 jobs each. It finishes in about 10 seconds and costs about $0.08.
2. Optional: set **job title keywords**, **locations**, **remote jobs only** or **posted within N days**. Set **Max jobs per company** to `0` to get every job.
3. Click **Start**.
4. Open the **Output** tab and download JSON, CSV, Excel or HTML, or connect Google Sheets, Zapier, Make or n8n.
5. To get only new jobs every day, turn on **Only new jobs** and create a **Schedule** (see [Integrations and scheduling](#integrations-and-scheduling)).

#### Input guide

**Company names, websites or career-site URLs (`companies`)**

One per line. For a name, the Actor tries the company's likely board address on each selected platform. `RUN_SUMMARY` lists the ATS and board found for each company, so you can check the match.

- Good: `Polestar`, `fly.io`, `emerson.com`, or a career-site URL such as `https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001`. A single job link works too; the whole board is scraped.
- Bad: `Polestar jobs in Sweden` (put places in **Locations** and words in **Job title keywords**).
- Tip: Oracle and Taleo tenant codes can't be guessed from a name. Use the company's domain, or paste the career-site URL.
- Warning: some companies load their careers links with JavaScript (e.g. Marriott, International Paper), so the name doesn't work. Click a job on their careers page and paste that URL.
- Warning: Greenhouse, Lever, Ashby, Workable, Recruitee, Personio and Workday boards are not scraped here. `RUN_SUMMARY` names the right sister scraper when it sees one.

URLs it understands:

| ATS | URL pattern |
|---|---|
| Oracle Recruiting Cloud | `https://{tenant}.fa.{region}.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1` |
| Taleo | `https://{company}.taleo.net/careersection/2/jobsearch.ftl` |
| Teamtailor | `https://{company}.teamtailor.com` (or a Teamtailor custom domain) |
| BambooHR | `https://{company}.bamboohr.com/careers` |
| Breezy HR | `https://{company}.breezy.hr` |
| Rippling | `https://ats.rippling.com/{board}/jobs` |
| JazzHR | `https://{company}.applytojob.com/apply` |
| Jobvite | `https://jobs.jobvite.com/{company}/jobs` |
| Gem | `https://jobs.gem.com/{company}` |

**Platforms to check (`platforms`)**

Which ATSs to try for a name. All 9 by default; fewer is faster. URLs are always detected.

**Find the job board via the company website (`scanCompanyWebsite`)**

On by default. If a name finds no board, the Actor opens the domain you typed (or `name.com`), follows up to 3 careers links on that site and collects the ATS links there. This finds Oracle tenants such as `hdjq.fa.us2.oraclecloud.com` for `emerson.com`. It doesn't work on careers pages built with JavaScript.

**Job title keywords (`titleKeywords`)**

Comma-separated. A job is kept if its title contains ANY of the words (case-insensitive). The filter runs before job pages are opened, so it also makes runs faster.

- Good: `engineer, data, nurse`
- Warning: `intern` also matches "International". Use `internship` when that matters.

**Locations (`locations`)**

A job is kept if its locations, country or country code contain ANY of these as a whole word or phrase (case-insensitive), so `US` matches "Remote - US" but not "Austin" or "Australia".

- Good: `United States`, `US`, `Germany`, `Stockholm`, `Remote`
- Bad: `San Fran`. Partial words don't match; write the full name, `San Francisco`.
- Warning: Taleo and Jobvite jobs have no country field, only the location text (e.g. `San Jose, California`). A country filter can drop them; use a city or state.

**Remote jobs only (`remoteOnly`)**

Keeps only jobs with `workMode` = `remote`. Jobs with unknown work mode are dropped.

**Posted within (days) (`postedWithinDays`)**

Only jobs posted in the last N days, e.g. `7`. JazzHR and Jobvite don't publish a date, so their jobs are always kept.

**Max jobs per company (`maxJobsPerCompany`)**

A limit per company, not per run. `0` means no limit. The Console prefill is 20; the default via API, MCP or an AI agent is 20; set `0` for all jobs.

Jobs removed by any filter are not saved, don't count toward the limit and are **not charged**.

**Only new jobs (`onlyNewJobs`) and Monitor name (`monitorName`)**

See [Monitoring mode](#monitoring-mode-only-new-jobs) below.

**Output options**

- `descriptionFormat`: `text` (default), `html`, `both` or `none`. `none` is fastest: it skips the per-job pages on Oracle, Taleo, BambooHR, Breezy, Rippling, JazzHR and Jobvite, so some fields (salary, and the posting date on BambooHR and Rippling) may be empty.
- `stripContactInfo` (default on): removes e-mails and phone numbers from descriptions. Keep it on to avoid storing personal data.

**Advanced**

- `proxyConfiguration`: off by default. These are public career sites; enable a proxy only if you see blocking errors in the log.

Example input:

```json
{
  "companies": ["Polestar", "fly.io", "emerson.com", "https://valero.taleo.net/careersection/2/jobsearch.ftl", "Rippling"],
  "titleKeywords": "engineer, nurse, sales",
  "locations": ["United States", "Remote"],
  "postedWithinDays": 30,
  "maxJobsPerCompany": 0,
  "onlyNewJobs": false
}
```

### Output

Each job is one item in the run's dataset. Here is one real item from the prefill run on 2026-10-05 (description shortened). Jobs from the other eight platforms have exactly the same fields.

```json
{
  "title": "Lead Software Engineer and ML Engineer - Sales Copilot",
  "company": "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001",
  "companyName": "Commercial & Investment Bank",
  "ats": "oracle",
  "jobId": "210795927",
  "url": "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001/job/210795927",
  "applyUrl": "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001/job/210795927/apply",
  "location": "Jersey City, NJ, United States",
  "locations": ["Jersey City, NJ, United States"],
  "country": "United States",
  "countryCode": "US",
  "workMode": null,
  "employmentType": "Full time",
  "department": "Technology",
  "team": "Software Engineering",
  "seniority": null,
  "postedDate": "2026-10-05T00:03:48Z",
  "updatedDate": null,
  "salaryMin": 156750,
  "salaryMax": 215000,
  "salaryCurrency": "USD",
  "salaryPeriod": "YEAR",
  "salaryText": "$156,750.00-$215,000.00",
  "description": "We have an opportunity to impact your career and provide an adventure where you can push the limits of what's possible.\nAs a Lead Software Engineer at JPMorganChase…",
  "descriptionHtml": null,
  "boardUrl": "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001/requisitions",
  "scrapedAt": "2026-10-05T02:12:15Z"
}
```

Notes:

- Field coverage depends on the ATS. In a 29-company test run, title, URL and description were filled for all jobs; salary for 100% of Gem jobs, 57% on Rippling, 26% on Taleo, 23% on Oracle, 21% on BambooHR and 12% on Jobvite.
- Taleo's `location` is whatever the employer configured, sometimes an organisation name.
- Empty values are `null`, so every item has the same columns in CSV and Excel.

#### Dataset views

The **Output** tab has two views of the same data:

| View | What it shows |
|---|---|
| **Jobs** | A compact table: title, company, ATS, location, work mode, posted date, salary range and link. Best for a quick look. |
| **Full details** | Adds company name, department, team, employment type, all locations, country code, salary text, description and apply link. |

Every export contains all fields, whichever view you look at. The run also writes a `RUN_SUMMARY` record to the key-value store: per company, the ATS and board found, jobs listed and saved, Oracle career sites, and companies not found (with a hint if they use Greenhouse, Lever, Workday & co.).

#### How to export the data

- **In the Console:** Output tab > **Export** > JSON, CSV, Excel, HTML, XML or RSS. You can pick fields and the view.
- **Google Sheets:** add the Google Sheets integration to the Actor or a schedule (Integrations tab), or use `=IMPORTDATA("https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=csv&token=<TOKEN>")`.
- **API:** `https://api.apify.com/v2/datasets/<DATASET_ID>/items?format=json` (also `csv`, `xlsx`, `xml`). Add `&view=overview` for the compact table.

### Pricing

This Actor uses **pay per event**. You pay **$1.25 per 1,000 jobs** ($0.00125 per job saved to the dataset), plus Apify's standard Actor start fee of **$0.00005 per run**. Platform compute is included in the price.

| Example run | Jobs saved | Cost |
|---|---|---|
| Prefill test (3 companies, 20 jobs each) | 60 | about $0.08 |
| 20 companies, 50 jobs each | 1,000 | about $1.25 |
| Emerson on Oracle, all open jobs | 1,055 | about $1.32 |
| Daily monitoring, ~50 new jobs per day for 30 days | 1,500 | about $1.88 per month |

What you don't pay for:

- jobs removed by your filters (title, location, remote, posted date),
- jobs already seen in monitoring mode,
- companies where no job board was found,
- malformed postings that couldn't be parsed (skipped),
- the `RUN_SUMMARY` record.

To cap spending, set **Max charge per run** in the run options; the Actor stops cleanly at that limit and keeps what it saved. Apify's free plan includes monthly platform credit you can use for this Actor.

### Use it via API

Get your API token in the Apify Console under **Settings > API & Integrations**. The examples below run the Actor, wait for it to finish and read the jobs.

**JavaScript / Node.js** (`npm install apify-client`)

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('kadi_bence/ats-plus-jobs-scraper').call({
    companies: ['Polestar', 'emerson.com', 'Rippling'],
    titleKeywords: 'engineer, sales',
    locations: ['United States', 'Remote'],
    maxJobsPerCompany: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`${items.length} jobs`, items[0]);
```

**Python** (`pip install apify-client`)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run = client.actor("kadi_bence/ats-plus-jobs-scraper").call(run_input={
    "companies": ["Polestar", "emerson.com", "Rippling"],
    "titleKeywords": "engineer, sales",
    "locations": ["United States", "Remote"],
    "maxJobsPerCompany": 100,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["ats"], job["title"], job["location"], job["salaryMin"], job["url"])
```

**cURL** (runs the Actor and returns the jobs in one request; best for runs under 5 minutes)

```bash
curl -X POST "https://api.apify.com/v2/acts/kadi_bence~ats-plus-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies": ["Polestar", "Nutanix"], "maxJobsPerCompany": 20}'
```

**Apify CLI**

```bash
apify call kadi_bence/ats-plus-jobs-scraper --input '{"companies": ["Polestar", "Nutanix"], "maxJobsPerCompany": 20}' --output-dataset
```

**MCP server for AI agents** (Claude, Cursor, VS Code and other MCP clients)

Add the Apify MCP server with this Actor as a tool. Your client will ask you to sign in to Apify (OAuth), or you can send your token as an `Authorization: Bearer YOUR_APIFY_TOKEN` header.

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?actors=kadi_bence/ats-plus-jobs-scraper"
    }
  }
}
```

Then ask your agent, for example: "Find all open sales jobs at Polestar and Rippling, and tell me which ones list a salary range."

### Integrations and scheduling

- **Schedules:** **Schedules > Create new**, pick this Actor (or a saved task) and a time, e.g. daily at 07:00. Each run gets its own dataset.
- **Webhooks:** on the **Integrations** tab, add a "Run succeeded" webhook to send the run and dataset ID to your server.
- **Zapier, Make and n8n:** trigger "Actor run finished", then "Get dataset items", then send jobs to Slack, e-mail, a CRM or Airtable.
- **Google Sheets:** the Google Sheets integration appends each run's jobs to a sheet; the easiest job-alert setup.
- **Slack and e-mail:** Apify's built-in integrations can notify you when a run finishes.

#### Monitoring mode (only new jobs)

Turn on **Only new jobs** (`onlyNewJobs: true`) and schedule the Actor:

1. The first run outputs all matching jobs and saves their IDs as a baseline.
2. Every later run outputs only jobs that weren't returned before.
3. You pay only for those new jobs.

In monitoring mode every output item has `isNew: true`. The "already seen" list is kept in a named key-value store (`ats-plus-jobs-monitor`) in your own Apify account, one list per monitor name and job board. Only saved jobs are added, so a job your filters dropped can appear later if you change the filters. Give two schedules on the same companies (e.g. engineers and sales) different **Monitor names**. To start over, use a new monitor name.

### Other job scrapers by the same developer

All of them use the same output fields where possible, so you can merge datasets.

- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/kadi_bence/ats-jobs-scraper): jobs from Greenhouse, Lever, Ashby, Workable, Recruitee and Personio boards, by company name.
- [Workday Jobs Scraper](https://apify.com/kadi_bence/workday-jobs-scraper): every job from company career sites on Workday (myworkdayjobs.com), by company name, with no 2,000-job cap.
- [Germany Jobs Scraper - Arbeitsagentur](https://apify.com/kadi_bence/arbeitsagentur-jobs-scraper): 1M+ German job offers from the federal employment agency's Jobbörse.
- [Sweden Jobs Scraper - Platsbanken](https://apify.com/kadi_bence/sweden-jobs-scraper): all Swedish job ads from Arbetsförmedlingen, with an archive since 2016.
- [EURES Jobs Scraper](https://apify.com/kadi_bence/eures-jobs-scraper): EU job vacancies from 31 countries via the official European Job Mobility Portal.
- [Remote Jobs Scraper](https://apify.com/kadi_bence/remote-jobs-scraper): remote jobs from RemoteOK, Himalayas, Jobicy and Arbeitnow in one de-duplicated feed.

Related company data for B2B leads: [SEC Form D Scraper](https://apify.com/kadi_bence/sec-form-d-funding) (startup funding rounds), [New Business Filings USA](https://apify.com/kadi_bence/us-new-business-filings) (newly registered companies) and [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) (technologies a company uses).

### FAQ

**How does it work? Is there an official API?**
There is no single official jobs API for these ATSs. Each vendor publishes its own public job feed for career sites (Oracle REST endpoints, Teamtailor RSS, BambooHR, Breezy, Rippling and Gem JSON, Taleo, JazzHR and Jobvite job pages), and each needs the company's board name or tenant code. The Actor finds the board, reads the feed, opens each job for the description where needed, and returns one schema. No browser is used.

**Which platforms are supported? Why not SmartRecruiters or iCIMS?**
The nine listed above, incl. Teamtailor custom domains and Taleo Enterprise career sections. We only read sources that allow it: SmartRecruiters' and Pinpoint's robots.txt block automated access, SuccessFactors' career hosts disallow crawling, and iCIMS shows a bot challenge. We don't work around those.

**How many jobs can I get? Is there a limit?**
All published jobs. With `maxJobsPerCompany: 0` you get every job, including Oracle boards above 10,000 jobs.

**How fast is it?**
The prefill takes about 10 seconds. A full run of 1,460 jobs (Emerson on Oracle, Rippling, Nutanix on Jobvite) took 77 seconds. Most platforms need one request per job for the description; `descriptionFormat: none` gives a faster list-only run.

**A company wasn't found, or the wrong one was. Why?**
Oracle and Taleo tenant codes can't be guessed from a name, and some websites load their careers links with JavaScript: paste a job URL instead. Name detection uses the board's public name (e.g. `polestar.teamtailor.com`); for generic names, check `companyName` and `boardUrl`.

**Why do I get fewer jobs than the career site shows?**
Usually because of a filter or `maxJobsPerCompany`. `RUN_SUMMARY` shows how many jobs each board lists and how many were saved. `remoteOnly` drops jobs with unknown work mode, and a country in **Locations** can drop Taleo and Jobvite jobs.

**Why are some salaries or dates empty?**
Many postings don't publish pay. Salary comes from the ATS's pay fields or a clear range in the description. JazzHR and Jobvite don't publish a posting date.

**Do I need proxies?**
No. These are public endpoints and requests are polite and low-volume.

**Is it legal to scrape these career sites?**
The Actor reads only the public career sites and job feeds that ATS vendors publish for candidates. It checks `robots.txt` (and honours crawl-delay), doesn't log in, never reads recruiter-contact fields, and removes e-mails and phone numbers from descriptions by default, so it doesn't collect personal data (GDPR). You are responsible for how you use the data, including the site's terms and data-protection law in your country.

**Can I use it from Python or another app?**
Yes. Use the Apify API, the JavaScript or Python client, the CLI, or the MCP server, as shown in [Use it via API](#use-it-via-api).

**How do I get only new jobs every day?**
Turn on **Only new jobs** and create a schedule. See [Monitoring mode](#monitoring-mode-only-new-jobs).

**The run failed or a field is missing. What should I do?**
Open an issue on the **Issues** tab with the run link or your input. Fixes usually land within 24–48 hours. See the changelog below for recent changes.

### Need a custom version?

I build custom scrapers, scheduled data feeds and integrations (CSV, Excel, Google Sheets, API, MCP for AI agents). Tell me the sites and fields you need:

- Email: bence.kadi@gmail.com
- Apify profile: https://apify.com/kadi_bence

### Related Actors

More low-cost Actors by the same developer, built on official APIs and public data:

- [Greenhouse, Lever & Ashby Jobs Scraper](https://apify.com/kadi_bence/ats-jobs-scraper) — all open jobs of a company from 6 applicant systems, plus Workday
- [Workday Jobs Scraper](https://apify.com/kadi_bence/workday-jobs-scraper) — open jobs of any company by name (NVIDIA, Salesforce), plus Greenhouse/Lever fallback
- [ATS Jobs Feed](https://apify.com/kadi_bence/ats-jobs-feed) — search a daily database of jobs from 1,000+ companies, no crawling wait
- [Remote Jobs Scraper](https://apify.com/kadi_bence/remote-jobs-scraper) — remote jobs from We Work Remotely, RemoteOK, Himalayas and more
- [EURES Jobs Scraper](https://apify.com/kadi_bence/eures-jobs-scraper) — EU job vacancies from 31 countries
- [Arbeitsagentur Jobs Scraper](https://apify.com/kadi_bence/arbeitsagentur-jobs-scraper) — 1M+ German job offers by keyword, city and radius
- [Website Tech Stack Detector](https://apify.com/kadi_bence/tech-stack-detector) — CMS, ecommerce, analytics and frameworks of any website

All my Actors: [apify.com/kadi_bence](https://apify.com/kadi_bence)

### Changelog

- **2026-10-05, 1.0:** first public release: 9 ATS platforms with auto-detection, company-website scan for Oracle/Taleo/Teamtailor custom domains, Oracle 10,000+ job boards, unified schema with salary, title/location/remote/date filters, monitoring mode.

# Actor input Schema

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

One per line, e.g. Polestar, fly.io, emerson.com, or a career-site URL like https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001 or https://acme.bamboohr.com/careers. A single job link works too. The Actor detects which applicant tracking system (ATS) each company uses; the RUN_SUMMARY record shows the board it found. Oracle and Taleo tenant codes can't be guessed from a name: type the company's website domain or paste the career-site URL.

## `platforms` (type: `array`):

Which ATS to try when detecting a company's job board from its name. Leave all selected unless you know the platform (fewer = faster). URLs are always detected, whatever you select here.

## `scanCompanyWebsite` (type: `boolean`):

If no board is found from the name, open the company's website (the domain you typed, or name.com) and follow up to 3 careers links to the job board. Finds Oracle tenants like hdjq.fa.us2.oraclecloud.com that can't be guessed from a name. Doesn't work on careers pages built with JavaScript; paste a job URL instead.

## `titleKeywords` (type: `string`):

Comma-separated. A job is kept if its title contains ANY of them (case-insensitive), e.g. 'engineer, data, nurse'. Note: 'intern' also matches 'International'. Leave empty for all jobs.

## `locations` (type: `array`):

Keep jobs whose location, country or country code contains ANY of these as a whole word, e.g. London, Germany, United States, US, Remote. Not case-sensitive; 'US' matches 'Remote - US' but not 'Austin'. Taleo and Jobvite jobs have no country field, so filter them by city or state. Leave empty for all.

## `remoteOnly` (type: `boolean`):

Keep only jobs marked as remote. Jobs whose work mode is unknown are dropped.

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

Only jobs posted in the last N days. Leave empty for any date. (JazzHR and Jobvite don't publish a posting date; their jobs are kept.)

## `maxJobsPerCompany` (type: `integer`):

Stop after this many jobs per company (not per run). 0 = no limit (all open jobs). The default without input (API, MCP and AI-agent calls) is 20.

## `onlyNewJobs` (type: `boolean`):

Remember returned jobs and output only NEW ones on later runs. Perfect for a daily schedule (hiring signals, job alerts). The first run returns everything that matches. You only pay for new jobs.

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

Separate 'already seen' lists for different schedules, e.g. 'engineers' and 'sales' on the same companies. Use a new name to start over.

## `descriptionFormat` (type: `string`):

How to output the job description. 'No description' is fastest: it skips the per-job detail pages (Oracle, Taleo, BambooHR, Breezy, Rippling, JazzHR, Jobvite), so some fields (salary, posting date on BambooHR/Rippling) may be empty.

## `stripContactInfo` (type: `boolean`):

Recommended (GDPR). Recruiter name/e-mail fields are never collected.

## `proxyConfiguration` (type: `object`):

Not needed for these public career sites. Enable only if you see blocking errors.

## Actor input object example

```json
{
  "companies": [
    "Polestar",
    "Nutanix",
    "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001"
  ],
  "platforms": [
    "oracle",
    "taleo",
    "teamtailor",
    "bamboohr",
    "breezy",
    "rippling",
    "jazzhr",
    "jobvite",
    "gem"
  ],
  "scanCompanyWebsite": true,
  "remoteOnly": false,
  "maxJobsPerCompany": 20,
  "onlyNewJobs": false,
  "monitorName": "default",
  "descriptionFormat": "text",
  "stripContactInfo": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped jobs (table view).

## `jobsFull` (type: `string`):

All scraped jobs with every field.

## `summary` (type: `string`):

Per-site/company counts, what was found and any problems.

# 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 = {
    "companies": [
        "Polestar",
        "Nutanix",
        "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001"
    ],
    "maxJobsPerCompany": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kadi_bence/ats-plus-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 = {
    "companies": [
        "Polestar",
        "Nutanix",
        "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001",
    ],
    "maxJobsPerCompany": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("kadi_bence/ats-plus-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 '{
  "companies": [
    "Polestar",
    "Nutanix",
    "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001"
  ],
  "maxJobsPerCompany": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call kadi_bence/ats-plus-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kadi_bence/ats-plus-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/kH6KCsmKggyTbbHwu/builds/vFK47ZwKmFnGcJsiL/openapi.json
