# Paylocity Jobs API (`johnvc/paylocity-jobs-api`) Actor

Live jobs from any Paylocity recruiting board, no keys. Built-in company discovery across thousands of tenants, plus new-postings change detection. Returns titles, locations, departments, structured salaries, and full descriptions as JSON, Markdown, or text. Pay only for rows delivered.

- **URL**: https://apify.com/johnvc/paylocity-jobs-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:**
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 job records

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

## Paylocity Jobs API

The Paylocity Jobs API pulls live jobs from any Paylocity-hosted recruiting board through one clean API, with no key and no login. Give it a board GUID, a board URL, or a company name and get back structured job records with titles, locations, departments, structured salaries, timestamps, and full descriptions. Or give it nothing, turn on discovery, and let it enumerate companies that hire on Paylocity straight from the public web archive.

[Paylocity](https://www.paylocity.com) is the HR and recruiting platform behind the career pages of thousands of employers. This actor reads their public recruiting boards live at run time, so every row reflects what the employer's board says right now, not what an index remembered from last week. It is the first live Paylocity jobs API on the store. This actor is not affiliated with, endorsed by, or connected to Paylocity; it reads publicly available recruiting boards and is not the company's official product.

### What you get per job

| Field group | Fields |
|---|---|
| Identity | id, title, companyName, boardGuid, boardUrl, url, applyUrl |
| Structure | department, location, address, isRemote, indeedRemoteType, employmentType, isInternal |
| Timestamps | datePublished, datePosted |
| Compensation | salaryMin, salaryMax, salaryCurrency, salaryPeriod, salaryUnit, salaryRaw |
| Content | snippet, descriptionHtml, descriptionMarkdown, descriptionText |
| Provenance | source, sourceType, scrapedAt |

### Three ways to use it

1. **Boards you name**: pass board GUIDs, board URLs, or company names and get every open job on those boards, each with its full description and structured salary.
2. **Company discovery**: turn on discovery to enumerate Paylocity recruiting boards from the public Common Crawl web archive, live-verified with a current open-jobs count, locations, and departments.
3. **Change feed**: set newerThan on a schedule and each run returns only the postings that appeared since the last one.

Every job record includes the source-HTML description at no extra step. Markdown and plain-text conversions are optional add-ons for AI pipelines.

### Track new postings without state

Every Paylocity job carries its own published timestamp. Set newerThan to 25h on a daily schedule and each run filters on that timestamp before fetching detail, so a daily poll of a large employer only fully processes the handful of roles that moved. There is no seen-list or delta store to maintain between runs, because the timestamp comes from the source.

### Pay for exactly what you receive

Billing is per delivered row, with no start fee and no minimum spend. Filters (title, department, location, remote, employment type, date) run before billing, so filtered jobs cost nothing. The base job record is one event and already carries the source-HTML description and structured salary. Markdown and plain-text descriptions and the whole-run report are optional add-ons, each billed only on the rows that actually carry them. Expired and filtered rows are never charged.

### Input parameters

| Parameter | Type | Default | What it does |
|---|---|---|---|
| companies | array | \["0062c37f-..."] | Board GUIDs, board URLs, or company names, mixed freely |
| startUrls | array | \[] | Same values in URL-list form; merged with companies |
| discoverAll | boolean | false | Enumerate every Paylocity board from the web archive |
| discoverOnly | boolean | false | Return the company directory only, skip jobs |
| discoveryQuery | string | "" | Text match over discovered board slugs |
| crawlDepth | integer | 2 | How many monthly web-archive snapshots to union |
| titleKeywords | array | \[] | Keep jobs whose title contains any of these |
| departments | array | \[] | Keep jobs in matching departments |
| locationKeywords | array | \[] | Keep jobs in matching locations |
| remoteOnly | boolean | false | Keep only remote-flagged jobs |
| employmentTypes | array | \[] | Keep only matching employment types |
| newerThan | string | "" | Change detection: 24h, 7d, 2w, or an ISO date |
| cutoffField | select | updated | Which timestamp newerThan compares against |
| includeDescriptionMarkdown | boolean | false | Add the description as Markdown (paid add-on) |
| includeDescriptionText | boolean | false | Add the description as plain text (paid add-on) |
| verifyLive | boolean | true | Live-probe each discovered board |
| includeInactive | boolean | false | Also return dead boards in discovery |
| report | select | none | Write a Markdown or HTML run report (paid add-on) |
| maxCompanies | integer | 25 | Cap on boards in a discovery run |
| maxJobsPerCompany | integer | 0 | Per-board cap, 0 = all |
| maxJobs | integer | 100 | Whole-run cap, the main cost control |
| maxConcurrency | integer | 5 | Parallel detail and verification requests |

### Example output

```json
{
  "resultType": "job",
  "id": "4478135",
  "title": "Nurse Manager - South Bend",
  "companyName": "Indiana Health Centers, Inc.",
  "boardGuid": "0062c37f-a34c-479c-978c-bd800d23f223",
  "url": "https://recruiting.paylocity.com/Recruiting/Jobs/Details/4478135",
  "applyUrl": "https://recruiting.paylocity.com/Recruiting/Jobs/Apply/4478135",
  "department": "Nursing",
  "location": "IHC South Bend",
  "address": { "street": "1901 #B Western Ave.", "city": "South Bend", "state": "IN", "zip": "46619" },
  "isRemote": false,
  "employmentType": "FULL_TIME",
  "datePublished": "2026-09-03T12:53:40-05:00",
  "salaryMin": 81463, "salaryMax": 91238, "salaryCurrency": "USD", "salaryPeriod": "year",
  "descriptionHtml": "<p>Description</p><p>Indiana Health Centers, Inc. ...</p>",
  "source": "paylocity",
  "sourceType": "ats",
  "scrapedAt": "2026-09-08T16:00:00Z"
}
```

### Use cases

- Job boards and aggregators: backfill and refresh listings straight from the source, not from a third-party index.
- Recruiters and sourcers: pull every open role at target companies, filtered by title, department, or location.
- Sales and GTM teams: hiring is a buying signal. Discover companies on Paylocity in your niche and watch where headcount is going.
- Talent analytics: track posting velocity, remote share, and salary transparency across thousands of employers.
- AI agents: structured JSON, Markdown descriptions, stable field names, and MCP support make this a clean tool for agent pipelines.

### Getting started

1. Paste a board GUID, a board URL, or a company name into the companies field.
2. Pick the description formats you want, or leave them off for lean metadata rows with the source HTML.
3. Run it. Rows land in the dataset; a per-board summary lands in the key-value store.

[View on Apify Store](https://apify.com/johnvc/paylocity-jobs-api?fpr=9n7kx3)

For scheduled monitoring, create a daily schedule with newerThan set to 25h and the actor becomes a change feed for the boards you care about.

### Integrations

- Apify API and clients: run the actor and read the dataset from Python or JavaScript with the [Apify API](https://docs.apify.com/api/v2), or export results as JSON, CSV, or Excel straight from the console.
- Schedules and monitoring: pair a daily schedule with newerThan for a hands-off change feed.
- MCP: add the actor to any MCP client through the hosted server (section below).
- Automation platforms: connect through Apify's [integrations](https://docs.apify.com/platform/integrations) for n8n, Make, Zapier, webhooks, and Google Sheets.
- Crypto-native agents: pay per run over the x402 protocol (section below).

### Related tools

Part of a family of job-data APIs on this account:

- [Greenhouse Job Board API](https://apify.com/johnvc/greenhouse-job-board-api?fpr=9n7kx3) for Greenhouse-hosted job boards
- [Workday Careers API](https://apify.com/johnvc/workday-careers-api?fpr=9n7kx3) for Workday-hosted career sites
- [Oracle and Taleo Jobs API](https://apify.com/johnvc/oracle-taleo-jobs-api?fpr=9n7kx3) for Oracle Fusion and Taleo boards
- [iCIMS Careers API](https://apify.com/johnvc/icims-careers-api?fpr=9n7kx3) for iCIMS career portals
- [Ashby Job Board API](https://apify.com/johnvc/ashby-job-board-scraper?fpr=9n7kx3) for Ashby-hosted job boards
- [Wellfound Jobs API](https://apify.com/johnvc/wellfound-jobs-api?fpr=9n7kx3) for startup jobs on Wellfound
- [Google Jobs Scraper](https://apify.com/johnvc/Google-Jobs-Scraper?fpr=9n7kx3) for Google Jobs listings

### 🔌 Use this API from Claude (MCP)

Add this actor as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), or any MCP client, through the hosted Apify MCP server:

```
https://mcp.apify.com/?tools=actors,docs,johnvc/paylocity-jobs-api
```

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

### 💸 Pay per run with crypto (x402)

The Paylocity Jobs API supports agentic payments via the [x402 protocol](https://docs.apify.com/platform/integrations/x402).
AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed:
point your agent at the [Apify MCP server](https://mcp.apify.com/?tools=actors,docs,johnvc/paylocity-jobs-api) and it can
discover, pay for, and run this actor autonomously. Read the
[Apify x402 announcement](https://apify.com/change-log/pay-for-apify-actors-with-x402?fpr=9n7kx3) for details.

### Paylocity jobs API pricing

Pay per event, per delivered row. The base job record covers every structured field plus the source-HTML description and the structured salary. Add-ons bill only on rows that carry them: Markdown and plain-text descriptions and the whole-run report. Discovered companies have their own low per-row event, and unverified or dead boards are free. No start fee, no monthly rental, no minimum results per run, and filtered rows are never charged. Current prices are on the store page's pricing card.

### FAQ

#### Does Paylocity have a jobs API?

Paylocity offers HR and payroll APIs to its own customers, and those need credentials and cover employee and payroll data, not public job listings. This actor is a jobs API over the public recruiting boards: point it at any employer's [Paylocity](https://www.paylocity.com) board and it returns structured job postings, with salaries and full descriptions, and no key. If you want the jobs data rather than a payroll integration, this is the Paylocity jobs API you are looking for. Paylocity is an [applicant tracking system](https://en.wikipedia.org/wiki/Applicant_tracking_system), and this actor turns its public boards into clean, structured rows.

#### Is this an API or a web scraper?

Both, honestly. Under the hood it reads the same public recruiting boards a scraper would. What you get is an API: structured JSON on demand, filters, stable field names, and no HTML unless you ask for it. If you have been maintaining your own Paylocity parser, this is the version where someone else maintains it.

#### Can I use this from Claude or another MCP client?

Yes. Add the hosted MCP server URL from the section above and the actor shows up as a callable tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), or any MCP client. That makes it a Paylocity MCP server for job data: agents can discover it, run it, and read the dataset without any glue code.

#### How do I find a company's Paylocity board GUID?

Open the company's careers page. A Paylocity board lives at recruiting.paylocity.com/recruiting/jobs/All/{guid}/{slug}, and the GUID is that path segment. Paste the whole URL or just the GUID. You can also pass the company name and let discovery resolve it.

#### How do I find companies that use Paylocity?

Turn on discoverOnly. The actor enumerates Paylocity recruiting boards from the public web archive and returns one row per company with its board GUID, a live open-jobs count, locations, and departments. Add a discoveryQuery to narrow the set.

#### How do I get only new job postings?

Set newerThan to a window like 24h or an ISO date. The actor filters on each posting's own published timestamp before fetching detail, so there is no state to manage between runs.

#### Is the job description included?

Yes. Every job record carries the source-HTML description and the structured salary in the base event. Markdown and plain-text conversions are separate toggles, each a per-row add-on charge, so you only pay for the formats you ship.

#### Why did a board return an error row?

Error rows carry a sanitized errorMessage and the context that produced them. A board that no longer exists reports that it is not public; a transient network issue reports a generic failure. Errors are in-band rows, so your pipeline sees them without reading logs, and they are never charged.

### 🌐 About Alpha OSINT

This Actor is part of [Alpha OSINT](https://www.alphaosint.com), toolset of financial and operations data sources and APIs.
For support or requests for this actor, please start a ticket [directly on our support page](https://apify.com/johnvc/paylocity-jobs-api/issues/open?fpr=9n7kx3).

Last Updated: 2026.09.10

# Actor input Schema

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

Paylocity boards to scrape, mixed freely: a board GUID (0062c37f-a34c-479c-978c-bd800d23f223), a full board URL (https://recruiting.paylocity.com/recruiting/jobs/All/{guid}/{slug}), or a bare company name (matched against boards discovered from the public web archive). Leave empty and turn on discoverAll to enumerate every Paylocity board instead.

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

Alternative to the companies field for URL-shaped input; both lists are merged. Accepts recruiting.paylocity.com board URLs of the form /recruiting/jobs/All/{guid}/{slug}.

## `discoverAll` (type: `boolean`):

Enumerate every Paylocity recruiting board from the public Common Crawl web archive, then scrape jobs from a sample capped at maxCompanies. Combine with discoverOnly to return just the company directory. No input list is needed when this is on.

## `discoverOnly` (type: `boolean`):

Return one lightweight company row per discovered tenant (board GUID, URL, live job count, locations, departments) and skip job scraping entirely. Billed only for live-verified tenants; unverified and dead tenants are free. Turn on discoverAll or provide companies to choose the tenant set.

## `discoveryQuery` (type: `string`):

Case-insensitive text matched against the board slug and GUID when discovering boards. Scopes discoverAll and discoverOnly runs. Leave empty to sample across all discovered boards.

## `crawlDepth` (type: `integer`):

How many monthly Common Crawl snapshots to union when discovering boards. Higher values find more (and older) boards at the cost of a slower discovery pass. Only used when discovering.

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

Keep only jobs whose title contains any of these words, for example nurse, engineer, driver. Case-insensitive. Filters run before billing, so filtered jobs cost nothing.

## `departments` (type: `array`):

Keep only jobs whose hiring department contains any of these values. Note that many Paylocity employers leave the department blank; those jobs are filtered out when this is set.

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

Keep only jobs whose location, city, state, or address contains any of these values, for example Remote, Indiana, South Bend.

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

Keep only jobs the board flags as remote.

## `employmentTypes` (type: `array`):

Keep only jobs whose employment type matches any of these values, for example FULL\_TIME, PART\_TIME, CONTRACTOR, TEMPORARY, INTERN. Employment type comes from the job detail page, so this filter runs after the detail fetch but still before billing.

## `newerThan` (type: `string`):

Keep only jobs published on or after this cutoff. Accepts a relative window (24h, 7d, 2w) or an ISO date or datetime (2026-08-01 or 2026-08-01T12:00:00Z). Applied to the listing's published date before the detail fetch, so a daily schedule with 25h only fully processes what changed. No state to manage between runs.

## `cutoffField` (type: `string`):

Which timestamp newerThan compares against. Paylocity publishes a single posting timestamp per job, so both options filter on the listing's published date; the field is kept for parity with other job-board APIs.

## `includeDescriptionMarkdown` (type: `boolean`):

Add descriptionMarkdown to each job row: the posting converted to clean Markdown, compact and ready for AI agents. Billed per job row that carries it. The base row already includes the source-HTML description at no extra charge.

## `includeDescriptionText` (type: `boolean`):

Add descriptionText to each job row: the posting flattened to plain prose. Billed per job row that carries it.

## `verifyLive` (type: `boolean`):

Discovery modes only: fetch each discovered board to confirm it is live and read its current job count, locations, and departments. Only live or empty verified tenants are billed as company results. Turn off to list discovered tenants unverified and free.

## `includeInactive` (type: `boolean`):

Discovery modes only: also return boards that no longer respond (status dead). Dead and unverified rows are always delivered free. Off by default so a discovery run returns only serving boards.

## `report` (type: `string`):

Also write a human-readable digest of every scraped job, grouped by company, to the key-value store under the REPORT key. One flat charge per report. Capped at 5000 rows. Applies to job runs only.

## `maxCompanies` (type: `integer`):

Cap on how many boards a discovery run processes, sampled evenly across the discovered keyspace. Keeps discovery runs small and predictable.

## `maxJobsPerCompany` (type: `integer`):

Cap on job rows per board after filtering. 0 means no per-company cap.

## `maxJobs` (type: `integer`):

Hard ceiling on job rows across the entire run, all boards combined. The main cost control. 0 means unlimited.

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

Parallel per-job detail requests and per-board verification probes.

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

Optional. The public recruiting boards answer direct connections, so leave this off unless your network requires a proxy.

## Actor input object example

```json
{
  "companies": [
    "0062c37f-a34c-479c-978c-bd800d23f223"
  ],
  "startUrls": [],
  "discoverAll": false,
  "discoverOnly": false,
  "discoveryQuery": "",
  "crawlDepth": 2,
  "titleKeywords": [],
  "departments": [],
  "locationKeywords": [],
  "remoteOnly": false,
  "employmentTypes": [],
  "newerThan": "",
  "cutoffField": "updated",
  "includeDescriptionMarkdown": false,
  "includeDescriptionText": false,
  "verifyLive": true,
  "includeInactive": false,
  "report": "none",
  "maxCompanies": 25,
  "maxJobsPerCompany": 0,
  "maxJobs": 100,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every row this run produced.

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

Job rows with the headline fields: title, company, location, published date, remote flag, and the detail link.

## `salaries` (type: `string`):

Job rows with the structured pay range: min, max, currency, and period.

## `companies` (type: `string`):

One row per discovered company with a live open-jobs count and a link to their board.

## `newPostings` (type: `string`):

Job rows ordered for monitoring, with the published date first.

## `report` (type: `string`):

The whole-run Markdown or HTML report, when the report add-on was enabled.

# 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 = {
    "companies": [
        "0062c37f-a34c-479c-978c-bd800d23f223"
    ],
    "startUrls": [],
    "titleKeywords": [],
    "departments": [],
    "locationKeywords": [],
    "employmentTypes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/paylocity-jobs-api").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 = {
    "companies": ["0062c37f-a34c-479c-978c-bd800d23f223"],
    "startUrls": [],
    "titleKeywords": [],
    "departments": [],
    "locationKeywords": [],
    "employmentTypes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("johnvc/paylocity-jobs-api").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 '{
  "companies": [
    "0062c37f-a34c-479c-978c-bd800d23f223"
  ],
  "startUrls": [],
  "titleKeywords": [],
  "departments": [],
  "locationKeywords": [],
  "employmentTypes": []
}' |
apify call johnvc/paylocity-jobs-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnvc/paylocity-jobs-api"
        }
    }
}

```

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/xFOb1wZZ7kOd7X6Iy/builds/v9R0mIn9SSfympWtC/openapi.json
