# Oracle Fusion Recruiting and Taleo Jobs API (`johnvc/oracle-taleo-jobs-api`) Actor

Pull Oracle job postings from any Oracle Fusion Recruiting (Cloud CX) or legacy Taleo careers board as structured JSON. Company names or careers URLs in, full job records out: salary, skills, coordinates, and descriptions in HTML, plain text, and Markdown.

- **URL**: https://apify.com/johnvc/oracle-taleo-jobs-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** Jobs, Developer tools
- **Stats:** 3 total users, 2 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.20 / 1,000 job returneds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Oracle Fusion Recruiting and Taleo Jobs API

Read Oracle job postings from any Oracle careers board as structured JSON. One run covers both Oracle recruiting products: Oracle Fusion Recruiting, sold today as Oracle Recruiting Cloud, and legacy Taleo jobs. It also finds the boards for you, so you give it a company name and it resolves that name to the Oracle careers sites the company actually runs. You never have to hunt down a tenant code first.

No proxies, no login, no API key. Names or URLs in, clean rows out.

### What you get

- **Full job records**: title, employer, every location, ISO posted and closing dates, requisition ID, category, organization, department, business unit, legal employer, worker type, contract type, schedule, shift, and workplace type.
- **Descriptions in three formats**: original HTML, clean plain text, and **Markdown**. No other Oracle jobs tool on the Store returns Markdown, and Markdown is the format you want when the output feeds an AI agent.
- **Skills and coordinates straight from the employer**: Oracle Fusion publishes the requisition's skill list and the primary location's latitude and longitude. Other tools pay a model to guess both and market it as "AI-extracted". These are the employer's own values, so there is nothing to hallucinate.
- **Pay ranges** extracted deterministically from the posting text when the employer publishes one.
- **A career-site directory**: tenant, site number, employer name, public careers URL, direct jobs API URL, and a live open-job count for every site a company runs.
- **Apply URLs** that go straight to the application form.

### Oracle Fusion Recruiting and Oracle Taleo jobs in one API

