Workable Jobs Scraper — API, no HTML

Unofficial — not affiliated with or endorsed by Workable.

Data note: job descriptions are employer-published public data and may contain recruiter contact info; don't use it for spam.

Version 0.2.6 · live since 2026-07-15 · 380 Workable boards verified 2026-07-15 · $1 per 1,000 jobs, $0 to start.

Live status: https://api.apify.com/v2/key-value-stores/WickFeed~wickfeed-public-status/records/status.json — real self-test results for every wickfeed scraper (pass/fail plus 30-day success rate), updated hourly, no login needed. Opens as raw data (JSON).

Which WickFeed tool do you want?

• Mixed systems, or unsure which one a company uses → ATS Job Aggregator
• Greenhouse only → Greenhouse Jobs Scraper
• Ashby only, with published salary ranges → Ashby Jobs Scraper
• Workable only → Workable Jobs Scraper (this page)
• Companies and their live job counts, not job rows → ATS Company Discovery

Download every open job at the Workable companies you choose — a fresh snapshot each run, as a table you can export to CSV, Excel, or JSON. Pick the bundled list or paste a careers URL, then press Start. No token hunting, no HTML scraping, and no Workable login or API key is required — you just need an Apify account to run the tool.

From click to CSV, four steps:

1. Click Try for free and sign in to Apify.
2. Leave the demo boards as they are and click Start.
3. When the run finishes, open Dataset to see the rows.
4. Click Export to download CSV, Excel, or JSON.

Built to keep running. It reads Workable's public widget API — the exact JSON the careers page itself loads — and writes one row per job. Because it reads that JSON and never parses rendered HTML, a careers-page restyle doesn't touch it: HTML scrapers break every time a careers page gets restyled, and choke when the jobs are drawn in JavaScript — this reads the data feed directly instead. The one thing that can require an update is Workable changing that feed's shape (see Limitations). If a board goes bad mid-run it's isolated and reported, the rest of the run finishes, and you're not charged for the one that failed. On a schedule, each run hands back a fresh full snapshot of what's open that day.

Demo cost: a few cents. The form comes prefilled with 3 demo boards (capgemini-insurance, avomind, crossbordertalents). Press Start and that first run tops out around $0.15 — and Apify's $5 monthly free credit covers it, so your first runs cost nothing. You're charged only for jobs you actually get; empty, dead, or misspelled boards never cost a thing.

Every run returns a fresh, full snapshot of what's open today — not a day-over-day diff. To get only the new and changed jobs picked out for you, see the ATS Job Aggregator, the diff monitor for the whole family.

What you get

A run over a few boards returns rows like these (real postings, fetched 2026-07-15):

Company	Title	Location	Remote	Posted
Capgemini	Agile Dev Team Member III : .Net Core Full Stack Developer	Pune, Maharashtra, India	no	2026-03-05
Cross Border Talents	Account Executive (Native English + Dutch)	Madrid, Community of Madrid, Spain	no	2026-06-25
Avomind	(Senior) Consultant Data Strategy	Munich, Bavaria, Germany	no	2026-06-19
CXG	Automobil-Luxusmarken-Evaluator - Amberg	Weiden in der Oberpfalz, Bavaria, Germany	no	2026-07-12

Each row also carries a stable id, department, the public application url, the plain-text description, and a fetch timestamp.

Paste a link, type a name — no token hunting

You don't need to know a company's Workable "board token." In the Companies box, put whatever you already have — one company per line:

• A careers page address. Copy it straight from the browser: https://apply.workable.com/capgemini-insurance. This is the reliable path — the board id is right there in the address, so it always works.
• A company name. Type CXG. Typed names are matched against the bundled list of 380 verified Workable companies — a starter directory, not every Workable company. If yours isn't in it, paste the careers page address instead.
• A bare board token. capgemini-insurance, exactly as before. Existing setups and saved runs keep working unchanged.

