# Rippling ATS Jobs Scraper (`automation-lab/rippling-ats-jobs-scraper`) Actor

Extract structured jobs from public Rippling ATS career boards and direct job URLs, including locations, departments, descriptions, dates, employment types, and pay.

- **URL**: https://apify.com/automation-lab/rippling-ats-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

Pay per event

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

## Rippling ATS Jobs Scraper

Export structured jobs from public Rippling-hosted career boards.

Provide employer board URLs, Rippling board slugs, or direct job URLs.
The Actor paginates boards, deduplicates jobs by UUID, and can enrich every row from its public detail page.

It uses direct HTTP and server-rendered `__NEXT_DATA__` rather than a browser.
No login, cookies, proxy, or private API token are required.

### What does Rippling ATS Jobs Scraper do?

The Actor turns public pages under `ats.rippling.com` into integration-ready dataset rows.

It supports:

- one or many public Rippling career boards;
- shorthand board slugs such as `swag`;
- locale-prefixed URLs such as `/de-DE/swag/jobs`;
- direct job posting URLs;
- board pagination up to your requested item limit;
- optional detail-page enrichment;
- UUID-based deduplication across all inputs;
- sanitized HTML and clean plain-text descriptions;
- visible compensation when the employer supplies it.

The default dataset is suitable for CSV, JSON, Excel, API, webhook, and database workflows.

### Who is this Rippling jobs extractor for?

**Recruiters and staffing teams** can monitor openings at target employers and route new roles into sourcing workflows.

**Job aggregators** can normalize Rippling-hosted vacancies alongside jobs from other ATS providers.

**Sales intelligence teams** can use department and location changes as hiring signals.

**Labor-market analysts** can collect recurring snapshots of roles, workplace modes, and geographies.

**Developers and data teams** can replace brittle page selectors with stable typed dataset rows.

### Why use this Actor?

Rippling boards expose structured server-rendered state, but every employer has its own slug and job inventory.
This Actor handles URL normalization, pagination, detail requests, retries, and output normalization in one run.

Unlike a generic webpage scraper, it understands Rippling job UUIDs, board metadata, location objects, department trees, and employment types.

Unlike a browser-heavy workflow, it avoids downloading images, fonts, and client-side application assets.
That keeps runs fast and economical.

### What Rippling job data can I extract?

| Field | Meaning |
| --- | --- |
| `jobId` | Stable Rippling job UUID |
| `title` | Public role title |
| `jobUrl` | Canonical public detail URL |
| `boardUrl` | Employer's canonical Rippling board URL |
| `boardSlug` | Rippling board identifier |
| `boardTitle` | Public career-board title |
| `companyName` | Employer name shown by Rippling |
| `department` | Primary department |
| `departmentTree` | Detailed department hierarchy |
| `locations` | Structured location objects |
| `locationNames` | Flat location labels |
| `countries`, `states`, `cities` | Geographic dimensions |
| `workplaceTypes` | Remote, hybrid, or on-site modes |
| `language` | Listing language code |
| `employmentType` | Human-readable employment type |
| `employmentTypeCode` | Rippling employment category |
| `createdAt` | Job creation timestamp |
| `companyDescriptionText` | Clean company description |
| `roleDescriptionText` | Clean role description |
| `companyDescriptionHtml` | Sanitized company HTML |
| `roleDescriptionHtml` | Sanitized role HTML |
| `compensationText` | Visible salary or pay range |
| `detailStatus` | Enrichment outcome |
| `scrapedAt` | Collection timestamp |

Fields unavailable on a particular employer's page are returned as `null` or an empty array.

### How to scrape Rippling ATS jobs

1. Open the Actor in Apify Console.
2. Add one or more public Rippling board or job URLs.
3. Optionally add board slugs for employers you monitor repeatedly.
4. Choose the maximum number of unique jobs.
5. Keep **Include job details** enabled when you need descriptions, dates, employment types, or compensation.
6. Click **Start**.
7. Open the **Jobs** dataset view.
8. Export the results or connect them to your workflow.

A small first run with 5–20 jobs is useful for checking a new board before scaling up.

### Input parameters

#### `startUrls`

An array of public HTTPS URLs on `ats.rippling.com`.
Both board and direct job paths are accepted.

Examples:

```text
https://ats.rippling.com/swag/jobs
https://ats.rippling.com/de-DE/swag/jobs
https://ats.rippling.com/astra/jobs/82d5d6a5-257f-440e-8b8f-d49af4ec3209
```

#### `boardSlugs`

Optional shorthand identifiers such as `swag` or `astra`.
A slug is expanded to `https://ats.rippling.com/<slug>/jobs`.
You can combine slugs with `startUrls`.

#### `maxItems`

Maximum unique jobs saved across every input.
The default is 100 and the supported range is 1–10,000.
Pagination stops when the limit is reached.

#### `includeDetails`

When `true`, fetches job pages for descriptions, employment metadata, dates, and compensation.
When `false`, board rows are returned without those detail-only fields.
Direct job URL inputs are always parsed as details.

#### `maxConcurrency`

Controls parallel detail requests from 1 to 10.
The default of 5 balances throughput with respectful request volume.

