# Rippling Jobs Scraper - ATS Board, Salary & Apply Links (`haketa/rippling-jobs-scraper`) Actor

Scrape every open role from any company's Rippling ATS board (ats.rippling.com): title, department, location, remote/hybrid/onsite, salary range, full description & apply link. No API key, no login. Filter by keyword, location, workplace type, country & salary.

- **URL**: https://apify.com/haketa/rippling-jobs-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Jobs, Business
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

## Rippling Jobs Scraper — ATS Board, Salary & Apply Links

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange?style=flat-square\&logo=apify)](https://apify.com/haketa/rippling-jobs-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg?style=flat-square)](https://apify.com/haketa/rippling-jobs-scraper)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-blue?style=flat-square)](https://apify.com/haketa/rippling-jobs-scraper)
[![Zero Login](https://img.shields.io/badge/Auth-Zero%20Login%20Required-brightgreen?style=flat-square)](https://apify.com/haketa/rippling-jobs-scraper)
[![Deep Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Unlocked-success?style=flat-square)](https://apify.com/haketa/rippling-jobs-scraper)

**Extract every open job posting from any company's [Rippling ATS](https://ats.rippling.com) career board in one fast, structured run.** This high-performance **Rippling jobs scraper** ingests public company career boards hosted on Rippling (`ats.rippling.com/{company}/jobs`) and extracts flat, comprehensive job records — including job title, corporate department, multi-location workplace details (remote, hybrid, on-site), structured compensation ranges (min, max, currency, frequency), employment types, full job descriptions, and direct public application links.

Export every posting directly to **JSON, CSV, Excel, or consume via REST API and Webhooks**.

> Built for **technical recruiters, talent intelligence platforms, executive search firms, compensation benchmarkers, sales prospecting teams, and private equity analysts** monitoring hiring velocity and workforce distribution across venture-backed startups and mid-market leaders.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target ATS** | [Rippling](https://ats.rippling.com) (`ats.rippling.com/{company}/jobs`) |
| **Input Methods** | Company board slugs (`gather`, `framework`, `rippling`) or full board URLs |
| **Data Formats** | JSON, CSV, Excel (XLSX), XML, HTML Table, RSS |
| **Speed & Runtime** | Direct lightweight HTTP (~50 roles scraped & enriched in 8–15 seconds) |
| **Default Concurrency** | 8 parallel workers (configurable up to 20) |
| **Deep Pagination** | Multi-page list iteration (100 per page, 1,000+ roles unlocked) |
| **Proxy Requirement** | Apify Datacenter Proxy (anti-rate-limiting IP distribution) |
| **Deduplication** | Automatic multi-location deduplication and location merging |
| **Salary Intelligence** | Native machine-readable pay brackets (`salaryMin`, `salaryMax`, `payRanges`) |

***

### 🔎 Why scrape Rippling ATS career boards?

[Rippling](https://ats.rippling.com) has become one of the fastest-growing modern HR, payroll, and applicant tracking systems, particularly among Series A through pre-IPO technology startups and high-growth mid-market enterprises. Companies that host their candidate portals on Rippling publish live hiring boards that provide crucial business and labor market signals:

- **Growth Velocity & Department Headcount**: Spot which engineering, AI research, go-to-market, or finance divisions are receiving accelerated headcount budgets.
- **Structured Pay Transparency Bands**: Unlike legacy ATS portals where pay is buried in free text, Rippling features structured compensation fields containing explicit minimum and maximum salary figures and pay intervals.
- **Workforce Distribution & Remote Flexibility**: Understand whether companies are mandating in-person attendance, adopting hub-and-spoke models, or hiring across all 50 US states.
- **Hiring Intent for B2B Sales**: An open requisition for specialized tooling (e.g. Snowflake Data Architect, Salesforce Admin, SOC2 Security Lead) signals active vendor evaluation and purchase intent.

Because Rippling offers no centralized public search across all employer boards, users must discover and pull listings board-by-board. This **Rippling jobs scraper** automates board ingestion, deduplicates repeated location listings, enriches roles with full details, and outputs a normalized tabular schema.

#### Key business use cases

- 🎯 **Executive Search & Talent Sourcing**: Track target employers to identify newly published leadership and engineering openings before general syndication.
- 💼 **Job Board Syndication**: Automatically ingest verified, non-expired tech job postings into specialized job platforms, regional directories, or remote workboards.
- 💰 **Compensation Intelligence & Salary Audits**: Analyze real market compensation data across titles, experience bands, and geographic cost-of-living tiers.
- 🔍 **B2B Account Prospecting & Intent Signals**: Discover target accounts actively expanding departments that your SaaS product or professional service serves.
- 📈 **Investor Diligence & Portfolio Tracking**: Benchmark hiring velocity across competitive startup categories to detect breakout operational momentum.

***

### ✨ Features & capabilities

- 🏢 **Multi-Board Parallel Harvesting**: Supply a list of company slugs; the actor processes multiple boards concurrently using high-efficiency worker pools.
- 🔄 **Unlocked 1,000+ Pagination**: Iterates systematically through multi-page board lists (`page` and `pageSize` pagination) to harvest large enterprise boards without artificial truncation.
- 📍 **Smart Multi-Location Deduplication**: Rippling frequently issues separate duplicate records for every location a role is open in. This scraper intelligently collapses duplicates into a single record with an aggregated `locations` array.
- 💵 **Structured Salary & Pay Range Extraction**: Captures numeric `salaryMin`, `salaryMax`, `salaryCurrency`, and `salaryInterval`, plus location-specific pay brackets inside `payRanges`.
- ⚡ **Two-Tier Resource Optimization**: Runs cheap, fast list filtering (keyword, location, department) first, only executing detail calls on matching roles to minimize runtime and proxy usage.
- 🧹 **Comprehensive Client-Side Filters**: Filter roles by keyword, location, department, workplace type (remote/hybrid/onsite), employment type, country, or minimum threshold salary.
- 🔒 **Zero Duplicate Guarantee**: Integrated ID set hashing ensures zero duplicated job UUIDs appear in your destination dataset.

***

### 🏢 Popular companies using Rippling ATS

Need board slug ideas? Here is a representative collection of companies using or having used Rippling ATS:

| Board Slug | Company Name | Industry / Vertical | Primary Locations |
|---|---|---|---|
| `rippling` | Rippling | HR, IT & Finance Cloud Platform | San Francisco, New York, Remote US |
| `gather` | Gather | Virtual Office & Proximity Chat | San Francisco, Remote Worldwide |
| `framework` | Framework Computer | Modular & Repairable Laptops | San Francisco, Taipei, Remote |
| `just-appraised-jobs` | Just Appraised | GovTech & Real Estate Tax Automation | Austin, Remote US |
| `closinglock` | Closinglock | FinTech & Wire Fraud Prevention | Austin, Remote US |
| `skillable-careers` | Skillable | Virtual Hands-On IT Labs | Remote US & Global |
| `double-app` | Double | Executive Assistant Platform | New York, Paris, Remote |
| `superhuman` | Superhuman | High-Speed Email & Productivity | San Francisco, Remote US |

***

### 📥 Input parameters

The scraper accepts flexible JSON input configurations. All parameters are optional, with smart demo fallbacks enabled when inputs are blank:

| Parameter | Type | Default | Description |
|---|---|---|---|
| `boards` | Array | `["rippling", "gather", "framework"]` | List of Rippling board slugs (e.g. `gather`, `framework`) or full career URLs (`https://ats.rippling.com/gather/jobs`). |
| `searchTerm` | String | `""` | Filter roles containing this keyword in job title or department. |
| `location` | String | `""` | Substring match against location strings (city, state, or country). |
| `department` | String | `""` | Case-insensitive filter matching hiring department (e.g. `Engineering`, `Sales`). |
| `workplaceType` | String | `"any"` | Workplace arrangement filter: `any`, `remote`, `hybrid`, or `onsite`. |
| `employmentType` | String | `""` | Filter by employment type (e.g. `full-time`, `contract`, `intern`). |
| `country` | String | `""` | 2-letter ISO country code filter (e.g. `US`, `GB`, `CA`). |
| `minSalary` | Integer | `0` | Drops roles whose maximum published salary is below this amount. Automatically forces details. |
| `fetchDetails` | Boolean | `true` | Fetch per-job detail endpoint for salary ranges, descriptions, and timestamps. |
| `includeDescription` | Boolean | `true` | When true, includes full job and company description text. |
| `maxItems` | Integer | `0` | Total maximum roles to save across all boards. Set to `0` for unlimited scraping. Fast prefill is set to `50`. |
| `maxConcurrency` | Integer | `8` | Number of simultaneous requests (boards and detail enrichment). |
| `proxyConfiguration` | Object | `Datacenter` | Proxy configuration. Apify Proxy prevents rate-limiting during batch scrapes. |

#### Example input configurations

##### 1. Fast multi-board engineering sweep

```json
{
  "boards": ["gather", "framework", "just-appraised-jobs"],
  "searchTerm": "Engineer",
  "workplaceType": "remote",
  "maxItems": 50
}
```

##### 2. Pay-transparency compensation benchmark

```json
{
  "boards": ["rippling"],
  "minSalary": 120000,
  "country": "US",
  "fetchDetails": true,
  "maxItems": 200
}
```

##### 3. Lightweight full inventory sweep (no detail overhead)

```json
{
  "boards": ["rippling", "gather", "framework"],
  "fetchDetails": false,
  "maxItems": 0,
  "maxConcurrency": 12
}
```

***

### 📊 Output data structure

Each scraped record provides a clean, normalized schema designed for immediate downstream data science and database ingestion:

#### 👔 Role & categorization attributes

| Field | Type | Coverage | Description |
|---|---|---|---|
| `id` | String | 🟢 High | Unique numerical Rippling job listing identifier. |
| `uuid` | String | 🟢 High | Universally unique identifier (UUID) for the role. |
| `board` | String | 🟢 High | Rippling company board slug identifier. |
| `title` | String | 🟢 High | Official job posting title. |
| `department` | String | 🟢 High | Corporate department name (e.g. `"Engineering"`). |
| `employmentType` | String | 🟢 High | Employment classification (e.g. `"Salaried, full-time"`). |
| `companyName` | String | 🟢 High | Clean corporate company entity name. |

#### 📍 Location & workplace attributes

| Field | Type | Coverage | Description |
|---|---|---|---|
| `primaryLocation` | String | 🟢 High | Formatted primary work location string (e.g. `"San Francisco, CA, USA"`). |
| `locations` | Array | 🟢 High | Array of all eligible location objects with city, state, country, and postal info. |
| `workplaceTypes` | Array | 🟢 High | Array of applicable models: `["remote"]`, `["hybrid"]`, or `["onsite"]`. |
| `isRemote` | Boolean | 🟢 High | True if the role permits remote work from home. |

#### 💰 Compensation & timing attributes

| Field | Type | Coverage | Description |
|---|---|---|---|
| `salaryMin` | Float | 🟡 Conditional | Minimum published salary range figure. |
| `salaryMax` | Float | 🟡 Conditional | Maximum published salary range figure. |
| `salaryCurrency` | String | 🟡 Conditional | Currency code for the salary (e.g. `"USD"`, `"CAD"`). |
| `salaryInterval` | String | 🟡 Conditional | Pay frequency: `"YEAR"`, `"MONTH"`, or `"HOUR"`. |
| `payRanges` | Array | 🟡 Conditional | Location-specific salary breakdown array with regional brackets. |
| `postedAt` | String | 🟢 High | ISO-8601 UTC timestamp when the job was published. |

#### 🔗 Links & textual attributes

| Field | Type | Coverage | Description |
|---|---|---|---|
| `url` | String | 🟢 High | Direct candidate application link on Rippling ATS. |
| `descriptionText` | String | 🟢 High | Full clean plain text job overview and requirements. |
| `scrapedAt` | String | 🟢 High | ISO-8601 execution timestamp. |

#### Example JSON output item

```json
{
  "id": "1849102",
  "uuid": "4b2e8a10-2f91-49b0-8172-fa7102e9a2b1",
  "board": "gather",
  "title": "Senior Infrastructure Engineer",
  "department": "Engineering",
  "employmentType": "Salaried, full-time",
  "companyName": "Gather",
  "primaryLocation": "San Francisco, CA, USA",
  "locations": [
    {
      "name": "San Francisco, CA, USA",
      "city": "San Francisco",
      "state": "CA",
      "country": "United States",
      "countryCode": "US",
      "workplaceType": "remote"
    }
  ],
  "workplaceTypes": ["remote"],
  "isRemote": true,
  "salaryMin": 160000,
  "salaryMax": 190000,
  "salaryCurrency": "USD",
  "salaryInterval": "YEAR",
  "payRanges": [
    {
      "location": "San Francisco, CA, USA",
      "currency": "USD",
      "frequency": "YEAR",
      "min": 160000,
      "max": 190000,
      "isRemote": true
    }
  ],
  "postedAt": "2026-11-05T18:30:00.000Z",
  "url": "https://ats.rippling.com/gather/jobs/4b2e8a10-2f91-49b0-8172-fa7102e9a2b1",
  "descriptionText": "About Gather: Gather is building the virtual headquarters for modern remote teams...",
  "scrapedAt": "2026-11-10T13:42:00.000Z"
}
```

***

### 📈 Pagination & scale guide

- **Two-Tier Architecture**: The scraper first iterates through board listings (`pageSize: 100`). Once the list is deduplicated and filtered, survivor roles are enriched via concurrent detail calls.
- **Deep Pagination**: Setting `maxItems: 0` traverses board pages until every requisition is collected without artificial ceilings.
- **Location Merging**: When a role lists 5 distinct geographic offices, the actor merges them into one record rather than pushing 5 duplicate items to your dataset.
- **Concurrent Efficiency**: The configurable concurrency pool (`maxConcurrency: 8` to `20`) ensures high throughput while preventing connection drops.

***

### 💡 Practical scraping tips

1. **How to Locate Slugs**: Inspect any job link hosted on `ats.rippling.com/<slug>/jobs`. The path segment immediately following the domain is the slug (e.g. `framework`).
2. **List-Only Inventory Mode**: For high-volume market scans where you only need role titles and department headcount, set `fetchDetails: false`. Runs execute in 3–5 seconds.
3. **Target Pay-Transparent Roles**: To extract only positions with verified salary ranges, configure `minSalary: 1`. Roles without a machine-readable compensation band will be excluded automatically.
4. **Automated Monitoring**: Create a weekly scheduled task on Apify to detect newly created or closed positions across your target startup competitors.

***

### 🛠️ Step-by-step workflow guide

#### Step 1: Input target boards

Open the actor on the Apify Console. Enter one or more Rippling board slugs or URLs into `boards`:

```text
rippling
gather
framework
just-appraised-jobs
```

#### Step 2: Configure extraction filters

- Select your target department (`Engineering`), workplace arrangement (`remote`), or keyword (`Staff`).
- Choose whether to fetch rich detail attributes or run in high-speed list-only mode.

#### Step 3: Run the scraper

Click **Start**. Real-time logs will display board discovery, location deduplication, and detail enrichment progress.

#### Step 4: Export your dataset

Download your dataset in JSON, CSV, or Excel formats, or sync results directly into your ATS or CRM via Apify integrations.

***

### 🗄️ Dataset storage & retention

Data extracted by this actor is preserved securely in your Apify account within the assigned run dataset:

- **Format Flexibility**: Download items anytime in JSON, CSV, Excel, XML, or HTML table formats via the Apify Console.
- **Longitudinal Databases**: Append multiple weekly runs into an Apify Named Dataset to build a persistent historical database of tech job openings.
- **Schema Guarantee**: Every record strictly conforms to the defined schema, guaranteeing seamless downstream ingestion into BI tools.

***

### 🔗 Compatible tools & export formats

- **Direct Downloads**: One-click export to JSON, CSV, Excel, XML, or TSV.
- **No-Code Integrations**: Connect seamlessly with Make.com, Zapier, n8n, or Google Sheets webhooks.
- **Developer API**: Ingest roles dynamically using Python or Node.js:

#### Python example

```python
from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("haketa/rippling-jobs-scraper").call(run_input={
    "boards": ["rippling", "gather", "framework"],
    "workplaceType": "remote",
    "maxItems": 100
})

items = list(client.dataset(run["defaultDatasetId"]).iterate_items())
df = pd.DataFrame(items)
print(f"Extracted {len(df)} remote roles. Median minimum salary: ${df['salaryMin'].dropna().median():,.0f}")
```

#### Node.js example

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('haketa/rippling-jobs-scraper').call({
    boards: ['gather', 'framework'],
    searchTerm: 'engineer',
    maxItems: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} engineering roles from Rippling.`);
```

***

### ❓ Frequently Asked Questions

##### Do I need a Rippling login or account?

No. The scraper accesses public career board feeds without authentication, cookies, or account logins.

##### How many boards can I scrape in a single run?

There is no hard limit. You can pass dozens or hundreds of board slugs in the input array; the actor queues and processes them using configurable concurrency workers.

##### Why does the raw posting count differ from the saved count?

Rippling natively returns a separate posting record for every location a role is advertised in. This scraper automatically merges duplicate locations into a single unified record, preventing redundant data.

##### Can I filter by minimum salary?

Yes. Setting `minSalary` filters for roles whose published maximum salary meets or exceeds your threshold, automatically discarding unpriced roles.

##### What happens if a board slug is invalid or empty?

If a slug does not exist, the actor logs a warning and proceeds to the remaining boards without failing the execution.

##### Does Rippling offer a global search across all companies?

No. Rippling operates strictly on an isolated per-company basis. You must supply the specific company slugs you wish to scrape.

***

##### Can I filter for roles in specific US states or metropolitan areas?

Yes. The `location` input parameter performs a case-insensitive substring match against the complete address string. For example, setting `location: "CA"` or `location: "New York"` will retain positions situated in those specific territories.

##### Are unlisted or internal-only roles accessible?

No. This actor accesses publicly indexable career boards only. Internal transfer requisitions or confidential searches gated behind employer authentication are not exposed.

### 📋 Changelog

#### v1.2 (2026-11)

- **1,000+ Deep Pagination Unlocked**: Removed artificial limits on multi-page list traversal; full board pagination enabled via `maxItems`.
- **Fast Prefill Execution**: Streamlined default validation run to 50 items for rapid verification in under 15 seconds.
- **Enhanced Location Deduplication**: Upgraded location merging logic to handle complex multi-country remote listings seamlessly.
- **Derived Remote Flagging**: Standardized `isRemote` boolean and clean `workplaceTypes` arrays across all records.

#### v1.1 (2026-10)

- Implemented two-tier list-then-detail enrichment pipeline.
- Added structured compensation parser (`salaryMin`, `salaryMax`, `payRanges`).
- Standardized ISO timestamp attributes.

#### v1.0 (2026-09)

- Initial release featuring lightweight HTTP extraction from Rippling ATS boards.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/rippling-jobs-scraper/changelog.md

# Actor input Schema

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

Companies whose Rippling board you want to scrape. Paste the slug (e.g. `gather`) or any ats.rippling.com URL (e.g. `https://ats.rippling.com/gather/jobs`) — one per line. Rippling has no cross-company search, so bring your own list. The slug is the first path segment after ats.rippling.com.

## `searchTerm` (type: `string`):

Keep only roles whose title or department contains this text (case-insensitive). Leave empty for all roles.

## `location` (type: `string`):

Keep only roles with a location (city / state / country) containing this text, e.g. `New York`, `United States`, `London`. Case-insensitive substring match.

## `department` (type: `string`):

Keep only roles whose department contains this text, e.g. `Engineering`, `Sales`. Case-insensitive.

## `workplaceType` (type: `string`):

Keep only roles that offer this workplace type (a role can list several).

## `employmentType` (type: `string`):

Keep only roles whose employment type contains this text, e.g. `full-time`, `contract`, `intern`. Requires details to be fetched. Case-insensitive.

## `country` (type: `string`):

Keep only roles with a location in this country, given as a 2-letter ISO code, e.g. `US`, `GB`, `CA`. Case-insensitive.

## `minSalary` (type: `integer`):

Keep only roles whose salary range top end is at least this amount (in the posting's own currency). Roles without a published salary are dropped. Setting this forces details to be fetched. 0 = no salary filter.

## `fetchDetails` (type: `boolean`):

Call the per-job detail endpoint to add salary range, employment type, posting date, company name and full description. Turn off for a fast, list-only run (title, department, locations & links only).

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

Include the full job + company description text in each row (requires 'Fetch job details'). Turn off for a leaner dataset.

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

Maximum number of jobs to save across all boards. Also caps how many roles get detail calls, keeping cost bounded. 0 = no limit. Fast prefill is set to 50.

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

How many requests to run in parallel (boards and detail calls). Higher = faster on big boards.

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

Proxy settings. Apify Proxy (default) spreads requests across IPs and keeps Rippling's rate-limiting at bay on large boards.

## Actor input object example

```json
{
  "boards": [
    "gather",
    "https://ats.rippling.com/framework/jobs",
    "rippling"
  ],
  "searchTerm": "engineer",
  "workplaceType": "any",
  "country": "US",
  "minSalary": 0,
  "fetchDetails": true,
  "includeDescription": true,
  "maxItems": 50,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

Job postings scraped from the Rippling ATS boards — role, department, location, workplace type, salary range, description and apply links.

# 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": [
        "rippling",
        "gather",
        "framework"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/rippling-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": [
        "rippling",
        "gather",
        "framework",
    ],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/rippling-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": [
    "rippling",
    "gather",
    "framework"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/rippling-jobs-scraper --silent --output-dataset

```

## MCP server setup

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