{ "sources": ["CXG", "https://apply.workable.com/avomind", "crossbordertalents"] }

If an entry can't be read — a blank line, an address for a different hiring system (a Greenhouse or Ashby link pasted here is caught and named), or a company name that isn't in the bundled list — that one line is skipped with a plain-English note telling you exactly what to paste instead. It never silently runs empty, and the rest of your list still runs. Reliable in, reliable out.

Quick start

1. Add companies. Just press Start to use the three demo boards already filled in (capgemini-insurance, avomind, crossbordertalents). Or paste careers-page addresses, type company names, or switch Company list to "All verified" to pull all 380 Workable boards.
2. (Optional) Narrow it. Add keywords (e.g. engineer, sales) or locations (e.g. berlin, remote) to keep only matching jobs.
3. Press Start. By default each board delivers up to 50 jobs — the first 50 that match your filters (or just the first 50 it finds, if you set none) — so the first run is quick and cheap. Bump Max results per board up once the output looks right.

Calling the API? Send an empty input {} and you get the same three demo boards the form starts with — capped at 50 jobs each, about $0.15. So a first API call does exactly what pressing Start does: no empty run, no surprise bill.

Bundled company list

Choose "All verified" and press Start — no token hunting. The list holds 380 Workable boards, every one confirmed live against Workable's own API on 2026-07-15. You can also add your own companies by hand in Companies (paste an apply.workable.com/... address, type a name, or enter a bare subdomain); the two lists merge and duplicates are removed.

Output schema

One row per job, the same fields every time:

Field	Meaning
id	Stable id workable:<token>:<jobId> — deduplicate on this.
ats	Always workable — the hiring system this row came from (kept so the schema matches the multi-ATS aggregator).
companyToken	The Workable subdomain this row came from (e.g. huggingface).
company	Account display name (Workable exposes it).
title	Job title.
department	Department when provided, else null.
location	City, state and country assembled into one string.
remote	true/false from Workable's telecommuting flag; null when unknown.
url	Public application URL.
postedAt	Publish date (ISO-8601), or null.
updatedAt	ISO-8601 string or null — always null for Workable (the widget API exposes no update time).
salaryRaw	Always null — the widget API doesn't expose pay (see FAQ).
descriptionText	Plain text, HTML stripped, capped at ~20,000 chars.
fetchedAt	When this run fetched the row.
schemaVersion	The output-record schema version (a number, currently 1). See Output contract below.

updatedAt is null because Workable's widget carries no update time. Turn on Include raw HTML description to also get descriptionHtml.

Two real records from a run over the huggingface board (fetched 2026-07-15) — every field present on every row, honest nulls where Workable's widget doesn't expose a value:

[
  {
    "id": "workable:huggingface:97904BAC90",
    "ats": "workable",
    "companyToken": "huggingface",
    "company": "Hugging Face",
    "title": "Data/Infrastructure Advocate Engineer - EMEA Remote",
    "department": "Product",
    "location": "Paris, Île-de-France, France",
    "remote": true,
    "url": "https://apply.workable.com/j/97904BAC90",
    "postedAt": "2026-05-29T00:00:00.000Z",
    "updatedAt": null,
    "salaryRaw": null,
    "descriptionText": "At Hugging Face we're on a journey to democratize good AI. As our first Data/Infrastructure Advocate Engineer, you'll bridge cutting-edge data infrastructure and the global community of data engineers …",
    "fetchedAt": "2026-07-15T18:00:00.000Z",
    "schemaVersion": 1
  },
  {
    "id": "workable:huggingface:CEACA06A2D",
    "ats": "workable",
    "companyToken": "huggingface",
    "company": "Hugging Face",
    "title": "Data/Infrastructure Advocate Engineer - US Remote",
    "department": "Product",
    "location": "New York, New York, United States",
    "remote": true,
    "url": "https://apply.workable.com/j/CEACA06A2D",
    "postedAt": "2026-05-29T00:00:00.000Z",
    "updatedAt": null,
    "salaryRaw": null,
    "descriptionText": "At Hugging Face we're on a journey to democratize good AI. As our first Data/Infrastructure Advocate Engineer, you'll bridge cutting-edge data infrastructure and the global community of data engineers …",
    "fetchedAt": "2026-07-15T18:00:00.000Z",
    "schemaVersion": 1
  }
]

