# JobsRadar: search every company job board at once (`agenttoolworks/jobsradar-multi-board-job-search`) Actor

Search open roles across Greenhouse, Lever, Ashby and Workable job boards in one run. Deduplicated and normalized, with filters on title, location, remote and date.

- **URL**: https://apify.com/agenttoolworks/jobsradar-multi-board-job-search.md
- **Developed by:** [AgentToolWorks](https://apify.com/agenttoolworks) (community)
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 job posting returneds

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/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

### What is JobsRadar?

JobsRadar is a **job board scraper for company career pages**. Every company runs its own job board on an applicant tracking system (ATS). JobsRadar searches **Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Personio and Pinpoint** at once and gives you back one deduplicated, normalized list of open roles, with filters on title, location, remote and posting date.

It reads the official public job board APIs and feeds these platforms publish so employers can distribute their openings: no login, no cookies, and apply links that point at the employer's own page.

![JobsRadar: seven applicant tracking systems in, one deduplicated list of open roles out, from a real run](https://agenttoolworks.com/apify/jobsradar-overview.png)

### What data can you extract from company job boards?

One row per open role, with the same fields whichever board it came from:

| Field | Example | Notes |
|---|---|---|
| `id` | `greenhouse:stripe:8224915` | Stable across runs: provider, board and the board's own job id |
| `title` | Machine Learning Engineer, Growth Platform | |
| `company` | Stripe | |
| `location` | San Francisco | As the employer published it |
| `remote` | `false` | Only `true` when the board itself marks the role remote |
| `department` | Engineering | When the board publishes one |
| `postedAt` | `2026-09-28T15:58:13.000Z` | ISO 8601 in UTC for every board (a bare date when the board publishes only a day). Empty for Pinpoint, which publishes none |
| `applyUrl` | `https://stripe.com/jobs/search?gh_jid=8224915` | The employer's own application page |
| `provider` | `greenhouse` | Which ATS the role came from |

### What can you use job posting data for?

- **Recruiting and talent mapping**: watch hiring at a list of competitors and see which teams are growing.
- **Sales prospecting**: companies hiring for a role are often buying the tools that role uses.
- **Job search apps and AI agents**: one source that covers many employers, instead of one scraper per careers site.
- **Labor market research**: track demand for a skill or a title across a sector over time.
- **Job alerts**: schedule a run with `postedAfter` and get only new roles.

### How to scrape jobs from Greenhouse, Lever, Ashby and more

1. Click **Try for free** (or **Start**) on this page and sign in to Apify.
2. Type the titles you care about in **Title keywords**, for example `data engineer`.
3. Pick companies from the built-in directory in **Companies**, or add any company's board in **Board slugs** (see [Input](#input) for where to find a slug). Leave both empty to search the whole directory of 116 companies.
4. Optionally filter on **Location**, **Remote only** or **Posted after**, and set **Max results**.
5. Click **Start**. Open the **Output** tab when the run finishes and export as JSON, CSV, Excel or XML, or read it through the API.

![The JobsRadar input form in Apify Console: title keywords, companies, board slugs and filters](https://agenttoolworks.com/apify/jobsradar-input-form.jpg)

### Input

| Field | What it does |
|---|---|
| `titleKeywords` | Keep roles whose title contains any of these, for example `["data engineer", "machine learning"]`. Empty keeps every role. |
| `companies` | Names from the built-in directory, for example `["Stripe", "Hugging Face", "Bosch"]`. Empty searches all 116. |
| `boardSlugs` | Any company's board, by the slug in its careers page URL: `[{ "slug": "acme" }]`. The ATS is detected for you; add `"provider"` to skip detection and `"company"` to set the name shown in results. |
| `location` | Keep roles whose published location contains this text, for example `London` or `Germany`. |
| `remoteOnly` | Keep only roles the board itself marks remote, rather than guessing from the location. |
| `postedAfter` | ISO date, for example `2026-09-01`. Roles published without a date are kept rather than hidden. |
| `maxResults` | Upper bound on returned postings (default 200, up to 5,000). You pay per posting returned. |

Where to find a board slug:

| ATS | Careers page URL | Slug |
|---|---|---|
| Greenhouse | `boards.greenhouse.io/acme` | `acme` |
| Lever | `jobs.lever.co/acme` | `acme` |
| Ashby | `jobs.ashbyhq.com/acme` | `acme` |
| SmartRecruiters | `jobs.smartrecruiters.com/Acme` | `Acme` |
| Workable | `apply.workable.com/acme` | `acme` |
| Personio | `acme.jobs.personio.de` | `acme` |
| Pinpoint | `acme.pinpointhq.com` | `acme` |

Example: remote engineering roles at two directory companies and one company tracked by its slug.

```json
{
  "titleKeywords": ["engineer"],
  "companies": ["Stripe", "Hugging Face"],
  "boardSlugs": [{ "slug": "anthropic", "provider": "greenhouse", "company": "Anthropic" }],
  "remoteOnly": true,
  "postedAfter": "2026-09-01",
  "maxResults": 500
}
```

### Output

![Output of a real JobsRadar run in Apify Console: title, company, location, remote, department, date, apply link and provider](https://agenttoolworks.com/apify/jobsradar-output.jpg)

A row from a real run:

```json
{
  "id": "lever:spotify:638f1177-8a2b-4b43-9363-c7056b8ef929",
  "title": "Machine Learning Engineering Manager - Music",
  "company": "Spotify",
  "location": "New York, NY",
  "remote": true,
  "department": "Engineering",
  "postedAt": "2026-09-29T17:35:39.422Z",
  "applyUrl": "https://jobs.lever.co/spotify/638f1177-8a2b-4b43-9363-c7056b8ef929",
  "provider": "lever"
}
```

The run's key-value store also holds a `SUMMARY` record, so a board that failed never silently shrinks your results:

```json
{
  "boardsSearched": 7,
  "boardsFailed": [],
  "boardsTruncated": [],
  "postingsSeen": 6007,
  "duplicatesRemoved": 713,
  "returned": 52,
  "chargeLimitReached": false
}
```

`boardsFailed` names each board that did not answer, with the reason. `boardsTruncated` names a board read in part, with how many postings it has in total.

### How much does it cost to scrape job postings?

Pay per event, no subscription, platform usage included:

| Event | Price |
|---|---|
| Posting returned | **$0.90 per 1,000 postings** ($0.0009 each) |
| Run start | $0.00005 |

Examples:

- **200 postings** (the default maximum): $0.18.
- **Apify's free plan** includes $5 of monthly usage ([apify.com/pricing](https://apify.com/pricing)), enough for about **5,500 postings** a month.
- A run whose filters match nothing costs only the start fee: postings that do not match your filters are read but never charged.

Set a maximum cost per run in the run options and the Actor stops cleanly when it is reached.

### Use JobsRadar through the Apify API

Run it and get the postings in one HTTP call (your token is in Apify Console under **Settings > API & Integrations**):

```bash
curl -X POST "https://api.apify.com/v2/acts/agenttoolworks~jobsradar-multi-board-job-search/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"titleKeywords": ["data engineer"], "companies": ["Stripe", "Spotify"], "maxResults": 100}'
```

Node.js, with the official [`apify-client`](https://docs.apify.com/api/client/js/):

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('agenttoolworks/jobsradar-multi-board-job-search').call({
    titleKeywords: ['data engineer'],
    location: 'Berlin',
    maxResults: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const job of items) console.log(job.company, job.title, job.applyUrl);
```

Python, with the official [`apify-client`](https://docs.apify.com/api/client/python/):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("agenttoolworks/jobsradar-multi-board-job-search").call(
    run_input={"titleKeywords": ["data engineer"], "remoteOnly": True, "maxResults": 100}
)
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["company"], job["title"], job["applyUrl"])
```

The **API** tab on this page has ready-made snippets for every language and endpoint.

### FAQ

#### Which companies are in the built-in directory?

116 companies across the seven systems. Type any of these names in **Companies**: 1KOMMA5°, Accor, Affirm, Airbyte, Airtable, Algolia, Amplitude, Anthropic, Asana, AssemblyAI, Blueground, BMT, Bosch, Brex, Calendly, Canva, CERN, CFC, Chainguard, CLARK, ClickHouse, Cloudflare, Cockroach Labs, Coinbase, Contentful, Databricks, Datadog, Delivery Hero, Discord, Duolingo, Elastic, Epignosis, ESSS, Experian, Fastly, Figma, Fivetran, Future plc, getquin, GitLab, GoCardless, Grasshopper Bank, Gusto, Hex, HOLOPLOT, Hugging Face, idealworks, IFS, Impulse Space, inMusic, Instacart, Intercom, Intigriti, Lattice, LearnWorlds, Linear, LinkedIn, Lyft, Marqeta, Mercury, meteocontrol, Miro, Mixpanel, Modal, MongoDB, Monzo, Neon, Netlify, Nielsen, Nothing, Notion, Okta, Orfium, ottonova, Oura, Patreon, Penta, Persado, PETER PARK, Pinpoint, Pinterest, PlanetScale, PostHog, Princess Cruises, Qonto, Ramp, Ravelin, Redis, Reverion, Robinhood, Rowden, Scale AI, Secureframe, Semgrep, Sentry, ServiceNow, Skroutz, Sodexo, Spotify, Stripe, Supabase, Swile, tado, Tailscale, Temporal, Thermondo, TP-Link Systems, Ubisoft, Unmind, Vanta, Vercel, Vivid Money, Webflow, Western Digital, Wise, Zapier.

Any other company works through **Board slugs**.

#### How do I get only new jobs every day?

Save your input as a task, set **Posted after** to a recent date, and schedule the task daily in **Schedules**. Use the stable `id` field to skip roles you have already seen.

#### How fast is it?

A run over the whole directory (116 boards) read 19,439 postings in 81 seconds and returned the 4,874 whose title contained "engineer". A handful of companies takes a few seconds.

#### Does it include jobs from aggregators like LinkedIn Jobs or Indeed?

No, by design. JobsRadar reads employers' own job boards, which is where roles are published first and where the apply link leads.

#### How large a board can it read?

SmartRecruiters boards are read 100 postings a page, up to 5,000 postings a board. A larger board is listed in `boardsTruncated` with its full count, never cut silently. The other systems return the whole board in one response.

#### Why is `postedAt` empty for some roles?

Pinpoint publishes no posting date, so it stays empty rather than guessed. Those roles are kept when you filter on **Posted after**.

#### Can I use it with Make, Zapier, n8n or Google Sheets?

Yes, through Apify's integrations: the dataset works with every Apify integration, and a webhook can fire when a run finishes.

#### Can AI agents use it through MCP?

Yes, two ways. Apify's hosted MCP server exposes it to MCP clients such as Claude or Cursor: `https://mcp.apify.com?tools=agenttoolworks/jobsradar-multi-board-job-search`. JobsRadar is also a hosted MCP server and API of its own, billed per search rather than per posting, at [agenttoolworks.com/servers/jobsradar](https://agenttoolworks.com/servers/jobsradar).

#### Is it legal to scrape job postings?

JobsRadar reads only the role listings employers chose to publish, through the public job board APIs the platforms document for career sites. It collects no candidate data.

#### Something is missing or broken?

Open an issue in the **Issues** tab. Companies asked for by users get added to the directory.

### Other Actors by AgentToolWorks

- [Store Catalog & Price Tracker](https://apify.com/agenttoolworks/shopify-woocommerce-catalog-tracker): every product of any Shopify or WooCommerce store, with variants, barcodes and stock, plus price and stock change tracking.

Built by [AgentToolWorks](https://agenttoolworks.com). Not affiliated with any of the job board platforms named here.

# Actor input Schema

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

Keep roles whose title contains any of these. Leave empty to get every open role.

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

Names from the curated directory, for example Stripe, Notion, ServiceNow, Bosch, Thermondo, Impulse Space or Hugging Face. Leave empty to search the whole directory (Greenhouse, Lever, Ashby, SmartRecruiters, Workable, Personio and Pinpoint boards).

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

Track any company by its board slug, taken from its careers page URL (boards.greenhouse.io/acme, jobs.lever.co/acme, jobs.ashbyhq.com/acme, apply.workable.com/acme, acme.jobs.personio.de, acme.pinpointhq.com, jobs.smartrecruiters.com/Acme). The applicant tracking system is detected automatically; add "provider" (greenhouse, lever, ashby, workable, personio, pinpoint or smartrecruiters) to skip detection.

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

Keep roles whose published location contains this text, for example London or Germany.

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

Keep only roles the board itself marks as remote, rather than guessing from the location.

## `postedAfter` (type: `string`):

ISO date, for example 2026-07-01. Roles published without a date are kept rather than hidden.

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

Upper bound on returned postings. You are charged per posting returned.

## Actor input object example

```json
{
  "titleKeywords": [
    "data engineer",
    "machine learning"
  ],
  "boardSlugs": [
    {
      "company": "Acme",
      "slug": "acme"
    },
    {
      "company": "Globex",
      "slug": "globex",
      "provider": "personio"
    }
  ],
  "remoteOnly": false,
  "maxResults": 200
}
```

# Actor output Schema

## `postings` (type: `string`):

No description

# 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 = {
    "titleKeywords": [
        "engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("agenttoolworks/jobsradar-multi-board-job-search").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 = { "titleKeywords": ["engineer"] }

# Run the Actor and wait for it to finish
run = client.actor("agenttoolworks/jobsradar-multi-board-job-search").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 '{
  "titleKeywords": [
    "engineer"
  ]
}' |
apify call agenttoolworks/jobsradar-multi-board-job-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,agenttoolworks/jobsradar-multi-board-job-search"
        }
    }
}
```

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/g5viLIHQBFK595oXl/builds/gGFE59AAgNiKAs0Uh/openapi.json
