# Manitoba Government Jobs Scraper (Canada) (`founder-experiment/manitoba-government-jobs`) Actor

Manitoba (Canada) government job listings, daily new-jobs feed: title, department, classification, salary, location, posted, closing date, link. JSON, CSV, API. No contacts. $0.50/1k. AI-operated.

- **URL**: https://apify.com/founder-experiment/manitoba-government-jobs.md
- **Developed by:** [Rowfield Data](https://apify.com/founder-experiment) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 job postings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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

## Manitoba Government Jobs Scraper (Canada)

Pay-per-result actor ($0.50 per 1,000 jobs) that exports public **Manitoba government job listings** (Canada) from the province's job site (jobsearch.gov.mb.ca) as clean rows: JSON, CSV, Excel or through the API, with a link to each posting. It returns posting facts only: no description text, no contact names, e-mail addresses or phone numbers.

Also searched as: Manitoba government jobs, Manitoba civil service jobs, Province of Manitoba careers, Winnipeg government jobs, Canada government jobs, Canada provincial government jobs feed, public sector jobs Canada.

**Coverage (checked 2026-10-29, from one read of the public feed):** 60 open postings (59 in English, 1 in French), posted 2026-06-19 to 2026-10-27, closing 2026-10-29 to 2027-01-15. The site offers 20 category feeds plus "All Positions".

### Quick start

1. Run it with the prefilled input: `{"category": "all", "maxItems": 20}`. That returns up to 20 jobs, about $0.01 at $0.50 per 1,000.
2. Export the dataset as CSV, JSON or Excel, or read it through the API.
3. For a daily feed, turn on `onlyNew` and add a schedule: later runs return and charge only postings you have not seen before.

### Use cases

| You want to... | What this actor gives you |
| --- | --- |
| Get Manitoba government job alerts | `onlyNew` on a daily schedule returns only new postings. |
| Track jobs by department, location or salary | Filters for title words, department, location, job type, language and minimum salary. |
| Catch deadlines | Posted and closing dates on every row, plus a days-to-closing filter. |
| Feed a job board, spreadsheet or AI agent | JSON, CSV, Excel or API output with a link to each posting. |

### How to scrape Manitoba government jobs?

- Reads the public RSS job feed that the job site publishes for RSS readers (one request per run), for all positions or one category.
- Returns one row per posting: advertisement number, title, classification, job type, department, location, salary (as shown plus annual min/max numbers), equity advertisement type, posting type, posted date, closing date, language, link, licence attribution.
- Filters by title words, excluded words, department, location, job type, language, minimum salary, days to closing and days since posting.
- `onlyNew` returns only postings you have not seen before. Good for a daily schedule.

### What it does not do

- It does not open individual job pages: no description, duties, qualifications or how-to-apply text.
- It returns no contact names, e-mails or phone numbers. A guard fails the run, with no rows pushed, if an e-mail or phone pattern shows up in the output.
- It does not log in, create accounts or apply for jobs.

### How much does it cost to scrape Manitoba government jobs?

Pay per result: $0.0005 per job returned ($0.50 per 1,000) and $0.00005 per run start; platform usage is included, so there is no separate compute fee. Jobs removed by your filters, cut by `maxItems` or skipped by `onlyNew` are not charged.

- Full feed (60 postings on 2026-10-29): about $0.03 per run.
- Daily `onlyNew` run: usually a few new postings, well under $0.01 per day.

### Can I get a daily feed of new Manitoba government jobs?

Yes. Schedule a daily run with `onlyNew` on: each run returns only postings that earlier runs did not return, so you pay only for new postings.

### Input

- `category`: `all` (default) or one category feed, e.g. `information-technology`, `health-social-services`, `maintenance-trades`, `bilingual`.
- `titleKeywords`: keep jobs whose title has a word starting with a keyword (`analyst`, `officer`).
- `excludeKeywords`: drop jobs whose title has a word starting with one of these.
- `departments`: part of the department name (`Justice`, `Families`, `Public Service Delivery`).
- `locations`: part of the location (`Winnipeg`, `Brandon`, `The Pas`).
- `jobTypes`: part of the job type (`Regular/full-time`, `Term`, `Departmental`).
- `language`: `any` (default), `en` or `fr`.
- `minSalary`: keep jobs whose annual salary range reaches at least this many CAD. Hourly, bi-weekly or missing salaries are kept.
- `closingWithinDays`, `postedWithinDays`: date windows from today.
- `onlyNew`: return only jobs not returned by an earlier run (memory in your key-value store `manitoba-gov-jobs-memory`).
- `maxItems`: return at most this many jobs.

### Input examples

IT jobs:

```json
{"category": "information-technology"}
```

Winnipeg roles paying at least $80,000 a year:

```json
{"locations": ["Winnipeg"], "minSalary": 80000}
```

Daily feed of new postings (schedule it daily):

```json
{"onlyNew": true}
```

### Output example

One row parsed from the public feed on 2026-10-29:

```json
{
  "title": "Director, Corporate Services and Finance",
  "adNo": "45770",
  "classification": "FI6 Financial Officer 6",
  "jobTypes": "Regular/full-time",
  "department": "Elections Manitoba",
  "locations": "Winnipeg MB",
  "salary": "FI6 $86,717.00 - $112,949.00 per year",
  "equityType": "Regular",
  "closingDate": "2026-11-09",
  "postedDate": "2026-10-23",
  "postingType": "Open",
  "postingId": "130395",
  "salaryMin": 86717,
  "salaryMax": 112949,
  "language": "en",
  "jobId": "45770-130395",
  "url": "http://jobsearch.gov.mb.ca/jow/advancedResult.action?postingType=0&category=0&jobType=0&lang=0&department=0&region=0&sort=postedDate&curPageNum=1&ID=130395#position",
  "source": "Contains information from the Government of Manitoba, licensed under the OpenMB Information and Data Use License (Manitoba.ca/OpenMB). Source: jobsearch.gov.mb.ca",
  "scrapedAt": "2026-10-29T10:25:13+00:00"
}
```

`salaryMin`/`salaryMax` are `null` for hourly or bi-weekly pay. French postings keep the French text as shown.

### Use it from an AI agent (MCP)

Add this actor as a tool through the Apify hosted MCP server:

```
https://mcp.apify.com?tools=founder-experiment/manitoba-government-jobs
```

Runs use your own Apify platform usage.

### Polite access

- robots.txt is read first; the run stops if it disallows the feed or returns an error. No robots.txt (404) means no rules.
- Two requests per run (robots.txt, then the feed), at least 2.5 seconds apart, no cookies sent back, no proxy, redirects not followed, no retries.
- The run stops, with nothing charged, if the feed returns an error or is not RSS.
- Please run it at most once a day.
- If the Manitoba government asks us to stop, we will unpublish this actor.

### FAQ

**What does it cost?** $0.50 per 1,000 jobs returned ($0.0005 per job) plus $0.00005 per run start. Platform usage is included. Jobs removed by your filters, cut by `maxItems` or skipped by `onlyNew` are not charged.

**How does `onlyNew` work?** The actor remembers the IDs of the postings it reads (up to 20,000) in a key-value store named `manitoba-gov-jobs-memory` in your own Apify account. With `onlyNew` on, postings already in that memory are skipped. Delete that store to start fresh.

**How long does a run take?** A few seconds plus start-up: it makes two requests.

**Where does the data come from?** From the public RSS job feed on jobsearch.gov.mb.ca, the same feed anyone can add to an RSS reader without logging in. Each row carries the OpenMB licence attribution and the link to the posting.

**Why no job descriptions?** To keep the output to posting facts and links. Open the `url` for the full ad and how to apply.

**Does it collect personal data?** No contact names, e-mails or phone numbers. A guard fails the run, with no rows pushed, if an e-mail or phone pattern shows up.

### Limits

- Only the facts in the feed. Values are kept as the feed shows them.
- About 60 open postings on 2026-10-29: a small, focused feed.
- Built and operated by an AI agent. Report problems in the Issues tab.

### Licence and not affiliated

Contains information from the Government of Manitoba, licensed under the OpenMB Information and Data Use License (Manitoba.ca/OpenMB). This actor is not made by, affiliated with or endorsed by the Government of Manitoba. It reads a public feed only and uses no government logos, crests or symbols.

### Related

- Victoria (Australia) government jobs: [Victoria Government Jobs (Careers Vic)](https://apify.com/founder-experiment/victoria-government-jobs-careers-vic).
- New York state jobs: [New York State Jobs (StateJobsNY)](https://apify.com/founder-experiment/new-york-state-jobs-statejobsny).
- California state jobs: [California State Jobs (CalCareers)](https://apify.com/founder-experiment/california-state-jobs-calcareers).

### Changelog

- 2026-10-29: Short description now names Canada (wording only; the data is unchanged).
- 2026-10-29: Clearer section headings and a daily new-jobs feed section; the short description now leads with the new-jobs feed (wording only; the data is unchanged).
- 2026-10-29: First version, pay per result ($0.0005 per job, $0.00005 per run start).

# Actor input Schema

## `category` (type: `string`):

Read all positions or one job category feed (the same categories the job site offers as RSS feeds). One request either way.

## `titleKeywords` (type: `array`):

Keep jobs whose title has a word starting with one of these (e.g. 'analyst', 'officer'). Applied after reading. Empty = all.

## `excludeKeywords` (type: `array`):

Drop jobs whose title has a word starting with one of these (e.g. 'term'). Empty = none.

## `departments` (type: `array`):

Keep jobs whose department contains one of these (e.g. 'Justice', 'Families'). Empty = all.

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

Keep jobs whose location contains one of these (e.g. 'Winnipeg', 'Brandon', 'The Pas'). Empty = all.

## `jobTypes` (type: `array`):

Keep jobs whose job type contains one of these (e.g. 'Regular/full-time', 'Term', 'Departmental'). Empty = all.

## `language` (type: `string`):

Most postings are in English; a few are published in French.

## `minSalary` (type: `integer`):

Keep jobs whose annual salary range reaches at least this amount. Jobs with hourly, bi-weekly or no salary are kept. Empty = any.

## `closingWithinDays` (type: `integer`):

Only jobs closing at most N days from today. 0 or empty = any.

## `postedWithinDays` (type: `integer`):

Only jobs posted in the last N days. 0 or empty = any.

## `onlyNew` (type: `boolean`):

Return only jobs not returned by an earlier run of this actor (for daily schedules).

## `maxItems` (type: `integer`):

Return at most this many jobs (feed order). Empty = all that match.

## Actor input object example

```json
{
  "category": "all",
  "language": "any",
  "onlyNew": false,
  "maxItems": 20
}
```

# Actor output Schema

## `results` (type: `string`):

All items in the default dataset, overview view.

# 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 = {
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("founder-experiment/manitoba-government-jobs").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 = { "maxItems": 20 }

# Run the Actor and wait for it to finish
run = client.actor("founder-experiment/manitoba-government-jobs").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 '{
  "maxItems": 20
}' |
apify call founder-experiment/manitoba-government-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,founder-experiment/manitoba-government-jobs"
        }
    }
}
```

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/nfIHXZaBhchJNFh81/builds/2xDGymxLsVtYZ8dMK/openapi.json