### Input example

```json
{
  "boardSlugs": ["swag", "astra"],
  "maxItems": 50,
  "includeDetails": true,
  "maxConcurrency": 5
}
```

You may instead use request-list URLs:

```json
{
  "startUrls": [
    { "url": "https://ats.rippling.com/de-DE/swag/jobs" }
  ],
  "maxItems": 20,
  "includeDetails": false
}
```

### Output example

A current enriched board run produces rows shaped like this:

```json
{
  "jobId": "6b1f2ec9-1206-4729-9d5e-75257bc5a06d",
  "title": "Chief Financial Officer",
  "jobUrl": "https://ats.rippling.com/swag/jobs/6b1f2ec9-1206-4729-9d5e-75257bc5a06d",
  "boardUrl": "https://ats.rippling.com/swag/jobs",
  "boardSlug": "swag",
  "boardTitle": "Southwest Accessory Group",
  "companyName": "Southwest Accessory Group",
  "department": "Finance",
  "locationNames": ["White Settlement, TX", "Haltom City, TX"],
  "countries": ["United States"],
  "states": ["Texas"],
  "workplaceTypes": ["ON_SITE"],
  "language": "en-US",
  "employmentType": "Salaried, full-time",
  "compensationText": "USD 225,000–280,000 per year (DFW)",
  "detailStatus": "enriched",
  "scrapedAt": "2026-07-26T03:00:00.000Z"
}
```

Descriptions are omitted from this snippet for readability but remain available in the dataset.

### How much does it cost to extract Rippling ATS jobs?

This Actor uses pay-per-event pricing:

- a small fee when each run starts;
- a tiered fee for each unique job saved;
- no charge for duplicate, rejected, or failed rows.

The current FREE-tier rates are **$0.005 per run** and **$0.000041071 per job**.
Higher usage tiers receive lower per-job rates.

FREE-tier calculation examples:

| Workflow | Charge formula |
| --- | --- |
| 10 saved jobs | one run-start event plus 10 per-job events |
| 100 saved jobs | one run-start event plus 100 per-job events |
| 1,000 saved jobs | one run-start event plus 1,000 per-job events |

Apify plan usage and platform costs are separate from Actor event charges.
Check the Console pricing panel for the active tier that applies to your account.

### Pagination, limits, and deduplication

Board pages are requested in bounded batches.
The Actor reads Rippling's advertised `totalPages` value and stops at exhaustion or `maxItems`.

Jobs are deduplicated by their stable Rippling UUID.
If the same job appears through two boards or a board plus direct URL, only one row is saved.

The item limit applies globally across all inputs, not once per board.
Input order therefore determines which boards are processed first when the limit is reached.

### Detail enrichment and clean descriptions

Detail enrichment adds fields that board cards do not expose consistently:

- role and company descriptions;
- employment type;
- creation date;
- department hierarchy;
- visible compensation.

The Actor removes styles, scripts, forms, iframes, metadata, and unsafe links from description HTML.
It also exports normalized plain text for search and NLP workflows.

If one detail request fails, the useful board row is preserved with `detailStatus` set to `detail_failed`.
Malformed board payloads fail clearly instead of pretending there are no jobs.

### Automation and integration ideas

#### Recruiting pipeline

Schedule the Actor daily, compare UUIDs with the previous dataset, and send new roles to a recruiter or ATS.

#### Job aggregation

Normalize this dataset with outputs from Greenhouse, Workday, and other job-board Actors.
Use `jobId`, `companyName`, and `jobUrl` as source dimensions.

#### Hiring-signal monitoring

Track counts by company, department, location, and workplace type.
Alert account teams when a target employer opens roles in a strategic function.

#### Labor-market analysis

Store periodic snapshots in a warehouse.
Analyze job creation dates, geographic expansion, remote-work patterns, and compensation availability.

#### Webhooks and integrations

Use Apify integrations to send completed datasets to Google Sheets, Make, Zapier, Slack, or a webhook endpoint.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~rippling-ats-jobs-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "boardSlugs": ["swag"],
    "maxItems": 20,
    "includeDetails": true
  }'
```

To wait for completion and receive dataset items, use the synchronous dataset-items endpoint documented by Apify.
Never commit your Apify token to source control.

### Run with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/rippling-ats-jobs-scraper').call({
    boardSlugs: ['swag'],
    maxItems: 20,
    includeDetails: true,
});

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

Install the client with:

```bash
npm install apify-client
```

### Run with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("automation-lab/rippling-ats-jobs-scraper").call(run_input={
    "boardSlugs": ["swag"],
    "maxItems": 20,
    "includeDetails": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["jobUrl"])
```

Install the client with:

```bash
pip install apify-client
```

### Use Rippling ATS Jobs Scraper through MCP

Add the Apify MCP server to Claude Code:

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

#### Claude Desktop setup

Add this server to the Claude Desktop MCP configuration:

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

#### Cursor setup

Use the same `mcpServers.apify.url` value in Cursor's MCP settings.
Restart Cursor after saving the configuration.

#### VS Code setup

