# Workable.com Scraper (`lexis-solutions/workable-com-scraper`) Actor

Scrape job listings from Workable.com—positions, company details, requirements, benefits, locations, job types, departments, and salaries. Supports keyword queries, date filtering. Ideal for recruiters, HR analytics, and market research.

- **URL**: https://apify.com/lexis-solutions/workable-com-scraper.md
- **Developed by:** [Lexis Solutions](https://apify.com/lexis-solutions) (community)
- **Categories:** Jobs, Lead generation, Agents
- **Stats:** 6 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

$39.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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.com Scraper

![banner](https://i.ibb.co/6RhmjDKZ/workable.png)

Automate job data extraction from Workable.com, one of the leading job platforms used by companies worldwide. This powerful scraper collects comprehensive job listings including positions, company details, requirements, and benefits across all industries and locations. Perfect for recruiters monitoring job market trends, HR professionals analyzing hiring patterns, and researchers studying employment opportunities. Get structured data in JSON format with detailed information about job types, workplace arrangements, and company information.

👋 Welcome to the Workable.com Scraper, an actor designed to help you gather job listings from Workable.com! With this actor, you can easily search for jobs across different industries and locations worldwide.

### Use Cases

Here are some typical scenarios in which the Workable.com Scraper can be useful:

- **Job Seekers** can use the scraper to find positions matching their skills and location preferences
- **Recruiters** can use the scraper to monitor market trends and competitor job postings
- **HR Professionals** can use the scraper to analyze hiring patterns and salary ranges
- **Market Researchers** can use the scraper to study employment trends across different industries and regions

### Input 📥

To use this actor, you need to provide the following input:

- Field: **query**
  - Type: string
  - Required: Yes
  - Description: Search query for job titles, skills, or keywords
- Field: **maxItems**
  - Type: integer
  - Required: No
  - Description: Maximum number of items to scrape
  - Default: 10
- Field: **since**
  - Type: string
  - Required: No
  - Description: Filter results by date. Supports relative formats (d7, m1, y1) or absolute dates (YYYY-MM-DD)
  - Default: "m1" (past month)
  - Examples:
    - `"d7"` - Last 7 days
    - `"m1"` - Last month
    - `"y1"` - Last year
    - `"2024-01-15"` - Since January 15, 2024
- Field: **proxyConfiguration**
  - Type: object
  - Required: No
  - Description: Your proxy configuration from Apify
  - Default: Uses Apify Proxy with no specific proxy groups

### Output 📤

An example output looks like this:

```json
{
  "url": "https://apply.workable.com/coresite/j/FF99CB5CDD/",
  "searchQuery": "Project Manager",
  "searchDate": "2025-10-01T22:28:22.631Z",
  "originalTitle": "Senior Construction Project Manager (SV9) (1693) - CoreSite",
  "originalSnippet": "The Construction Senior Project Manager is responsible for overseeing all aspects of assigned capital construction projects.",
  "jobTitle": "Senior Construction Project Manager (SV9) (1693)",
  "company": "CoreSite",
  "logoUrl": "https://workablehr.s3.amazonaws.com/uploads/account/logo/373150/logo",
  "location": "Santa Clara, California, United States",
  "jobType": "Full time",
  "jobDepartment": "Construction",
  "jobWorkplace": "Hybrid",
  "salary": "$150,000 - $175,000",
  "description": "DescriptionAbout CoresiteAt CoreSite, we empower a more connected future through high-performance data centers...",
  "requirements": "RequirementsKnowledge, Skills & Abilities: Ability to thrive in a hybrid work environment...",
  "benefits": "BenefitsNot only does CoreSite have a fun, team-focused work environment...",
  "deadline": "",
  "postedDate": "2025-09-03",
  "extractedAt": "2025-10-01T22:28:50.073Z",
  "source": "workable"
}
````

### How many listings can the Workable.com Scraper extract?

The Workable.com Scraper uses pagination to extract job listings from Workable.com. You can control the number of listings to scrape by setting the `maxItems` input parameter. If you don't set the `maxItems` parameter, the scraper will extract up to 10 listings by default.

### Date Filtering 📅

The scraper supports powerful date filtering to help you find the most relevant and recent job postings:

- **Relative Date Formats**: Use `d7` for last 7 days, `m1` for last month, `y1` for last year
- **Absolute Date Formats**: Use `YYYY-MM-DD` format for specific dates (e.g., `2024-01-15`)
- **Default Behavior**: If no `since` parameter is provided, the scraper defaults to the last month (`m1`)

#### Example Usage

```json
{
  "query": "software engineer",
  "maxItems": 50,
  "since": "d7"
}
```

This will find software engineer jobs posted in the last 7 days, up to 50 results.

### Why use the Workable.com Scraper?

- ⚡️ **Fast** - The scraper efficiently handles complex job postings and company information.

- 🤙 **Easy to use** - Simply input your search criteria and let the scraper handle the complexities of job data extraction.

- 🌐 **Comprehensive** - Extracts detailed job information including descriptions, requirements, benefits, and company details.

- 📅 **Date-Filtered** - Filter results by specific time periods to find the most recent and relevant job postings.

- ☑️ **Well-Maintained** - The scraper is maintained by the Lexis Solutions team, ensuring reliable performance.

### Limitations

- The scraper will return a maximum of 1000 results per search.
- Some job postings may have limited information depending on how companies structure their listings.

### FAQ 💬

- **What is Workable.com?**

  Workable.com is a leading job platform used by companies worldwide to post job openings and manage their hiring process. It's used by startups to Fortune 500 companies.

- **How can I find jobs on Workable.com?**

  You can find jobs by visiting Workable.com and using their search function. The Workable.com scraper automates this process by extracting listings based on your specified criteria.

- **Can I use the Workable.com scraper to apply for jobs?**

  No, the Workable.com scraper is for data extraction and analysis only. It should not be used to submit applications or interact with the website directly.

- **What types of jobs can the Workable.com scraper find?**

  The scraper can find any type of job listed on Workable.com, including:

  - Full-time positions
  - Part-time jobs
  - Contract roles
  - Remote positions
  - Hybrid positions
  - Executive positions

- **How does the date filtering work?**

  The `since` parameter allows you to filter job postings by their publication date. You can use relative formats like `d7` (last 7 days), `m1` (last month), or `y1` (last year). You can also use absolute dates in `YYYY-MM-DD` format. This helps you find the most recent and relevant job opportunities.

- **What if the website changes?**

  Website changes may affect the scraper's functionality. In such cases, our team will update the scraper to maintain compatibility. We regularly monitor and maintain our scrapers to ensure reliable operation.

### Need to scrape other job platforms?

Here are some other job platform scrapers you might find useful:

- Germany 🇩🇪

  - [Arbeitsagentur Scraper](https://apify.com/lexis-solutions/bundesagentur-fur-arbeit-arbeitsagentur-scraper)

- Netherlands 🇳🇱

  - [Werk.nl Scraper](https://apify.com/lexis-solutions/werk-nl-scraper)

- United Kingdom 🇬🇧

  - [Reed.co.uk Scraper](https://apify.com/lexis-solutions/reed-co-uk-scraper)
  - [TotalJobs Scraper](https://apify.com/lexis-solutions/totaljobs-scraper)

- France 🇫🇷

  - [HelloWork Scraper](https://apify.com/lexis-solutions/hellowork-scraper)

- Switzerland 🇨🇭

  - [Jobs.ch Scraper](https://apify.com/lexis-solutions/jobs-ch-scraper)

***

👀 p.s.

Got feedback or need an extension?

Lexis Solutions is a [certified Apify Partner](https://apify.com/partners). We can help you with custom solutions or data extraction projects.

Contact us over [Email](mailto:info@lexis.solutions) or [LinkedIn](https://www.linkedin.com/company/lexis-solutions)

# Actor input Schema

## `query` (type: `string`):

The keyword(s) for the job you're looking for.

## `since` (type: `string`):

The date range for the job you're looking for.

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

The maximum number of job listings to scrape

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

Your proxy configuration from Apify

## Actor input object example

```json
{
  "query": "software engineer",
  "since": "m1",
  "maxItems": 2,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": []
  }
}
```

# 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 = {
    "query": "software engineer",
    "since": "m1"
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/workable-com-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 = {
    "query": "software engineer",
    "since": "m1",
}

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/workable-com-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 '{
  "query": "software engineer",
  "since": "m1"
}' |
apify call lexis-solutions/workable-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Workable.com Scraper",
        "description": "Scrape job listings from Workable.com—positions, company details, requirements, benefits, locations, job types, departments, and salaries. Supports keyword queries, date filtering. Ideal for recruiters, HR analytics, and market research.",
        "version": "0.0",
        "x-build-id": "C67jh1SzEBHzegTDa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lexis-solutions~workable-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lexis-solutions-workable-com-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/lexis-solutions~workable-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lexis-solutions-workable-com-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/lexis-solutions~workable-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lexis-solutions-workable-com-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",
                "required": [
                    "query",
                    "proxyConfiguration"
                ],
                "properties": {
                    "query": {
                        "title": "Query",
                        "type": "string",
                        "description": "The keyword(s) for the job you're looking for."
                    },
                    "since": {
                        "title": "Since",
                        "type": "string",
                        "description": "The date range for the job you're looking for."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "type": "integer",
                        "description": "The maximum number of job listings to scrape",
                        "default": 2
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Your proxy configuration from Apify",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": []
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```