# ADP Jobs Scraper: Any ADP Careers Site, No API Key (`glitchbound/adp-jobs-scraper`) Actor

Every open role from any ADP career site (myjobs.adp.com), the system PepsiCo Beverages, Casey's and Follett hire on. Type a company name for one of 327 verified employers, or paste the site's slug. Titles, places, categories, dates and descriptions as clean JSON. No API key, no login.

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

## Pricing

from $0.20 / 1,000 job postings

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

## ADP Jobs Scraper: Any ADP Careers Site, No API Key

**Every open role from any ADP career site (`myjobs.adp.com`), the system PepsiCo Beverages, Casey's and Follett hire on. Type a company name for one of the 327 employers this Actor has already verified, or paste the site's slug. Titles, places, categories, dates and descriptions as clean JSON, with no API key and no login.**

### Features

- **Type a company name, for 327 employers.** The Actor ships a map of 503 ADP career sites it has already read open jobs from (104,451 open roles when it was built), so `Casey's` works without you knowing that its site is called `caseysstore`. Nobody would guess that Dhanani Group's site is `popeyes`, which is exactly why the map exists.
- **Every site an employer runs.** 67 of the 327 keep more than one: Follett has a retail site and a corporate one, Citi Trends has one for stores and one for distribution. A name gets all of them.
- **A slug or the address, in any spelling.** `pbna`, `PBNA` or `https://myjobs.adp.com/pbna` all read PepsiCo Beverages North America. A job link works too.
- **The employer's real name on every row**, read from the career site's own settings rather than guessed from the slug, so `popeyes` comes back as Dhanani Group.
- **Every posting, not the first page.** 200 jobs per request, paged to the end: PepsiCo Beverages alone lists over 1,100.
- **Not cut off at a round number.** ADP's own job count stops at 10,000 however many roles a site really has, and its list keeps going: the largest employer here declares 10,000 and answers past 13,500. This Actor pages to the real end of the list instead of believing the number.
- **Descriptions cost no extra requests.** ADP returns the full description and the qualifications inside the same job list, so `includeDescription` only makes the answer bigger, never slower per job. Most scrapers on other systems pay one request per role for this.
- **Hourly or salaried on the row**, which is how staffing and labour research split this platform's employers. It is what the employer filed, not a guess from the title.
- **A posting date on every row**, so a daily run tells you who started hiring and when.
- **One row per job, as clean JSON**, with the same fields as our [Workday](https://apify.com/glitchbound/workday-jobs-scraper) and [Oracle](https://apify.com/glitchbound/oracle-jobs-scraper) scrapers, so the outputs stack.
- **Filters that cost you nothing.** Rows dropped by `titleKeywords`, `locationKeywords` or `remoteOnly` are never charged.
- **Errors are per company.** One bad slug does not end the run, and error rows are not charged.

### How to use it

1. Click **Try for free**.
2. Put company names in `companies`, or site slugs in `boards`. The example below is real.
3. Optionally narrow it with `titleKeywords`, `locationKeywords` or `remoteOnly`.
4. Run it, and download the rows as JSON, CSV or Excel, or read them through the API.

### Input

```json
{
  "companies": ["Casey's", "Follett Corporation"],
  "boards": ["pbna"],
  "titleKeywords": ["manager", "driver"],
  "locationKeywords": ["Texas"],
  "includeDescription": true,
  "maxResultsPerCompany": 300
}
```

| Field | What it does | Default |
|---|---|---|
| `companies` | company names from the verified map, e.g. `Casey's`, `Merakey`, `Citi Trends` | none |
| `boards` | career site slugs, e.g. `pbna`, or the full `https://myjobs.adp.com/pbna` | none |
| `titleKeywords` | keep roles whose title contains any of these | all |
| `locationKeywords` | keep roles whose location contains any of these | all |
| `remoteOnly` | keep roles whose title or place says remote | off |
| `includeDescription` | add the full description and the qualifications | off |
| `maxResultsPerCompany` | ceiling per career site | 1,000 |
| `maxItems` | ceiling for the whole run | none |

### Output

```json
{
  "jobId": "5001221965906",
  "title": "Merchandiser Conway, Clinton, and Russellville Seasonal",
  "company": "PepsiCo Beverages North America",
  "location": "Maumelle, Arkansas, United States",
  "city": "Maumelle",
  "region": "Arkansas",
  "country": "United States",
  "departments": ["Merchandiser"],
  "employmentType": "full-time",
  "payBasis": "hourly",
  "workArrangement": "onsite",
  "isRemote": false,
  "postedAt": "2026-09-17T17:38:58Z",
  "url": "https://myjobs.adp.com/pbna/cx/job-details?reqId=5001221965906",
  "description": "This position is responsible for merchandising Pepsi products ...",
  "atsPlatform": "adp",
  "boardToken": "pbna",
  "boardUrl": "https://myjobs.adp.com/pbna",
  "boardTokenResolved": "G4SED7FXSFECJWZ4"
}
```

| Field | What it is |
|---|---|
| `jobId`, `title`, `url` | ADP's own requisition id, and a link that opens that job |
| `company` | the employer, from the career site's own settings |
| `location`, `offices` | the primary place on the requisition, and every other place it is open in |
| `city`, `region`, `country` | the primary place, split |
| `departments` | the job category the employer assigned |
| `employmentType` | full-time or part-time, as the employer filed it |
| `payBasis` | hourly or salaried, where the employer filed it |
| `seniority`, `workArrangement`, `isRemote` | read from the title and the place |
| `postedAt` | when the employer posted the job, on every row |
| `description` | the full text and the qualifications, with `includeDescription` |
| `boardToken`, `boardUrl`, `boardTokenResolved` | the site slug, its address, and the employer's ADP organisation id, which is the same on every site they run |

### A company name, or the slug

An ADP career site is a slug the employer chose: `pbna`, `caseysstore`, `popeyes`. ADP publishes nothing that turns `caseys.com` into `caseysstore`, so a name only works when this Actor already holds the slug, which it does for 327 employers, found in Common Crawl's public URL index and each confirmed against ADP's live API with at least one open job. A name outside that map is refused with an error row, never guessed. For those, open the company's careers page, see where it goes on `myjobs.adp.com`, and pass that last path segment in `boards`.

### What people use this for

- **Job boards and aggregators** backfilling hourly and field roles that never reach LinkedIn in full.
- **Recruiters and staffing firms** watching which large employers are hiring, where, and for what.
- **Sales teams** using open roles as a buying signal: a franchise group hiring 300 crew members is a lead.
- **Market and labour research** across retail, food service, logistics, healthcare and non-profits, the sectors that run on ADP.

### Pricing

**$0.50 per 1,000 jobs, down to $0.20 per 1,000 on higher Apify plans.** No subscription. Error rows and filtered rows are free, and `maxItems` caps the whole run.

### Integrations and API

Run it from the Apify API, a schedule, Make, Zapier, n8n or any MCP client. Every run's rows are in its default dataset.

### FAQ

**Do I need an ADP account or an API key?** No. This reads the same public API every `myjobs.adp.com` career page calls.

**Does it cover ADP Workforce Now's older career centre?** No. `workforcenow.adp.com/.../careercenter` is a different ADP product on a different API, and its addresses do not name the employer at all. This Actor reads the `myjobs.adp.com` career sites employers move to. Paste one of those and you get an error row saying so, not a silent empty result.

**Why is the company name different from the slug?** Because the slug is whatever the employer typed when they set the site up. `popeyes` is Dhanani Group, a franchise operator; the name on every row is the one ADP holds in the site's settings.

**Can I schedule it?** Yes, and every row carries `postedAt`, so daily runs show new postings without diffing anything yourself.

### Related

- [Oracle Recruiting Jobs Scraper](https://apify.com/glitchbound/oracle-jobs-scraper): the other enterprise careers system, 762 employers
- [Workday Jobs Scraper](https://apify.com/glitchbound/workday-jobs-scraper): 1,555 verified Workday tenants by name
- [ATS Jobs Search](https://apify.com/glitchbound/ats-jobs-search): search one index of jobs across many careers systems
- [ATS Finder](https://apify.com/glitchbound/ats-finder): which careers system a company uses

### Use it from an AI agent

This Actor is a ready-made tool for Claude, ChatGPT, Cursor or any other MCP
client, through Apify's MCP server. Add it as a connector at:

```
https://mcp.apify.com?tools=glitchbound/adp-jobs-scraper
```

In Cursor or VS Code the same address goes in `mcp.json`:

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

The first call asks you to sign in to Apify, or takes an API token. From then
on the agent sees this Actor's input fields and calls it directly.

### Feedback

If this saved you time, a review on the Actor's Store page helps other people
find it. If something is missing or wrong, the Issues tab on the same page is
the fastest way to reach me, and it gets read.

# Actor input Schema

## `companies` (type: `array`):

Company names, one per line, e.g. 'Follett Corporation' or 'US Renal Care'. This Actor ships a map of ADP career sites it has already read open jobs from, so a name in that map resolves without you finding the site's slug, and an employer running several sites gets all of them. A name that is NOT in the map is refused rather than guessed at: ADP publishes nothing that turns a company's domain into its slug. Use `boards` for those.

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

ADP career site slugs, one per line, e.g. 'pbna', which is the first path segment of the careers address. The full address works too: https://myjobs.adp.com/pbna. Case does not matter.

## `titleKeywords` (type: `array`):

Keep only roles whose title contains any of these, one per line, e.g. security or staff engineer. Matched as plain text, case-insensitive, so c++ and node.js mean exactly that. Filtered rows are not charged.

## `locationKeywords` (type: `array`):

Keep only roles whose location contains any of these, one per line, e.g. London or Israel. Filtered rows are not charged.

## `remoteOnly` (type: `boolean`):

Keep only roles whose title or place says remote or anywhere. ADP publishes no remote flag of its own.

## `includeDescription` (type: `boolean`):

Adds the full description and the qualifications to every row. ADP returns them in the same request as the rest, so this costs no extra requests, only a bigger reply: 100 rows a page instead of 200.

## `maxResultsPerCompany` (type: `integer`):

Ceiling on roles taken from any single career site. PepsiCo Beverages alone lists over 1,100.

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

A hard ceiling on rows for the entire run, across every company. The per-company limit above caps each one separately, so fifty companies at a thousand each is still fifty thousand rows; this caps the total. The run stops cleanly when it is reached and nothing beyond that point is fetched or charged. Leave empty for no ceiling.

## `proxyConfiguration` (type: `object`):

Proxy settings. ADP's career API is public and answers datacenter addresses, so the default is fine.

## Actor input object example

```json
{
  "boards": [
    "pbna"
  ],
  "remoteOnly": false,
  "includeDescription": false,
  "maxResultsPerCompany": 300,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All rows this run produced, as JSON.

# 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": [
        "pbna"
    ],
    "maxResultsPerCompany": 300
};

// Run the Actor and wait for it to finish
const run = await client.actor("glitchbound/adp-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 = {
    "boards": ["pbna"],
    "maxResultsPerCompany": 300,
}

# Run the Actor and wait for it to finish
run = client.actor("glitchbound/adp-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 '{
  "boards": [
    "pbna"
  ],
  "maxResultsPerCompany": 300
}' |
apify call glitchbound/adp-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,glitchbound/adp-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/SW9ZvR4Wg4RIhyQN0/builds/tu0VmQrzikNjB1DsS/openapi.json