# Dayforce Jobs Scraper (`automation-lab/dayforce-jobs-scraper`) Actor

Scrape public Dayforce employer job boards and posting pages. Export normalized IDs, dates, locations, attributes, descriptions, salary fields, and apply URLs.

- **URL**: https://apify.com/automation-lab/dayforce-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.02 / 1,000 item extracteds

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

## Dayforce Jobs Scraper

Extract normalized job postings from public Dayforce employer career sites.

Give the Actor one or more `jobs.dayforcehcm.com` board or job URLs. It discovers postings, follows pagination, opens each job page, and returns complete records ready for recruiting, aggregation, monitoring, or labor-market analysis.

No Dayforce login is required for the supported public career-site scope.

### What does Dayforce Jobs Scraper do?

Dayforce Jobs Scraper supports two entry points:

- an employer board URL, such as `https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL`;
- an individual posting URL ending in `/jobs/{jobPostingId}`.

For board URLs, the Actor uses Dayforce's public search data to discover jobs and then enriches every result from its public posting page.

For direct job URLs, it extracts that exact posting, including expired postings when Dayforce still serves their public record.

Results from multiple inputs are deduplicated by tenant, career site, and posting ID.

### Who is this Actor for?

**Job aggregators** can collect first-party employer postings with canonical application links.

**Recruiters and talent teams** can watch target employers for newly opened or changed roles.

**Labor-market analysts** can study titles, locations, functions, posting dates, and expiries.

**Sales and hiring-signal teams** can feed active vacancies into company research and outreach workflows.

**Developers** can replace brittle browser automation with structured dataset output and API-triggered runs.

### Why use this Dayforce job extractor?

- Supports both board discovery and exact posting extraction.
- Uses the public Dayforce data surface without browser rendering.
- Returns requisition IDs and posting IDs for stable downstream deduplication.
- Preserves both plain-text and source-HTML descriptions.
- Normalizes locations and coordinates.
- Applies one global output limit across all inputs.
- Supports optional keyword filtering.
- Produces one consistent dataset schema for integrations.

This Actor focuses specifically on public Dayforce career sites. It does not scrape private employee portals, candidate accounts, applications, or personal candidate data.

### What Dayforce job data can I extract?

| Field | Description |
|---|---|
| `employerName` | Employer or career-site name exposed by Dayforce |
| `clientNamespace` | Dayforce tenant namespace |
| `careerSiteCode` | Career-site code from the source URL |
| `language` | Posting locale |
| `jobPostingId` | Stable Dayforce posting ID |
| `requisitionId` | Employer requisition ID |
| `title` | Job title |
| `postingStatus` | Source posting status value |
| `postedAt` | Posting start timestamp |
| `expiresAt` | Posting expiry timestamp |
| `createdAt` | Source record creation timestamp |
| `modifiedAt` | Source record modification timestamp |
| `isEvergreen` | Evergreen posting flag |
| `isInternal` | Internal posting flag when exposed |
| `isRemote` | Virtual-location flag |
| `relocationEligible` | Relocation flag when exposed |
| `locations` | Addresses, city, region, country, IDs, and coordinates |
| `jobFamily` | Job family attribute |
| `jobFunction` | Job function attribute |
| `payType` | Hourly, salary, or another exposed pay type |
| `salary` | Structured range when Dayforce exposes one |
| `descriptionText` | Full description converted to plain text |
| `descriptionHtml` | Full source HTML description |
| `applyUrl` | Direct application URL |
| `canonicalUrl` | Canonical public job URL |
| `sourceUrl` | Input URL that produced the record |
| `scrapedAt` | Extraction timestamp |

Source fields can be `null` when an employer does not expose them.

### How to scrape Dayforce jobs

1. Open the Actor in Apify Console.
2. Add one or more public Dayforce board or job URLs to **Dayforce board or job URLs**.
3. Optionally enter **Search text** for board discovery.
4. Set **Maximum jobs** to bound the dataset and cost.
5. Click **Start**.
6. Open the **Dataset** tab to preview or export the results.
7. Download JSON, CSV, Excel, XML, or RSS, or consume the dataset through the Apify API.

Start with a small limit when testing a new employer board.

### Input parameters

#### `startUrls`

Required array of public `https://jobs.dayforcehcm.com` URLs.

Accepted shapes:

```text
https://jobs.dayforcehcm.com/{locale}/{tenant}/{careerSite}
https://jobs.dayforcehcm.com/{locale}/{tenant}/{careerSite}/jobs/{postingId}
```

Other hosts, insecure URLs, and unsupported Dayforce paths fail closed with a clear error.

#### `searchText`

Optional keyword text, 1–200 characters.

Dayforce applies it during board search. The Actor also checks direct posting inputs against the title and full description, so filters behave consistently for both input routes.

#### `maxItems`

Maximum unique jobs saved across all inputs.

- Default: `100`
- Minimum: `1`
- Maximum: `10000`

The Actor stops scheduling additional pages and postings when the limit is reached.

### Example input: search an employer board

```json
{
  "startUrls": [
    { "url": "https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL" }
  ],
  "searchText": "Customer Accounts",
  "maxItems": 10
}
```

### Example input: extract one posting

```json
{
  "startUrls": [
    { "url": "https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL/jobs/143649" }
  ],
  "maxItems": 1
}
```

### Output example

A dataset item has this shape:

```json
{
  "employerName": "Example Retail Group",
  "clientNamespace": "sampleco",
  "careerSiteCode": "CANDIDATEPORTAL",
  "language": "en-US",
  "jobPostingId": 123456,
  "requisitionId": 65432,
  "title": "Customer Support Advisor",
  "postingStatus": 4,
  "postedAt": "2025-01-15T06:00:00+00:00",
  "expiresAt": "2025-02-15T05:59:00+00:00",
  "isEvergreen": false,
  "isRemote": false,
  "locations": [
    {
      "formattedAddress": "100 Main Street, Sample City, California, United States",
      "countryCode": "US",
      "stateCode": "CA",
      "city": "Sample City",
      "latitude": 37.7749,
      "longitude": -122.4194
    }
  ],
  "jobFamily": "Retail Operations",
  "jobFunction": "Customer Service",
  "payType": "Hourly",
  "descriptionText": "Join our customer support team...",
  "applyUrl": "https://jobs.dayforcehcm.com/en-US/sampleco/CANDIDATEPORTAL/jobs/123456/apply",
  "canonicalUrl": "https://jobs.dayforcehcm.com/en-US/sampleco/CANDIDATEPORTAL/jobs/123456",
  "scrapedAt": "2025-01-15T12:00:00.000Z"
}
```

The actual output contains every field documented in the dataset schema.

### How much does it cost to scrape Dayforce job postings?

The Actor uses pay-per-event pricing:

- **Start:** $0.005 once per run.
- **Job posting:** charged only for each complete record saved.

| Apify plan tier | Price per saved job |
|---|---:|
| Free | $0.000041071 |
| Bronze | $0.000035714 |
| Silver | $0.000027857 |
| Gold | $0.000021429 |
| Platinum | $0.000014286 |
| Diamond | $0.000010000 |

At the Free-tier item price, approximate totals are:

- 1 job: $0.005041071 including the start event;
- 10 jobs: $0.005410710 including the start event;
- 100 jobs: $0.009107100 including the start event.

Duplicates, rejected records, and pages that produce no jobs do not generate a job-posting event.

### Monitoring and data workflows

#### Hiring-signal monitoring

Schedule a run for target employer boards, then compare `jobPostingId`, `modifiedAt`, and `postingStatus` against the previous dataset.

#### Recruiting enrichment

Start with known posting URLs and enrich them with full descriptions, functions, pay types, locations, and direct apply links.

#### Job aggregation

Use `canonicalUrl` and `jobPostingId` as stable source keys before merging Dayforce records with other ATS feeds.

#### Labor-market analysis

Export timestamps, job families, functions, and locations into a warehouse or notebook for trend analysis.

#### Webhook automation

Use an Apify webhook to notify Make, Zapier, n8n, or a custom endpoint after a scheduled run succeeds.

### Use the Actor through the API

Replace `YOUR_TOKEN` with your Apify API token.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~dayforce-jobs-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{"url":"https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL"}],
    "maxItems": 10
  }'