Output contract (schema stability)

A shipped update shouldn't break your spreadsheet or your pipeline. Here's that promise, in writing:

• A field never gets renamed or removed inside a major version. The columns above — id, title, url, descriptionText, and the rest — keep their names and their meaning, so you can build on them safely.
• A null is honest, not missing. Where Workable's widget doesn't expose a value (salaryRaw, updatedAt, sometimes department), the field is still there, set to null — never dropped, so a column you read is always present.
• New fields get added, never forced on you. We may add a field over time; doing that never touches the fields you already read, so your existing code keeps working untouched.
• A breaking change is loud, not silent. If a field ever had to be renamed or removed, that's a major version bump — called out in the Changelog (and the Issues tab) before it lands, never a surprise on your next scheduled run.
• schemaVersion is a breaking-contract version. Every row carries it (it's in RUN_SUMMARY too). It's not the release number and not an exact-shape fingerprint: adding a new field doesn't bump it — it changes only when an existing field is renamed, removed, or retyped (a breaking change, which also bumps the major version). So while this number holds, every field you already read keeps its name, type, and meaning; new fields may have been added alongside. It's 1 today.
• The field list is published for machines too. The actor ships a machine-readable output schema (a JSON Schema of every field above), so a pipeline or AI agent can discover the exact row shape without parsing this table.

updatedAt and salaryRaw are always null for Workable (the widget exposes neither); descriptionHtml is added only when Include raw HTML description is on.

Pricing

You pay for jobs delivered, nothing else: $1.00 per 1,000 jobs, and $0 just to start a run (that's the job-fetched event). An empty run, a dead board, a misspelled one — none of them cost anything.

In plain numbers: a job costs a tenth of a cent — $1 per 1,000 works out to $0.001 each. So 500 jobs is about $0.50 and 2,000 jobs is about $2.00. Dead boards, misspelled ones, and boards with no open roles come back empty and cost nothing — you pay for jobs you actually get.

Free to try. Apify's free plan includes monthly usage credit — enough to cover a first demo run at no cost, so you see the output before paying anything.

How that compares. Other single-system Workable job actors on the store list around $1.15–$4 per 1,000 (feeds that cover several systems cost more), and most tack on a fee each time a run starts. This one is a flat $1 per 1,000, no start fee. A few listings do price lower per job and charge a fixed start fee instead — for example automation-lab/workable-jobs-scraper (about $0.14–$0.58 per 1,000 plus a $0.005 start fee) and fetch_cat/workable-jobs-scraper (lower still per job, plus a $0.005 start fee), both checked 2026-07-16 — so on a large pull they can come in under this one, while on a very small run the fixed fee can tip it the other way. Prices move, so compare on the current listings. Store prices as listed 2026-07-15; competitor prices checked 2026-07-16.

If a charge ever looks wrong, open an issue on the Issues tab with your run ID. We look into it the same day, and if we over-billed you we file a credit request with Apify to put the money back on your account. (Apify pays this kind of seller compensation as account credit, not cash, so that's what we can promise and what we'll do — we can't speak for how Apify itself handles it.)

Limitations (read this)

• Public boards only. It reads what a company publishes on its Workable board — not private ATS data, internal reqs, or candidate information.
• No salary. Workable's public widget API doesn't return pay, so every salaryRaw is null. If you need salary ranges, see the Ashby scraper below.
• You supply the companies. No API lists every Workable company, and this actor doesn't crawl. Use the bundled 380-board list, or read a token off a careers URL.
• No server-side search. Each board returns its whole job list; the keyword, location, remote and date filters run over the whole board after fetching, and Max results per board then caps the matching jobs delivered (so a match is never hidden past the cap).
• Politeness. Requests are capped at ~2/second with retries and backoff, so very large runs take proportionally longer.
• Endpoint drift. If Workable changes its response shape, the reader may need an update; a bad board is isolated and reported, never fatal.

FAQ

I got few or zero jobs back — is it broken?

Usually not. Start with the simple checks: clear your Keywords and Locations, turn off Remote only, and raise Max results per board — narrow filters or a low cap are the common reasons a run looks thin. Then open the run's Status and Logs to spot a mistyped company or a board that came back empty. Still looks wrong? Open the Issues tab with your run link and we'll take a look.

Advanced diagnostics: the per-board breakdown (fetched, matched, delivered, filtered, and any board errors) is saved to the run's key-value store as RUN_SUMMARY, and rows that fail validation go to REJECTS — check RUN_SUMMARY for a typo'd token. When a board has more matching jobs than the cap, its row shows how many matched, so you can raise Max results per board to get the rest.

Does it scrape HTML?

No. It calls Workable's official public widget API and reads JSON — the very request your browser fires when a careers page loads. No proxies, no headless browser, nothing to knock over.

Is this allowed?

It reads the same public JSON feed your browser pulls when you open a Workable careers page — no login, no password, no API key, no HTML scraping. It only touches data a company chose to make public. What you do with the results is up to you, and you're responsible for that use — for example, don't use it for spam or unsolicited outreach. This describes how the tool works; it isn't legal advice.

Can I schedule daily runs?

Yes — use Apify's scheduler. Every run starts fresh and returns a full snapshot of every open role that day, so a daily schedule gives you today's complete list, not a running diff. This tool doesn't compare one day to the next. If you want only the new and changed jobs picked out (real alerts that bill only for what changed), the Jobs Scraper API is the diff monitor and does exactly that.

What happens to a dead or misspelled board?

It's skipped and noted for that one board, the rest of the run finishes as normal, and you're never charged for a board that came back with nothing.

Why is salary always empty?

Workable's public widget endpoint doesn't include pay data, so there's nothing honest to put in salaryRaw. If you need salary ranges, the Ashby scraper (below) passes them straight through.

Use with AI agents (MCP)

AI agents can call this actor as a tool — Claude Desktop, Cursor, n8n, LangGraph, CrewAI, or any MCP-compatible client — through Apify's hosted MCP server at mcp.apify.com. An agent finds it with search-actors, checks its input with fetch-actor-details, and runs it with call-actor. Point your MCP client at Apify's server:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com"
    }
  }
}

