# Oracle Recruiting Cloud Jobs Scraper - oraclecloud.com Careers (`maydit/oracle-recruiting-jobs-scraper`) Actor

Scrape open job requisitions from any employer's Oracle Recruiting Cloud careers site. Clean-text descriptions, every location, salary text where published, new-postings-only mode. No API key.

- **URL**: https://apify.com/maydit/oracle-recruiting-jobs-scraper.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (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.60 / 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?

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 Jobs Scraper

Scrape open job requisitions from an employer's **Oracle Recruiting Cloud careers site** (the `xxxx.fa.xxx.oraclecloud.com/hcmUI/CandidateExperience/...` sites that thousands of large employers, universities, hospitals and public bodies use) and get them back as flat CSV, JSON or Excel rows. Paste the careers URL as it appears in the browser and this Oracle HCM jobs scraper returns every open requisition on that site: title, category, workplace type, schedule, primary and secondary locations, posting date, the **full description, qualifications and responsibilities converted from Oracle's rich-text HTML into clean plain text**, the **pay range parsed out of the description** where the employer published one, and the posting link.

Built for recruiters, sourcers, job-board operators, ATS data pipelines and anyone tracking hiring at a list of employers. It reads the same public JSON the careers page itself loads, so there is **no API key, no login and no Oracle account** involved. Pass one employer or a list.

This Actor targets **third-party employers' Oracle-hosted careers sites** - International Paper, Pearson, UNDP, Marks & Spencer, Emerson, JPMorgan Chase and the like. Oracle Corporation's own careers tenant is deliberately not included in any default or preset: oracle.com's Terms of Use carry a no-automated-access clause and that tenant links them, whereas the third-party tenants checked link no oracle.com legal page. If you want Oracle's own postings, that is a decision for you to make against those terms, not one this Actor makes for you.

### What you get

One row per open job requisition. Fill rates were measured on 320 rows from four real runs across six employers on 2026-09-25; fields that depend on how each employer configured Oracle are marked with the measured rate rather than promised.

| Field | What it is |
| --- | --- |
| `employer` | The enterprise name where the employer configured it in Oracle (`International Paper`, `Pearson`, `Lucas County`, `Marks & Spencer Plc`), otherwise the careers site's own name (`Emerson Career Site`, `JPMC Candidate Experience page`). Always filled. |
| `tenantHost` | The oraclecloud.com host the row came from, e.g. `iazbqy.fa.ocs.oraclecloud.com`. |
| `siteNumber` | The careers site on that tenant, e.g. `CX_1`, `CX_1001` or bare `CX`. One tenant can run several sites (UNDP, UN Women and ICAO share one tenant). |
| `siteName` | The site's display name as configured by the employer. |
| `requisitionId` | Oracle's requisition id, as a string. Stable - use it to dedupe across runs. |
| `title` | Job title. |
| `category` | Job category the employer filed the role under (`Production/Facility`, `Healthcare`, `Technology`). Employer-configured: filled on 43% of rows overall - 100% at Pearson, Lucas County, Emerson and M\&S, 0% at UNDP and 33% at International Paper. |
| `jobFunction` | Job function (`Sales`, `Operations`, `Administrative`). Employer-configured, 23% filled. |
| `jobSchedule` | `Full time` / `Part time` as published. 98% filled. |
| `workplaceType` | `remote`, `hybrid` or `onsite`, normalized from Oracle's workplace type. Employer-configured: 33% filled overall (100% at Lucas County and Emerson, 91% at Pearson, 85% at M\&S, 6% at International Paper, 0% at UNDP - empty where the employer does not use the field). `null` means not stated, not "on-site". |
| `postingDate` | ISO 8601 UTC timestamp of when the requisition was posted (from the detail record; the list only carries a date). Rows are newest first *within each site* by posting day (Oracle sorts on the date, so two postings from the same day come back in Oracle's order); sites are written in the order you listed them. With details off this field is the bare date (`2026-09-25`) from the list row. |
| `postingEndDate` | ISO 8601 UTC timestamp the posting is scheduled to close, when set. 77% filled. |
| `primaryLocation` | The main location line as published, e.g. `Omaha, NE, United States`. Always filled. |
| `primaryLocationCountry` | ISO country code of the primary location. Always filled. |
| `secondaryLocations` | Array of additional location names, expanded from Oracle's `secondaryLocations` list. Empty array when the posting has one location, which is the common case (7% of rows had extra locations; on International Paper's multi-plant roles it is two or three cities). |
| `locationCount` | Primary + secondary locations, as a number. |
| `shortDescription` | The employer's short summary line, when they wrote one. 53% filled. |
| `descriptionText` | The whole job description as clean plain text: HTML entities decoded, tags removed, list items kept as `- ` bullets. Capped at 20,000 characters. 99% filled with details on. |
| `qualificationsText` | Oracle's separate "qualifications" section as clean text. Most employers leave this section empty and write everything into the description: 6% filled overall (Lucas County 18 of 20, every other employer 0). |
| `responsibilitiesText` | Oracle's separate "responsibilities" section, same caveat: 5% filled. |
| `salaryText` | The pay figure or range exactly as written in the posting (`$89,000 - $118,600`, `$33.05/hr - $39.61`, `EUR 4,819 to EUR 6,188`, `13.60/hour`). See the FAQ for how it is found and how often. |
| `salaryMin` / `salaryMax` | The two numbers of the range as published (hourly rates stay hourly, annual stay annual, no currency conversion). A single published figure fills `salaryMin` only. |
| `detailFetched` | `true` when the detail record was retrieved for this row. `false` only when details were turned off or the run ran out of time part-way through a site. |
| `url` | Public link to the posting on the employer's careers site. |
| `scrapedAt` | ISO 8601 UTC timestamp of the run. |

