# Rippling Jobs API - Career Site Job Scraper (`blooming_gator/rippling-jobs-api`) Actor

Job postings direct from company career sites on Rippling. Includes a verified directory of 864 live Rippling boards, so you never guess a company's board slug. Completeness checked against the vendor's own published count and reported per board.

- **URL**: https://apify.com/blooming\_gator/rippling-jobs-api.md
- **Developed by:** [Kaleb Confer](https://apify.com/blooming_gator) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 verified 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.

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 Jobs API - Career Site Job Scraper

Job postings pulled straight from company career sites running **Rippling**, with a
verified directory of **864 Rippling boards** included so you never have to guess
a company's board slug.

Rippling's ATS board API returns a company's full posting list in one call. No vendor count is published, so completeness is reported as unknown.

### Why this exists

Most job data on the market is scraped from aggregators, where postings are
reposted, stale, or routed through a third-party apply flow. These come from the
employer's own Rippling board: one hop from the hiring team, with the employer's
real apply URL.

### Completeness is reported honestly

Rippling returns a whole board in one call, so there is no pagination that could
silently truncate. But Rippling publishes no job count, so there is nothing to check
against - and this Actor reports `null` for that board rather than claiming a
completeness it cannot prove.

### What you get

| Field | Meaning |
|---|---|
| `company` | Employer name |
| `title` | Role title |
| `location` | Location as the employer wrote it |
| `department` | Team or department, when the board exposes one |
| `url` | Direct apply URL on the employer's board |
| `updated` | Posting or last-updated timestamp from the vendor |
| `board_token` | The Rippling board identifier, reusable in later runs |
| `job_id` | Vendor's own job id |
| `verified_complete` | `true`, `false`, or `null` - see below |

Every run also writes a `PROVENANCE` record to the key-value store: per board, how
many postings were fetched, what count the vendor published, and whether the two
matched.

### `verified_complete` is three-valued on purpose

- `true` - the vendor published a count and our row count matched it.
- `false` - the vendor published a count and we did **not** match it. Something is
  wrong; the run tells you rather than hiding it.
- `null` - the vendor publishes no count. Honestly unknown.

Most job scrapers report only what they found. That is indistinguishable from a
board that half-failed. A silent partial result is worse than an error, because
you build on it.

### Input

| Option | What it does |
|---|---|
| `companies` | Company names. Resolved against the verified directory first, then live. |
| `boards` | Exact Rippling board tokens, if you already know them. |
| `listKnownBoards` | Return the whole verified directory of 864 boards instead of jobs. |
| `allBoards` | Sweep directory boards when no company is given. |
| `keyword` | Case-insensitive filter on job title. |
| `maxBoards` | Cap boards per run (default 25). |
| `maxResults` | Cap rows returned. |

#### Start here

Set `listKnownBoards` to `true`. You get every Rippling board we have confirmed live,
and can pick the companies you care about from real tokens instead of guessing.

### Platform notes

Rippling is a newer ATS with fewer public boards than the incumbents, so the directory here is smaller and grows as boards appear.

### Where the directory comes from

Board tokens are harvested from public web crawl archives, then **every one is
re-checked against Rippling's own public API before it ships**. A token that was seen
once but no longer resolves does not make it in. Guessing company slugs instead
was measured at a 0.77% hit rate; this approach measured about 67%.

To be exact about what the directory is: a board qualifies when it resolved **and
had at least one open role** at validation time. A real board that happened to be
empty that day is not in here. So treat the count as a floor, not a census.

### Legal

This Actor reads Rippling's documented public job board endpoints - the same data any
visitor sees without logging in. No login, no cookies, no terms accepted, no
paywall or access control circumvented. Job postings are published by employers
specifically to be seen.

### Limits

- Coverage is the directory plus anything you name explicitly; it is not every
  Rippling board in existence, and this README says so rather than implying totals.
- `updated` is passed through from the vendor and means slightly different things
  on different platforms.
- Rate limits are the vendor's, not ours. Errors are reported per board.

# Actor input Schema

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

Company names to look up on Rippling. Matched against the verified directory first.

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

Exact board tokens, if you already know them.

## `listKnownBoards` (type: `boolean`):

Ignore everything else and return all 864 confirmed-live Rippling boards.

## `allBoards` (type: `boolean`):

If no company is given, pull jobs from the directory up to Max boards.

## `keyword` (type: `string`):

Case-insensitive substring match on job title.

## `maxBoards` (type: `integer`):

How many boards to pull in one run. Keeps a run bounded and predictable in cost.

## `maxResults` (type: `integer`):

0 means no cap.

## Actor input object example

```json
{
  "companies": [],
  "boards": [],
  "listKnownBoards": false,
  "allBoards": false,
  "maxBoards": 25,
  "maxResults": 0
}
```

# Actor output Schema

## `roles` (type: `string`):

One row per unique role.

## `provenance` (type: `string`):

Per board: fetched, vendor count, match.

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

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

# Run the Actor and wait for it to finish
run = client.actor("blooming_gator/rippling-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": [],
  "boards": []
}' |
apify call blooming_gator/rippling-jobs-api --silent --output-dataset

```

## MCP server setup

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