# Workable Jobs Scraper (`automation-lab/workable-jobs-scraper`) Actor

Scrape public Jobs by Workable listings by keyword and location. Export job, company, location, workplace, salary, and description data.

- **URL**: https://apify.com/automation-lab/workable-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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/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.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 Jobs Scraper

Scrape public job listings from Jobs by Workable by keyword and location. Export job titles, company details, locations, workplace mode, descriptions, requirements, benefits, salary snippets, and timestamps in a clean dataset.

### What does Workable Jobs Scraper do?

Workable Jobs Scraper collects public listings from `jobs.workable.com` search results.

It is built for repeatable monitoring of companies and roles that are hiring through Workable-powered job boards.

Typical runs start with a keyword such as `sales`, `engineer`, `marketing`, or `customer success` and a location such as `United States`, `London`, `Remote`, or `Canada`.

The actor saves one dataset row per job listing.

Each row includes the job URL, title, company, company website, locations, employment type, workplace mode, description text, requirements, benefits, and useful metadata.

### Who is it for?

Recruiters can use it to track companies hiring for specific roles.

Lead generation teams can find companies that are actively expanding departments.

Sales teams can discover hiring signals that indicate growth, budget, and operational change.

Labor-market analysts can monitor demand by role and geography.

Competitive intelligence teams can track hiring activity across Workable customers.

Job board operators can collect public market data for enrichment and benchmarking.

### Why use this actor?

Jobs by Workable exposes many public jobs across companies, but manual search is slow.

This actor turns those public search results into structured data that can be exported to JSON, CSV, Excel, Google Sheets, databases, or webhooks.

It is HTTP-first and lightweight, so small monitoring runs are fast and inexpensive.

It also preserves useful Workable-specific fields that generic search scrapers often miss.

### What data can it extract?

The dataset focuses on job listings and company context.

| Field | Description |
| --- | --- |
| `jobId` | Workable job identifier |
| `title` | Job title |
| `url` | Public Workable job URL |
| `companyName` | Hiring company name |
| `companyWebsite` | Company website when available |
| `locations` | Workable locations array |
| `workplace` | Remote, hybrid, or on-site indicator when available |
| `employmentType` | Full-time, part-time, contract, or similar value |
| `descriptionText` | Cleaned job description |
| `requirementsText` | Cleaned requirements section |
| `benefitsText` | Cleaned benefits section |
| `salaryText` | Salary snippet detected in text when present |

### How much does it cost to scrape Workable jobs?

This actor uses pay-per-event pricing.

You pay a small start charge for each run and a per-result charge for every job listing saved.

The default prefill collects only 20 jobs so you can test cheaply before increasing the limit.

For production monitoring, set `maxResults` to the number of Workable jobs you need for your workflow.

### How to use Workable Jobs Scraper

1. Open the actor on Apify.
2. Enter a job keyword in **Job keyword**.
3. Enter a location in **Location**.
4. Keep **Maximum jobs** low for your first test.
5. Run the actor.
6. Open the dataset tab.
7. Export the results in your preferred format.

### Input options

`query` is the role, skill, company, or keyword you want to search.

`location` is the location filter used by Jobs by Workable.

`maxResults` controls how many jobs are saved.

`includeDescriptionHtml` adds raw HTML descriptions for users who need links or formatting.

`maxRequestRetries` controls retries for temporary network or Workable API errors.

### Example input

```json
{
  "query": "sales",
  "location": "United States",
  "maxResults": 20,
  "includeDescriptionHtml": false,
  "maxRequestRetries": 3
}
````

### Output example

```json
{
  "jobId": "8539378a-f892-4028-bf1e-36d840a1ba52",
  "title": "B2B Sales Executive - Outside Sales",
  "url": "https://jobs.workable.com/view/...",
  "companyName": "City Wide Facility Solutions",
  "companyWebsite": "https://gocitywide.com/",
  "locations": ["Fort Walton Beach, Florida, United States"],
  "workplace": "hybrid",
  "isRemote": false,
  "employmentType": "Full-time",
  "salaryText": "$35,000 - $45,000",
  "sourceQuery": "sales",
  "sourceLocation": "United States"
}
```

### Tips for better results

Use broad keywords when you want market coverage.

Use specific keywords when you want precise lead lists.

Try `Remote` as a location if you want remote roles.

Run the actor on a schedule to monitor new hiring signals.

Enable HTML descriptions only when you need formatted job content.

### Common use cases

📌 Build a list of companies hiring salespeople.

📌 Track engineering roles by country.

📌 Monitor remote jobs from Workable customers.

📌 Enrich CRM accounts with hiring signals.

📌 Compare hiring activity across job categories.

📌 Feed labor-market dashboards with public Workable listings.

### Integrations

Send new Workable jobs to Google Sheets for recruiter review.

Push results to a CRM as hiring-intent signals.

Use webhooks to trigger enrichment when new jobs appear.

Store recurring outputs in a database for historical trend analysis.

Connect the dataset to BI tools for role and location dashboards.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/workable-jobs-scraper').call({
  query: 'sales',
  location: 'United States',
  maxResults: 20
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/workable-jobs-scraper').call(run_input={
    'query': 'sales',
    'location': 'United States',
    'maxResults': 20,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~workable-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"sales","location":"United States","maxResults":20}'
```

