# ADP Workforce Now Jobs Scraper (`automation-lab/adp-workforce-now-jobs-scraper`) Actor

Extract live public ADP job requisitions, full descriptions, structured locations, IDs, and direct apply links from one or more employer career centers.

- **URL**: https://apify.com/automation-lab/adp-workforce-now-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.03 / 1,000 adp job saveds

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/platform/actors/running/actors-in-store#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

## ADP Workforce Now Jobs Scraper

Extract live public job requisitions from ADP Workforce Now employer career centers.

Get job titles, requisition IDs, post dates, structured locations, full descriptions, and direct application links as clean JSON, CSV, Excel, XML, or RSS-ready data.

Use the scraper for recurring employer monitoring, job-board ingestion, recruiting intelligence, and labor-market analysis—without a browser, login, or private ADP account.

### What does ADP Workforce Now Jobs Scraper do?

ADP Workforce Now Jobs Scraper reads one or more public `workforcenow.adp.com` career-center URLs.

It discovers the tenant identifier from each URL, paginates all live requisitions, and saves one dataset row per unique job.

When full details are enabled, it also retrieves each requisition's description and tenant-specific fields.

The Actor can:

- extract current public ADP Workforce Now jobs;
- combine jobs from multiple employers in one run;
- preserve ADP item, requisition, and external job IDs;
- return display locations and structured location objects;
- provide both HTML and plain-text descriptions;
- create canonical candidate application links;
- stop at a configurable global job limit;
- deduplicate jobs by ADP tenant and item ID;
- run on a schedule for continuous monitoring.

The separate `myjobs.adp.com` platform is not supported in this version.

### Who is it for?

#### Job boards and aggregators

Build a direct employer job feed and avoid stale reposted vacancies.

#### Recruiters and staffing teams

Track newly posted roles at target employers and route matching opportunities into your CRM.

#### Labor-market analysts

Measure hiring activity, role mix, locations, and posting trends across selected companies.

#### Competitive intelligence teams

Monitor where competitors are expanding and which functions they are hiring.

#### Developers and data engineers

Use a typed JSON feed instead of maintaining tenant-specific ADP pagination code.

### Why scrape ADP Workforce Now jobs?

Public employer career pages are a primary source of hiring intent.

They often contain jobs before aggregators index them and remove jobs sooner after employers close them.

A repeatable feed helps you:

- discover fresh openings;
- reduce ghost-job contamination;
- map hiring by geography;
- compare requisition volumes over time;
- enrich company or talent datasets;
- trigger alerts from new job IDs;
- create source-linked candidate experiences.

### Why use this Actor?

The Actor uses ADP's anonymous public structured endpoints rather than rendering a heavy browser page.

Benefits include:

- fast HTTP-only extraction;
- no proxy required for the verified public route;
- no login or ADP credentials;
- bounded request concurrency;
- transient error retry with exponential backoff;
- strict validation of supported domains;
- fail-closed behavior when no useful jobs are extracted;
- one consistent schema across ADP tenants.

### Supported URLs

Supply public URLs hosted on:

`https://workforcenow.adp.com/`

A valid URL must contain a `cid` query parameter.

Most career-center links also contain `ccId` and `lang`.

Example:

```text
https://workforcenow.adp.com/mascsr/default/mdf/recruitment/recruitment.html?ccId=19000101_000001&cid=39bc5efc-a576-4a4d-83eb-32e95d4e96c8&lang=en_US
```

URLs on other hosts are rejected rather than silently scraped as the wrong product.

### How to scrape ADP Workforce Now jobs

1. Open the employer's public ADP career center.
2. Copy the complete browser URL.
3. Add it to **ADP career center URLs**.
4. Choose a maximum number of jobs.
5. Keep **Fetch full job details** enabled for descriptions.
6. Click **Start**.
7. Export the dataset or connect it to your workflow.

For a cheap first run, keep the prefilled limit of 20 jobs.

### Input

```json
{
  "startUrls": [
    {
      "url": "https://workforcenow.adp.com/mascsr/default/mdf/recruitment/recruitment.html?ccId=19000101_000001&cid=39bc5efc-a576-4a4d-83eb-32e95d4e96c8&lang=en_US",
      "name": "Metrea"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "maxConcurrency": 5
}
```

