# Workable Jobs Scraper & API (`jobo.world/workable-jobs-scraper-api`) Actor

Search 250,000+ live Workable jobs from SMBs worldwide like Treatwell, COBS Bread and Costello Medical. Filter by title, location, salary, skills and company. Career sites checked daily for new and expired listings. Built for job boards, AI agents and hiring research.

- **URL**: https://apify.com/jobo.world/workable-jobs-scraper-api.md
- **Developed by:** [Jobo](https://apify.com/jobo.world) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 68 total users, 10 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.30 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

**Workable Jobs Scraper & API** — search **250,000+ live jobs** scraped from [Workable](https://www.workable.com), one of the world's most widely used SMB hiring platforms, used by companies like **Treatwell, COBS Bread, and Costello Medical**. One normalized JSON schema, career sites checked daily for new and expired listings. Open the actor, hit **Try for free**, and run the default input (`queries: ["Software Engineer", "Account Manager"]`) — no code or API key required.

[![Service Status](https://img.shields.io/badge/Service%20Status-jobo.world%2Fstatus-brightgreen)](https://jobo.world/status)

> **Build your input at [jobo.world/api/search-builder](https://jobo.world/api/search-builder).** Pick keywords, skills, salary, locations and job categories from lists, and see how many jobs match with five samples. Set **Source** to Workable to count only this actor's jobs. Its **Apify** tab writes the input JSON: switch the Input tab to JSON, paste it, and delete `sources` and `search_description`, which only Career Site Jobs API takes.

### What does Workable Jobs Scraper do?

- Searches **250,000+ live Workable jobs** across thousands of company boards in one call — no board tokens, no per-company setup
- Filters by **job category, work model, employment type, experience level, salary range, skills, companies, and posting date**
- Excludes noise with **negative keywords** — prefix any query token with `-` (`["Software Engineer", "-staff"]`)
- Returns **de-duplicated listings** — one record per posting, keyed on the ATS's native job ID; repeats across an employer's boards are merged, and expired jobs drop out through the daily career-site checks
- Processes every job with **Jobo's AI extraction**: typed hard/soft skills, responsibilities and benefits when the posting states them, a short summary, geocoded locations, annual-USD salaries when pay is disclosed, and work-authorization signals (H1B sponsorship, clearance) when the posting mentions them
- Optionally attaches the **full company profile** — funding, ratings, tech stack, H1B history where available — with one switch
- Exports to **JSON, CSV, or Excel**, and plugs into **schedules, webhooks, Zapier, Make, and the Apify API**

### Why scrape Workable jobs?

Workable is one of the world's most widely used SMB hiring platforms, and its boards show a side of the labor market the big aggregators mostly miss: bakery chains, logistics firms, medical-communications agencies, scientific publishers, clinics — real small and mid-sized businesses hiring in their own towns and time zones. Because Workable's customers are spread across many countries, its inventory is a rare structured window into worldwide SMB hiring, not just tech-hub hiring.

Jobo's live Workable index currently holds **250,000+ open roles**, nearly half of them in the United States, with the UK and Canada next. Companies hiring through Workable right now include **Treatwell, COBS Bread, Charger Logistics, Costello Medical, and Frontiers Media** — alongside thousands of small businesses you won't find on any other structured feed.

#### Can I use the official Workable API instead?

Workable's public endpoints are **per-account** job and widget feeds with no search or filtering, and the richer SPI v3 API requires each employer's own access token — fine for embedding one company's careers page, useless for market-wide data. No ATS offers a public cross-company search API. That's the gap this actor closes: one query across every Workable account Jobo indexes, with fields the official feeds don't provide — geocoded locations, USD-normalized salaries, and AI-extracted skills.

### What data can you extract from Workable?

Every result is a structured job record in Jobo's normalized schema — the same shape across all Jobo actors, so you can mix sources freely. Highlights:

| Field | Description |
|-------|-------------|
| `title` / `normalized_title` | Raw posting title + canonical title for grouping |
| `occupation` | What kind of job: category › subcategory › occupation (e.g. Healthcare › Nursing › Registered Nurse), with a stable `id` |
| `company` | Company preview: name, website, logo, summary, industries (+ `id` for enrichment) |
| `brand` | The brand the company trades under, when it is part of one (franchisee, independent agent or agency, hotel under a hotel group's flag): `id`, `name`, `domain`, `logo_url`. Omitted otherwise |
| `locations` | Geocoded: city, region, country, latitude/longitude |
| `compensation` | `{min, max, currency, period}`, normalized to annual USD for filtering |
| `employment_type` / `workplace_type` / `experience_level` | e.g. `"Full-time"` / `"Remote"` / `"Mid Level"` |
| `qualifications` | AI-extracted must-have & preferred skills (typed hard/soft), education, certifications |
| `responsibilities` / `benefits` | Bullet lists extracted from the description |
| `summary` / `description` | Short AI summary + full description, HTML stripped |
| `listing_url` / `apply_url` | Canonical Workable listing + the employer's ATS application page, or the listing itself when there is no separate form |
| `is_h1b_sponsor` / `is_work_auth_required` / `is_clearance_required` | Work-authorization signals |
| `date_posted` / `created_at` / `updated_at` | Employer posting date + Jobo index/refresh timestamps |
| `source` | Always `"workable"` for this actor |

Set `include_company_details: true` to replace the company preview with the **fully enriched profile**: where available, funding rounds and investors, employee ratings, tech stack, headcount and revenue bands, and H1B filing history. The complete field list is on this page's **Output schema** tab and at [jobo.world/docs](https://jobo.world/docs/api-reference/companies/object).

### How much does it cost?

This actor uses **pay-per-result pricing**: you pay a fixed rate per job record returned — the current rate is in the pricing box on this page. There are no separate compute, proxy, or storage charges, and a run never returns more than `page_size` results, so spend is fully predictable. Apify's **free plan** includes enough credit to pull thousands of jobs, so you can evaluate the full dataset before paying anything.

### How do I scrape Workable jobs?

1. **Open the actor** and click **Try for free** — you'll need a free [Apify account](https://console.apify.com/).
2. **Enter your search** on the Input tab: keep the default `queries` (`["Software Engineer", "Account Manager"]`) or add your own titles and `locations`.
3. **Narrow with filters** (optional): job category, work model, experience level, salary range, skills, or specific companies.
4. **Click Start.** A typical run finishes in under a minute.
5. **Export your results** from the Output tab as JSON, CSV, or Excel — or connect a schedule, webhook, or integration to make it run on autopilot.

### ⬇️ Input

Every field is optional — an empty input returns the newest Workable jobs. Up to **5** `queries` are OR-ed together; prefix a token with `-` to exclude it.

| Parameter | Type | Description |
|-----------|------|-------------|
| `queries` | array (≤5) | Job titles or keywords, OR-ed. `-token` excludes. |
| `locations` | array | Cities, regions, or countries — geocoded server-side. |
| `work_models` | array | `remote`, `hybrid`, `onsite`. |
| `employment_types` | array | `full-time`, `part-time`, `contract`, `internship`, `freelance`, `temporary`. |
| `experience_levels` | array | `intern`, `entry`, `mid`, `senior`, `lead`, `executive`. |
| `job_categories` / `job_subcategories` | array | What kind of job, picked from a list (e.g. `Healthcare`, `Nursing`). |
| `occupation_ids` | array | Exact occupations by id, from the `occupation.id` of any result. Browse categories, subcategories and occupation ids at [jobo.world/api/search-builder](https://jobo.world/api/search-builder). |
| `skills_include` / `skills_exclude` | array | Match against AI-extracted skills. |
| `companies_include` / `companies_exclude` | array | Company name (whole-name match, case-insensitive), website domain, or Jobo company id. See the FAQ. |
| `min_salary_usd` / `max_salary_usd` | integer | Annual USD bounds; jobs without a disclosed salary are excluded when set. |
| `posted_after` / `posted_before` | string | ISO 8601 (`2026-01-01`) or relative (`7 days ago`). |
| `page` / `page_size` | integer | Page 1–100 × 1–100 results per page (default 50). |
| `include_company_details` | boolean | Attach the full enriched company profile (default `false`). |
| `description_format` | string | `markdown` (default) or `html`. `enhanced` and `enhanced_html` (beta) return the same words with consistent headings, lists and key facts; they are not guaranteed to be perfect, and a job without an enhanced description returns its standard one. |

The full input schema with defaults is on this page's **Input schema** tab.

**Remote roles, biggest page**

```json
{
  "queries": ["Software Engineer"],
  "work_models": ["remote"],
  "page_size": 100
}
```

**Every full-time UK opening at Treatwell and Costello Medical**

```json
{
  "companies_include": ["Treatwell", "Costello Medical"],
  "locations": ["United Kingdom"],
  "employment_types": ["full-time"],
  "page_size": 100
}
```

### ⬆️ Output example

Results land in the dataset under two views: *Workable Job Listings* (one row per job) and *Company details* (populated when `include_company_details` is on). Export as JSON, CSV, or Excel. A typical record:

```json
{
  "id": "52b308c6-87fc-424a-84e7-aaf51ae07f1d",
  "title": "Account Manager",
  "normalized_title": "Account Manager",
  "occupation": {
    "id": "esco:2eac08c2-a81a-46fc-8d75-eb0e0f3e0f6d",
    "name": "Account Manager",
    "category": "Sales",
    "subcategory": "B2B Sales & Account Management",
    "isco_code": "1420",
    "onet_soc_codes": ["11-2022.00"]
  },
  "summary": "The Account Manager builds strong client relationships and drives growth for Inventi's payment infrastructure technology. Responsibilities include managing client onboarding, reducing churn, and increasing revenue…",
  "company": {
    "id": "847e6b74-f118-4115-afb4-d91e83314334",
    "name": "Inventi",
    "website": "https://inventi.io/",
    "logo_url": "https://images.jobo.world/logos/4JnndWjmPak3E63ZB3EZu7.jpg",
    "industries": ["Custom Software & IT Services"],
    "details_url": "https://connect.jobo.world/api/companies/847e6b74-f118-4115-afb4-d91e83314334"
  },
  "locations": [
    {
      "location": "Vilnius, Vilnius City Municipality, Lithuania",
      "city": "Vilnius",
      "region": "Vilnius County",
      "country": "Lithuania",
      "latitude": 54.6870458,
      "longitude": 25.2829111
    }
  ],
  "compensation": { "min": 2600, "max": 3400, "currency": "EUR", "period": "monthly" },
  "employment_type": "Full-time",
  "workplace_type": "Hybrid",
  "experience_level": "Mid Level",
  "qualifications": {
    "must_have": {
      "skills": [
        { "name": "Account Management", "type": "hard" },
        { "name": "Client Onboarding", "type": "hard" },
        { "name": "Upselling", "type": "hard" }
      ]
    },
    "preferred": {
      "skills": [
        { "name": "Finance", "type": "hard" },
        { "name": "Payments", "type": "hard" }
      ]
    }
  },
  "listing_url": "https://jobs.workable.com/view/7yvMGzV5iMKcmvrLF95Dci/hybrid-account-manager-in-vilnius-at-inventi",
  "apply_url": "https://jobs.workable.com/view/7yvMGzV5iMKcmvrLF95Dci/hybrid-account-manager-in-vilnius-at-inventi",
  "source": "workable",
  "date_posted": "2026-07-07T12:28:21Z",
  "description": "…full job description, HTML stripped…"
}
```

### What can you expect from a run?

- **One run returns one page** — up to 100 results per call. Walk `page` 1→100 to reach **10,000 jobs per query**; for full-inventory pulls use [Career Site Jobs Feed](https://apify.com/jobo.world/career-site-jobs-feed) (cursor pagination, 1,000 jobs per batch).
- **Freshness**: Jobo checks every tracked Workable career site daily for new and expired listings; jobs removed from the employer's site drop out of the feed.
- **Salaries**: disclosed salaries are converted to annual USD using a fixed exchange-rate table, so `min_salary_usd` works across currencies (values are approximate).
- **Geocoding is best-effort** — loose strings like `"Worldwide"` won't geocode, but the raw location string is always preserved.
- **`industries` can be empty** for long-tail companies that Jobo's enrichment pipeline hasn't profiled yet.
- **`source` is always `"workable"`** — handy for provenance when you mix datasets from several Jobo actors.

### Integrations, API & MCP

Everything on the Apify platform works out of the box: **schedules** (hourly/daily/weekly runs), **webhooks** on run completion, and one-click integrations with **Zapier, Make, n8n, Slack, Google Sheets, and Google Drive**.

Prefer code? Call this actor as a **Workable jobs API** from Python or JavaScript with the [Apify API clients](https://docs.apify.com/api) — start a run, wait for it, and page through the dataset in a few lines (ready-made snippets are in the **API** section of this page). AI agents can run it through the **[Apify MCP server](https://mcp.apify.com)**, which exposes this actor as a tool.

### Use cases

| Who | What for |
|-----|----------|
| **Job boards** | Local and niche job boards built on SMB inventory the big aggregators miss |
| **AI agents** | Career copilots and résumé-matching agents grounded in live SMB openings worldwide |
| **Recruiters** | Sourcing intel on small and mid-sized employers hiring under the radar |
| **HR tech** | SMB hiring dashboards across the US, UK, Canada, and beyond |
| **Salary research** | Compensation benchmarks from SMB postings across markets and currencies |
| **Market research** | Small-business hiring trends across sectors and countries |

### ❓ FAQ

#### My company filter returned zero jobs — why?

One of three causes — the **Company match report** in the run's Output tab gives
a per-name answer:

1. **Not the full stored name.** Matching is whole-name, case-insensitive:
   `Glenmark` won't find `Glenmark Pharmaceuticals`. Passing the company's
   website domain (`glenmark.com`) or Jobo company id works too and sidesteps
   spelling entirely.
2. **The company is on a different ATS.** This actor only covers Workable — use
   [Career Site Jobs API](https://apify.com/jobo.world/ats-jobs-api) for cross-platform
   coverage.
3. **Another filter excluded everything.** `queries` is pre-filled with example
   job titles — clear it to search a company's whole job list.

#### Should I use this actor or Career Site Jobs API?

Use **this actor** if you only need Workable — simpler input, identical output schema. Use [Career Site Jobs API](https://apify.com/jobo.world/ats-jobs-api) to search Workable together with Workday, SmartRecruiters, iCIMS, and 200+ other platforms in one call.

#### How do I download more than 10,000 jobs?

Use [Career Site Jobs Feed](https://apify.com/jobo.world/career-site-jobs-feed) — it streams the full inventory with cursor pagination at 1,000 jobs per batch, built for ETL pipelines.

#### Are duplicate listings removed?

Yes. Listings are de-duplicated by the source ATS's native job ID within each employer.

#### Can I filter by salary?

Yes — `min_salary_usd` / `max_salary_usd`, matched against USD-normalized compensation. Jobs that don't disclose a salary are excluded whenever a salary filter is set.

#### How fresh is the data?

New Workable jobs are picked up on the next daily check. Jobo checks every tracked Workable career site daily for new and expired listings, and jobs removed from the employer's site drop out of the feed.

#### What kinds of companies hire on Workable?

Mostly small and mid-sized businesses — the honest middle of the market. Current employers include **Treatwell, COBS Bread, Charger Logistics, Costello Medical, and Frontiers Media**, spanning food retail, logistics, medical communications, and scientific publishing. Nearly half of postings are in the US, with the UK and Canada next — so expect real local businesses, not just tech startups.

#### Does this actor cover private or unlisted Workable postings?

No — it indexes publicly published job boards only, the listings employers post to be found. Internal-only or unlisted requisitions never appear.

#### Where can I check if the API behind this actor is up?

At [jobo.world/status](https://jobo.world/status) — the live status page for the Jobo Connect API that powers every Jobo actor.

### ⚖️ Is it legal to scrape Workable job listings?

Jobo only collects job postings employers publish publicly on their career sites, and returns no personal data about candidates. Postings can still incidentally contain personal data (e.g., a recruiter's name in a job description), which the GDPR and similar regulations protect, so only process it with a legitimate reason. Whether a use is lawful depends on your jurisdiction and use case, so check with your counsel for anything sensitive. Read more in Apify's guide to [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

Workable is a trademark of Workable. This actor is an independent product and is not affiliated with, endorsed by, or sponsored by Workable.

### 🔗 Related actors

| Actor | Best for |
|-------|----------|
| [Career Site Jobs API](https://apify.com/jobo.world/ats-jobs-api) | Search 200+ ATS platforms in one call |
| [Career Site Jobs Feed](https://apify.com/jobo.world/career-site-jobs-feed) | Bulk export for data pipelines — cursor pagination, 1,000 jobs/batch |
| [AI Deep Job Search](https://apify.com/jobo.world/ai-deep-job-search) | Describe your ideal job in plain English, get AI-scored matches |
| [SmartRecruiters Jobs Scraper](https://apify.com/jobo.world/smartrecruiters-jobs-scraper-api) | 375,000+ jobs from global brands on SmartRecruiters |
| [BambooHR Jobs Scraper](https://apify.com/jobo.world/bamboohr-jobs-scraper-api) | 60,000+ jobs from North American SMBs on BambooHR |

### About Jobo & support

Jobo builds job-data infrastructure: a normalized index of jobs built from daily checks of company ATS career sites, powering job boards, AI agents, and HR-tech products.

- **Questions or bugs?** Open a ticket on this actor's **Issues** tab and we'll follow up.
- **Website**: [jobo.world](https://jobo.world/?src=apify) · **Enterprise API**: [jobo.world/enterprise](https://jobo.world/enterprise?src=apify) · **API status**: [jobo.world/status](https://jobo.world/status)
- **Email**: enrico@jobo.world

# Changelog

This Actor's version history is a separate document: https://apify.com/jobo.world/workable-jobs-scraper-api/changelog.md

# Actor input Schema

## `queries` (type: `array`):

Job titles or keywords (e.g., 'Software Engineer', 'Account Manager'). Multiple values are OR-ed. Up to 5 keywords. Adding more rarely improves results — narrow your filters (skills, companies, locations) for better matches.

## `locations` (type: `array`):

Cities, regions, or countries (e.g., 'London', 'Berlin', 'United States'). Geocoded server-side for better matching.

## `work_models` (type: `array`):

Where the work is performed. Leave empty for all.

## `employment_types` (type: `array`):

Filter by employment type. Leave empty for all.

## `experience_levels` (type: `array`):

Filter by seniority. Leave empty for all.

## `job_categories` (type: `array`):

Only return jobs in ANY of these categories (e.g. Healthcare, Technology). Most jobs are classified as category › subcategory › occupation, returned in their `occupation` field; jobs without one are left out when this filter is set. Leave empty for all.

## `job_subcategories` (type: `array`):

Only return jobs in ANY of these subcategories (e.g. Healthcare › Nursing). Combined with Job Category, a job must match both, so pick subcategories inside the categories you chose. Leave empty for all.

## `occupation_ids` (type: `array`):

Only return jobs with ANY of these occupations, by id (e.g. esco:8d3e8aaa-791b-4c75-a465-f3f827028f50 for Registered Nurse). Copy ids from the occupation.id field of any result; ids stay stable when names improve.

## `skills_include` (type: `array`):

Only return jobs that require ANY of these skills (e.g., 'JavaScript', 'AWS', 'Salesforce'). Matched case-insensitively against the AI-extracted qualifications.

## `skills_exclude` (type: `array`):

Exclude jobs that require ANY of these skills.

## `companies_include` (type: `array`):

Only return jobs from these companies — and only companies whose jobs are indexed on Workable. Each entry can be the company's FULL name as stored in the Jobo index, its website domain (e.g. fedex.com), or its Jobo company id; name matching is on the whole name and case-insensitive, not partial ("Glenmark" will not find "Glenmark Pharmaceuticals"), though common legal suffixes are handled. A company hosted on a DIFFERENT ATS returns zero results here even when the name is spelled correctly — use the Career Site Jobs API actor for cross-platform coverage. If a run returns nothing, open Output → Company match report. Tip: the exact stored name is the company.name field on any job result. To build a list, run a search without this filter and copy the company.name values from the output instead of typing names by hand.

## `companies_exclude` (type: `array`):

Exclude jobs from these companies. Useful for filtering out staffing agencies or companies you have already applied to. Entries take the same forms as the include filter: a whole company name, a website domain, or a Jobo company id. An entry that matches no stored company is a silent no-op: it excludes nothing and the run does not fail.

## `min_salary_usd` (type: `integer`):

Minimum annual salary in USD. Jobs without disclosed salary are excluded when this filter is set.

## `max_salary_usd` (type: `integer`):

Maximum annual salary in USD. Combine with min_salary_usd for a range.

## `posted_after` (type: `string`):

Only show jobs whose employer posting date is after this date. Jobs without an ATS posting date use the Jobo first-indexed date. Accepts ISO 8601 (e.g. '2026-01-01T00:00:00Z') or relative strings ('7 days ago', '1 month').

## `posted_before` (type: `string`):

Only show jobs whose employer posting date is before this date. Jobs without an ATS posting date use the Jobo first-indexed date. Accepts ISO 8601 dates or relative strings.

## `page` (type: `integer`):

Page number for paginated results. Up to page 100.

## `page_size` (type: `integer`):

Number of results per page (1-100).

## `include_company_details` (type: `boolean`):

When enabled, replaces the lightweight company preview on each job with the fully enriched company profile (funding, ratings, tech stack, H1B stats, etc., where available) fetched from GET /api/companies/{id}. Companies are deduplicated, so each unique company is fetched only once per run. Slower and uses more API calls — leave off if you only need basic company info.

## `description_format` (type: `string`):

Format of each job's description: Markdown (default) or HTML. The enhanced formats (beta) return the same words with consistent headings, lists and key facts, and are not guaranteed to be perfect; a job without an enhanced description returns its standard one.

## Actor input object example

```json
{
  "queries": [
    "Software Engineer",
    "Account Manager"
  ],
  "page": 1,
  "page_size": 50,
  "include_company_details": false,
  "description_format": "markdown"
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `csv_export` (type: `string`):

No description

## `company_match_report` (type: `string`):

Which of your companies_include entries matched a company, which did not, and which are indexed on a different ATS. Written whenever a company filter is used.

# 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 = {
    "queries": [
        "Software Engineer",
        "Account Manager"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("jobo.world/workable-jobs-scraper-api").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 = { "queries": [
        "Software Engineer",
        "Account Manager",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("jobo.world/workable-jobs-scraper-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "Software Engineer",
    "Account Manager"
  ]
}' |
apify call jobo.world/workable-jobs-scraper-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,jobo.world/workable-jobs-scraper-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/OhdgXhuXnMVv1kbHo/builds/nWfTerKC2WX2bkrcB/openapi.json