A `SUMMARY` record is written to the run's key-value store with, per site, the host, site number, employer, how many requisitions the site reports, how many were listed, how many detail lookups succeeded and how many rows were written; plus the sites that failed and why, and whether the run stopped early on its time budget.

### Input

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `careersUrls` | string list | empty | One entry per employer: the careers URL as it appears in the browser. Job-page URLs (`.../job/12345`), `/jobs` and `/requisitions` pages, and a bare host all work; the host and the `/sites/<number>` segment are read out of it. When this is filled in, `preset` is ignored. |
| `preset` | select | `verified-sample` | Used only when `careersUrls` is empty. `verified-sample` scrapes three third-party employers verified live (International Paper, Pearson, Lucas County OH). `none` means you will supply your own URLs - if the list is still empty the Actor falls back to the sample so a run never silently returns nothing. |
| `keyword` | string | empty | Passed to Oracle's own job search on each site. Fuzzy - see the FAQ. |
| `sortBy` | select | `POSTING_DATES_DESC` | Newest first, or Oracle's relevance ranking (only meaningful with a keyword). |
| `includeDetails` | boolean | `true` | One extra request per posting for the description, qualifications, responsibilities, category, function, schedule, full posting timestamp and salary text. Off = list-only rows (title, locations, workplace type, posting date). |
| `maxJobsPerSite` | integer | `25` | Row cap per site, newest first. The Actor lists 100 rows per request, so a 500-posting site is 5 list calls plus, with details on, 500 detail calls. |
| `detailConcurrency` | integer | `5` | Detail lookups in flight against one tenant, capped at 8. Sites are always scraped one after another. |
| `onlyNewSinceLastRun` | boolean | `false` | Save only requisitions this Actor has not seen before. See the FAQ for exactly how the first run behaves. |
| `maxRunSeconds` | integer | `240` | Wall-clock budget. When it is reached the run stops cleanly, keeps everything already saved, and logs which sites and which detail lookups it did not reach. |

### Example output

A real row from a default run (description truncated here for readability):

```json
{
  "employer": "International Paper",
  "tenantHost": "iazbqy.fa.ocs.oraclecloud.com",
  "siteNumber": "CX_1",
  "siteName": "IP Global Career Site",
  "requisitionId": "2003681",
  "title": "Site Manager",
  "category": null,
  "jobFunction": null,
  "jobSchedule": "Full time",
  "workplaceType": null,
  "postingDate": "2026-09-25T13:15:23.000Z",
  "postingEndDate": "2026-10-23T05:00:00.000Z",
  "primaryLocation": "Manitowoc, WI, United States",
  "primaryLocationCountry": "US",
  "secondaryLocations": [],
  "locationCount": 1,
  "shortDescription": null,
  "descriptionText": "Position Title: Site Manager\nPay Rate : $137,400 - $183,200\nMultiple factors, including Individual experience, skills and abilities will determine where an employee is ultimately placed in the pay range. ...",
  "qualificationsText": null,
  "responsibilitiesText": null,
  "salaryText": "$137,400 - $183,200",
  "salaryMin": 137400,
  "salaryMax": 183200,
  "detailFetched": true,
  "url": "https://iazbqy.fa.ocs.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1/job/2003681",
  "scrapedAt": "2026-09-25T17:45:20.051Z"
}
```