#### Input fields

| Field | Type | Default | Description |
|---|---|---:|---|
| `startUrls` | array | required | Public ADP Workforce Now career-center URLs. |
| `startUrls[].url` | string | required | URL containing the ADP `cid`. |
| `startUrls[].name` | string | optional | Employer label copied into output. |
| `maxItems` | integer | `20` | Global maximum across all supplied career centers. |
| `includeDetails` | boolean | `true` | Fetch full descriptions and detail fields. |
| `maxConcurrency` | integer | `5` | Concurrent detail requests, from 1 to 10. |

### Output

Each dataset row represents one live ADP requisition.

```json
{
  "tenantId": "39bc5efc-a576-4a4d-83eb-32e95d4e96c8",
  "careerCenterId": "19000101_000001",
  "employerName": "Metrea",
  "itemID": "9201059050835_1",
  "requisitionId": "2374",
  "externalJobId": "566833",
  "title": "Armament/Electrical/Avionics Advisor",
  "postDate": "2026-07-15T15:39:00.000-04:00",
  "locations": ["Kujawsko-Pomorskie, Kuyavian-Pomeranian Voivodeship, PL"],
  "locationDetails": [
    {
      "displayName": "Kujawsko-Pomorskie, Kuyavian-Pomeranian Voivodeship, PL",
      "city": "Kujawsko-Pomorskie",
      "region": "Kuyavian-Pomeranian Voivodeship",
      "country": "PL"
    }
  ],
  "organizationalUnits": [],
  "descriptionHtml": "<p>Company Overview...</p>",
  "descriptionText": "Company Overview...",
  "applyUrl": "https://workforcenow.adp.com/...&jobId=9201059050835_1",
  "sourceUrl": "https://workforcenow.adp.com/...",
  "scrapedAt": "2026-07-24T00:00:00.000Z"
}
```

### ADP job data fields

| Field | Meaning |
|---|---|
| `tenantId` | ADP client identifier from `cid`. |
| `careerCenterId` | Career-center configuration identifier. |
| `employerName` | Optional label supplied with the URL. |
| `itemID` | Stable ADP requisition item identifier. |
| `requisitionId` | Employer-facing requisition ID when available. |
| `externalJobId` | External posting ID when exposed by ADP. |
| `title` | Requisition title. |
| `postDate` | Source post timestamp. |
| `locations` | Human-readable location labels. |
| `locationDetails` | Structured city, region, country, and postal code. |
| `employmentType` | Tenant-specific work type when available. |
| `workLevel` | Tenant-specific job level when available. |
| `organizationalUnits` | Organization labels exposed for the requisition. |
| `descriptionHtml` | Original formatted requisition description. |
| `descriptionText` | Clean text generated from the HTML. |
| `applyUrl` | Direct career-center link containing the job ID. |
| `sourceUrl` | Input career-center URL. |
| `scrapedAt` | UTC extraction timestamp. |

Some optional fields vary by employer configuration.

The Actor preserves missing tenant-specific fields as absent instead of inventing values.

### How much does it cost to scrape ADP jobs?

The Actor uses pay-per-event pricing:

- a small start charge per run;
- a charge for each saved ADP job.

The current BRONZE reference price is $0.001 per run plus $0.001 per saved job.

Apify plan tiers receive the tiered rates shown on the Actor page.

Platform compute usage is included in pay-per-event billing; you do not need to size servers.

Use a small `maxItems` value when evaluating a new employer feed.

### Listing-only versus full-detail mode

Set `includeDetails` to `true` when you need descriptions and every available field.

This performs one additional public request per job.

Set it to `false` for fast high-frequency monitoring where IDs, titles, dates, and locations are enough.

Listing-only mode still emits the same schema, with unavailable detail fields omitted.

### Multiple employer career centers

Add several URLs to `startUrls` to build a combined feed.

The `maxItems` limit applies to the whole run, not separately to every employer.

Use each URL's optional `name` to keep a readable employer label in downstream exports.

Deduplication uses `tenantId:itemID`, so identical-looking jobs from different ADP clients remain separate.

