# Workable Jobs Scraper (`schnellscrapers/workable-jobs-scraper`) Actor
Pull every active Workable job — search 170k+ postings across all Workable customers, or grab every job from one Workable company in one run. Returns titles, locations, departments, employment type, full HTML descriptions, and apply URLs.
- **URL**: https://apify.com/schnellscrapers/workable-jobs-scraper.md
- **Developed by:** [Nate Schnell](https://apify.com/schnellscrapers) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet
## Pricing
$0.90 / 1,000 jobs
This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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
### What does Workable Jobs Scraper do?
Workable Jobs Scraper pulls every active job from the Workable ATS — either by **searching across all Workable customers** (170,000+ active postings on Workable's own meta-search at `jobs.workable.com`) or by **pulling every job from a specific Workable-hosted company** (via `apply.workable.com/{slug}`). Paste a search query, one or many company slugs, or both — the actor returns a clean, structured record per posting straight from Workable's public JSON endpoints. No headless browser, no proxy, no rendered HTML to fight with.
Built for talent-intelligence teams, ATS-aggregator job boards, sourcing tools, hiring-velocity dashboards, recruiter prospecting, and anyone who needs Workable job data without writing a paginator or stitching two endpoints by hand.
### What data can you extract from Workable?
- **Identity** — `id` (composite, stable across runs), `uuid` (Workable's internal UUID for search-mode records), `shortcode`, `code` (employer-set reference)
- **Title** — `title`
- **Company** — `companyName`, `companySlug` (apply.workable.com slug), `companyId` (Workable UUID), `companyWebsite`
- **Taxonomy** — `department`, `function`, `industry`, `employmentType`, `experienceLevel`, `education`
- **Workplace** — `workplace` (`remote` / `hybrid` / `on_site`), convenience `isRemote` boolean, `language`
- **Location** — primary `location` (country, countryCode, city, region, fullLocation) plus a `locations` array for multi-location postings
- **URLs** — `url` (public listing page), `shortlink`, `applyUrl`, optional `linkoutUrl` (employer redirect, when present)
- **Timing** — `publishedAt`, `createdAt`, `updatedAt`
- **Flags** — `isFeatured`
- **Description** — `descriptionHtml`, `requirementsHtml`, `benefitsHtml` (kept separate by default); optional combined `descriptionHtml` and plain-text `descriptionText` for embeddings / LLM ingestion
- **Social** — `socialSharingDescription`
- **Provenance** — `scrapedAt`, `source`
35 fields per posting, all named and typed in the [dataset schema](#output).
### How to use Workable Jobs Scraper
1. **Sign in to Apify** ([create a free account](https://console.apify.com/sign-up) if you don't have one — Apify's free tier covers most experiments).
2. **Open the actor** and click **Try for free**.
3. **Pick a mode** (or combine both):
- **Search mode** — set `query`, `location`, `workplace`, `employmentType`, and/or `dayRange`. Returns matching jobs across every company on Workable.
- **Per-company mode** — paste apply.workable.com slugs into `companies` (e.g. `allucent`, `northramp`, `same-day-water-heaters`). The actor pulls every active job at each slug.
4. **(Optional) Apply filters.** Client-side: `titleFilter`, `titleExcludeFilter`, `departmentFilter`, `functionFilter`, `industryFilter`, `experienceLevels`, `countryFilter`, `remoteOnly`, `postedAfter`, `descriptionContains`.
5. **(Optional)** Toggle `includeDescription` off if you only need titles + metadata (per-company mode then uses a leaner payload, ~10× smaller). Toggle `parseDescription` on for a plain-text `descriptionText` field. Toggle `combineDescription` to stitch description + requirements + benefits into one HTML body.
6. **Click Run.** Results stream into the dataset as they're scraped.
7. **Download** as JSON, JSONL, CSV, Excel, XML, or fetch via the Apify dataset API.
### How much does it cost?
**$1 per 1,000 job postings** ($0.001 per posting) plus a small **$0.005 actor-start fee**. Pay only for postings the actor emits to the dataset — failed company slugs, filtered-out jobs, and out-of-range dates cost nothing. The actor uses public Workable endpoints directly with no proxy, so **there are no proxy charges and no per-CPU-second charges**; the per-record price covers the whole compute.
A search run for "remote engineer" capped at 200 records → **$0.205** ($0.005 start + 200 × $0.001). A multi-company run of 5 Workable companies averaging 25 jobs each → 125 records → **$0.13**. Enabling `includeDescription` (default ON) is already baked into the per-record price.
Apify's $5 monthly free tier covers about 5,000 postings of trial use.
### Input
The actor takes **no required fields** — supply either search params (`query`, `location`, `workplace`, `employmentType`, `dayRange`) or per-company slugs (`companies`), or combine them. Client-side filters narrow the output (and the bill, since you pay per emitted record). `maxItems`, `maxItemsPerCompany`, and `maxItemsPerSearch` cap output for cost-bounded test runs.
```json
{
"query": "software engineer",
"workplace": "remote",
"dayRange": 14,
"companies": ["allucent", "northramp"],
"titleExcludeFilter": ["senior", "principal"],
"countryFilter": ["United States", "United Kingdom"],
"postedAfter": "2026-04-01",
"includeDescription": true,
"parseDescription": true,
"maxItems": 500
}
````
### Output
One record per active Workable posting. Every field is typed in the dataset schema — open the **Output** tab on the actor page for the full column list, then export to JSON / CSV / Excel / XML. Below is a real per-company record (description truncated):
```json
{
"id": "allucent:52D18CB3E4",
"uuid": null,
"shortcode": "52D18CB3E4",
"code": null,
"title": "Associate Director/Director, Pharmacometrician",
"companyName": "Allucent",
"companySlug": "allucent",
"companyId": null,
"companyWebsite": null,
"department": "Product Development Strategy (PDS)",
"function": "Research",
"industry": "Biotechnology",
"employmentType": "Full-time",
"experienceLevel": "Director",
"education": null,
"workplace": "remote",
"isRemote": true,
"language": null,
"location": {
"country": "United States",
"countryCode": null,
"city": null,
"region": null,
"fullLocation": "United States"
},
"locations": [
{ "country": "United States", "countryCode": "US", "city": null, "region": null, "hidden": false }
],
"url": "https://apply.workable.com/j/52D18CB3E4",
"shortlink": "https://apply.workable.com/j/52D18CB3E4",
"applyUrl": "https://apply.workable.com/j/52D18CB3E4/apply",
"linkoutUrl": null,
"publishedAt": "2026-05-06",
"createdAt": "2026-05-04",
"updatedAt": null,
"isFeatured": null,
"descriptionHtml": "Associate Director/Director, Pharmacometrician
Step into a role where science meets strategy…
",
"requirementsHtml": null,
"benefitsHtml": null,
"descriptionText": "Associate Director/Director, Pharmacometrician\n\nStep into a role where science meets strategy…",
"socialSharingDescription": null,
"scrapedAt": "2026-05-22T15:30:00.000Z",
"source": "https://apply.workable.com/api/v1/widget/accounts/allucent?details=true"
}
```
Search-mode records use the same shape but populate `uuid`, `companyId`, `requirementsHtml`, `benefitsHtml`, `language`, `isFeatured`, `socialSharingDescription`, and `updatedAt` (which the per-company widget doesn't expose). The `id` is `wk:` for search-mode records, `:` for per-company records — both are stable across runs so you can dedupe on `id` into your warehouse.
### Integrations
Use the actor's results in Make, n8n, Zapier, LangChain, LlamaIndex, your own pipelines via the [Apify API](https://docs.apify.com/api/v2), or wire up webhooks to fire whenever a run finishes. Schedule daily / hourly pulls with [Apify Scheduler](https://docs.apify.com/platform/schedules) and dedupe into your warehouse on the stable `id` field.
### Related actors
- [Greenhouse Jobs Scraper](https://apify.com/schnellscrapers/greenhouse-jobs-scraper) — same shape, same author, for any Greenhouse-hosted careers board.
- [Lever Jobs Scraper](https://apify.com/schnellscrapers/lever-jobs-scraper) — for any Lever-hosted careers board.
- [Ashby Jobs Scraper](https://apify.com/schnellscrapers/ashby-jobs-scraper) — for any Ashby-hosted careers board.
- [SmartRecruiters Jobs Scraper](https://apify.com/schnellscrapers/smartrecruiters-jobs-scraper) — for any SmartRecruiters careers page.
- [Indeed Jobs Scraper](https://apify.com/schnellscrapers/indeed-jobs-scraper) — when you need open-market job-board coverage on top of direct-from-employer ATS data.
Combine any two to cover both ATSes in one warehouse table — every actor in this family normalizes to a similar record shape.
### FAQ
#### How does Workable Jobs Scraper work?
It calls two public Workable JSON endpoints directly:
- **Search mode** — `jobs.workable.com/api/v1/jobs?query=…&workplace=…` (Workable's own cross-customer meta-search). Paginated via `nextPageToken`, capped at 20 jobs per page by Workable; the actor paginates automatically.
- **Per-company mode** — `apply.workable.com/api/v1/widget/accounts/{slug}?details=true` (the same endpoint Workable's embed widget uses on customers' own career sites). Returns every active job at the company in one response.
No headless browser, no proxy, no scraping fragile HTML. Both endpoints are public, unauthenticated, and respond to standard `User-Agent` headers.
#### Can I use Workable Jobs Scraper as an API?
Yes. Start a run by POSTing to the Apify [Run Actor endpoint](https://docs.apify.com/api/v2#/reference/actors/run-actor/run-actor) with your input JSON, then read the dataset via [`GET /v2/datasets/{datasetId}/items`](https://docs.apify.com/api/v2#/reference/datasets/item-collection). Apify also exposes the actor as a synchronous run with `run-sync` and as a [task](https://docs.apify.com/platform/actors/running/tasks) if you want to save reusable input presets.
#### Can I use Workable Jobs Scraper in Python or Node.js?
Yes. With the [`apify-client`](https://docs.apify.com/api/client/python) package:
```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("schnellscrapers/workable-jobs-scraper").call(
run_input={"query": "engineer", "workplace": "remote", "maxItems": 200}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item["title"], item["companyName"], item["location"]["fullLocation"])
```
#### Is it legal to scrape Workable job listings?
Workable's `jobs.workable.com` is Workable's own public meta job board — they actively encourage indexing and even ship an LLM-friendly `/jobs.md` documentation endpoint describing the search parameters. `apply.workable.com/{slug}` is each customer's public hosted careers page. Scraping publicly accessible job postings is generally legal in the US and EU. This actor only fetches public data — no logged-in scraping, no captcha-bypass, no PII beyond what employers chose to publish. Respect Workable's terms, rate-limit your runs, and don't reuse scraped data in ways that violate GDPR, CCPA, or your local employment-data regulations.
#### How do I find a company's Workable slug?
Open the company's careers page. If the URL is `https://apply.workable.com/allucent` then `allucent` is the slug. You can also paste a full apply.workable.com URL into the `companies` field; the actor extracts the slug for you. Note that not every company you see on Workable's meta-search is hosted on `apply.workable.com` — Workable also indexes external careers pages — so if a slug returns 0 jobs, the company is likely on a different ATS or routes through their own domain.
#### Can I search across all Workable customers without picking specific companies?
Yes — that's search mode. Set any combination of `query`, `location`, `workplace`, `employmentType`, and `dayRange`, and the actor paginates Workable's meta-search (170k+ active postings) until you hit `maxItems` or run out of results. Combine with `titleExcludeFilter` and `countryFilter` to narrow further.
#### What's the difference between search mode and per-company mode?
- **Search mode** is best when you don't know which companies have what you want — search broadly and let Workable's index surface the matches. Returns up to ~170k records cross-customer.
- **Per-company mode** is best when you have a list of target employers — pulls every active job at each (no 20-per-page cap, no search ranking), and exposes a few extra fields the search index doesn't (`function`, `industry`, `experienceLevel`, `education`, `code`).
- You can combine both in a single run; results are deduped by `id`.
#### Why is `descriptionHtml` `null` for some records?
You disabled `includeDescription`. Per-company mode then uses Workable's lighter `details=false` payload (~10× smaller) which omits the description. Search-mode records always include the description regardless of this setting (Workable's search returns it inline). Re-enable `includeDescription` to populate it.
#### Can I filter by department, function, or industry?
Yes — use `departmentFilter`, `functionFilter`, `industryFilter`. All are case-insensitive substring matches. Note that `function` and `industry` are only populated on per-company records (Workable's search index doesn't expose them).
#### What's the 170,000-job ceiling about?
Workable's `jobs.workable.com/api/v1/jobs` meta-search currently indexes roughly 170k active postings across all Workable customers. That's the practical upper bound for a "scrape everything" search-mode run. Per-company runs aren't subject to this — pull each company directly.
#### Will Workable rate-limit or block me?
We've seen no rate-limiting or anti-bot challenges in months of operation across hundreds of company slugs and thousands of search pages. Both endpoints respond to plain `User-Agent` headers without proxy. The actor inserts a small courtesy delay between search pages.
### Your feedback
Open an issue on this actor's **Issues** tab on Apify with bug reports or feature requests — additional output fields, multi-keyword search, salary parsing, or AI enrichment are all on the table.
# Actor input Schema
## `query` (type: `string`):
Keyword run against Workable's own search index (title + description). Example: `engineer`, `nurse`, `account manager`. Combine with the client-side title/description filters below for finer control. Leave blank to skip search mode.
## `location` (type: `string`):
City, region, or country. Workable matches phrases against location text (e.g. `London`, `California`, `Germany`). Combine with `workplace=remote` to find remote roles tied to a country.
## `workplace` (type: `string`):
Restrict to one work arrangement. Workable only exposes three categories.
## `employmentType` (type: `string`):
Contract type. Workable groups internships under Temporary on the search index.
## `dayRange` (type: `integer`):
Keep only jobs first listed in the last N days (Workable's `day_range` parameter). Leave at 0 to ignore.
## `maxItemsPerSearch` (type: `integer`):
Cap on records pulled from cross-customer search. Leave at 0 to keep pulling until `maxItems` or end of results. Useful as a guardrail when buyers experiment with broad queries — Workable can return tens of thousands of matches.
## `companies` (type: `array`):
Companies to pull every active job from. Paste the apply.workable.com slug (e.g. `allucent`, `northramp`, `same-day-water-heaters`) or any apply.workable.com URL — `https://apply.workable.com/allucent`. The slug is the path segment after the host. Use this together with — or instead of — search mode.
## `titleFilter` (type: `array`):
Case-insensitive substring match against the job title. A record is kept if any term matches (e.g. `engineer`, `designer`).
## `titleExcludeFilter` (type: `array`):
Drop jobs whose title contains any of these substrings (e.g. `senior`, `manager`, `intern`).
## `departmentFilter` (type: `array`):
Substring match against the `department` field (e.g. `engineering`, `operations`, `customer success`). Workable lets employers define their own department names.
## `functionFilter` (type: `array`):
Substring match against the `function` field (e.g. `Information Technology`, `Research`, `Sales`). Only populated on the per-company widget endpoint — not on cross-customer search results.
## `industryFilter` (type: `array`):
Substring match against the `industry` field (e.g. `Biotechnology`, `Hospitality`). Only populated on the per-company widget endpoint — not on cross-customer search results.
## `experienceLevels` (type: `array`):
Substring match against the `experience` field. Common Workable values: `Entry level`, `Mid-Senior level`, `Director`, `Executive`. Only populated on the per-company widget endpoint.
## `countryFilter` (type: `array`):
Substring match against the location country (e.g. `United States`, `Germany`, `United Kingdom`).
## `remoteOnly` (type: `boolean`):
Keep only fully-remote jobs (`workplace=remote` or `telecommuting=true`). Faster to apply at the server level via the `workplace` input above — this catches remote jobs from per-company runs too.
## `postedAfter` (type: `string`):
ISO 8601 date (e.g. `2026-05-01`). Drops jobs whose `publishedAt` is older. Leave blank to keep every active job.
## `descriptionContains` (type: `array`):
Substring match against the description body (and requirements + benefits sections when present). Useful for terms like `python`, `kubernetes`, `visa sponsorship`. Auto-enables description fetching.
## `includeDescription` (type: `boolean`):
When ON (default), descriptions are pulled with each record. On the cross-customer search endpoint, descriptions come back in the same response — no extra cost. On the per-company endpoint, this toggles between the lighter `details=false` payload (no description, ~700 bytes/job) and the full payload (~7 KB/job).
## `parseDescription` (type: `boolean`):
Add a `descriptionText` field with HTML stripped and entities decoded. Useful for downstream search, embeddings, and LLM ingestion.
## `combineDescription` (type: `boolean`):
Some buyers want one HTML blob covering description, requirements, and benefits. When ON, `descriptionHtml` becomes the stitched version (sections wrapped in `` so they remain identifiable).
## `enrichLinkout` (type: `boolean`):
Some employers redirect applicants to their own site via a `linkoutUrl`. This field is only on the per-job detail endpoint. Turn this on to pay one extra HTTP fetch per emitted search record and capture it. No effect on per-company runs (the widget never exposes this field).
## `maxItems` (type: `integer`):
Hard cap on total records emitted across both modes. Useful for cost-bounded test runs. Leave at 0 to emit every matching job.
## `maxItemsPerCompany` (type: `integer`):
Per-company cap when iterating `companies`. Useful when one large employer would dominate a multi-company run. Leave at 0 for no per-company cap.
## `dryRun` (type: `boolean`):
Fetch and parse but do not write to the dataset. Use to preview without spending credits.
## Actor input object example
```json
{
"dayRange": 0,
"maxItemsPerSearch": 0,
"companies": [],
"titleFilter": [],
"titleExcludeFilter": [],
"departmentFilter": [],
"functionFilter": [],
"industryFilter": [],
"experienceLevels": [],
"countryFilter": [],
"remoteOnly": false,
"descriptionContains": [],
"includeDescription": true,
"parseDescription": false,
"combineDescription": false,
"enrichLinkout": false,
"maxItems": 0,
"maxItemsPerCompany": 0,
"dryRun": false
}
```
# Actor output Schema
## `jobs` (type: `string`):
Default dataset of Workable job records. Key fields: title, companyName, location, workplace, department, publishedAt, url, descriptionHtml.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"companies": [],
"titleFilter": [],
"titleExcludeFilter": [],
"departmentFilter": [],
"functionFilter": [],
"industryFilter": [],
"experienceLevels": [],
"countryFilter": [],
"descriptionContains": []
};
// Run the Actor and wait for it to finish
const run = await client.actor("schnellscrapers/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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"companies": [],
"titleFilter": [],
"titleExcludeFilter": [],
"departmentFilter": [],
"functionFilter": [],
"industryFilter": [],
"experienceLevels": [],
"countryFilter": [],
"descriptionContains": [],
}
# Run the Actor and wait for it to finish
run = client.actor("schnellscrapers/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 '{
"companies": [],
"titleFilter": [],
"titleExcludeFilter": [],
"departmentFilter": [],
"functionFilter": [],
"industryFilter": [],
"experienceLevels": [],
"countryFilter": [],
"descriptionContains": []
}' |
apify call schnellscrapers/workable-jobs-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=schnellscrapers/workable-jobs-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Workable Jobs Scraper",
"description": "Pull every active Workable job — search 170k+ postings across all Workable customers, or grab every job from one Workable company in one run. Returns titles, locations, departments, employment type, full HTML descriptions, and apply URLs.",
"version": "0.1",
"x-build-id": "cDuBPNdSV9itGu0Le"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/schnellscrapers~workable-jobs-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-schnellscrapers-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/schnellscrapers~workable-jobs-scraper/runs": {
"post": {
"operationId": "runs-sync-schnellscrapers-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/schnellscrapers~workable-jobs-scraper/run-sync": {
"post": {
"operationId": "run-sync-schnellscrapers-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": "Search keyword",
"type": "string",
"description": "Keyword run against Workable's own search index (title + description). Example: `engineer`, `nurse`, `account manager`. Combine with the client-side title/description filters below for finer control. Leave blank to skip search mode."
},
"location": {
"title": "Location",
"type": "string",
"description": "City, region, or country. Workable matches phrases against location text (e.g. `London`, `California`, `Germany`). Combine with `workplace=remote` to find remote roles tied to a country."
},
"workplace": {
"title": "Workplace",
"enum": [
"remote",
"hybrid",
"on_site"
],
"type": "string",
"description": "Restrict to one work arrangement. Workable only exposes three categories."
},
"employmentType": {
"title": "Employment type",
"enum": [
"Full-time",
"Part-time",
"Contract",
"Temporary"
],
"type": "string",
"description": "Contract type. Workable groups internships under Temporary on the search index."
},
"dayRange": {
"title": "Posted within N days",
"minimum": 0,
"maximum": 365,
"type": "integer",
"description": "Keep only jobs first listed in the last N days (Workable's `day_range` parameter). Leave at 0 to ignore.",
"default": 0
},
"maxItemsPerSearch": {
"title": "Maximum records from search mode",
"minimum": 0,
"maximum": 1000000,
"type": "integer",
"description": "Cap on records pulled from cross-customer search. Leave at 0 to keep pulling until `maxItems` or end of results. Useful as a guardrail when buyers experiment with broad queries — Workable can return tens of thousands of matches.",
"default": 0
},
"companies": {
"title": "Workable companies",
"type": "array",
"description": "Companies to pull every active job from. Paste the apply.workable.com slug (e.g. `allucent`, `northramp`, `same-day-water-heaters`) or any apply.workable.com URL — `https://apply.workable.com/allucent`. The slug is the path segment after the host. Use this together with — or instead of — search mode.",
"items": {
"type": "string"
}
},
"titleFilter": {
"title": "Title includes",
"type": "array",
"description": "Case-insensitive substring match against the job title. A record is kept if any term matches (e.g. `engineer`, `designer`).",
"items": {
"type": "string"
}
},
"titleExcludeFilter": {
"title": "Title excludes",
"type": "array",
"description": "Drop jobs whose title contains any of these substrings (e.g. `senior`, `manager`, `intern`).",
"items": {
"type": "string"
}
},
"departmentFilter": {
"title": "Department includes",
"type": "array",
"description": "Substring match against the `department` field (e.g. `engineering`, `operations`, `customer success`). Workable lets employers define their own department names.",
"items": {
"type": "string"
}
},
"functionFilter": {
"title": "Function includes",
"type": "array",
"description": "Substring match against the `function` field (e.g. `Information Technology`, `Research`, `Sales`). Only populated on the per-company widget endpoint — not on cross-customer search results.",
"items": {
"type": "string"
}
},
"industryFilter": {
"title": "Industry includes",
"type": "array",
"description": "Substring match against the `industry` field (e.g. `Biotechnology`, `Hospitality`). Only populated on the per-company widget endpoint — not on cross-customer search results.",
"items": {
"type": "string"
}
},
"experienceLevels": {
"title": "Experience levels",
"type": "array",
"description": "Substring match against the `experience` field. Common Workable values: `Entry level`, `Mid-Senior level`, `Director`, `Executive`. Only populated on the per-company widget endpoint.",
"items": {
"type": "string"
}
},
"countryFilter": {
"title": "Country includes",
"type": "array",
"description": "Substring match against the location country (e.g. `United States`, `Germany`, `United Kingdom`).",
"items": {
"type": "string"
}
},
"remoteOnly": {
"title": "Remote only",
"type": "boolean",
"description": "Keep only fully-remote jobs (`workplace=remote` or `telecommuting=true`). Faster to apply at the server level via the `workplace` input above — this catches remote jobs from per-company runs too.",
"default": false
},
"postedAfter": {
"title": "Only jobs posted after",
"type": "string",
"description": "ISO 8601 date (e.g. `2026-05-01`). Drops jobs whose `publishedAt` is older. Leave blank to keep every active job."
},
"descriptionContains": {
"title": "Description contains",
"type": "array",
"description": "Substring match against the description body (and requirements + benefits sections when present). Useful for terms like `python`, `kubernetes`, `visa sponsorship`. Auto-enables description fetching.",
"items": {
"type": "string"
}
},
"includeDescription": {
"title": "Include full job description",
"type": "boolean",
"description": "When ON (default), descriptions are pulled with each record. On the cross-customer search endpoint, descriptions come back in the same response — no extra cost. On the per-company endpoint, this toggles between the lighter `details=false` payload (no description, ~700 bytes/job) and the full payload (~7 KB/job).",
"default": true
},
"parseDescription": {
"title": "Also produce plain-text description",
"type": "boolean",
"description": "Add a `descriptionText` field with HTML stripped and entities decoded. Useful for downstream search, embeddings, and LLM ingestion.",
"default": false
},
"combineDescription": {
"title": "Combine description + requirements + benefits",
"type": "boolean",
"description": "Some buyers want one HTML blob covering description, requirements, and benefits. When ON, `descriptionHtml` becomes the stitched version (sections wrapped in `` so they remain identifiable).",
"default": false
},
"enrichLinkout": {
"title": "Enrich with linkout URL",
"type": "boolean",
"description": "Some employers redirect applicants to their own site via a `linkoutUrl`. This field is only on the per-job detail endpoint. Turn this on to pay one extra HTTP fetch per emitted search record and capture it. No effect on per-company runs (the widget never exposes this field).",
"default": false
},
"maxItems": {
"title": "Maximum records (total)",
"minimum": 0,
"maximum": 1000000,
"type": "integer",
"description": "Hard cap on total records emitted across both modes. Useful for cost-bounded test runs. Leave at 0 to emit every matching job.",
"default": 0
},
"maxItemsPerCompany": {
"title": "Maximum records per company",
"minimum": 0,
"maximum": 1000000,
"type": "integer",
"description": "Per-company cap when iterating `companies`. Useful when one large employer would dominate a multi-company run. Leave at 0 for no per-company cap.",
"default": 0
},
"dryRun": {
"title": "Dry run",
"type": "boolean",
"description": "Fetch and parse but do not write to the dataset. Use to preview without spending credits.",
"default": false
}
}
},
"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
}
}
}
}
}
}
}
}
}
}
```