### MCP usage

Use this actor through Apify MCP when you want an AI assistant to collect fresh Workable jobs.

MCP server URL:

```text
https://mcp.apify.com/?tools=automation-lab/workable-jobs-scraper
```

Claude Code setup:

```bash
claude mcp add apify-workable-jobs "https://mcp.apify.com/?tools=automation-lab/workable-jobs-scraper"
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-workable-jobs": {
      "url": "https://mcp.apify.com/?tools=automation-lab/workable-jobs-scraper"
    }
  }
}
```

Example prompts:

- "Find 20 remote customer success jobs on Workable and summarize the companies."
- "Collect sales jobs in the United States from Workable and return companies with websites."
- "Monitor engineering jobs in Berlin from Workable and highlight remote roles."

### Scheduling

You can schedule the actor daily, weekly, or hourly depending on your monitoring needs.

For lead generation, a daily schedule is usually enough.

For fast-moving hiring categories, run more frequently with a focused query and location.

### Data quality notes

The actor returns public data available from Jobs by Workable.

Some companies provide richer descriptions than others.

Salary is detected from text and may be missing if the employer does not publish compensation.

Company websites and logos are included when Workable returns them.

### Limitations

The actor does not log in to private Workable accounts.

It does not apply to jobs or contact candidates.

It does not guarantee that every job has salary, requirements, or benefits sections.

It collects public search results only.

### Legality

This actor is designed to collect publicly available job listing data.

You are responsible for using the data in accordance with applicable laws, platform terms, and privacy obligations.

Avoid using scraped data for spam or discriminatory hiring practices.

### Troubleshooting

If you get fewer jobs than expected, try a broader keyword or location.

If salary is empty, the employer probably did not publish a salary in the listing text.

If a run times out, lower `maxResults` or narrow your query.

If HTML output is too large for your workflow, keep `includeDescriptionHtml` disabled.

### FAQ

#### Can I scrape remote Workable jobs?

Yes. Use `Remote` as the location or use a keyword plus a broad location and filter the `isRemote` field.

#### Does it include company websites?

Yes, when Workable returns a company website in the public job data.

#### Can I run it on a schedule?

Yes. Apify schedules work well for recurring hiring-signal monitoring.

#### Does it scrape private jobs?

No. It only collects public Jobs by Workable search results.

### Related scrapers

Explore related actors from automation-lab for recruiting and market intelligence workflows:

- https://apify.com/automation-lab/google-search-scraper
- https://apify.com/automation-lab/indeed-scraper
- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/company-enrichment-scraper
- https://apify.com/automation-lab/apify-store-analyzer

### Changelog

Initial version extracts public Workable job listings by keyword and location with company enrichment and cleaned text fields.

# Actor input Schema

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

Keyword, role, skill, or company term to search on Jobs by Workable.

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

Location filter, for example United States, London, Berlin, Remote, or Canada.

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

Maximum number of job listings to save. Keep this low for your first run, then increase for production monitoring.

## `includeDescriptionHtml` (type: `boolean`):

Save raw HTML for job descriptions in addition to cleaned text. Useful if you need links or formatting.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for temporary Workable API/network failures.

## Actor input object example

```json
{
  "query": "sales",
  "location": "United States",
  "maxResults": 20,
  "includeDescriptionHtml": false,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (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 = {
    "query": "sales",
    "location": "United States",
    "maxResults": 20,
    "includeDescriptionHtml": false,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "query": "sales",
    "location": "United States",
    "maxResults": 20,
    "includeDescriptionHtml": False,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "query": "sales",
  "location": "United States",
  "maxResults": 20,
  "includeDescriptionHtml": false,
  "maxRequestRetries": 3
}' |
apify call automation-lab/workable-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Workable Jobs Scraper",
        "description": "Scrape public Jobs by Workable listings by keyword and location. Export job, company, location, workplace, salary, and description data.",
        "version": "0.1",
        "x-build-id": "8eDwtpcA5fcy3ZPs9"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~workable-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~workable-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~workable-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": {
                    "query": {
                        "title": "Job keyword",
                        "type": "string",
                        "description": "Keyword, role, skill, or company term to search on Jobs by Workable.",
                        "default": "sales"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location filter, for example United States, London, Berlin, Remote, or Canada.",
                        "default": "United States"
                    },
                    "maxResults": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of job listings to save. Keep this low for your first run, then increase for production monitoring.",
                        "default": 50
                    },
                    "includeDescriptionHtml": {
                        "title": "Include description HTML",
                        "type": "boolean",
                        "description": "Save raw HTML for job descriptions in addition to cleaned text. Useful if you need links or formatting.",
                        "default": false
                    },
                    "maxRequestRetries": {
                        "title": "Maximum request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for temporary Workable API/network failures.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