### Scheduling and change monitoring

Use an Apify schedule to run hourly, daily, or weekly.

Recommended workflow:

1. Run the Actor with stable input.
2. Store `tenantId` plus `itemID` as your unique key.
3. Compare the latest dataset with the previous run.
4. Alert on new keys.
5. Mark missing keys as closed only after your preferred grace period.

This approach handles reposted titles more reliably than title-based matching.

### Integrations

Connect the dataset to:

- Google Sheets for recruiter watchlists;
- Slack for new-job alerts;
- Make for no-code routing;
- Zapier for CRM actions;
- webhooks for event-driven processing;
- BigQuery or Snowflake for hiring analytics;
- S3 for historical snapshots;
- Tableau or Power BI for dashboards;
- your own REST API or job board.

Apify datasets can be exported as JSON, JSONL, CSV, Excel, XML, and RSS.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/adp-workforce-now-jobs-scraper').call({
  startUrls: [{
    url: 'https://workforcenow.adp.com/mascsr/default/mdf/recruitment/recruitment.html?ccId=19000101_000001&cid=39bc5efc-a576-4a4d-83eb-32e95d4e96c8&lang=en_US',
    name: 'Metrea',
  }],
  maxItems: 20,
  includeDetails: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/adp-workforce-now-jobs-scraper').call(run_input={
    'startUrls': [{
        'url': 'https://workforcenow.adp.com/mascsr/default/mdf/recruitment/recruitment.html?ccId=19000101_000001&cid=39bc5efc-a576-4a4d-83eb-32e95d4e96c8&lang=en_US',
        'name': 'Metrea',
    }],
    'maxItems': 20,
    'includeDetails': True,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~adp-workforce-now-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "startUrls": [{
      "url": "https://workforcenow.adp.com/mascsr/default/mdf/recruitment/recruitment.html?ccId=19000101_000001&cid=39bc5efc-a576-4a4d-83eb-32e95d4e96c8&lang=en_US",
      "name": "Metrea"
    }],
    "maxItems": 20,
    "includeDetails": true
  }'
