# Workable Jobs Scraper - Global Hiring Data (`benthepythondev/workable-jobs-scraper`) Actor

Scrape jobs from jobs.workable.com with title, company, company website, location, workplace mode, employment type, descriptions and job URLs.

- **URL**: https://apify.com/benthepythondev/workable-jobs-scraper.md
- **Developed by:** [Ben](https://apify.com/benthepythondev) (community)
- **Categories:** Jobs, Business, Lead generation
- **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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

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

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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

## Workable Jobs Scraper - Global Hiring Data

Scrape jobs from **jobs.workable.com**, the public Workable job marketplace, in one run. Search by keyword and location, then export structured job listings with job title, company, company website, company profile, location, workplace mode, employment type, description, requirements, benefits and the direct application URL. Export to JSON/CSV/Excel, run on a schedule, call via API, or connect to Make, Zapier or n8n.

### What is the Workable Jobs Scraper?

Workable is one of the most widely used applicant-tracking systems for startups, SaaS companies, agencies and growing businesses. Many employers publish open roles through Workable, and jobs.workable.com aggregates those roles into a searchable public job marketplace. This actor turns that marketplace into clean data that can be used for recruiting intelligence, lead generation, talent-market research, job monitoring and workflow automation.

Unlike a browser automation actor, this scraper uses Workable's public JSON endpoint directly. That makes it fast, inexpensive and reliable for scheduled runs. It is designed to finish comfortably inside Apify's daily auto-test window and does not need a login, browser, residential proxy or paid unblocker in the tested path.

#### What data does it extract?

**Job basics:** job ID, title, department, employment type, workplace mode, language, state and featured flag.

**Company data:** company name, company ID, company website, Workable company profile URL, logo and public company description when available.

**Location data:** city, region, country and full location strings.

**Job content:** cleaned description, requirements, benefits and summary text.

**Timing:** created and updated timestamps from Workable.

**Source fields:** direct job URL, search query and search location.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `queries` | array | Keywords to search on jobs.workable.com, such as `python`, `sales`, `marketing` or `data engineer`. |
| `locations` | array | Optional location filters. Leave empty for global results. |
| `maxResults` | integer | Maximum jobs to return across all searches. |
| `maxPages` | integer | Maximum API pages to fetch per query/location pair. |

#### Example input

```json
{
  "queries": ["python", "sales"],
  "locations": ["United States", ""],
  "maxResults": 50,
  "maxPages": 2
}
````

### Output

Each job is pushed as one dataset item.

```json
{
  "id": "e4eb6b3e-8d6e-4973-a085-305e38952fce",
  "title": "Python Developer",
  "company": "Neostella",
  "company_website": "https://www.neostella.com/",
  "company_profile_url": "https://jobs.workable.com/company/...",
  "company_logo": "https://workablehr.s3.amazonaws.com/...",
  "department": "Research & Development",
  "employment_type": "Full-time",
  "workplace": "hybrid",
  "city": "Milwaukee",
  "region": "Wisconsin",
  "country": "United States",
  "locations": ["Milwaukee, Wisconsin, United States"],
  "url": "https://jobs.workable.com/view/...",
  "created_at": "2026-06-30T18:23:10.000Z",
  "updated_at": "2026-07-01T09:14:55.000Z",
  "description": "Who We Are: Every industry has a moment...",
  "requirements": "Write high-quality production-ready code...",
  "benefits": "Competitive benefits and growth opportunities...",
  "search_query": "python",
  "search_location": "United States"
}
```

### Use cases

**Recruiting intelligence:** Monitor hiring activity from companies that use Workable, including company websites and job profile links.

**Lead generation:** Find companies currently hiring for specific roles and enrich them through their company website, location and hiring department.

**Market research:** Track demand for skills, locations, remote/hybrid roles, departments and employment types across thousands of Workable postings.

**Job-board automation:** Feed fresh Workable jobs into a niche job board, spreadsheet, database, CRM or notification workflow.

**Competitive hiring analysis:** Watch competitors, industries or regions for new hiring patterns and team expansion signals.

### FAQ

**Do I need a Workable account?** No. The actor reads public jobs from jobs.workable.com and does not require login credentials.

**Does it scrape individual company career pages?** This version searches Workable's public marketplace. It does not require a company subdomain list.

**Can I search multiple keywords?** Yes. Add multiple values to `queries`, and the actor will run each search.

**Can I filter by location?** Yes. Add one or more location strings, or leave the location empty for global results.

**Does it support pagination?** Yes. The actor uses Workable's next-page token and respects `maxPages` and `maxResults`.

**Does it include company websites?** Often yes. Workable exposes a company website field for many postings, which is useful for lead generation and enrichment.

**Why are some fields null?** Employers control how much data they publish. Some jobs may not include benefits, requirements, company descriptions or logos.

**Is it legal to scrape Workable jobs?** Use public job data responsibly, follow applicable laws and Workable's terms, and avoid spam or unlawful outreach. For compliance-sensitive workflows, consult your legal team.

**Can I schedule it?** Yes. Run it daily or hourly on Apify to keep a fresh hiring dataset.

### You might also like

- [Greenhouse Jobs Scraper](https://apify.com/benthepythondev/greenhouse-jobs-scraper) for Greenhouse-hosted career pages.
- [Lever Jobs Scraper](https://apify.com/benthepythondev/lever-jobs-scraper) for Lever-hosted job boards.
- [ATS Jobs Aggregator](https://apify.com/benthepythondev/ats-jobs-aggregator) for multiple ATS sources in one actor.
- [StepStone Scraper](https://apify.com/benthepythondev/stepstone-scraper) for European job listings.

**Keywords:** Workable scraper, Workable jobs scraper, Workable API, jobs.workable.com scraper, ATS jobs scraper, applicant tracking system jobs, recruiting intelligence, job lead generation, hiring data, company hiring signals, startup jobs scraper, SaaS jobs scraper, remote jobs data, Workable job board, Apify Workable scraper

### Support and feedback

If this Actor saves time in your workflow, please leave a short Apify Store review. Reviews help other users evaluate the tool and help prioritize maintenance. If a source changes or a field stops populating, open an Actor issue with the run ID, public input, and expected field. Never include passwords, private cookies, or confidential data.

### Building a repeatable Workable hiring monitor

For recurring research, start with a small list of target employers and schedule one run per day. Store the job ID and canonical URL as the durable keys, compare each new dataset with the previous snapshot, and send only newly observed roles to a spreadsheet, Slack channel, or CRM. Keep employer, department, workplace type, location, and employment type as separate columns so analysts can filter without reparsing descriptions. A posting is a public hiring signal, not proof that a company has approved outreach, so combine it only with lawful business-contact sources and apply appropriate suppression rules. Small, frequent runs are easier to audit, cost less, and make source changes visible sooner than infrequent bulk exports.

# Actor input Schema

## `queries` (type: `array`):

Job keywords to search on jobs.workable.com.

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

Optional location filters. Leave empty for global jobs.

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

Maximum jobs to return across all queries and locations.

## `maxPages` (type: `integer`):

Maximum API pages to fetch for each query/location pair.

## Actor input object example

```json
{
  "queries": [
    "python"
  ],
  "locations": [
    ""
  ],
  "maxResults": 10,
  "maxPages": 1
}
```

# Actor output Schema

## `results` (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 = {
    "queries": [
        "python"
    ],
    "locations": [
        ""
    ],
    "maxResults": 10,
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/workable-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 = {
    "queries": ["python"],
    "locations": [""],
    "maxResults": 10,
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/workable-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 '{
  "queries": [
    "python"
  ],
  "locations": [
    ""
  ],
  "maxResults": 10,
  "maxPages": 1
}' |
apify call benthepythondev/workable-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Workable Jobs Scraper - Global Hiring Data",
        "description": "Scrape jobs from jobs.workable.com with title, company, company website, location, workplace mode, employment type, descriptions and job URLs.",
        "version": "1.0",
        "x-build-id": "gFNrZWyueA3tg0srY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~workable-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-workable-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/benthepythondev~workable-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-workable-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/benthepythondev~workable-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-workable-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Job keywords to search on jobs.workable.com.",
                        "default": [
                            "python"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional location filters. Leave empty for global jobs.",
                        "default": [
                            ""
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum jobs to return across all queries and locations.",
                        "default": 10
                    },
                    "maxPages": {
                        "title": "Max pages per search",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum API pages to fetch for each query/location pair.",
                        "default": 3
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
