# Workopolis Jobs Search Scraper (`soft_alexist/workopolis-jobs-search-scraper`) Actor

Scrape Workopolis.com search results at scale. This scraper collects job titles, company details, salary info, job types, benefits, remote attributes, and 18+ fields per listing — perfect for recruiters, job aggregators, and labor market researchers.

- **URL**: https://apify.com/soft\_alexist/workopolis-jobs-search-scraper.md
- **Developed by:** [Soft Alexist](https://apify.com/soft_alexist) (community)
- **Categories:** Automation, Developer tools, Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Workopolis Jobs Search Scraper: Bulk Extract Canadian Job Listings

---

### What Is Workopolis.com?

Workopolis.com is Canada's largest job search platform, hosting hundreds of thousands of active job listings across all industries and skill levels. It is a go-to destination for Canadian job seekers and recruiters alike. Manually collecting data from Workopolis search results is laborious — the **Workopolis Jobs Search Scraper** automates this process, extracting structured job data directly from search pages and delivering ready-to-analyze records.

---

### Overview

The **Workopolis Jobs Search Scraper** extracts job listings from Workopolis search results pages, converting unstructured job cards into clean, queryable data. It is ideal for:

- **Recruiters** monitoring competitive job postings and talent demand
- **Job aggregator platforms** feeding Canadian job data into multi-site boards
- **HR analysts** building labor market datasets and salary benchmarks
- **Career researchers** studying job market trends in Canada
- **Business intelligence teams** tracking hiring patterns by industry

Key features include support for large batch extractions (up to 200 items per URL), fault tolerance via `ignore_url_failures`, and comprehensive output fields covering job details, compensation, benefits, and company information.

---

### Input Format

The scraper accepts a JSON configuration object:

```json
{
  "urls": [
    "https://www.workopolis.com/search?q=full+time"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 200
}
````

#### Input Parameters Explained

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array of strings | Direct links to Workopolis search results pages. Use search filters (keyword, location, job type) to customize. Example: `https://www.workopolis.com/search?q=full+time&l=Toronto` |
| `ignore_url_failures` | Boolean | If `true`, the scraper skips URLs that fail to load instead of halting the entire run. Recommended for bulk operations. |
| `max_items_per_url` | Integer | Maximum number of job listings to extract per search URL. Range: 1–200. Use `200` for maximum bulk extraction, or lower values to limit results. |

> **Example URLs:**
>
> - `https://www.workopolis.com/search?q=full+time` — All full-time roles
> - `https://www.workopolis.com/search?q=software+engineer&l=Vancouver` — Software engineers in Vancouver
> - `https://www.workopolis.com/search?q=data+analyst&d=50` — Data analysts within 50 km radius

***

### Output Format

**Sample output**

```json
{
  "job_key": "TgeS04vKnHF9iIqe8aNmggVV81J-K3dHdb79bpsVihO7Da2_3_phmttY-UDY9sF1",
  "snippet": "All studies require that you be able to read, write and take direction as well as type a minimum of 25 words per minute.",
  "title": "Remote Data Entry Admin Assistant",
  "job_card_tracking_key": "5-pdx1-0-1jt6hl26dj2pe800-c888dd8af5a27aea",
  "encoded_url": "%2Fjobsearch%2Fviewjob%2FTgeS04vKnHF9iIqe8aNmggVV81J-K3dHdb79bpsVihO7Da2_3_phmttY-UDY9sF1%3FjobCardTrackingKey%3D5-pdx1-0-1jt6hl26dj2pe800-c888dd8af5a27aea%26xkcb%3DSoCs67M3hmrbjHxQLZ0KbzkdCdPP",
  "requirements": [
    "No experience needed",
    "Administrative experience",
    "Data entry",
    "Typing"
  ],
  "job_types": [
    "Full-time"
  ],
  "benefits": [],
  "remote_attributes": [
    "Remote"
  ],
  "uncategorized": [
    "Mobile devices"
  ],
  "bot_url": "/jobsearch/viewjob/TgeS04vKnHF9iIqe8aNmggVV81J-K3dHdb79bpsVihO7Da2_3_phmttY-UDY9sF1",
  "location": "Arizona, MB",
  "company": "Pathway Serious Mental Illness Society",
  "company_rating": -1,
  "salary_info": "",
  "indeed_apply": true,
  "date_on_indeed": 1752483050138,
  "sponsored": false,
  "auction": false,
  "camk": "",
  "company_page_url": "/browse-jobs/companies/Pathway-Serious-Mental-Illness-Society",
  "encoded_job_click_ping_url": "%2Fout%3Fr%3DklXCGs3VzdPImJqjFnsQAp1Q1D749yRwquGbik3xETavjnadqU_SSyQVPaCqv-VGEomzNuVisf3oTdOldL4LNrqoc2DEpKeRgWiFkQKjUlfp4eRxZFdrcCGoGFyzmBf2bLgykNMeTcg7G3LhC7asoGq0WrFuDZMSCn8QiZtwLMEija526QZWL82Sbv4QnuMnfgwlrKinocTgJb-D2DUcAe7pnm-cc_ePtWTnYY9MHYw3XjipkQdCvRYMZQsjLjhNbb91Amn39w6Haqv_wDV1Dbq9IRIqPsIds7ZggQ9eL3RNn2BeiKETpAPWTjcCh0JxSEROZqYXy506eztfBjI3mGtOgUY0vIvranrAQxBGeqJrgMccjk8rWoh2Cdrft39ZXIYJgJTJzAbUwRg1nsx_8dcH",
  "from_url": "https://www.workopolis.com/search?q=full+time"
}
```

Each extracted job listing returns a structured record with 18 data fields:

#### Identification & Tracking

| Field | Meaning | Example |
|---|---|---|
| `Job Key` | Unique identifier for this job posting | `abc123xyz` |
| `Job Card Tracking Key` | Internal tracking code used by Workopolis | `track_456` |
| `Encoded URL` | URL-encoded job application link | `https://www.workopolis.com/job/...` |
| `Bot URL` | Machine-readable job URL for tracking | `https://...bot-tracking...` |
| `Encoded Job Click Ping URL` | Analytics ping URL for click tracking | `https://...ping...` |

#### Job Core Information

| Field | Meaning | Example |
|---|---|---|
| `Title` | Job position title | "Senior Software Engineer" |
| `Snippet` | Short summary of the job posting | "We're hiring a Senior Software Engineer..." |
| `Requirements` | Required qualifications and skills | "5+ years experience, Python, AWS" |
| `Job Types` | Employment classification | "Full-time, Permanent" |

#### Location & Company

| Field | Meaning | Example |
|---|---|---|
| `Location` | Job work location | "Toronto, ON" or "Remote" |
| `Company` | Employer name | "Acme Corporation" |
| `Company Rating` | Employer reputation score (if available) | "4.2/5" |
| `Company Page URL` | Direct link to the employer's company page | `https://www.workopolis.com/company/...` |

#### Compensation & Benefits

| Field | Meaning | Example |
|---|---|---|
| `Salary Info` | Stated wage range or salary (if disclosed) | "$80,000 - $120,000 per year" or "Competitive salary" |
| `Benefits` | Offered perks and benefits | "Health insurance, Dental, 3 weeks vacation, RRSP matching" |

#### Work Arrangement

| Field | Meaning | Example |
|---|---|---|
| `Remote Attributes` | Work location flexibility | "Fully remote, Hybrid, On-site" |

#### Miscellaneous

| Field | Meaning | Example |
|---|---|---|
| `Uncategorized` | Additional unclassified metadata | (Varies by posting) |
| `Sponsored` | Whether the listing is a paid promotion | `true` or `false` |
| `Auction` | Auction or bidding status (if applicable) | `true` or `false` |
| `CAMK` | Campaign/market code identifier | `CA_2024_Q1` |
| `Date On Indeed` | Posting date (when indexed) | `2024-01-15` |

***

### How to Use

1. **Build search URLs** — Visit Workopolis.com and construct search queries using filters (keyword, location, job type, salary range, remote status). Copy the resulting URL.

2. **Enter URLs** — Paste one or more Workopolis search URLs into the `urls` array. You can add multiple search combinations in a single run.

3. **Set extraction limits** — Adjust `max_items_per_url`:
   - `20–50` for focused, smaller datasets
   - `100–200` for bulk extraction from large search results

4. **Enable fault tolerance** — Set `ignore_url_failures: true` to prevent single failed URLs from stopping the entire job.

5. **Execute the scraper** — Start the run and monitor progress via logs.

6. **Export data** — Download results as JSON, CSV, or Excel for analysis or integration.

**Best practices:**

- Use location and keyword filters in URLs to narrow results and reduce noise
- Test with a small `max_items_per_url` (e.g., 20) before scaling to 200
- For very large extractions, split into multiple jobs rather than one massive URL list
- Store date of scrape alongside results for historical tracking

***

### Use Cases & Business Value

- **Job market intelligence:** Track hiring volume, trending skills, and salary benchmarks across Canadian industries
- **Competitor analysis:** Monitor what rival companies are posting and how they position roles
- **Aggregator platforms:** Feed real-time Canadian job data into multi-source job boards
- **Academic research:** Study Canadian labor market dynamics and sectoral trends
- **Talent pipeline:** Build proprietary job databases for targeted outreach campaigns

By automating data collection from Workopolis, you eliminate weeks of manual browsing and build datasets that power smarter hiring decisions.

***

### Conclusion

The **Workopolis Jobs Search Scraper** is a powerful, reliable solution for anyone needing structured Canadian job data at volume. With 18 detailed output fields and flexible configuration, it turns Workopolis search results into actionable intelligence. Whether you're a recruiter, researcher, or platform builder, this scraper accelerates your workflow and unlocks insights that manual collection simply cannot provide.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.workopolis.com/search?q=full+time"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.workopolis.com/search?q=full+time"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("soft_alexist/workopolis-jobs-search-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "urls": ["https://www.workopolis.com/search?q=full+time"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("soft_alexist/workopolis-jobs-search-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 '{
  "urls": [
    "https://www.workopolis.com/search?q=full+time"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call soft_alexist/workopolis-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Workopolis Jobs Search Scraper",
        "description": "Scrape Workopolis.com search results at scale. This scraper collects job titles, company details, salary info, job types, benefits, remote attributes, and 18+ fields per listing — perfect for recruiters, job aggregators, and labor market researchers.",
        "version": "0.0",
        "x-build-id": "KtgycSkY4g9nQq1lH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/soft_alexist~workopolis-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-soft_alexist-workopolis-jobs-search-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/soft_alexist~workopolis-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-soft_alexist-workopolis-jobs-search-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/soft_alexist~workopolis-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-soft_alexist-workopolis-jobs-search-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": {
                    "urls": {
                        "title": "URLs of the Jobs list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
