# Workable Jobs: Search Every Workable Employer (`deepmine/workable-jobs`) Actor

Search open jobs across every company hiring on Workable (jobs.workable.com) by keyword and location, or export any company's Workable board. Get title, company, logo, location, remote or hybrid, job type, department, posting time, full description and job link. No login.

- **URL**: https://apify.com/deepmine/workable-jobs.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.35 / 1,000 jobs

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

## Workable Jobs: Search Every Workable Employer

Search Workable jobs from every company hiring on Workable: type a job title or keyword and a place, and get one clean row per job with the company logo, title, company, location, remote or hybrid, job type, department, posting time, full description and the job link.

| 💼 Title | 🏢 Company | 📍 Location | 🏠 Workplace | 🕒 Job Type | 📅 Posted |
|---|---|---|---|---|---|
| Digital Delivery Manager/ Data Analyst - Federal Sector | Procon Consulting | Las Vegas, Nevada, United States | On-site | Full-time | 2026-09-09 |
| Data Analyst, BI Developer | Sand Cherry Associates | United States | Remote | Contract | 2026-09-08 |
| Product Manager | GaggleAMP Inc. | Seattle, Washington, United States (+4 places) | Remote | Full-time | 2026-09-25 |

<sub>Collected 2026-09-28.</sub>

**$0.49 per 1,000 jobs** on the Starter plan ($0.59 Free, $0.39 Scale, $0.35 Business). The prefilled run (100 jobs: 50 for each of 2 searches in the United States) costs about $0.05.

A Workable job scraper with no setup: it searches Workable's public job board (jobs.workable.com), which lists the open jobs of the companies that hire with Workable, about 170,000 jobs on 2026-09-27. No browser and no login. Every run reads the jobs live.

### What you can do with it

- **Find jobs by role and place** across thousands of small and mid-size employers, many of which never post on the big job boards.
- **Feed a job board or an alert service**: schedule a daily run with `postedWithinDays` set to 1 and get each day's new jobs.
- **Build sales signals**: companies hiring a "data engineer" or "office manager" right now are leads.
- **Export one company's Workable board**: add its board URL under ➕ Company boards.

### Input

```json
{
  "searchTerms": ["data analyst", "product manager"],
  "locations": ["United States"],
  "remoteOnly": false,
  "postedWithinDays": 7,
  "maxJobsPerSearch": 100,
  "maxResults": 1000
}
```

| Field | What it does |
|---|---|
| `searchTerms` | Job titles or keywords, one per line. Each one searches every company on Workable, like the search box on jobs.workable.com. |
| `locations` | Places to search in: a city, region or country (`London`, `Germany`), or a two-letter country code (`US`, `GB`). Each search runs once per place. Empty = everywhere. |
| `remoteOnly` | Keep only jobs the company marks as remote. |
| `postedWithinDays` | Keep only jobs posted in the last N days (0 = any date). |
| `maxJobsPerSearch` | Each search's jobs per place, most relevant first, up to this many (default 100; 0 = all). You pay per job, so this caps the cost per search. With title keywords or other filters, a search stops after 10 pages in a row (200 results) where no job passes them: put the words in the search term instead. |
| `maxResults` | Stop after this many jobs in total, which caps the run's cost. |
| `titleKeywords` | Under **🎛️ Filters**: keep only jobs whose title contains any of these words. Workable's search also matches descriptions; this narrows it to titles. |
| `companies` | Under **➕ Company boards**: also export every job of these companies, e.g. `https://apply.workable.com/huggingface/`. Board URLs from Greenhouse, Lever, Ashby, SmartRecruiters, Workday, BambooHR, Recruitee, Personio, Teamtailor, Breezy HR and Rippling work too. Delivered before the searches. |
| `maxJobsPerCompany` | Under **➕ Company boards**: each company's newest jobs, up to this many (default 100). |
| `includeDescription` | Full description as text, requirements and benefits included (on by default). |
| `includeHtml` | Also the description with its original HTML formatting (`descriptionHtml`). |

### Output

One row per job, in the order of your searches, each search's jobs in Workable's ranking (most relevant first). Workable lists a job offered in several places once per place; this Actor merges them into one row with every place in `locations`, so you pay once. A job that two of your searches find is delivered once, with the first search.

