# Oracle HCM & Taleo Jobs Scraper — Salary, Dates, No Login (`yugenox/oracle-taleo-jobs-scraper`) Actor

Jobs from any employer on Oracle Recruiting Cloud (Oracle HCM) or Taleo: type company names (JPMorgan, Goldman Sachs, Marriott, Kroger…) or paste career-site URLs. Keyword, location, remote and category filters. Full descriptions, parsed salary, real posted/closing dates, only-new mode.

- **URL**: https://apify.com/yugenox/oracle-taleo-jobs-scraper.md
- **Developed by:** [Yugenox Corp](https://apify.com/yugenox) (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.00 / 1,000 job listings

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 Recruiting Cloud & Taleo Jobs Scraper

Scrape open jobs from **any employer that hires through Oracle Recruiting Cloud** (Oracle HCM "Candidate Experience" career sites, `*.oraclecloud.com`) or **Oracle Taleo** (`*.taleo.net`). These platforms run the career sites of big banks, insurers, tech companies, hospitals, universities and governments: JPMorgan Chase, Goldman Sachs, Oracle, DTCC, UnitedHealth Group, Cognizant, State of Ohio and thousands more.

Type **company names**, or paste any career-site link. Filter by keyword, location, remote/hybrid, category and posting date. Each job comes back with its **full description, a parsed salary range, real posted and closing dates**, locations with coordinates, skills and the employer's own extra fields.

- 🏢 **Company names in, jobs out.** A built-in directory maps names like "JPMorgan", "Goldman Sachs" or "State of Ohio" to their career sites. Any career-site URL works too: a search page, a single job, just the host (`jpmc.fa.oraclecloud.com`), or the company's own careers page that links to one.
- 🔎 **Every public site of an employer.** Many Oracle employers run several career sites (campus, lateral, regional). Give just the host and all public sites are searched, with duplicates removed.
- 💰 **Structured salary.** Pay is read from the employer's pay field ("Base Pay/Salary: New York, NY $110,000-$125,000") or from the pay-transparency text in the description, into `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod`. Shift differentials and bonuses are not counted as pay.
- 📅 **Real dates.** Exact `postedDate` and, where the employer sets one, `closingDate`.
- 🌎 **Filters that understand each site.** "Toronto", "Ontario", "New York, NY" or "Canada" are matched to the site's own location list. Remote/hybrid uses the site's tag where there is one, otherwise what the posting says.
- ⚡ **Fast and complete.** Up to 200 jobs per request on Oracle sites, and no 10,000-job ceiling: a full 13,000-job employer takes under a minute.
- 🆕 **Only-new mode.** Schedule it daily and receive only jobs you haven't seen before. You pay only for new ones.
- 🔓 **No login, no cookies, no API key.**

### How to use

**1. Jobs at specific companies**

```json
{
  "companies": ["JPMorgan Chase", "Goldman Sachs", "DTCC"],
  "searchTerms": ["data analyst"],
  "locations": ["New York, NY"],
  "maxItems": 200
}
```

**2. A career site you already have open.** Filters in the URL are kept.

```json
{
  "startUrls": [
    "https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_45001/requisitions?keyword=engineer",
    "https://dasstateoh.taleo.net/careersection/oh_ext/jobsearch.ftl?lang=en"
  ],
  "postedWithinDays": 7
}
```

**3. Everything an employer has open, as a fast list**

```json
{
  "startUrls": ["jpmc.fa.oraclecloud.com"],
  "includeDetails": false
}
```

**4. Search across the largest employers in the directory** (leave companies and URLs empty)

```json
{
  "searchTerms": ["registered nurse"],
  "locations": ["Ohio"],
  "maxCompanies": 100,
  "maxItems": 500
}
```

**5. Daily new-jobs alert.** Save this as a task, schedule it daily, then add a webhook, email or Slack integration.

```json
{
  "companies": ["JPMorgan Chase", "Goldman Sachs"],
  "searchTerms": ["quant"],
  "onlyNew": true,
  "onlyNewStateKey": "banks-quant"
}
```

### Input

| Field | What it does |
|---|---|
| `startUrls` | Oracle Recruiting Cloud URLs (`…oraclecloud.com/hcmUI/CandidateExperience/<lang>/sites/<site>…`), bare Oracle hosts, Taleo URLs (`…taleo.net/careersection/<section>/jobsearch.ftl`), single job links, or a company careers page that links to one of these. |
| `companies` | Company names (or URLs). Resolved through the built-in directory. |
| `searchTerms` | Keywords, each run as its own search on every site. All words must appear. Leave empty for all open jobs. |
| `locations` | Cities, states/provinces or countries. Several are combined with OR. |
| `remoteTypes` | `remote`, `hybrid`, `onsite`. |
| `jobCategories` | Job families or categories, e.g. `Technology`, `Nursing`. |
| `postedWithinDays` | Only jobs posted in the last N days. |
| `includeDetails` | Full description, qualifications, salary, skills and extra fields (default **on**). Turn it off for a fast list. |
| `maxItems` / `maxItemsPerCompany` | Limits for the whole run and per employer. |
| `onlyNew` / `onlyNewStateKey` | Skip jobs returned by earlier runs. Use a different key per task. |
| `maxCompanies` | How many employers to search when you give keywords but no companies or URLs. |
| `proxyConfiguration` | Datacenter proxy by default. A site that blocks it switches to residential automatically. |

### Reliability

- Every run finishes **successfully with a clear status message**, whatever the input or the career sites do: a site that is down, blocking or mid-maintenance is skipped and named in the message; a run that would hit its time limit stops early and reports "Partial — …" with everything it got.
- **You pay only for delivered jobs.** A job whose detail page could not be read is delivered as a list row and is not charged the details add-on.
- Requests are retried on fresh proxy sessions with backoff (Retry-After honoured); a site that keeps failing is paused instead of retried forever; datacenter proxies switch to residential per site when blocked.
- Input aliases from other job scrapers work too: `urls`, `keyword`, `maxResults` / `limit`, `location`, `fetchDetails`.
- A `RUN_REPORT` record in the run's key-value store summarises what happened (rows, details, charges, requests, failures).

### Output

One row per job. A real example, shortened:

```json
{
  "ats": "oracle",
  "title": "Credit Trading – Private Credit – Analyst",
  "company": "JPMorgan Chase",
  "jobId": "210793803",
  "requisitionNumber": "210793803",
  "url": "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001/job/210793803",
  "applyUrl": "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001/job/210793803/apply/email",
  "location": "New York, NY, United States",
  "countryCode": "US",
  "additionalLocations": [],
  "workLocations": [{ "name": "60064-270 Park", "address": "270 Park Ave", "city": "New York", "region": "NY", "postalCode": "10017", "countryCode": "US", "latitude": 40.7519, "longitude": -73.97314 }],
  "latitude": 40.58055,
  "longitude": -74.00391,
  "remoteType": null,
  "category": "Analysts",
  "jobFunction": "Program Analysts & Associate",
  "businessUnit": "Commercial & Investment Bank",
  "requisitionType": "Professional",
  "employmentType": "Full time",
  "postedDate": "2026-09-23",
  "postedDaysAgo": 1,
  "closingDate": null,
  "salaryMin": 110000,
  "salaryMax": 125000,
  "salaryCurrency": "USD",
  "salaryPeriod": "YEAR",
  "salaryText": "$110,000.00-$125,000.00",
  "salarySource": "field",
  "shortDescription": "Join the CIB Credit Trading & Financing organization!",
  "descriptionText": "As an Analyst in Credit Trading…",
  "descriptionHtml": "<p>As an Analyst in Credit Trading…",
  "qualificationsText": null,
  "responsibilitiesText": null,
  "skills": [],
  "extraFields": { "Base Pay/Salary": "New York,NY $110,000.00-$125,000.00" },
  "detailsIncluded": true,
  "careerSiteUrl": "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001",
  "siteNumber": "CX_1001",
  "tenantHost": "jpmc.fa.oraclecloud.com",
  "searchText": "analyst",
  "scrapedAt": "2026-09-24T08:18:14.638Z"
}
```

- `ats` is `oracle` or `taleo`. Both give the same fields; ones a platform doesn't have are `null`.
- `salaryPeriod` is `HOUR`, `DAY`, `WEEK`, `MONTH` or `YEAR`. `salarySource` says where the pay came from: `field` (the employer's pay field) or `description`. When a pay field exists but gives no numbers ("Competitive"), `salaryText` keeps it and the numbers are `null`.
- `remoteType` is `Remote`, `Hybrid`, `On Site` or `null`, and `remoteTypeSource` says whether it came from the site's tag, the location or the posting text.
- `extraFields` holds the employer's own labelled fields (job type, clearance, years of experience, schedule, union status…). Contact names, emails and phone numbers are left out.
- With `includeDetails` off you still get the title, company, location(s), posted date, category, function, employment type (where listed) and links.

### Use cases

- **Job seekers:** a daily feed of new roles at the banks, insurers and agencies you want, with pay and closing dates.
- **Recruiters and staffing agencies:** track who is hiring for what, where, and at what pay.
- **Salary benchmarking:** structured pay ranges across employers, cities and job families.
- **Job boards and aggregators:** a clean, de-duplicated feed from thousands of employer career sites.
- **Labour-market, investment and public-sector research:** hiring volume by employer, function and location over time.
- **Sales prospecting:** find companies actively hiring for roles your product serves.

### FAQ

**Which employers are supported?**
Any employer whose careers site runs on Oracle Recruiting Cloud (the address contains `oraclecloud.com/hcmUI/CandidateExperience`) or Taleo (`taleo.net/careersection`). If a company name isn't found in the directory, paste its careers URL into `startUrls`.

**An employer has several career sites. Which do I get?**
With a company name or a bare host, all of its public sites, de-duplicated. With a URL that names a site, only that site.

**How complete are the results?**
Every open job that matches your search. Oracle sites only list the first 10,000 results of any search; bigger searches (Marriott has 13,000+ openings) are split automatically by posting date, category or country, so you still get every job, de-duplicated. Oracle sites are read 200 jobs per request, Taleo sites 25.

**How is salary found?**
From the employer's pay field when it has one, otherwise from the pay section of the description. Jobs without pay information have `null` salary fields.

**How is "remote / hybrid / on-site" decided?**
From the site's own work-arrangement tag when it uses one; otherwise from the job location ("US, Remote") or what the posting says ("This role is hybrid", "#LI-Remote", "This is not a remote position"). On sites without tags, the remote/hybrid filter reads each candidate posting, so it takes longer.

**Do older Taleo career sites work?**
Yes. Some Taleo sections still use Taleo's old "basic search" page (many city, county and hospital sites). They are read page by page, so they are slower, and keywords are matched against the job title and the listed fields rather than the full posting. Location, category and date filters are applied to each job.

**What if a site is down or has moved?**
Sites under maintenance, retired sites and career sections that now redirect to another careers site are reported in the run's status message and skipped. The rest of the run continues and you are not charged for them.

**Can I run it on a schedule?**
Yes. Save your input as a task, add a schedule, and turn on `onlyNew` so each run returns only new jobs.

**How fast is it?**
About 50 jobs with full details in 10–15 seconds. List-only runs cover thousands of jobs a minute on Oracle sites.

**How much does it cost?**
$1.00 per 1,000 jobs, plus $0.50 per 1,000 for jobs returned with full details (description, qualifications, parsed salary, skills, extra fields), so $1.50 per 1,000 detailed jobs all-in. Turn `includeDetails` off for the cheaper list-only tier. A job whose detail page could not be read is delivered as a list row and is not charged the details add-on, and with `onlyNew` on, jobs you have already received are skipped and not charged again.

**Is it legal to scrape Oracle Recruiting Cloud and Taleo career sites?**
This actor collects only public job postings: the same listings employers publish on their open career sites for anyone to read, without an account. The output is about jobs and employers, but a posting's description can name a contact person or give a work email or phone number (for example an HR or accommodation contact), so if you store or process that personal data, follow the data-protection rules that apply to you, such as GDPR, PIPEDA or CCPA, and use the data in line with the career site's terms. Recruiter names, emails and phone numbers found in the employer's extra fields are left out of the output. If you are unsure whether your use case is legitimate, check with a lawyer. Apify's guide [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) is a good starting point.

**Does it access any private data?**
No. It reads only what a logged-out visitor sees on an employer's public Oracle Recruiting Cloud or Taleo careers page. It never signs in and never uses cookies, accounts or API keys of any person. Candidate profiles, applications and anything behind a sign-in are never accessed; a career section that only opens after signing in cannot be read and is named in the run's status message.

# Actor input Schema

## `startUrls` (type: `array`):

Any Oracle Recruiting Cloud or Taleo careers page: https://<pod>.fa.<region>.oraclecloud.com/hcmUI/CandidateExperience/en/sites/<site> (a search page with filters or a single job link works too), just the host (jpmc.fa.oraclecloud.com — every public site of that employer is searched), https://<company>.taleo.net/careersection/<section>/jobsearch.ftl, or a company's own careers page that links to one of these.

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

Company names, resolved against a built-in directory of employers that hire through Oracle Recruiting Cloud or Taleo (e.g. JPMorgan Chase, Goldman Sachs, Oracle, DTCC, UnitedHealth Group, Cognizant, State of Ohio). A career-site URL or host works here too.

## `searchTerms` (type: `array`):

Job title or keywords, searched on each career site (the same search as the site's own search box; several words must all appear). Each keyword is a separate search; results are de-duplicated. Leave empty for all open jobs. With keywords but no companies or URLs, the largest employers in the directory are searched.

## `maxItems` (type: `integer`):

Maximum number of jobs across the whole run. Leave empty for no limit.

## `maxItemsPerCompany` (type: `integer`):

Cap per employer, so one big employer doesn't use up the whole run. Leave empty for no per-company limit.

## `includeDetails` (type: `boolean`):

Adds the full description (text + HTML), qualifications, responsibilities, parsed salary range, skills, employment type, closing date and extra fields. Turn off for a much faster, cheaper list (title, location, posted date, category, link).

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

Cities, states/provinces or countries, e.g. Toronto, Ontario, New York, NY, Canada, United Kingdom. Matched to each site's own locations (a job matches if any of its locations does); several locations are combined with OR.

## `remoteTypes` (type: `array`):

Only remote, hybrid or on-site jobs. Uses the site's own work-arrangement tag where it has one; otherwise what the posting says ("This role is hybrid…", "Location: US, Remote").

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

Job families / categories, e.g. Technology, Finance, Nursing, Engineering. Matched to each site's own category filter, or to the job's category text.

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

Only jobs posted in the last N days.

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

Remembers every job this actor has returned to you and skips it next time — schedule the actor daily for a new-jobs feed. You only pay for new jobs.

## `onlyNewStateKey` (type: `string`):

Use a different name per saved task/schedule to keep their “already seen” lists separate.

## `maxCompanies` (type: `integer`):

With keywords but no companies or URLs, this many of the largest employers in the directory are searched.

## `maxConcurrency` (type: `integer`):

Requests in flight across all career sites.

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

Apify datacenter proxy works well and is cheapest. If a site blocks it, that site automatically switches to residential proxies.

## Actor input object example

```json
{
  "startUrls": [
    "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001"
  ],
  "searchTerms": [
    "analyst"
  ],
  "maxItems": 50,
  "includeDetails": true,
  "onlyNew": false,
  "onlyNewStateKey": "default",
  "maxCompanies": 60,
  "maxConcurrency": 16,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped job postings.

## `run` (type: `string`):

Status and statistics for this run.

# 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 = {
    "startUrls": [
        "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001"
    ],
    "searchTerms": [
        "analyst"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("yugenox/oracle-taleo-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 = {
    "startUrls": ["https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001"],
    "searchTerms": ["analyst"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("yugenox/oracle-taleo-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 '{
  "startUrls": [
    "https://jpmc.fa.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1001"
  ],
  "searchTerms": [
    "analyst"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call yugenox/oracle-taleo-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,yugenox/oracle-taleo-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/658u0PwkMQjQ43thB/builds/Nwc99gdukECNg8yKF/openapi.json