```

#### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/dayforce-jobs-scraper').call({
  startUrls: [{ url: 'https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL' }],
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_TOKEN")
run = client.actor("automation-lab/dayforce-jobs-scraper").call(run_input={
    "startUrls": [{
        "url": "https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL"
    }],
    "maxItems": 10,
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

### Use Dayforce Jobs Scraper with MCP

#### Claude Code

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/dayforce-jobs-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code can use this HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/dayforce-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Extract the first 20 jobs from this Dayforce employer board."
- "Get the full description and location for this Dayforce posting URL."
- "Find customer service jobs on this Dayforce career site and return canonical apply links."

### Limits and expected behavior

- Only public `jobs.dayforcehcm.com` pages are supported.
- The Actor does not bypass login or access private candidate or employee data.
- Board search follows Dayforce's current public pagination, normally 25 summaries per page.
- Detail requests use bounded concurrency and transient retries.
- A deleted posting can return an upstream unavailable error.
- An expired posting is returned when Dayforce still exposes its public structured record.
- Employer-specific optional fields can be absent.
- Salary is returned as structured data only when the source exposes a structured range.
- Source-site changes can temporarily require parser updates.
- No proxy is used by default because the supported route is publicly accessible.

### Reliability tips

- Supply canonical board or posting URLs copied from the browser address bar.
- Keep `maxItems` small while validating an unfamiliar tenant.
- Use a specific `searchText` to reduce details fetched from large boards.
- Store `jobPostingId` and `modifiedAt` for repeat-run change detection.
- Treat `expiresAt` as source metadata, not a guarantee that the employer will keep the page online.
- Inspect the run log if Dayforce returns a tenant-specific error.

### Troubleshooting

#### Why did the run reject my URL?

The Actor accepts HTTPS URLs on `jobs.dayforcehcm.com` with a locale, tenant namespace, and career-site code. Other Dayforce products and legacy `CandidatePortal` hosts are outside this input contract.

#### Why did a valid board return zero jobs?

The board may currently have no public postings, or `searchText` may not match any title or description. Retry without the filter and inspect the board manually.

#### Why is salary null?

Many employers mention compensation only inside description prose. The Actor does not guess a structured range from arbitrary text; it returns `salary` when Dayforce exposes structured salary fields.

#### Why is employerName null or unusual?

Dayforce career-site configuration controls this label. Tenant administrators can omit it or use a recruiting department name.

### Responsible use and legality

This Actor extracts publicly accessible job advertisements.

You are responsible for complying with the source site's terms, applicable law, database rights, privacy rules, and your organization's data-retention policies.

Do not use the Actor to collect private candidate information, circumvent authentication, discriminate unlawfully, send spam, or make automated employment decisions without appropriate review.

Minimize retention of personal information that an employer may include in free-text descriptions.

### Related Automation Lab Actors

- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper) for Greenhouse career boards.
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) for LinkedIn job discovery.
- [Google Jobs Scraper](https://apify.com/automation-lab/google-jobs-scraper) for aggregated job-search results.

Choose this Actor when the authoritative source is a public Dayforce career site and stable Dayforce IDs matter to the workflow.

### FAQ

#### Does the Actor need a Dayforce account?

No. The supported public employer-board and posting scope is anonymous.

#### Can I scrape several employer boards in one run?

Yes. Add multiple URLs to `startUrls`. The global `maxItems` limit applies across all of them.

#### Does it remove duplicate jobs?

Yes. Records are deduplicated by tenant namespace, career-site code, and job posting ID.

#### Can it retrieve historical or expired jobs?

It can extract a direct job URL while Dayforce still serves that posting's public embedded record. It cannot recover a page that the source has deleted.

#### Can I schedule it?

Yes. Use Apify schedules and optionally attach a webhook for downstream processing.

#### What happens when Dayforce is temporarily unavailable?

The Actor retries transient network errors, rate limits, and server errors with bounded exponential backoff. Permanent invalid-input and not-found responses fail without wasteful retries.

#### Which output format should I use?

Use JSON for APIs and nested location data, CSV or Excel for analyst review, and the dataset API for repeat automation.

# Actor input Schema

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

Public jobs.dayforcehcm.com employer board URLs or individual /jobs/{id} posting URLs.

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

Optional keyword query applied when discovering postings from board URLs. Direct job URLs are still returned only when that posting contains the query in Dayforce's public search scope.

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

Maximum number of unique job records saved across all supplied URLs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing all extracted Dayforce job records.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/dayforce-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/dayforce-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://jobs.dayforcehcm.com/en-US/aan/CANDIDATEPORTAL"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/dayforce-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/dayforce-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/2B3IObZSPWToez6fY/builds/mnpOe5VroPB6IoAIF/openapi.json