Dataset **💼 All Jobs**. Views: **📊 Overview** (🖼️ Logo, 💼 Title, 🏢 Company, 📍 Location, 🏠 Workplace, 🕒 Job Type, 🗂️ Department, 💰 Salary, 📅 Posted, 🔗 Job Page) and **📝 Details** (💼 Title, 🏢 Company, 🕒 Job Type, 🗂️ Department, 🗺️ All Locations, 🌍 Country, ⚙️ ATS, 📋 Job Board, 🆔 Job ID, 🔗 Job Page). A second dataset, **💰 With Salary**, holds the delivered jobs with a pay range: search jobs whose description names one (about 4 in 10 in our example run) and jobs from company boards that publish pay.

#### Output fields

In row order:

- `companyLogo`: the company's logo on Workable (a stable image link). Empty when the company has none (about 1 in 8 jobs).
- `title`: job title.
- `company`: company name.
- `location`: the job's first place, as Workable writes it (`New York, New York, United States`).
- `workplaceType`: `Remote`, `Hybrid` or `On-site`.
- `employmentType`: `Full-time`, `Part-time`, `Contract`, `Internship`, `Temporary` or `Other`. Empty when the company doesn't say.
- `department`: department the company files the job under.
- `salary`: the pay range. Workable has no pay field, so it's read from the description when one names a range ("Salary estimates for this job range from $85,000 - $184,000" gives `USD 85,000 - 184,000 per year`); empty otherwise.
- `salaryMin`: lowest published pay, as a number (same as `salary`).
- `salaryMax`: highest published pay, as a number (same as `salary`).
- `salaryCurrency`: ISO currency code (same as `salary`).
- `salaryPeriod`: `year`, `month`, `week`, `day` or `hour` (same as `salary`).
- `postedAt`: when the job was published, in UTC (`2026-09-24T02:01:43Z`).
- `jobUrl`: the job's page on jobs.workable.com.
- `applyUrl`: a separate application page. Empty for searched jobs, where you apply on the job page.
- `locations`: every place the job is offered, as a list.
- `countryCode`: ISO code of the job's country, e.g. `US`.
- `description`: the full job description as plain text, requirements and benefits included. Only with `includeDescription` (on by default).
- `descriptionHtml`: the description with the company's formatting. Only with `includeHtml`.
- `ats`: the hiring system, `Workable` for searched jobs.
- `boardUrl`: the company's page on jobs.workable.com (or the company board you gave).
- `jobId`: the job's id on Workable (for a job in several places, the first place's id).
- `companyInput`: the search term (or company entry) that found this job.
- `scrapedAt`: when this run read the job (UTC).

Example row (description shortened):

```json
{
  "companyLogo": "https://workablehr.s3.amazonaws.com/uploads/account/logo/523772/logo",
  "title": "Data Analyst, BI Developer",
  "company": "Sand Cherry Associates",
  "location": "United States",
  "workplaceType": "Remote",
  "employmentType": "Contract",
  "department": "Data",
  "salary": null,
  "salaryMin": null,
  "salaryMax": null,
  "salaryCurrency": null,
  "salaryPeriod": null,
  "postedAt": "2026-09-08T20:33:31Z",
  "jobUrl": "https://jobs.workable.com/view/hMJF4opSq696fs3CDLgRFR/remote-data-analyst%2C-bi-developer-in-united-states-at-sand-cherry-associates",
  "applyUrl": null,
  "locations": ["United States"],
  "countryCode": "US",
  "description": "Overview\n\nWe are seeking a Data Analyst, BI Developer with exceptional expertise...",
  "ats": "Workable",
  "boardUrl": "https://jobs.workable.com/company/qbMJp8vh5NCTWuSqfKpgLi/jobs-at-sand-cherry-associates",
  "jobId": "87f4fc94-6940-4a7c-8980-69db3a513423",
  "companyInput": "data analyst",
  "scrapedAt": "2026-09-28T02:42:11Z"
}
```

The run's **🧾 Run summary** (the OUTPUT record in the key-value store) shows, per search, how many jobs Workable counted, how many were read and delivered, and how many were skipped as already delivered by an earlier search.

### When something goes wrong