`category`, `jobFunction` and `workplaceType` are `null` here because International Paper does not fill those Oracle fields on most of its postings; the same row from Lucas County reads `"category": "Finance", "workplaceType": "onsite"` and carries `qualificationsText` and `responsibilitiesText` because that employer uses all three sections.

### FAQ

**Where do I find an employer's careers URL?**
Open the employer's job list in a browser and copy the address bar. It is an `oraclecloud.com` host with `/hcmUI/CandidateExperience/` in the path. Four host shapes were verified on 2026-09-25 and all answer the same contract: `iazbqy.fa.ocs.oraclecloud.com` (`{tenant}.fa.{region}`, regions verified: ocs, us2, us6, em2, em3), `fa-eqid-saasfaprod1.fa.ocs.oraclecloud.com` (the older provisioning shape), `jpmc.fa.oraclecloud.com` (no region) and `egue-dev12.fa.us2.oraclecloud.com` (`{tenant}-{env}`). The site number is the segment after `/sites/` - usually `CX_1` or `CX_1001`, sometimes bare `CX`. If you paste a URL without it, the Actor lists the tenant's sites and uses the first active one, logging the others so you can pick.

**Can I paste careers.company.com?**
Best effort only. Oracle's vanity-URL feature is a reverse proxy the employer runs, so the Actor first tries the Oracle REST path on that host, then follows the page's redirect, then looks for an `oraclecloud.com` careers link on the page. If none of that finds the tenant, that entry fails with a message telling you to click through to the job list and paste the `oraclecloud.com` URL from the address bar; the other entries in your list still run. No real vanity domain was available to verify the happy path against, which is why this is described as an attempt, not a feature.

**What happens if I get the site number wrong?**
Oracle does not return an error for a non-existent site number - it silently answers with the tenant's default postings, and every job link built from the wrong number would be dead. This Actor therefore checks the number against the tenant's own site list first; an unknown number is swapped for the first active site with a warning naming the sites that do exist.

**How does the keyword work?**
It is Oracle's own site search, so it behaves like the search box on the careers page: it matches the description as well as the title and it is fuzzy. On International Paper's site, `nurse` returned one result, titled "Fire Medic"; `software engineer` returned six, led by "Graphic Designer". Treat it as a first cut and filter the rows afterwards. With a keyword, `sortBy: RELEVANCY` orders results the way the careers page does; the default keeps newest first.

**How is the salary found, and how often?**
Oracle has no structured pay field. Employers write pay into the description, so this Actor scans the description, qualifications and responsibilities text for a pay cue ("pay range", "pay rate", "salary", "compensation", "remuneration", "wage" and a few more) and takes the range or single figure that follows it within about 240 characters. A range gives `salaryMin` and `salaryMax`; a lone figure gives `salaryMin` only; `salaryText` always holds the literal snippet so you can check it. Ranges without a pay cue nearby are ignored on purpose - an Emerson internship's "monthly reimbursement ranging from EUR 500 to EUR 800" and M\&S's "+ GBP 3.00 p/h unsocial premium" are not salaries and are not reported as such. Measured on 320 rows: `salaryText` was filled on 37% overall and 56% of the default sample. It is entirely down to the employer: International Paper 90 of 95 rows (66 with a full range; the rest are single hourly figures such as `$22.72`), Pearson 26 of 45, Emerson 2 of 20, UNDP 1 of 120, Lucas County and M\&S 0. Known misses: postings that say "will be discussed during the hiring process", figures with neither a currency mark nor an hourly unit, and non-Latin currency words.

