# 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

### What does Taleo Job Board Scraper do?

Oracle Taleo career sections are old, and they render nothing useful into their HTML. `jobsearch.ftl`
is a shell whose results table is filled in afterwards 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.

Give it a career-section URL such as
`https://drhorton.taleo.net/careersection/2/jobsearch.ftl` and it returns the section's postings with
requisition id, title, department, employment type, posted date, apply link, and the location split
into city, state and country.

Opening a section costs two things at once. The shell fetch supplies the `portal` id the endpoint
refuses to answer without, and it also supplies the results table's column headers, which is the part
that matters more than it sounds:

- Taleo returns a posting as a bare `column` array. What each position means is per-section
  configuration, not a schema. One tenant publishes five columns, another two, and they share no
  ordering.
- The headers read from the shell are what make that array legible. `department`, `employmentType` and
  `postedAt` are claimed only when the header list lines up one-to-one with the payload. Where it does
  not, those fields stay `null` rather than being filled from the wrong column.

After that, results come one page at a time at the section's own page size, 25 by default. Pages are
flattened across every section in the input, so one slow career section cannot hold up the run.

No Taleo account, login or cookie is used.

### What data does it extract?

| Field | Type | Description |
| --- | --- | --- |
| `jobId` | string | Taleo's requisition id. Stable, so use it to de-duplicate and diff |
| `title` | string | The posting title, taken from the column the payload marks as the linked one |
| `company` | string | Always `null`. Taleo career sections publish no company display name |
| `tenant` | string | The Taleo tenant, read from the host, for example `drhorton` |
| `location` | string | The section's own location node, verbatim, for example `US-TX-Arlington`. Several locations join with `; ` |
| `city` | string | Resolved from the location node. `null` when the posting lists more than one location |
| `state` | string | US state or Canadian province, matched against a closed vocabulary |
| `country` | string | ISO code, matched against a closed vocabulary of names and codes |
| `isRemote` | boolean | `true` when the location or the title names remote, virtual, telecommute or work from home |
| `department` | string | The section's category column: `Job Field`, `Job Category`, `Department`, `Function` and similar |
| `employmentType` | string | The section's employment column: `Employment Type`, `Job Schedule`, `Appointment Type`, `Position Type` and similar |
| `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 canonical career section |
| `sourceUrl` | string | The job-board endpoint the row came from |
| `collectedAt` | string | ISO 8601 timestamp of the run |

#### Reading a Taleo location

A location node is a path through the section's own location tree, and the tree's depth is
configuration rather than a standard. The same two-segment shape means state and city at one employer
(`TX-Arlington`), city and building at another (`Dallas-W T White High School`), and country and state
at a third (`United States-Texas`).

Segments are therefore resolved against a fixed vocabulary rather than by position, and a segment that
matches nothing is dropped instead of being allowed to displace a real value. A bare `CA` reads as
California rather than Canada, because it is far more often California, and a spelled-out country name
is never ambiguous. `location` always carries the node verbatim, which is the one field this cannot get
wrong.

### Why scrape Oracle Taleo career sections?

Taleo is legacy software with an enormous installed base. Hospital systems, universities, school
districts, homebuilders, hotel groups and government agencies still run their hiring on it, and those
employers are systematically under-covered by scrapers built for modern boards.

- Follow public-sector and education hiring, where Taleo remains common and aggregator coverage is thin.
- Track construction and hospitality requisitions by site, using the location tree the employer built.
- Supply labour-market research with employers that technology-focused datasets miss entirely.
- Keep a staffing desk stocked with fresh requisitions from a defined list of career sections.
- Detect openings and expansions from where new requisitions cluster geographically.

### How to use it

1. On the employer's site, follow "search jobs" or "view all openings" until you reach a URL containing
   `taleo.net/careersection/`. Copy the whole URL.
2. Paste it into **Job boards**. Up to 100 sections per run. A `joblist.ftl` link, a `jobsearch.ftl`
   link and a bare section path all rebuild to the same canonical section and are fetched once.
3. Set **Maximum results**, which matters here because results are paginated 25 at a time.
4. Start the run and export the dataset, or read it over the API.

Unlike the boards addressed by a company slug, Taleo needs the full URL. The section number in the
path (`/careersection/2/`) is part of the address, and a single employer often runs several sections
for different job families.

### Input

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `boards` | array of strings | required | Taleo career-section URLs on `taleo.net`. Between 1 and 100 entries |
| `maxItems` | integer | `1000` | Cap on dataset rows, up to 50,000 |
| `concurrency` | integer | `2` | Sections and result pages fetched in parallel, up to 5 |

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

A host outside `taleo.net`, or a URL with no `/careersection/<section>` in its path, is rejected with a
reason rather than fetched.

### Output

One row per requisition. Illustrative shape:

```json
{
  "jobId": "2600123",
  "title": "Construction Superintendent",
  "company": null,
  "tenant": "drhorton",
  "location": "US-TX-Arlington",
  "city": "Arlington",
  "state": "TX",
  "country": "US",
  "isRemote": false,
  "department": "Construction",
  "employmentType": "Full-time",
  "postedAt": "2026-06-18",
  "jobUrl": "https://drhorton.taleo.net/careersection/2/jobdetail.ftl?job=2600123&lang=en",
  "boardUrl": "https://drhorton.taleo.net/careersection/2/jobsearch.ftl?lang=en",
  "sourceUrl": "https://drhorton.taleo.net/careersection/rest/jobboard/searchjobs?lang=en&portal=101430233",
  "collectedAt": "2026-08-20T09:14:02.118Z"
}
```

A posting open in several locations reads `"location": "US-TX-Arlington; US-TX-Frisco"` with `city`,
`state` and `country` all `null`, since none of them can describe two places at once.

The run also writes a `SUMMARY` record listing the item count, the failure count and every section or
page that failed with its error.

### How much does it cost?

Pay per event, charged once per result row written to the dataset. The rate is on this Actor's pricing
tab. A section that will not open produces no rows and costs nothing.

Two requests open a section and each further page returns 25 rows, so requests here scale with rows
rather than with employers. `maxItems` is the lever that controls the bill.

Runs from an Apify **free plan** stop at **250 requests and 250 results** and report the limit in the
run status. Any paid plan runs the full input. The cap binds on requests as well as rows because the
fetches run on our own infrastructure, which Apify does not reimburse for free-plan runs.

### Using it with the Apify API

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run = client.actor("usestring/taleo-jobs").call(run_input={
    "boards": ["https://drhorton.taleo.net/careersection/2/jobsearch.ftl"],
    "maxItems": 1500,
})

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["postedAt"], job["state"], job["title"])

summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("SUMMARY")
print(summary["value"]["failureCount"], "target(s) failed")
```