Two Oracle recruiting products are in the wild at once. [Oracle Recruiting Cloud](https://www.oracle.com/human-capital-management/recruiting/) is the current one and runs on `oraclecloud.com` hosts. Taleo is the one Oracle bought in 2012, and it still runs at plenty of universities, hospitals, school districts, and UN agencies. Most tools read one or the other. This one reads both in the same run, and the `product` input narrows it to `fusion` or `taleo` when you only want one.

#### Find any company's Oracle careers site without a tenant code

Oracle careers boards live on hosts like `eeho.fa.us2.oraclecloud.com`. That `eeho` is an opaque tenant code, not a company name, so a URL-only tool is useless until you already know the answer. Put a company name or a website domain into **Companies** and this API resolves it to the Oracle boards that company runs, then reads the employer's own site directory to label each one.

#### It filters the decoys

Oracle tenants publish backup and reference-only sites right alongside the real ones. Oracle's own tenant publishes six career sites, of which five are inactive placeholders with names like "FOR REFERENCE ONLY", "Backup", and "Baseline DO NOT UPDATE". JPMorgan Chase publishes seven. A naive tool hands you all of them. This one checks each site's published status and its live job count before returning it.

#### It handles every Oracle host shape

Oracle uses three at once: the regional form (`{code}.fa.{region}.oraclecloud.com`), the regionless form (`{code}.fa.oraclecloud.com`), and the named form (`{name}-{code}.fa.ocs.oraclecloud.com`). All three work here.

### Oracle Taleo jobs, the boards no other tool reads

Taleo's public search endpoint is awkward to call, which is why nothing else on the Store covers it. Adding it costs you nothing, though: when a Taleo board has been retired by its owner, you get a clearly labelled error row instead of a failed run, and error rows are never charged.

Taleo is also on the way out. Roughly one in five `taleo.net` hostnames still has a public job board; the rest have migrated, gone behind a candidate login, or stopped resolving. Discovery mode is worth running first for that reason alone, since it tells you which boards are alive before you spend anything reading them.

### Oracle Recruiting Cloud and Taleo: what is the difference

Oracle Recruiting Cloud, part of Oracle Cloud HCM, is the current product. Job seekers meet it as a careers page on an `oraclecloud.com` host, and its requisitions carry rich structured fields: skills, coordinates, business unit, worker type, and a proper posting timestamp.

[Oracle Taleo](https://www.oracle.com/human-capital-management/taleo/) is the older product, hosted on `taleo.net`. Its public job boards return a thinner record: title, requisition ID, location, posted date, and the description. Both land in the same schema here, so a row from either product has the same field names and you do not have to branch on `product` unless you want to.

### Job descriptions in Markdown for AI agents

Set `descriptionFormat` to `markdown` and every job description comes back as clean Markdown with the employer's headings and bullet lists intact. Raw HTML wastes tokens on markup, and flattening to plain text loses the structure that separates a requirement from a benefit. Markdown keeps the structure and stays cheap to put in a context window.

Use `both` when you want all three formats on the same row: `descriptionHtml` for rendering, `descriptionText` for search indexing, `descriptionMarkdown` for the model.

### Employer-published skills and coordinates, not AI guesses

Oracle Fusion publishes a skill list and the primary location's latitude and longitude on the requisition itself. This API passes both through unchanged. Nothing is inferred, so `skills` is what the employer typed into the requisition and `latitude` and `longitude` are the employer's own values for the primary location. Tools that advertise "AI-extracted skills" are paying a model to guess at data the employer already published.

### Map the Oracle ATS market: which companies run Taleo and which run Oracle Recruiting Cloud

Turn on **Return career sites only** and the run skips job scraping entirely. You get one row per career site: company, tenant, host, site number, published status, careers URL, the direct jobs API URL, and a live open-job count. That gives you an install-base map of the Oracle ATS built from the boards themselves, not from a vendor's static customer list. Every answer to "which companies use Taleo" or "who is still on Oracle HCM" arrives with a URL and a current job count attached, which is the part a firmographic list cannot give you.

Run discovery first, keep the sites you care about, then scrape only those in a second run. It is the cheapest way to work through a large set of employers.

### Use cases

- Build a live jobs feed for a job board or aggregator across hundreds of Oracle employers at once.
- Track a competitor's hiring: which teams are growing, in which cities, at what pay bands.
- Feed an AI recruiting agent clean Markdown job descriptions with the employer's own skill tags already attached.
- Map an entire ATS market: which companies run Oracle Recruiting Cloud, which still run Taleo, and how many roles each has open.
- Watch a single employer's board on a schedule and diff new postings against yesterday's run.

### Input parameters

Every field is optional. An empty run returns one explanatory row and exits cleanly rather than failing.

| Parameter | Type | Required | Default | What it does |
|---|---|---|---|---|
| `companies` | array of strings | no | empty | Company names or website domains to resolve to their Oracle careers boards, for example `Oracle`, `JPMorgan Chase`, or `alleghenycollege.edu`. |
| `startUrls` | array of URLs | no | empty | Oracle Fusion or Taleo careers URLs to read directly, skipping resolution. All three Fusion host shapes work, as do `taleo.net` career sections. |
| `discoverAll` | boolean | no | `false` | Enumerate Oracle careers boards in bulk from a public web index instead of resolving a named list. |
| `discoverOnly` | boolean | no | `false` | Return one row per career site and skip job scraping entirely. |
| `product` | string | no | `both` | Limit the run to one product. Accepts `both`, `fusion`, or `taleo`. |
| `searchText` | string | no | empty | Keyword filter, run through the board's own search. |
| `locationFilter` | string | no | empty | Location filter, run through the board's own location search, for example `United States`, `London`, or `Bengaluru`. |
| `postedAfter` | string | no | empty | ISO date, `YYYY-MM-DD`. Returns only jobs posted on or after it. Most accurate with `includeDetails` on. |
| `maxJobsPerSite` | integer | no | `0` | Soft cap on jobs per career site. `0` means every job. Minimum `0`. |
| `maxSites` | integer | no | `25` | Cap on career sites processed in one run, from `1` to `2000`. The main cost control in bulk discovery. |
| `includeDetails` | boolean | no | `true` | Fetch each job's full detail record. Turn it off for a fast, cheap list-only pass at up to 200 jobs per request. |
| `descriptionFormat` | string | no | `both` | Accepts `both`, `html`, `text`, or `markdown`. `both` returns all three. |
| `detailConcurrency` | integer | no | `5` | Parallel detail requests, from `1` to `10`. |
| `verifyLive` | boolean | no | `true` | Check each site's live job count before returning it. This is what filters out backup and reference-only sites. |
| `includeInactive` | boolean | no | `false` | Also return backup and reference-only sites. |
| `crawlDepth` | integer | no | `1` | How many index snapshots to combine when resolving companies or discovering boards, from `1` to `4`. Most runs need `1`. |

### Output fields

One dataset row per result. The `resultType` field tells you which shape you are looking at: `job` for a job posting, `site` for a career site in discovery mode, and `error` for a board that could not be read.

**Identity and provenance**: `resultType`, `product`, `company`, `tenant`, `host`, `siteNumber`, `siteName`, `siteCode`, `siteUrlName`, `careerSection`, `portalId`, `sourceUrl`, `scrapedAt`.

**The job**: `title`, `jobId`, `requisitionId`, `url`, `applyUrl`, `category`, `organization`, `department`, `businessUnit`, `legalEmployer`, `jobFamily`, `jobFunction`, `managerLevel`, `workerType`, `contractType`, `jobSchedule`, `jobShift`, `jobType`, `studyLevel`, `workplaceType`, `hotJob`.

**Where it is**: `primaryLocation`, `secondaryLocations`, `locationsText`, `country`, `countryCode`, `latitude`, `longitude`.

**When it was posted**: `postedDate` (ISO date), `postedDateTime` (ISO timestamp), `postingEndDate`.

**What it says**: `shortDescription`, `descriptionHtml`, `descriptionText`, `descriptionMarkdown`, `qualifications`, `responsibilities`, `skills`.

**What it pays**: `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`. All null when the employer publishes no range.

**Career-site rows add**: `statusCode`, `careersUrl`, `apiUrl`, `totalJobs`, `totalJobsOnSite`, `status`, `siteSource`, `discoveredAt`.

**Error rows carry**: `errorMessage` and `errorType`, and are never charged.

Every field is nullable, so a thinner Taleo record and a rich Fusion record share one schema and one set of column names.

#### Example output: a job row

```json
{
  "resultType": "job",
  "product": "fusion",
  "title": "Lead Principal Platform Software Engineer",
  "company": "Oracle",
  "tenant": "eeho",
  "host": "eeho.fa.us2.oraclecloud.com",
  "siteNumber": "CX_45001",
  "siteName": "Oracle",
  "url": "https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/jobsearch/job/342237",
  "applyUrl": "https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/jobsearch/job/342237/apply",
  "jobId": "342237",
  "requisitionId": "260005TT",
  "category": "Product and Research",
  "organization": "Oracle Cloud Infrastructure",
  "workplaceType": "Hybrid",
  "hotJob": false,
  "primaryLocation": "Bengaluru, India",
  "secondaryLocations": ["Hyderabad, India"],
  "countryCode": "IN",
  "latitude": 12.99838,
  "longitude": 77.73981,
  "postedDate": "2026-08-10",
  "postedDateTime": "2026-08-10T10:12:17+00:00",
  "postingEndDate": null,
  "shortDescription": "Join the team building the next generation of cloud networking.",
  "skills": ["C Programming Language", "C++ (Programming Language)", "Cloud Architecture"],
  "descriptionMarkdown": "## About the role\n\n- Design and operate distributed services at scale\n",
  "salaryText": null,
  "salaryMin": null,
  "salaryMax": null,
  "salaryCurrency": null,
  "totalJobsOnSite": 2288,
  "scrapedAt": "2026-08-10T16:20:00Z"
}
```

#### Example output: a career-site row

```json
{
  "resultType": "site",
  "product": "fusion",
  "company": "Oracle",
  "tenant": "eeho",
  "host": "eeho.fa.us2.oraclecloud.com",
  "siteNumber": "CX_45001",
  "siteName": "Oracle",
  "statusCode": "ORA_ACTIVE",
  "careersUrl": "https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/jobsearch",
  "apiUrl": "https://eeho.fa.us2.oraclecloud.com/hcmRestApi/resources/latest/recruitingCEJobRequisitions?onlyData=true",
  "totalJobs": 2288,
  "status": "live",
  "siteSource": "site-directory",
  "discoveredAt": "2026-08-10T16:20:00Z"
}
```

### Pricing

Pay per result, with no subscription and no minimum. Two events:

| Event | When it is charged |
|---|---|
| `job_returned` | Once per job posting returned to the dataset. |
| `site_returned` | Once per verified career site returned in discovery-only mode. |

Error rows are never charged, so a retired Taleo board or a company that turns out not to run Oracle costs you nothing. Current rates are on the Store card above and in the Actor's Monetization details. Set a maximum cost on the run and it stops cleanly the moment it reaches it, with a message telling you what happened.

### How to get started

1. Open the Actor and put a company name into **Companies**, for example `Oracle`, or paste an Oracle careers URL into **Oracle careers URLs**.
2. Set **Max jobs per career site** to something small like 25 for a first run.
3. Run it. Results land in the dataset, and the Overview, Salaries, and Career sites views give you three ready-made tables.
4. Export as JSON, CSV, or Excel, or pull the dataset straight from the Apify API.

[View on Apify Store](https://apify.com/johnvc/oracle-taleo-jobs-api?fpr=9n7kx3)

There is a public example repository with a Python quick-start and MCP client walkthroughs: **[github.com/johnisanerd/Apify-Oracle-Taleo-Jobs-API](https://github.com/johnisanerd/Apify-Oracle-Taleo-Jobs-API)**.

### 🔌 Oracle MCP server: use this API from Claude

Looking for an MCP server for Oracle job data? Add this actor as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), Cursor, or any other MCP client, via the hosted Apify MCP server. Use this actor-specific URL:

https://mcp.apify.com/?tools=actors,docs,johnvc/oracle-taleo-jobs-api

Setup walkthrough:

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

With the server connected, an agent can resolve an employer to its Oracle boards, pull the open roles, and read `descriptionMarkdown` back mid-conversation, without you leaving the chat.

### 🔌 Integrations: turn Oracle job postings into a standing pipeline

One run answers a question. A schedule builds a dataset. Most of the value here comes from running this on a timer and diffing what changed, and the native [Apify platform integrations](https://docs.apify.com/platform/integrations) wire it into your stack without servers or cron jobs of your own.

#### Tasks and schedules: track Oracle job postings on a schedule

The pattern is one saved task per employer, one schedule across all of them.

1. **Create a task.** A [saved task](https://docs.apify.com/platform/actors/running/tasks) is this Actor plus a saved input. Give each employer you follow its own named task, for example *"UT Southwestern daily"* with `companies: ["UT Southwestern"]` and `maxJobsPerSite: 0`. Click **Create empty task** on the Actor page, fill in the input, and save.
2. **Attach a schedule.** Open [Schedules](https://docs.apify.com/platform/schedules) in the Apify Console and add your tasks to one schedule with a cron expression. Useful ones: `0 7 * * *` for every morning at 7 AM, `0 */6 * * *` for every six hours, `0 9 * * 1` for Mondays. One schedule can trigger many tasks, so a single "daily board check" can cover every employer you saved.
3. **Diff the runs.** `requisitionId` is stable per posting, so comparing today's set against yesterday's gives you new roles, closed roles, and edited titles. Set `includeDetails` to `false` on the polling run to make it fast and cheap, then re-run with details only on the requisition IDs that are new.

#### n8n

Apify has a native [n8n integration](https://docs.apify.com/platform/integrations/n8n) with Run Actor and Get Dataset Items nodes. A working alert workflow is four steps: **Schedule Trigger** every morning, then the **Apify node** running this Actor for your employer list, then a **Filter node** keeping rows whose `postedDate` is today, then a **Slack or email node** with the title, location, and `applyUrl`.

#### Make and Zapier

Both have native Apify integrations, [Apify on Make](https://docs.apify.com/platform/integrations/make) and [Apify on Zapier](https://docs.apify.com/platform/integrations/zapier), with the same Run Actor and Get Dataset Items actions. The same pattern applies: trigger on a schedule, run this Actor, filter on `postedDate`, then notify or store.

#### Supabase: keep an Oracle job history

Tracking hiring over time means storing it somewhere queryable. [Supabase](https://supabase.com/) (hosted Postgres) fits well, and there are two paths.

- **No code**: in n8n, connect the Apify node to the built-in Supabase node and insert a row per job after each scheduled run.
- **A few lines of Python**: run the Actor and bulk-insert the rows into an `oracle_jobs` table. `url` is a stable primary key and `postedDateTime` is the column to upsert on.

```python
from apify_client import ApifyClient
from supabase import create_client

apify = ApifyClient("YOUR_APIFY_TOKEN")
supabase = create_client("https://YOUR_PROJECT.supabase.co", "YOUR_SERVICE_ROLE_KEY")

run = apify.actor("johnvc/oracle-taleo-jobs-api").call(
    run_input={
        "companies": ["Oracle"],
        "maxJobsPerSite": 200,
        "descriptionFormat": "markdown",
    }
)

rows = [
    {
        "url": item["url"],
        "title": item["title"],
        "company": item["company"],
        "requisition_id": item["requisitionId"],
        "location": item["primaryLocation"],
        "workplace_type": item["workplaceType"],
        "posted_at": item["postedDateTime"],
        "salary_min": item["salaryMin"],
        "salary_max": item["salaryMax"],
        "description_md": item["descriptionMarkdown"],
    }
    for item in apify.dataset(run.default_dataset_id).iterate_items()
    if item.get("resultType") == "job"
]

if rows:
    supabase.table("oracle_jobs").upsert(rows, on_conflict="url").execute()
```

Run that on a schedule and you have a growing hiring history ready for dashboards and trend analysis.

#### MCP and AI agents

The [Apify MCP server](https://mcp.apify.com/) exposes this Actor as a tool, so Claude, Cursor, and any other MCP client can answer questions like "which Oracle boards does this company run, and what has it posted in engineering this month" against live data. See the MCP section above for the exact URL.

#### Webhooks

For anything custom, attach an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) to `ACTOR.RUN.SUCCEEDED`. Every time a scheduled run finishes, Apify POSTs the run details, including the dataset ID, to your endpoint, which can then fetch the rows and do whatever you need with them.

### 🔗 Related Tools

Job and hiring data across the rest of the portfolio:

- [Workday Careers API](https://apify.com/johnvc/workday-careers-api?fpr=9n7kx3): the same job for Workday career sites, the other enterprise ATS you will hit constantly when working through a list of large employers.
- [Workday Career Sites API](https://apify.com/johnvc/workday-career-sites-api?fpr=9n7kx3): the discovery half for Workday, so you can map that install base the way `discoverOnly` maps Oracle's.
- [iCIMS API](https://apify.com/johnvc/icims-careers-api?fpr=9n7kx3): live postings from iCIMS career sites, the third platform in the enterprise ATS set.
- [LinkedIn Jobs API](https://apify.com/johnvc/linkedin-jobs-api?fpr=9n7kx3): the same roles from the destination side of the market, useful for spotting which postings an employer also syndicates.
- [Glassdoor Reviews API](https://apify.com/johnvc/glassdoor-reviews-api?fpr=9n7kx3): employer reviews and ratings, for scoring the companies whose boards you just read.

For contrast, [netOrb Web Scraper](https://apify.com/netorb/netorb-web-scraper?fpr=9n7kx3) also lists Oracle and Taleo among the platforms it detects, but it is scoped to Canadian career pages, it needs you to supply the career-page URL yourself, and its last published update was in June 2026. This API resolves the board from a company name, covers Oracle boards worldwide, and is maintained continuously.

### 💡 Applications

Ready-to-run recipes. Each one is a complete input you can paste into the Actor's input editor. Published task pages for these are being added and will appear on the [Examples tab](https://apify.com/johnvc/oracle-taleo-jobs-api/examples?fpr=9n7kx3).

#### Find any company's Oracle careers site by name

Give a company name and get every Oracle careers board it runs, with tenant, host, site number, careers URL, direct jobs API URL, and a live open-role count.

`{"companies": ["JPMorgan Chase"], "discoverOnly": true}`

#### Monitor new Oracle and Taleo job postings daily

Run an employer's board on a schedule and diff `requisitionId`, `title`, and `postedDate` to catch new roles the day they go live. Cheap because details are off.

`{"companies": ["Oracle"], "includeDetails": false, "maxJobsPerSite": 0}`

#### Pull Taleo job postings through an API with no login

Read any public Taleo board and get title, requisition ID, location, posted date, apply URL, and descriptions in all three formats.

`{"startUrls": [{"url": "https://uab.taleo.net/careersection/ext/jobsearch.ftl"}], "product": "taleo"}`

#### Oracle HCM job data for Claude and ChatGPT over MCP

Feed an AI agent live Oracle job postings: Markdown descriptions, employer skills, location, coordinates, and posted date. No tenant credentials.

`{"companies": ["Oracle"], "descriptionFormat": "markdown", "maxJobsPerSite": 50}`

#### Export Oracle Recruiting Cloud jobs to CSV or JSON

Pull every open role from an Oracle Recruiting Cloud career site with category, organization, workplace type, skills, and pay range, then export from the dataset.

`{"companies": ["Oracle"], "product": "fusion", "maxJobsPerSite": 0}`

#### Map which companies run Oracle Recruiting Cloud or Taleo

Discovery mode across a list of employers, returning one row per career site with a live open-job count, so you can see who is on which product before spending anything on jobs.

`{"companies": ["Oracle", "JPMorgan Chase", "UAB"], "discoverOnly": true, "maxSites": 100}`

### 💸 Pay per run with crypto (x402)

The Oracle Fusion Recruiting and Taleo Jobs API supports agentic payments via the [x402 protocol](https://docs.apify.com/platform/integrations/x402).
AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed:
point your agent at the [Apify MCP server](https://mcp.apify.com/?tools=actors,docs,johnvc/oracle-taleo-jobs-api) and it can
discover, pay for, and run this Actor autonomously. Read the
[Apify x402 announcement](https://apify.com/change-log/pay-for-apify-actors-with-x402?fpr=9n7kx3) for details.

### ❓ FAQ

#### How do I connect Oracle HCM job data to Claude?

Add this Actor as a tool through the hosted Apify MCP server and Claude can call it mid-conversation. The URL is `https://mcp.apify.com/?tools=actors,docs,johnvc/oracle-taleo-jobs-api`, and it works in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), and the Claude desktop and web clients. Ask for Markdown descriptions and Claude gets job text it can actually reason over rather than a wall of HTML. No Oracle tenant login is involved, because this reads the public candidate feed.

#### How do I get started with an Oracle HCM MCP server?

There is no official Oracle one for public job postings, and the enterprise HCM connectors that do exist need your own tenant credentials and cover workers and absences rather than open roles. This Actor is the shortcut: point any MCP client at `https://mcp.apify.com/?tools=actors,docs,johnvc/oracle-taleo-jobs-api`, and you have an Oracle job-posting tool in about a minute. The [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp) cover client-by-client setup.

#### How do I connect Oracle job data to ChatGPT, Copilot, Gemini, LangChain, or CrewAI?

Two routes. If the client speaks MCP, use the same MCP URL as above. If it does not, call the Apify API directly: start a run, wait for it, then read the dataset as JSON. Every framework that can make an HTTP request can do this, and `apify-client` exists for both Python and Node.js if you would rather not write the polling loop. For agent frameworks specifically, set `descriptionFormat` to `markdown` so the description field drops straight into a prompt.

#### How do I use Oracle Taleo job data in n8n?

Use Apify's [n8n integration](https://docs.apify.com/platform/integrations/n8n): a Schedule Trigger, then the Apify node running this Actor with `product` set to `taleo`, then a Filter on `postedDate`, then Slack or email. The Integrations section above has the full four-step recipe.

#### What is Taleo?

Taleo is a recruiting and applicant tracking product Oracle acquired in 2012. Employers use it to post jobs and manage applications, and candidates meet it as a careers page on a `taleo.net` address. [Wikipedia's Taleo article](https://en.wikipedia.org/wiki/Taleo) covers the company history. Oracle now sells Oracle Recruiting Cloud instead, but many organizations, especially in government, healthcare, and higher education, still run Taleo.

#### Is Taleo an ATS?

Yes. Taleo is an [applicant tracking system](https://en.wikipedia.org/wiki/Applicant_tracking_system): software that receives, stores, and moves job applications through a hiring process. The public job board is only the front door of it. This API reads that public front door, not the tracking system behind it.

#### Is Oracle Fusion Recruiting an ATS?

Yes. Oracle Fusion Recruiting, part of Oracle Cloud HCM, is one of the most widely used applicant tracking systems in large enterprises. Taleo is its older sibling and still runs at many organizations, particularly in government and higher education. Between them they make up a large share of the Oracle ATS install base, and this API reads the public job boards of both.

#### What is the difference between Oracle Fusion Recruiting and Oracle Taleo?

Fusion Recruiting is the current product and lives on `oraclecloud.com` hosts. Taleo is the legacy product Oracle acquired in 2012 and lives on `taleo.net` hosts. Many organizations still run Taleo and plenty have migrated. This API reads both, the `product` input targets one or the other, and the section above spells out how the two record shapes differ.

#### What is taleo.net?

It is the domain Oracle hosts Taleo career sites on. Each employer gets a subdomain, so a company's board looks like `company.taleo.net/careersection/ex/jobsearch.ftl`. The `careersection` path segment names which board you are on, since one employer often runs several: an external one, an internal one, and sometimes a campus or contractor board.

#### What is Oracle Recruiting Cloud?

It is Oracle's current recruiting product, part of Oracle Cloud HCM, and the successor to Taleo. It is also called Oracle Fusion Recruiting or Oracle Recruiting. Its career sites live on `oraclecloud.com` hosts, and its requisitions carry more structure than Taleo's, which is why Fusion rows here come back with skills, coordinates, business unit, and worker type filled in.

#### What is Oracle HCM?

Oracle Cloud HCM is Oracle's human capital management suite: payroll, benefits, talent, and recruiting in one product family. [Oracle's HCM pages](https://www.oracle.com/human-capital-management/) describe the whole suite. Recruiting is the module this API cares about, and only its public job-posting side.

#### Is this an official Oracle API?

No. This is an independent tool and is not affiliated with, endorsed by, or connected to Oracle Corporation. It reads the same public job feed that an Oracle careers page loads in a browser, and it makes no claim to match the feature set of Oracle's own products or its authenticated HCM REST API.

#### Does Oracle have a public API for job postings?

Oracle's official HCM REST API is built for authenticated enterprise HR integrations, so it needs your own tenant credentials and is scoped to your own data. The public candidate-facing job feed that backs every Oracle careers page is a different thing, and that is what this API reads. No credentials are needed for it.

#### What is REST API in Oracle Fusion, and is it the same feed this reads?

Oracle Fusion's REST API is the credentialed interface an Oracle customer uses to integrate their own HCM instance with other systems. It is not what this reads. The candidate experience feed is separate, unauthenticated, and public, because a careers page has to load for anyone.

#### Should I use an API or a web scraper for Oracle job postings?

Both terms get used loosely here, so it helps to be precise. An [API](https://en.wikipedia.org/wiki/API) is a defined interface that returns structured data. [Web scraping](https://en.wikipedia.org/wiki/Web_scraping) means parsing a rendered page to recover data that was never offered as structured output. Oracle's official API is credentialed and quota bound, and a browser-driven scraper for Oracle careers pages is slow and brittle because the pages render client side. This Actor sits between the two: it reads the same structured public feed the careers page itself calls, so you get clean typed fields at API speed, with no key and no quota, from a tool you drive like any web scraper.

#### Can I schedule this Oracle jobs scraper to run automatically?

Yes, and this is where most of the value is. Save your input as a [task](https://docs.apify.com/platform/actors/running/tasks), then attach a [schedule](https://docs.apify.com/platform/schedules) from the Actor's **Actions**, then **Schedule** menu. Cron examples: `0 7 * * *` runs every morning at 7 AM, `0 */6 * * *` every six hours, `0 9 * * 1` Mondays at 9. One schedule can trigger many tasks at once, so a single daily schedule can cover every employer you follow. The Integrations section above has the full monitoring recipe, including the cheap list-only polling pattern and how to diff runs on `requisitionId`.

#### Can I integrate this Oracle jobs scraper with other apps?

Yes. It connects to almost any cloud service through [Apify integrations](https://docs.apify.com/platform/integrations), including [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier), [n8n](https://docs.apify.com/platform/integrations/n8n), [Slack](https://docs.apify.com/platform/integrations/slack), Google Drive, and GitHub. For anything custom, [webhooks](https://docs.apify.com/platform/integrations/webhooks) fire on `ACTOR.RUN.SUCCEEDED` and hand your endpoint the dataset ID. See the Integrations section above for the worked recipes.

#### Can I use this Oracle jobs API from the Apify API?

Yes. The Apify API runs the Actor, schedules it, and returns datasets programmatically, and the `apify-client` package wraps it for both Node.js and Python. The Actor's own [API tab](https://apify.com/johnvc/oracle-taleo-jobs-api/api?fpr=9n7kx3) has copy-paste snippets with your token filled in.

#### How else can I collect ATS and job data?

Most large employers run one of three enterprise systems, so a portfolio approach beats a single board. [Workday Careers API](https://apify.com/johnvc/workday-careers-api?fpr=9n7kx3) covers Workday postings and [Workday Career Sites API](https://apify.com/johnvc/workday-career-sites-api?fpr=9n7kx3) maps who runs it, [iCIMS API](https://apify.com/johnvc/icims-careers-api?fpr=9n7kx3) covers the third platform, and [LinkedIn Jobs API](https://apify.com/johnvc/linkedin-jobs-api?fpr=9n7kx3) picks up the same roles from the candidate side. The full list is in Related Tools above.

#### Which companies use Oracle Taleo, and can I get a list?

Yes, and it is a live list rather than a purchased one. Turn on **Return career sites only** and each row is a real career site with its tenant, host, published status, careers URL, and current open-job count. Vendors sell static Oracle HCM customer lists; this returns the boards themselves, so you can tell which ones are actually still hiring.

#### I do not know the company's Oracle URL. Can I still use this?

Yes, and that is the point. Put the company name or its website domain into **Companies** and the Actor resolves it to the Oracle careers boards that company runs. Oracle tenant codes are usually opaque, so a name-based lookup is the only practical way in.

#### Why does the output include a `siteNumber` and why does it matter?

An Oracle tenant can host several career sites, and only the site's real site number scopes a job query to that site. Feeding the slug from a browser URL instead quietly returns the tenant's entire requisition set rather than that one board's. The Actor resolves the correct site number through the employer's own site directory, so you get the board you asked for.

#### Why do some career sites come back with zero jobs?

Because they genuinely have none open right now. Oracle tenants also publish backup and reference-only sites, and those are filtered out by default. Turn on **Include inactive and backup sites** if you are auditing a tenant's full directory.

#### Why did a Taleo board fail?

Many Taleo boards have been retired by their owners: the application is still up but the public job board is switched off, or the career section is behind a candidate login. That produces a clearly labelled error row, the run keeps going, and you are not charged for it.

#### Where do the skills and coordinates come from?

From the employer. Oracle Fusion publishes a skill list and the primary location's latitude and longitude on the requisition itself, so the Actor passes them through unchanged rather than asking a model to guess.

#### Where do the salary fields come from?

From the posting text. When the employer publishes a pay range in the description, the Actor extracts it with a deterministic pattern match. When no range is published, the fields are null.

#### How much does Taleo cost, and what does this cost?

Taleo itself is enterprise software sold to employers on a negotiated contract, so there is no list price and it is not something an individual buys. This Actor is unrelated to that: you pay per job or per career site returned, with no subscription and no minimum, and error rows are free. Current rates are on the Store card above.

#### Do I need proxies or an API key?

No. The Actor reads the same public data feed the careers page itself uses, and it paces its requests politely.

#### How fresh is the data?

Every run is live. There is no cached database in between, so what the careers board shows is what you get.

#### Which description format should I use?

Use `markdown` if the output feeds an AI agent, `text` for search indexing and analysis, `html` if you are rendering it in a page, and `both` when you want all three.

#### Are Oracle jobs remote?

Some are. Fusion requisitions carry a `workplaceType` field with values like Remote, Hybrid, and On-site, so you can filter on it directly rather than guessing from the description. Taleo rows usually do not carry it, and there you have to read the description text.

#### Does LinkedIn have an API for job search, and how does this compare?

LinkedIn's official job APIs are partner programs, not something you sign up for on a card. The practical difference is which side of the market you read: LinkedIn shows what employers chose to syndicate, while an Oracle board shows every requisition the employer published, including the ones never posted anywhere else, with the real apply URL rather than a redirect. [LinkedIn Jobs API](https://apify.com/johnvc/linkedin-jobs-api?fpr=9n7kx3) covers the LinkedIn side if you want both.

***

### 🌐 About Alpha OSINT

This Actor is part of [Alpha OSINT](https://www.alphaosint.com), toolset of financial and operations data sources and APIs.
For support or requests for this actor, please start a ticket [directly on our support page](https://apify.com/johnvc/oracle-taleo-jobs-api/issues/open?fpr=9n7kx3).

Last Updated: 2026.08.25

# Actor input Schema

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

Provide company names or website domains, for example 'Oracle', 'JPMorgan Chase', or 'alleghenycollege.edu'. Each one is resolved to the Oracle careers boards that company runs, including boards hosted on opaque tenant codes, and every live career site it operates is returned. Leave empty if you are supplying careers URLs instead.

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

Provide one or more Oracle careers URLs to scrape directly, skipping company resolution. All three Oracle Fusion Recruiting host shapes work (https://eeho.fa.us2.oraclecloud.com/..., https://jpmc.fa.oraclecloud.com/..., https://somecollege-abc123.fa.ocs.oraclecloud.com/...), as do Oracle Taleo boards (https://company.taleo.net/careersection/ex/jobsearch.ftl). A career site slug in the URL is honoured when the board confirms it.

## `discoverAll` (type: `boolean`):

Enumerate Oracle careers boards in bulk from a public web index instead of resolving a named list. Use 'Maximum career sites' to control how many are returned and how long the run takes.

## `discoverOnly` (type: `boolean`):

Return one row per career site (tenant, site number, employer name, careers URL, direct jobs API URL, open-job count) and skip job scraping entirely. Use this to build a directory of Oracle careers boards, then scrape the ones you care about in a later run.

## `product` (type: `string`):

Limit the run to one Oracle recruiting product. 'fusion' covers Oracle Fusion Recruiting (Cloud CX) boards, 'taleo' covers legacy Oracle Taleo boards, and 'both' (default) covers either. Taleo boards are older and many have been retired by their owners, so restrict to 'fusion' if you want only high-yield targets.

## `searchText` (type: `string`):

Filter jobs by keyword using the careers board's own search, the same way the search box on the careers page does. Leave empty to return every job on each site.

## `locationFilter` (type: `string`):

Filter jobs by location using the careers board's own location search, for example 'United States', 'London', or 'Bengaluru'. Leave empty to return jobs in every location.

## `postedAfter` (type: `string`):

Return only jobs posted on or after this ISO date, for example 2026-07-01. Most accurate with job details enabled, because the exact posting timestamp lives on the detail record. Leave empty for no date filter.

## `maxJobsPerSite` (type: `integer`):

Set a soft cap on the jobs returned from each career site. Use 0 for every job on the site. Keep this small on test runs: some Oracle boards carry thousands of open roles.

## `maxSites` (type: `integer`):

Set an upper bound on how many career sites a single run processes. This is the main cost and runtime control in bulk discovery mode, where one run can otherwise reach thousands of boards.

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

When true (default), open each job's detail record to add the full description, exact posting dates, category, employer skills, and geographic coordinates. When false, return only the fast list fields (title, location, dates, requisition ID) at up to 200 jobs per request, which is much faster and cheaper.

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

Choose the format for the job description fields. 'html' keeps the original rich text, 'text' returns clean plain text, 'markdown' returns LLM-ready Markdown with headings and lists preserved, and 'both' (default) returns all three. Markdown is the format to pick when the output feeds an AI agent.

## `detailConcurrency` (type: `integer`):

Set how many job-detail requests run in parallel, from 1 to 10. The actor always paces its requests and backs off politely on rate limits, so raise this only for very large boards.

## `verifyLive` (type: `boolean`):

Check each career site against its jobs endpoint and record the current open-job count before returning it. Leave this on for clean data: it is what filters out the backup and reference-only sites that Oracle tenants publish alongside their real ones.

## `includeInactive` (type: `boolean`):

Also return career sites that are marked inactive or that look like backups, copies, or reference-only placeholders. Off by default because these are decoys rather than real job boards. Turn it on only when auditing a tenant's full site directory.

## `crawlDepth` (type: `integer`):

Set how many historical snapshots of the public web index to combine when resolving companies or discovering boards in bulk. Higher values find more boards, including ones that have since gone quiet, at the cost of a longer run. Most runs need 1.

## Actor input object example

```json
{
  "companies": [
    "Oracle"
  ],
  "startUrls": [
    {
      "url": "https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_45001"
    }
  ],
  "discoverAll": false,
  "discoverOnly": false,
  "product": "both",
  "maxJobsPerSite": 25,
  "maxSites": 25,
  "includeDetails": true,
  "descriptionFormat": "both",
  "detailConcurrency": 5,
  "verifyLive": true,
  "includeInactive": false,
  "crawlDepth": 1
}
```

# Actor output Schema

## `allResults` (type: `string`):

All dataset items from this run: job rows, career-site rows, and any error rows.

## `overview` (type: `string`):

Compact table of jobs: title, employer, location, workplace type, category, posted date, and links.

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

Jobs table focused on the extracted pay-range fields.

## `sites` (type: `string`):

Directory of the Oracle career sites found, with tenant, site number, open-job count, and the direct jobs API URL for each.

# 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": [
        "Oracle"
    ],
    "startUrls": [
        {
            "url": "https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_45001"
        }
    ],
    "searchText": "",
    "locationFilter": "",
    "maxJobsPerSite": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/oracle-taleo-jobs-api").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": ["Oracle"],
    "startUrls": [{ "url": "https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_45001" }],
    "searchText": "",
    "locationFilter": "",
    "maxJobsPerSite": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("johnvc/oracle-taleo-jobs-api").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": [
    "Oracle"
  ],
  "startUrls": [
    {
      "url": "https://eeho.fa.us2.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_45001"
    }
  ],
  "searchText": "",
  "locationFilter": "",
  "maxJobsPerSite": 25
}' |
apify call johnvc/oracle-taleo-jobs-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnvc/oracle-taleo-jobs-api"
        }
    }
}

```

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/QTzCLm6kNPnQTuCkO/builds/92RMW54Asy0iWe4c6/openapi.json