Add the same HTTP MCP server URL through VS Code's MCP server configuration or command palette.
Confirm the `automation-lab/rippling-ats-jobs-scraper` tool is listed before running a prompt.

Example prompts:

- “Extract up to 50 current roles from the Rippling board slug `swag`.”
- “Enrich this public Rippling job URL and return its compensation and locations.”
- “Compare departments and workplace types across the `swag` and `astra` boards.”

### Responsible use and legality

The Actor reads publicly accessible employer job postings.
It does not bypass authentication or collect application responses.

You are responsible for complying with applicable laws, website terms, robots guidance, and contractual obligations.
Do not use results for unlawful discrimination, spam, or decisions that require human review under employment law.

Job descriptions can contain names, contact details, equal-opportunity statements, or other employer-provided text.
Apply appropriate retention and access controls to exported data.

### Limitations

- Only public `https://ats.rippling.com` board and job URLs are supported.
- Closed, unlisted, or deleted jobs may return HTTP 404.
- Employers choose which fields to publish, so many values can be null.
- Compensation extraction only reports visible employer-supplied text or pay-range data.
- The Actor does not submit applications or scrape candidate information.
- Upstream Next.js payload changes can require parser updates.
- No automatic proxy or browser fallback is enabled.
- `maxItems` is a global cap across all supplied boards.

### Troubleshooting

#### “Only public ats.rippling.com URLs are supported”

Check that the input uses HTTPS and the exact `ats.rippling.com` hostname.
Company marketing sites and other ATS vendors are intentionally rejected.

#### “Unsupported Rippling ATS URL path”

Use a board path ending in `/jobs` or a direct job path ending in `/jobs/<UUID>`.
Locale prefixes such as `/de-DE/` are supported.

#### A row has `detailStatus: detail_failed`

The list record was valid, but its detail request failed after bounded retries.
Run again later or use the canonical `jobUrl` to confirm that the employer has not closed the posting.

#### A board returns zero rows

Open the same public board URL and confirm the employer currently advertises jobs.
A valid empty board produces an empty dataset; an unrecognized payload causes an explicit run failure.

#### The run reached `maxItems`

Increase the limit or split employers into separate runs if you need complete coverage for every board.

### Related Automation Lab Actors

- [Greenhouse Jobs Scraper](https://apify.com/automation-lab/greenhouse-jobs-scraper) for Greenhouse-hosted career boards.
- [Workday Jobs Scraper](https://apify.com/automation-lab/workday-jobs-scraper) for public Workday career sites.
- [LinkedIn Jobs Scraper](https://apify.com/automation-lab/linkedin-jobs-scraper) for LinkedIn job discovery.

Use source-specific Actors when you know the employer's ATS.
Combine their normalized outputs for broader job-market coverage.

### FAQ

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

No. It only uses public employer career boards and job pages.

#### Does it use a browser or proxy?

No. The current implementation uses direct HTTPS and server-rendered structured data.

#### Can I supply multiple employers?

Yes. Add multiple URLs or board slugs.
Results are deduplicated by job UUID and limited globally by `maxItems`.

#### Can I skip descriptions to reduce requests?

Yes. Set `includeDetails` to `false` for board inputs.
Direct job URLs still return their public detail fields.

#### Does it find every job on the internet?

No. It extracts jobs from the specific public Rippling ATS inputs you provide.
It is not a general web search engine.

#### Can I schedule recurring monitoring?

Yes. Use an Apify schedule and compare job UUIDs between runs.
A webhook or automation platform can route newly observed records downstream.

#### What happens when Rippling changes its page structure?

Shape validation prevents false empty success.
Inspect the run error and contact the Actor maintainer with the affected public URL.

# Actor input Schema

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

Public ats.rippling.com board URLs and direct job URLs. Locale-aware URLs such as /de-DE/swag/jobs are supported.

## `boardSlugs` (type: `array`):

Optional Rippling board identifiers, for example swag or astra. You can combine these with start URLs.

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

Maximum unique job records saved across all inputs. Pagination stops as soon as this limit is reached.

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

Fetch each job page for descriptions, employment type, creation date, department hierarchy, and compensation text. Direct job URLs are always returned with details.

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

Number of detail pages fetched in parallel. Keep the default for stable, respectful extraction.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://ats.rippling.com/swag/jobs"
    }
  ],
  "boardSlugs": [
    "swag"
  ],
  "maxItems": 20,
  "includeDetails": true,
  "maxConcurrency": 5
}
```

# Actor output Schema

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

Default dataset containing all unique Rippling 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://ats.rippling.com/swag/jobs"
        }
    ],
    "boardSlugs": [
        "swag"
    ],
    "maxItems": 20,
    "includeDetails": true,
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/rippling-ats-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://ats.rippling.com/swag/jobs" }],
    "boardSlugs": ["swag"],
    "maxItems": 20,
    "includeDetails": True,
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/rippling-ats-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://ats.rippling.com/swag/jobs"
    }
  ],
  "boardSlugs": [
    "swag"
  ],
  "maxItems": 20,
  "includeDetails": true,
  "maxConcurrency": 5
}' |
apify call automation-lab/rippling-ats-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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