The JavaScript client and the REST API take the same input.

### Is it legal to scrape Oracle Taleo career sections?

A Taleo career section is a public job search that employers run so candidates can find and apply to
open roles. This Actor reads the same unauthenticated job-board endpoint the section's own page reads,
with no account, no cookie and no API key.

The rows describe requisitions. There is no candidate data, no application record and no recruiter
contact information in the output, and `company` is always `null` because Taleo publishes no display
name to collect.

Whether a particular use is permitted depends on your jurisdiction and on the terms you agreed to.
This is background rather than legal advice.

### Related actors

- [Workday Job Board Scraper](https://apify.com/usestring/workday-jobs) is where most Taleo employers
  eventually migrate, so a watchlist usually needs both.
- [iCIMS Job Board Scraper](https://apify.com/usestring/icims-jobs) covers the same kind of
  high-volume, site-based hiring.
- [Greenhouse Job Board Scraper](https://apify.com/usestring/greenhouse-jobs) handles the technology
  end of an employer list.
- [Indeed Job Listings Scraper](https://apify.com/usestring/indeed-jobs) searches the aggregate market
  when you do not have a list of employers yet.
- [Glassdoor Jobs Scraper](https://apify.com/usestring/glassdoor-jobs) adds the employer reputation
  context around a requisition.

### FAQ

**How do I find a company's Taleo career section?** Follow "search jobs" or "view all openings" from
the employer's careers page and copy the URL once it contains `taleo.net/careersection/`. There is no
shorter handle to pass, and one employer may run several sections.

**How many postings come back per request?** The section's own page size, 25 by default, plus one
opening request for the shell that carries the portal id and the column labels.

**Does it work for every company on Taleo?** For every career section that exposes the job-board
endpoint, which is the one the section's own search page calls. A section whose shell publishes no
portal id is reported as a failure naming that reason, rather than returning an empty result.

**Why are `department`, `employmentType` and `postedAt` sometimes empty?** Each career section picks
its own result columns and its own names for them. Those three fields are filled only when the section
publishes a column this Actor recognises. `Organization`, `Division` and `Business Unit` are
deliberately excluded from the department match: at least one large tenant files a posting's hotel
under `Organization`, which is a place rather than a department, and a column that means something
different per employer is worse than an empty one.

**Why is `postedAt` sometimes null when the section clearly shows a date?** Only unambiguous written
forms are read. A numeric date such as `03/04/2026` means March in one section's locale and April in
another's, and Taleo never states which, so it is left `null` rather than guessed.

**Why is `company` always null?** Taleo career sections do not publish a company display name anywhere
in the payload. `tenant` is the identity the section is addressed by, and it is the field to join on.

**What happens if one section fails?** It is recorded in `SUMMARY` under `failures` with its error, and
the other sections still produce rows. The run only exits with an error when every section failed.

### Feedback

If a career section will not open, or a column lands in the wrong field, open an issue from this
Actor's Store page and include the section URL. Column-label coverage is the part that most often needs
extending, and one URL is enough to extend it.

# 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`):

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.

## `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/IDtSFIC3aUcRJcZxB/openapi.json