```

### Use with Apify MCP

Connect Claude or another MCP client to Apify's MCP server:

```text
https://mcp.apify.com?tools=automation-lab/adp-workforce-now-jobs-scraper
```

#### Claude Code setup

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

#### Claude Desktop setup

#### Cursor setup

#### VS Code setup

Use this MCP JSON block in Claude Desktop, Cursor, or VS Code, adding your Apify authentication as required by your client:

```json
{
  "mcpServers": {
    "apify-adp-jobs": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/adp-workforce-now-jobs-scraper"
    }
  }
}
```

Example prompts:

- “Scrape the first 50 live jobs from this ADP Workforce Now career center.”
- “Return job IDs, titles, post dates, and locations from these employer URLs.”
- “Fetch full descriptions and summarize the skills these employers seek.”
- “Compare the current dataset with yesterday's and list new requisitions.”

For Claude Desktop, add the Apify MCP endpoint to your MCP server configuration and authenticate with your Apify token.

For Claude Code, register the same URL as an HTTP MCP server.

### Reliability and respectful use

The Actor sends bounded requests to public endpoints.

It retries only transient 429 and server errors.

It does not attempt to bypass authentication, CAPTCHA, or private candidate areas.

Concurrency is capped at 10 and defaults to 5.

Use schedules and limits that match your legitimate data-refresh needs.

### Troubleshooting

#### Why does the Actor say the cid is missing?

Copy the complete career-center URL from the browser, including everything after `?`.

A shortened homepage URL does not identify an ADP tenant.

#### Why is employerName empty?

ADP's public feed does not consistently expose a company display name.

Set `name` beside each input URL when you want a stable employer label.

#### Why are employmentType or workLevel empty?

These are tenant-specific custom fields.

Not every employer configures or publishes them.

#### Why did a valid run return no jobs?

The employer may currently have no public requisitions, or the supplied career center may no longer be active.

The Actor fails rather than returning a misleading successful empty run.

#### Why is the description absent?

Make sure `includeDetails` is enabled.

Some tenants can still omit a description from their public detail record.

### Tips for better ADP job data

- Keep employer labels consistent across scheduled inputs.
- Use stable IDs instead of job titles for deduplication.
- Store `postDate` as a timestamp, including its source timezone offset.
- Keep both HTML and text descriptions if downstream formatting matters.
- Start with 20 jobs before increasing limits.
- Use listing-only mode for very frequent discovery checks.
- Fetch details only for newly discovered IDs in your downstream pipeline.
- Preserve source and apply URLs for auditing.

### Legal and privacy

This Actor extracts publicly accessible employer job postings.

Public availability does not remove your responsibility to follow applicable law, ADP terms, employer policies, copyright rules, and data-protection requirements.

Do not use the Actor to access candidate accounts, private applications, or authenticated HR data.

Job descriptions may be copyrighted by their employers.

Use the data for legitimate purposes and retain only what your workflow needs.

### Related scrapers

Explore other job and business-data tools from Automation Lab:

- [Workday Jobs Scraper](https://apify.com/automation-lab/workday-jobs-scraper)
- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper)
- [Indeed Jobs Scraper](https://apify.com/automation-lab/indeed-scraper)
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper)

Choose this Actor when the source URL is specifically on `workforcenow.adp.com`.

### FAQ

#### Does it require an ADP login?

No. It only reads public employer career-center data.

#### Does it need a proxy?

No proxy was required for the verified public JSON route.

#### Can it scrape more than one company?

Yes. Add multiple URLs to `startUrls`.

#### Can it retrieve every current job?

Yes, up to your `maxItems` limit and the jobs publicly returned by each supplied tenant.

#### Does it include closed jobs?

No. The source endpoint represents currently public requisitions.

#### Can it scrape myjobs.adp.com?

No. That is a separate ADP platform and outside this version's scope.

#### Can I export to CSV or Excel?

Yes. Open the run dataset and choose your preferred export format.

#### Can I schedule the scraper?

Yes. Use Apify schedules and webhooks for recurring feeds.

#### What is the best unique key?

Use the combination of `tenantId` and `itemID`.

#### Is one row one job?

Yes. Every charged result is one saved public requisition.

### Support

If a public ADP Workforce Now URL fails, include:

- the exact source URL;
- the run URL;
- whether detail mode was enabled;
- the expected public job count;
- one example job visible in the career center.

Do not share candidate credentials or private HR information.

# Actor input Schema

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

Add public ADP Workforce Now recruitment URLs containing a cid parameter. Optionally set name to label the employer in output.

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

Stop after saving this many unique live requisitions across all career centers.

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

Fetch each requisition detail endpoint for description and additional fields. Disable for faster listing-only monitoring.

## `maxConcurrency` (type: `integer`):

Concurrent detail requests per run. Keep the default for reliable ADP access.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://workforcenow.adp.com/mascsr/default/mdf/recruitment/recruitment.html?ccId=19000101_000001&cid=39bc5efc-a576-4a4d-83eb-32e95d4e96c8&lang=en_US",
      "name": "Metrea"
    }
  ],
  "maxItems": 20,
  "includeDetails": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Open the default dataset in the ADP jobs table view.

# 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://workforcenow.adp.com/mascsr/default/mdf/recruitment/recruitment.html?ccId=19000101_000001&cid=39bc5efc-a576-4a4d-83eb-32e95d4e96c8&lang=en_US",
            "name": "Metrea"
        }
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/adp-workforce-now-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://workforcenow.adp.com/mascsr/default/mdf/recruitment/recruitment.html?ccId=19000101_000001&cid=39bc5efc-a576-4a4d-83eb-32e95d4e96c8&lang=en_US",
            "name": "Metrea",
        }],
    "maxItems": 20,
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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://workforcenow.adp.com/mascsr/default/mdf/recruitment/recruitment.html?ccId=19000101_000001&cid=39bc5efc-a576-4a4d-83eb-32e95d4e96c8&lang=en_US",
      "name": "Metrea"
    }
  ],
  "maxItems": 20
}' |
apify call automation-lab/adp-workforce-now-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/adp-workforce-now-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/KAMzJuiS03EFWls9v/builds/otqgMlZcic65yFkZf/openapi.json