Workable Jobs Scraper: Up to 1,000 Free Results a Month (2026)

Workable Jobs Scraper provides structured job data from Workable, a platform hosting over 50,000 active job listings. It extracts critical fields such as job title, department, employment type, workplace type, requirements, benefits, and the application URL. Each job record includes an array of location strings, such as 'locations', along with denormalized 'locationCity' and 'locationCountry' fields. This is suitable for recruiters and market researchers needing current job market insights, but not for anyone who requires direct contact details for hiring managers, as these are not part of the output beyond the application URL.

Try it: open Workable Jobs Scraper on Apify, sign in on the free plan and run the prefilled example.

Can you try Workable Jobs Scraper before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Workable Jobs Scraper a month, before run-start charges and platform usage.

The example request further down caps maxItems at 5, so a first run returns at most 5 results and costs at most $0.025 in result charges. That is enough to see the real shape of the data before deciding anything.

Workable Jobs Scraper was last updated on 2026-06-02. It is one of 1,729 Actors CrawlerBros publishes on Apify, which together have 746,619 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Workable Jobs Scraper?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

The 'maxItems' input control significantly influences your bill, as per-result charges apply only to results written to the dataset. For instance, running with a small 'maxItems' value, such as the example input's cap of 5, costs at most $0.025 in result charges, and lets you quickly verify that the output structure and content meet your needs before committing to larger data volumes. Remember that the run-start fee is charged every time a run begins, regardless of whether results are returned.

How do you run Workable Jobs Scraper from the API?

The schema marks 1 of its 8 controls as required: mode. The payload below uses the schema's own prefilled values, so it runs as written once you substitute your API token.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~workable-jobs-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"mode":"searchJobs","query":"","employmentType":"","workplace":"","includeDescription":false,"maxItems":5}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "mode": "searchJobs",
  "query": "",
  "employmentType": "",
  "workplace": "",
  "includeDescription": False,
  "maxItems": 5
}

run = client.actor("crawlerbros~workable-jobs-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "mode": "searchJobs",
  "query": "",
  "employmentType": "",
  "workplace": "",
  "includeDescription": false,
  "maxItems": 5
}

const run = await client.actor('crawlerbros~workable-jobs-scraper').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

The synchronous endpoint holds the connection open until the run finishes, which is convenient for small batches and wrong for large ones. For anything long running, start the run asynchronously and poll, or attach a webhook, so a dropped connection does not cost you the results.

Which Workable Jobs Scraper inputs matter, and which can you skip?

This Actor exposes 8 input controls, with 'mode' being the single required one. You'll primarily interact with 'mode' to switch between global job searches ('searchJobs') and company-specific scraping ('getJobs'). When in 'searchJobs' mode, 'query' and 'location' are your most impactful controls for defining the result set. Most users should leave 'employmentType' and 'workplace' at their defaults for initial runs to get a broad overview before applying more specific filters.

• mode (string): Select what to scrape: search all Workable jobs globally, or get jobs from one or more company boards. Default: "searchJobs".
• query (string): Keyword to search for (e.g. 'software engineer', 'marketing manager'). Used in searchJobs mode.
• location (string): Filter by city or country (e.g. 'New York', 'Germany'). Used in searchJobs mode.
• employmentType (string): Filter by employment type. Default: "".
• workplace (string): Filter by workplace arrangement. Default: "".
• companySlugs (array): Workable company slugs to fetch jobs from (e.g. ['stripe', 'airbnb']). These are the subdomain names from apply.workable.com/{slug}/.
• includeDescription (boolean): Include the full HTML job description, requirements, and benefits sections in the output. Default: false.
• maxItems (integer): Maximum number of job records to emit. Default: 100.

Fixed-choice controls: mode accepts searchJobs (Search jobs globally (keyword, location, employment type, workplace)), getJobs (Get company board jobs (by company Workable slug)); employmentType accepts "" (All types), full-time, part-time, contract, temporary, internship, volunteer; workplace accepts "" (All workplaces), remote, on_site (On-site), hybrid.

What does Workable Jobs Scraper return?

The output includes job records with fields like 'title', 'department', 'locations', 'company.title', and 'url'. When 'includeDescription' is set to true, you also get the full HTML 'description', 'requirementsSection', and 'benefitsSection'. This data is well-suited for market analysis or feeding into recruitment systems, but it does not include direct email addresses or phone numbers for individuals.

Output

• id: Unique job UUID
• title: Job title
• department: Department or team
• employmentType: Full-time, Part-time, Contract, etc.
• workplace: remote, on_site, or hybrid
• locations: Array of location strings
• locationCity: City (denormalized)
• locationCountry: Country name (denormalized)
• created: ISO 8601 creation timestamp
• updated: ISO 8601 last-updated timestamp
• url: Link to the job listing
• sourceUrl: Same as url
• company.title: Company name
• company.website: Company website
• companyName: Denormalized company name
• state: Job state (e.g. "published")
• language: Language code (e.g. "en")
• isFeatured: Whether it's a featured listing
• description: Full HTML description (only if includeDescription=true)
• requirementsSection: HTML requirements (only if includeDescription=true)
• benefitsSection: HTML benefits (only if includeDescription=true)
• recordType: Always "job"
• scrapedAt: ISO timestamp when this record was scraped

