# Oracle Taleo Career Section Jobs Scraper (`usestring/taleo-jobs`) Actor

Collects postings from an Oracle Taleo career section on taleo.net through the same JSON job-board endpoint the search page uses. Returns the requisition ID, title, department, employmentType, postedAt, a jobdetail.ftl apply link, and the location split into city, state and country.

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

## Pricing

from $0.75 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## Taleo Job Board Scraper — any Oracle Taleo career section

Collect job postings from any Oracle Taleo career section on `taleo.net`. Give this Actor a Taleo
careers-site URL, and it returns the section's postings with title, requisition ID, location split
into city, state and country, department, employment type, posted date and apply URL.

An Oracle Taleo career section renders no jobs into its HTML: `jobsearch.ftl` is a shell whose result
table is filled by a JSON job-board endpoint. This Actor reads that endpoint, which is both the only
complete source and the exact one the page itself uses. Opening a board costs one request for the
shell — which carries the portal ID the endpoint requires and the result table's column labels — and
then one request per page of results, at the section's own page size of 25 by default.

No Taleo account, login, API key or cookies are used. This Actor reads the public career section that
a logged-out visitor sees.

### What it returns

| Field | Type | Notes |
| --- | --- | --- |
| `jobId` | string | Taleo's own requisition ID — stable, use it to de-duplicate |
| `title` | string | |
| `tenant` | string | The Taleo tenant the section belongs to, e.g. `drhorton` |
| `location` | string | The section's own location node, verbatim, e.g. `"US-TX-Arlington"`. Several locations are joined with `; ` |
| `city`, `state`, `country` | string | Split from the location node against a closed vocabulary of countries and US/Canadian subdivisions, so `"TX-Arlington"` and `"United States-Texas"` both resolve. `null` when a posting lists more than one location, or when a segment resolves to nothing |
| `isRemote` | boolean | `true` when the location or the title names remote, virtual, telecommute or work from home. `"(non-remote)"` in a title is read as not remote |
| `department` | string | The section's own category column — `Job Field`, `Job Category`, `Department` and similar. `null` when the section publishes none |
| `employmentType` | string | The section's employment column — `Employment Type`, `Job Schedule`, `Position Type` and similar. `null` when the section publishes none |
| `postedAt` | string | Calendar date, `YYYY-MM-DD`, from the section's posting-date column |
| `jobUrl` | string | Direct link to the posting's `jobdetail.ftl` page |
| `boardUrl` | string | The career section a person would open |
| `sourceUrl`, `collectedAt` | string | Provenance for every row |

### Input

```json
{ "boards": ["https://drhorton.taleo.net/careersection/2/jobsearch.ftl"], "maxItems": 1000 }
```

| Field | Description |
| --- | --- |
| `boards` | Oracle Taleo career-section URLs on `taleo.net`. Required, 1–100. |
| `maxItems` | Cap on dataset items. Default 1000, maximum 50,000. Free plans stop at 250 requests and 250 results — see below. |
| `concurrency` | Boards fetched in parallel. Default 2, maximum 5. |

A `jobsearch.ftl` URL, a `joblist.ftl` URL and a bare career-section path all rebuild to the same
canonical section and are fetched once rather than billed several times. Result pages are flattened
across boards, so one slow section cannot hold up the whole run.

### Use cases

- Tracking enterprise and hourly hiring across a watchlist of Oracle Taleo career sections
- Competitor headcount signals by location, department and employment type
- Filling an ATS, job board or talent CRM with live postings straight from the employer
- Recruiting lead lists filtered on `city`, `state`, `country` or `isRemote`
- Monitoring a section over time by re-running on a schedule and diffing on `jobId`

### Reliability

Taleo returns a posting's fields as a bare `column` array whose meaning is per-section configuration
— five columns for one tenant, two for another, with no ordering they share. The result table's
column headers, read from the same shell fetch, are what make that array readable, and `department`,
`employmentType` and `postedAt` are only claimed when the headers line up one to one with the
payload. Where they do not, those fields are `null` rather than filled with the wrong column.