- If Workable's search can't be read after several retries on fresh IPs, the run ends as **failed** with the reason, so you notice. The jobs read before that are still in the dataset.
- A search with no match ends as succeeded with 0 jobs, and the status message says so.
- When `maxResults` is reached, the searches after that point get nothing; the run summary marks them as skipped.

### Pricing

You pay per job delivered: $0.59 per 1,000 jobs on the Free plan, $0.49 on Starter, $0.39 on Scale and $0.35 on Business. Descriptions are included at the same price. Searches, jobs removed by your filters and jobs merged or skipped as duplicates cost nothing.

Examples on Starter: the prefilled run (100 jobs) about $0.05; the default `maxResults` of 1,000 jobs $0.49. `maxJobsPerSearch` and `maxResults` cap what a run can cost.

### FAQ

**Do I need a proxy?** The default Apify datacenter proxy is all Workable needs. Residential and SERP proxies are replaced with datacenter; your own proxy URLs work too.

**How many jobs can a search return?** Every job Workable finds for it: set `maxJobsPerSearch` to 0. A broad term like `engineer` can match tens of thousands, so keep `maxResults` in mind.

**Why do some jobs have no salary?** Workable has no pay field. When the description names a range, it fills `salary`, `salaryMin` and `salaryMax`; many postings name none.

**Can I get new jobs every day?** Yes: save your input as a task, schedule it daily, and set `postedWithinDays` to 1.

### Feedback

Missing a field, a filter or a place? Open an issue on the Issues tab and we'll look at it. If the data helped you, a short review on this page helps other people find it.

# Actor input Schema

## `searchTerms` (type: `array`):

Job titles or keywords, one per line, e.g. data analyst, registered nurse. Each searches every Workable employer; a job two searches find comes once.

## `locations` (type: `array`):

Places to search in, e.g. London, Germany, or a country code (US, GB). Each search runs once per place. Empty = everywhere.

## `maxJobsPerSearch` (type: `integer`):

Each search's most relevant jobs per place, up to this many. You pay per job, so this caps the cost per search. 0 = every job found.

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

Stop after this many jobs in total, delivered in the order of your inputs. You pay per job, so this caps the run's cost.

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

Adds the full description as plain text, at the same price. Requirements and benefits included.

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

Keep only jobs the company marks as remote, or whose location says Remote.

## `postedWithinDays` (type: `integer`):

Keep jobs posted in the last N days, e.g. 7 for a weekly scheduled run. 0 = any date.

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

Keep jobs whose title contains any of these words or phrases, e.g. engineer, sales manager. Not case-sensitive. Empty = every job.

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

Also every job of these companies: a Workable board (https://apply.workable.com/huggingface/) or a name. Other hiring systems work too. Delivered before the searches.

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

Each company's newest jobs, up to this many. You pay per job, so this caps the cost per company. 0 = every job.

## `includeHtml` (type: `boolean`):

Adds descriptionHtml with the company's own formatting. Same price. Needs job descriptions on.

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

Leave as is: Apify datacenter proxies are all these job boards need. Residential and SERP proxies are replaced with datacenter (they cost more and add nothing here); your own proxy URLs work too.

## Actor input object example

```json
{
  "searchTerms": [
    "data analyst",
    "product manager"
  ],
  "locations": [
    "United States"
  ],
  "maxJobsPerSearch": 50,
  "maxResults": 1000,
  "includeDescription": true,
  "remoteOnly": false,
  "postedWithinDays": 0,
  "maxJobsPerCompany": 100,
  "includeHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `withSalaryUrl` (type: `string`):

No description

## `summary` (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 = {
    "searchTerms": [
        "data analyst",
        "product manager"
    ],
    "locations": [
        "United States"
    ],
    "maxJobsPerSearch": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/workable-jobs").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 = {
    "searchTerms": [
        "data analyst",
        "product manager",
    ],
    "locations": ["United States"],
    "maxJobsPerSearch": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("deepmine/workable-jobs").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 '{
  "searchTerms": [
    "data analyst",
    "product manager"
  ],
  "locations": [
    "United States"
  ],
  "maxJobsPerSearch": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call deepmine/workable-jobs --silent --output-dataset

```

## MCP server setup

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

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/VNJ1PQgSVZanXvrpL/builds/I7x7y7QwWKnGN0rxI/openapi.json