Company board mode (getJobs) additional fields

• shortcode: Company-specific job shortcode
• companySlug: The company's Workable slug
• applicationUrl: Direct application URL
• shortlink: Short URL for the job
• remote: Boolean - is it remote?
• city: City from company board
• country: Country code from company board

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Workable Jobs Scraper and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Set the 'mode' to 'searchJobs' and provide a 'query' like 'software engineer', then run and check for results that match your criteria.
2. To target specific companies, set 'mode' to 'getJobs' and populate the 'companySlugs' array with entries like ['stripe', 'airbnb'].
3. Enable 'includeDescription' to fetch full job descriptions, requirements, and benefits; inspect a few records to ensure the HTML content is present as expected.
4. Begin with a small 'maxItems' limit, for example 50, to quickly assess the relevance and structure of the output before scaling up.
5. When refining search queries, test different 'employmentType' and 'workplace' filters with a small 'maxItems' to see how they affect the result set size and content.
6. Verify the 'locations' array and 'locationCity' and 'locationCountry' fields for consistency after running, especially when using a 'location' filter in 'searchJobs' mode.

How do you apply it? Three worked playbooks

These are Workable Jobs Scraper's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Competitive intelligence

Outcome: Monitor hiring at competitor or target companies

Configure: Set 'mode' to 'getJobs' and provide a list of competitors' Workable slugs in 'companySlugs', such as ['competitor-a', 'competitor-b'].

Working method: Start by running the Actor with the 'companySlugs' array populated by a few target companies. Review the initial output to ensure all expected companies are returning results and that key fields like 'title' and 'department' are present. Schedule regular runs, perhaps daily, and compare new job listings against previous runs to identify new openings, closures, or changes in hiring patterns at your target organizations.

Deliverable: A dataset of current and historical job postings from specified competitor companies, highlighting changes in their hiring activity over time.

Stop condition: Runs return no jobs for a company known to be actively hiring, or job titles appear malformed or incomplete.

Use case 2: Talent market research

Outcome: Analyze which skills and roles are in demand by geography or company type

Configure: Set 'mode' to 'searchJobs'. Use the 'query' field for desired skills or roles (e.g., 'data scientist'), 'location' for geographies (e.g., 'London, UK'), and 'employmentType' or 'workplace' for specific job types.

Working method: Begin with a broad 'query' and 'location' and set 'maxItems' to a few hundred. Iterate by refining your 'query' to include specific skills or technologies (e.g., 'Python developer'). Use the 'location' filter to narrow down by city or country. Analyze the aggregated job titles, descriptions, and requirements to identify recurring skill demands. Consider running separate searches for different employment or workplace types to compare demand across these categories.

Deliverable: Aggregated data and trends showing in-demand skills, roles, and job types across various geographies, or within specific employment and workplace categories.

Stop condition: Job records consistently show irrelevant results for a given query, or the 'description' field is missing when 'includeDescription' is expected to be true.

Use case 3: Recruitment tooling

Outcome: Feed job data into ATS or outreach pipelines

Configure: Set 'mode' to either 'searchJobs' with relevant 'query', 'location', 'employmentType', 'workplace' filters or 'getJobs' with 'companySlugs'. Always set 'includeDescription' to true.

Working method: Start with a targeted set of job criteria, such as 'query': 'product manager' and 'location': 'San Francisco', ensuring 'includeDescription' is enabled. Review the first few dozen results to confirm that 'description', 'requirementsSection', and 'benefitsSection' are present and well-formed for each record. Integrate the output, particularly the 'title', 'company.title', 'applicationUrl', and full descriptions, into your applicant tracking system or outreach tool. Schedule runs to capture new listings frequently, perhaps every 12 to 24 hours.

Deliverable: A continuous feed of structured job data, including full descriptions and application URLs, ready for direct ingestion into an ATS or outreach platform.

Stop condition: The 'applicationUrl' field is frequently missing or malformed, preventing direct integration into recruitment workflows.

What breaks, and how do you design around it?

If a broad search returns fewer results than expected or if specific company slugs yield zero jobs, consider narrowing your 'query' or 'location' filters, or double-check the company slug's accuracy against the company's Workable careers page. If you require a very large volume of jobs, break your requests into multiple runs with smaller 'maxItems' limits to manage processing efficiently.

When should you not use Workable Jobs Scraper?