The location node is likewise resolved against a closed vocabulary rather than by position, because
the same two-segment shape is state-and-city at one tenant (`TX-Arlington`) and city-and-building at
another (`Dallas-W T White High School`). A segment that resolves to nothing is left out instead of
displacing a real value, and `location` always carries the node verbatim.

A section that cannot be read is recorded in the run's `SUMMARY` under `failures` rather than
silently returning fewer rows, and a run where every section failed exits with an error.

### Frequently asked questions

**How do I find a company's Taleo career-section URL?** A Taleo career section looks like
`https://<tenant>.taleo.net/careersection/<section>/jobsearch.ftl` — for example
`https://drhorton.taleo.net/careersection/2/jobsearch.ftl`. Open the company's "search jobs" or "view
all openings" link and copy the URL from the address bar.

**Do I need a Taleo account, API key or login?** No. This Actor reads the same unauthenticated
job-board endpoint the public career section renders from. No account, no cookies, no session.

**How many job postings does one request return?** The section's own page size, which is 25 by
default. Opening a board costs one extra request for the shell that carries the portal ID and the
column labels, then one request per page.

**Does it work for any company on Taleo?** Any career section that exposes the job-board endpoint,
which is the one the section's own search page uses. A section that does not publish a portal ID in
its shell is reported as a failure with that reason.

**Why are `department`, `employmentType` and `postedAt` sometimes empty?** Taleo lets each career
section choose its own result columns and its own names for them. Those three fields are only filled
when the section publishes a matching column. `Organization`, `Division` and `Business Unit` are
deliberately not read as departments, because at least one tenant files a posting's hotel under
`Organization` — a place, not a department.

### Limitations

Result-table fields only: no job description body, no compensation, no application counts and no
recruiter contacts. No company display name — Taleo career sections publish none, and `tenant` is the
identity the section is addressed by. `postedAt` is a date rather than a timestamp, and a numeric
date such as `03/04/2026` is left `null` because it means March in one section's locale and April in
another's. Only `taleo.net` career sections are accepted — a URL on any other host is rejected rather
than fetched.

### Free plan limit

Runs started from an Apify **free plan** stop at **250 requests and 250 results**, and the run
reports that it reached the limit. Any paid plan runs the full input and `maxItems` you set.

The limit exists because this Actor fetches through our own infrastructure, which Apify does not
cover for free-plan runs. It binds on requests as well as results so that a large input list cannot
spend those fetches for rows the run will not return.

# Actor input Schema

## `boards` (type: `array`):

Taleo careers-site URLs (…taleo.net).

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

Global cap on dataset items. Runs started from an Apify free plan stop at 250 requests and 250 results; any paid plan runs the full amount.

## `concurrency` (type: `integer`):

Targets fetched in parallel.

## Actor input object example

```json
{
  "boards": [
    "https://drhorton.taleo.net/careersection/2/jobsearch.ftl"
  ],
  "maxItems": 1000,
  "concurrency": 2
}
```

# Actor output Schema

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

Collect job postings from any Oracle Taleo career section on taleo.net.

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

Item count, failure count and every target that failed, with its error.

# 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 = {
    "boards": [
        "https://drhorton.taleo.net/careersection/2/jobsearch.ftl"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("usestring/taleo-jobs").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 = { "boards": ["https://drhorton.taleo.net/careersection/2/jobsearch.ftl"] }

# Run the Actor and wait for it to finish
run = client.actor("usestring/taleo-jobs").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 '{
  "boards": [
    "https://drhorton.taleo.net/careersection/2/jobsearch.ftl"
  ]
}' |
apify call usestring/taleo-jobs --silent --output-dataset

```

## MCP server setup

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

```

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/vJjHqrYKyBV11lRVg/builds/dWydoKWrp24HMJscT/openapi.json