That setup signs in with OAuth; to use a token instead, add "headers": { "Authorization": "Bearer <YOUR_APIFY_TOKEN>" }. The output is flat, stable JSON meant for machines to read, and agent-style pay-per-event billing is turned on.

Integrations

Download your results as CSV, Excel, or Google Sheets — no code needed. Or wire it up: it works with n8n, Make, and Zapier through Apify's built-in integrations, so you can send the dataset to Slack, a webhook, a Google Sheet, or your own pipeline.

Changelog

• 0.2.6 — 2026-07-16 — Added a public live-status link (real self-test results, no login).
• 0.2.5 — 2026-07-16 — Filters now run over the whole board before the cap, plus honesty fixes. Max results per board used to cap the raw job list before your keyword, location, remote, and date filters ran — so a matching job sitting past the cap could be missed. Now the filters run over the whole board first and the cap limits the matching jobs delivered, so a match is never hidden past the cap. Runs with no filters behave exactly as before (still the first N jobs), and per-board cost ceilings are unchanged (at most the cap × $0.001 per board — the prefilled 3-board demo still tops out around $0.15). An unreadable Posted after date is now rejected with a plain-English message instead of quietly switching the date filter off. The output schema table now lists updatedAt (always null for Workable), the actor publishes a machine-readable output schema for pipelines and agents, and the schemaVersion wording is corrected to a breaking-contract version (adding a field doesn't bump it). No price or count changed.
• 0.2.4 — 2026-07-16 — Honest snapshot wording, a fix for lowercase company names, and a clearer first run. Typing a company name in lowercase now finds the same board as typing it in normal case — before, a lowercase one-word name could be taken as a raw board token and miss the bundled listing. The page now says plainly that each run returns a fresh full snapshot (not day-to-day tracking) and points to the ATS Job Aggregator for real new-and-changed alerts; added a four-step "click to CSV" walkthrough, a chooser for picking the right WickFeed tool, and a plain "no login/API key needed, but an Apify account is" line. Troubleshooting now leads with the simple checks (filters, Max results, the run's Status and Logs) before the technical RUN_SUMMARY details. No price, count, or run behavior changed.
• 0.2.3 — 2026-07-16 — Each page now speaks in its own voice. Rewrote the shared, templated-feeling sections of this README — pricing, the output contract, the FAQ, the AI-agents (MCP) and integrations sections, and the footer — in this scraper's own plain, no-fuss voice, so it no longer reads word-for-word like the Greenhouse and Ashby pages. Every fact, price, and promise is unchanged, and nothing about how a run behaves changed.
• 0.2.2 — 2026-07-16 — Error messages now point you to the right scraper. Paste a careers link for a different hiring system and the message now names the product that reads it — our Greenhouse or Ashby Jobs Scraper for those, or our all-in-one Jobs Scraper + Job Monitor that covers all five systems (Greenhouse, Lever, Ashby, Workable, Recruitee) in one run; paste your company's own website and it points you to that aggregator, which can take the company name and look for the board. The Companies box now also states the first-run cost ceiling (about $0.15 for the prefilled 3-board demo). No change to how a valid run behaves.
• 0.2.1 — 2026-07-16 — Paste a link or type a name — no token hunting. The Companies box now accepts a pasted careers-page address (https://apply.workable.com/capgemini-insurance) or a plain company name (matched against the 380 bundled verified companies), alongside the bare subdomains it always took — existing setups and saved runs are unchanged. A link for a different hiring system (Greenhouse, Ashby, Lever, …), a company homepage, junk, or a name that isn't bundled is caught and reported in plain English with the exact thing to paste instead, never a silent empty run. Also: every output row now carries a schemaVersion field (currently 1) and this README documents the output contract (existing fields are never renamed or removed within a major version; null means honestly-absent, not missing) — additive, so existing pipelines are unaffected. And a bare {} API call now runs the same three demo boards the form prefills (≈ $0.15) instead of failing, so a first call can't surprise-bill.
• 0.1.0 — Initial release. Reads Workable's public widget API (no HTML scraping), one normalized row per job, 380 verified-live boards bundled, keyword / location / remote / date filters applied after fetch, per-board failure isolation with retries and backoff, schema-validated output, and pay-per-event billing at $1 per 1,000 jobs ($0 to start a run).

Related actors

• Need 5 hiring systems in one feed? The Jobs Scraper API covers Greenhouse, Lever, Ashby, Workable and Recruitee in this same schema. Start with its starter-500 preset — 500 verified-live boards in one click — and turn on diff mode to track only the new and changed jobs on a daily schedule (and pay $0 on a quiet day).
• Want published salary ranges as a field? The Ashby Jobs Scraper passes pay ranges straight through as salaryRaw.
• Not sure which companies use Workable? ATS Company Discovery finds live boards and their current open-job counts across five systems.

Need help? Open an Issue with your run link. If a run misbehaves or a charge looks off, open the Issues tab and include your run link — that's the fastest way to reach us, and we fix buyer-facing breakages the same day.