This Actor is not the right choice if your primary need is to collect direct contact information for individual recruiters or hiring managers. The output focuses on job posting details, company information, and application URLs, but it does not provide direct email addresses or phone numbers for individuals. If you require advanced filtering capabilities not present in the input schema, such as filtering by specific salary ranges, a more specialized job board scraper might be more effective. For example, if salary data is critical, the Salarship Jobs Scraper might be a better fit, as it explicitly includes estimated salary. Similarly, if your focus is exclusively on remote positions and you need comprehensive coverage of remote-only boards, Actors like the Jobicy Remote Jobs Scraper or Himalayas Remote Jobs Scraper offer dedicated scraping for those specific remote job boards, potentially providing a more focused dataset for that niche.

What should you check before trusting the output?

• Check that the 'id' field is always unique for each job record.
• Verify that 'title' and 'company.title' fields are consistently present and accurately reflect the job and employer.
• When 'includeDescription' is true, confirm that 'description', 'requirementsSection', and 'benefitsSection' contain valid HTML and are not empty for a significant portion of records.
• For 'getJobs' mode, ensure that 'companySlug' matches the input and that 'applicationUrl' is a working link.
• Monitor the count of returned jobs; a sudden drop below an expected threshold (e.g., fewer than 100 jobs for a broad search) should trigger an investigation.
• Inspect the 'created' and 'updated' timestamps for reasonable values to catch potential data freshness issues.

None of this proves a record is correct. It gives a scheduled Workable Jobs Scraper run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What does it cost to use Workable Jobs Scraper?

The Workable Jobs Scraper costs $0.005 per result. This means 1,000 results will cost you $5.00 in result charges. Apify's free plan includes $5.00 of monthly usage, which covers up to 1,000 results of this Actor without needing a credit card, before run-start charges. The run-start fee is charged every time a run starts, but result charges only apply when records are actually written to your dataset.

How do I find a company's Workable slug?

To find a company's Workable slug, navigate to their Workable careers page in your web browser. The URL typically follows the format https://apply.workable.com/{slug}/. The slug is the subdomain part of the company's Workable board URL. You then provide this slug in the 'companySlugs' input array when using the 'getJobs' mode.

Can I get the full job description and requirements?

Yes, you can include the full job description, requirements section, and benefits section in the output. To do this, you need to set the 'includeDescription' input control to true. By default, this option is false to keep the output records smaller. Enabling it will provide the full HTML content for these fields.

What happens if a company slug returns no jobs?

If you provide a company slug in 'getJobs' mode and it returns zero jobs, it typically means one of two things. Either the company currently has no active job postings on Workable, or the Workable slug you provided is incorrect. First, double-check that the slug is accurate by verifying the company's Workable careers page URL. If the slug is correct, it indicates that there are no available jobs to scrape from that specific company at that moment.

Does this Actor support filtering by specific locations and employment types?

Yes, when using the 'searchJobs' mode, you can filter job listings by 'location', such as 'New York' or 'Germany', and by 'employmentType', including options like 'full-time', 'part-time', 'contract', 'temporary', 'internship', or 'volunteer'. Additionally, you can filter by 'workplace' type, choosing 'remote', 'on_site', or 'hybrid'. These filters help you narrow down the global job board results to match your specific criteria.

Where to go next

When you are ready to run it, open Workable Jobs Scraper on Apify; the free plan covers up to 1,000 results a month.

Start with the Workable Jobs Scraper Actor page for the current input schema, pricing tier, and run history.

If you are comparing approaches rather than committing to one Actor, these category pages list every option we publish:

• Job listing scrapers covers 81 Actors in this family.

Other Actors we maintain for related data:

• SimplyHired Jobs Scraper: Scrape job listings from SimplyHired.com - search by keyword and location, filter by employment type, remote work, date posted, and minimum salary.
• Remote Jobs Scraper: Scrape remote job listings from Jobicy - a curated remote job board with 1,000+ active remote jobs.
• Jobicy Remote Jobs Scraper: Scrape Jobicy.com - a curated remote job board with 1,000+ active listings.
• Himalayas Remote Jobs Scraper: Scrape Himalayas.app, a remote-first startup job board with 100k+ listings.
• We Work Remotely Jobs Scraper: Scrape remote job listings from WeWorkRemotely.com with titles, companies, locations, salaries, full descriptions, and company profiles.
• Working Nomads Jobs Scraper: Scrape remote job listings from the Working Nomads public API.
• Salarship Jobs Scraper: Scrape Salarship.com - a global job board with salary estimates for 100,000+ positions.
• Bumeran Jobs Scraper: Search job listings on Bumeran (bumeran.com.ar) - Argentina's largest job board - by keyword, province, job category, work mode, employment type, seniority, and contract type.

Related guides:

• Himalayas Remote Jobs Scraper: 3 Practical Use Cases
• Jobs.ac.uk Academic Jobs Scraper: 21 Data Fields per Record (2026)
• The Hub Startup Jobs Scraper: 19 Data Fields per Record (2026)
• LinkedIn Jobs Scraper: Up to 2,500 Free Results a Month (2026)

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-10-06.

• Actor last updated by its maintainers on 2026-06-02.

• Run outcome figures cover the 30 day public window ending 2026-10-06.

• Workable Jobs Scraper on Apify