**What exactly does "only postings new since the last run" do?**
With the option on, the Actor records the key `tenantHost:siteNumber:requisitionId` of every posting it listed, in a named key-value store called `oracle-recruiting-jobs-scraper-state` that is shared by all runs of this Actor on your account. On the **first** run there is no baseline, so you get **every** posting and the baseline is written; the log says so explicitly. From the second run on you get only requisitions that were not there before. A run with nothing new finishes successfully with an empty dataset and a warning - that is the expected result, not a failure. The baseline is merged, never replaced, so a partial run cannot erase history, and it is only written on runs where the option is on. Two schedules watching the *same* site will each consume the other's new postings; different site lists are safe.

**How fast is it?**
Measured locally on 2026-09-25, end to end including writing the rows. The default run (3 sites, 70 postings, details on) took 10.7-11.3 seconds on three consecutive runs. International Paper's 50 newest with details: 6 seconds. Four employers x 20 newest with details: 14 seconds. UNDP's entire board, 120 postings with details: 36 seconds - that tenant answers detail calls noticeably slower than the others, so per-site speed varies with the employer's Oracle region and load. Platform runs add the time to write results over Apify Storage. Large runs are bounded by `maxRunSeconds`: with a 30-second budget against 400 postings per site on two sites, the run saved 400 rows (346 with detail), logged that the second site was not started, and finished successfully in 32 seconds. A host that does not exist costs one 20-second timeout (some Oracle regions answer such a host with HTTP 503 "DNS failure" at once, others never answer), after which the run moves on to the next site.

**Why are category, workplace type or qualifications empty for my employer?**
Because those are optional Oracle fields that each employer fills or not. The Actor never fabricates a value: an employer that leaves the workplace-type field blank gets `null`, not `onsite`. Run once and look at the `SUMMARY` and a few rows to see what a given employer publishes.

**Does it also cover Workday, Greenhouse, Lever, SuccessFactors or Taleo?**
No. This Actor talks to Oracle Recruiting Cloud (the "CandidateExperience" careers sites) and nothing else. An employer on Oracle Taleo (`taleo.net`) or another system is out of scope; for Workday use our **Workday Jobs Scraper**, for Greenhouse, Lever, Ashby, SmartRecruiters, Recruitee and Workable use our **ATS Job Postings Scraper**.

### Data source, access and limits

- **Source:** the public JSON endpoints behind each employer's Oracle Recruiting Cloud careers page - `recruitingCESites` (the tenant's site list, one call per tenant), `recruitingCEJobRequisitions` (the list, up to 100 rows per call) and `recruitingCEJobRequisitionDetails` (one call per posting). No key, no login, no cookies. Only requisitions the employer has published on their external careers site; internal-only postings are never visible here.
- **Verified on nine tenants across the four host shapes on 2026-09-25** (International Paper, Pearson, Lucas County, UNDP, Emerson, Marks & Spencer, JPMorgan Chase, IOM and one `{tenant}-{env}` host). A tenant that refuses anonymous requests (HTTP 401/403) would fail with that status in the log and in `SUMMARY`; none of the tenants checked did. None of the hosts checked publishes a `robots.txt`: eight answer HTTP 404 and JPMorgan Chase's tenant answers HTTP 403 from Oracle's WAF for that path while its careers API answers normally, so there is no crawl policy on any of them to honour or to break.
- **Polite by construction.** Sites are scraped strictly one after another; inside a site, detail lookups run at most 8 wide (default 5) with a short pause between calls; every request has a 12-25 second timeout so a host that never answers (a real tenant on the wrong region, or a non-existent tenant on some regions, does exactly that) costs one timeout, not the whole run.
- **Everything is passed through as published.** Titles, categories, locations, schedules and timestamps come from the employer's own Oracle data, including its inconsistencies. `workplaceType` is normalized to three values; `salaryMin`/`salaryMax` are parsed from text and should be treated as such.
- **No personal data is extracted.** Every row describes a *job requisition*, not a person. Oracle's detail record has recruiter-contact fields (`ExternalContactName`, `ExternalContactEmail`); this Actor does not read them and there is no contact, hiring-manager or applicant column in the output. `descriptionText` is the employer's own published text reproduced as text, so an address an employer wrote into a posting stays there.
- **Failures are explicit.** Sites that cannot be reached or parsed are named in the log and in `SUMMARY` with the HTTP status or the reason, and the run still saves everything from the sites that worked. If *every* site fails, the run fails with a message naming the likely cause instead of returning an empty dataset that looks like "no jobs".
- **Billing:** this Actor is billed per result on Apify - the current rate is on the Pricing tab of this Actor's page. There is nothing else to buy; the data source itself needs no account.
- **Not affiliated with Oracle Corporation or any of the employers named above.** Oracle is a trademark of Oracle Corporation; employer names are the trademarks of their owners; this Actor is an independent tool that reads publicly available careers-site data.

# Actor input Schema

## `careersUrls` (type: `array`):

One entry per employer. Paste the careers URL exactly as it appears in the browser, e.g. https://iazbqy.fa.ocs.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX\_1/requisitions - the host and the site number (the segment after /sites/) are read out of it. Job-page URLs (/job/12345), /jobs pages and the older fa-xxxx-saasfaprod1.fa.ocs.oraclecloud.com hosts all work. A URL with no /sites/ segment uses the tenant's first active site. Vanity domains (careers.company.com) are tried on a best-effort basis and reported clearly when they cannot be traced to an oraclecloud.com host. When this list is filled in, the preset below is ignored.

## `preset` (type: `string`):

Used only when 'Oracle careers site URLs' is empty. 'verified-sample' scrapes three third-party employers whose Oracle-hosted careers sites were verified live (International Paper, Pearson, Lucas County OH). 'none' means you will supply your own URLs; if the list is still empty the Actor falls back to the sample so a run never silently returns nothing.

## `keyword` (type: `string`):

Passed to Oracle's own job search on each site. It matches the description as well as the title and is fuzzy (a search for 'nurse' can return 'Fire Medic'), so treat it as a first filter, not an exact match. Leave empty for every open requisition.

## `sortBy` (type: `string`):

Newest posting first (the default) or Oracle's relevance ranking, which is only meaningful together with a keyword.

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

Calls each requisition's detail endpoint. This adds the description, qualifications and responsibilities as clean text, the category, job function and schedule, the full posting timestamp, and the salary text parsed out of the description. Turn it off for a faster, list-only run (title, locations, workplace type and posting date only).

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

Cap on postings written for each careers site, newest first. The Actor lists 100 rows per request; with details on, every posting is one extra request, so a 500-posting site is 5 list calls plus 500 detail calls - raise 'Max run seconds' with it.

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

How many detail lookups run at once against one tenant. Sites are always scraped one after another; this only controls parallelism inside a site. Capped at 8 to stay a polite guest on someone else's tenant.

## `onlyNewSinceLastRun` (type: `boolean`):

Compares this run against the requisition ids stored by the previous run in the named key-value store 'oracle-recruiting-jobs-scraper-state' and writes only postings that were not there. The FIRST run has no baseline, so it returns everything and saves it - from the second run on you get just the new openings. An empty dataset then means nothing new was posted (the run succeeds with a warning).

## `maxRunSeconds` (type: `integer`):

Wall-clock budget. The Actor stops cleanly at this point and keeps everything collected so far, instead of being killed mid-write. Raise it for large sites; the platform run timeout still applies on top.

## Actor input object example

```json
{
  "careersUrls": [
    "https://iazbqy.fa.ocs.oraclecloud.com/hcmUI/CandidateExperience/en/sites/CX_1/requisitions"
  ],
  "preset": "verified-sample",
  "keyword": "engineer",
  "sortBy": "POSTING_DATES_DESC",
  "includeDetails": true,
  "maxJobsPerSite": 25,
  "detailConcurrency": 5,
  "onlyNewSinceLastRun": false,
  "maxRunSeconds": 240
}
```

# Actor output Schema

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

One row per open job requisition from each Oracle Recruiting Cloud careers site, with clean-text description, expanded locations and parsed salary text.

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

Totals for the run: sites requested versus scraped, per-site counts, sites that failed and why, preset health, and whether the run stopped early on its time budget.

# 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 = {
    "careersUrls": [],
    "maxJobsPerSite": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/oracle-recruiting-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 = {
    "careersUrls": [],
    "maxJobsPerSite": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("maydit/oracle-recruiting-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 '{
  "careersUrls": [],
  "maxJobsPerSite": 25
}' |
apify call maydit/oracle-recruiting-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,maydit/oracle-recruiting-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/DPHCocdtvwNuj75oc/builds/mG082YCi3zmLcBp5X/openapi.json