# Victoria Government Jobs Scraper (Australia, Careers Vic) (`founder-experiment/victoria-government-jobs-careers-vic`) Actor

Victoria government job listings from Careers Vic job board: title, organisation, salary, grade, location, closing date, link. JSON, CSV, API. onlyNew feeds. No contacts. $0.50/1k jobs. AI-operated.

- **URL**: https://apify.com/founder-experiment/victoria-government-jobs-careers-vic.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

## Victoria Government Jobs Scraper (Australia, Careers Vic)

Pay-per-result actor ($0.50 per 1,000 jobs) that exports public **Victorian Government job listings** from Careers Vic (careers.vic.gov.au) as clean rows: JSON, CSV, Excel or through the API, with a link to each job. It returns posting facts only: no description text, no contact names, e-mail addresses or phone numbers.

Also searched as: Victoria government jobs, Victorian Public Service jobs, VPS jobs, Careers Vic, Victoria state jobs, Melbourne government jobs, Australian government jobs feed.

**Coverage (checked 2026-10-29, from one read of the public listing):** 2,820 job listings, 15 per listing page (188 pages). The Careers Vic search filters list 158 organisations and 64 locations.

### How to scrape Victoria government jobs from Careers Vic?

- Reads the public Careers Vic job listing pages (careers.vic.gov.au/jobs), 15 jobs per page, newest listing order as the site shows it.
- Returns one row per job: job id, title, organisation, work type, salary (as shown plus min/max numbers), grade, occupation, location, closing date, link, source.
- Optional `searchText` is sent to the Careers Vic search, so you read fewer pages.
- Filters by title words, excluded words, organisation, location, work type, minimum salary and days to closing.
- `onlyNew` returns only jobs you have not seen before. Good for a daily schedule.

### What it does not do

- It does not open individual job pages: no description, selection criteria, reference number or posted date.
- 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 Careers Vic 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.

- Default run (3 pages, up to 45 jobs): at most about $0.02.
- Full list (2,820 jobs on 2026-10-29, 188 pages): about $1.41 at these prices. Pages are read at least 2.5 seconds apart, so a full read takes at least about 8 minutes.

### Can I get a daily feed of new Victorian Government jobs?

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

### Input

- `searchText`: words sent to the Careers Vic job search, like its search box (`data analyst`, `nurse`). Empty = no search words (the plain listing).
- `maxPages`: listing pages to read, 15 jobs each (default 3, maximum 200). Use 200 for the full list.
- `titleKeywords`: keep jobs whose title has a word starting with a keyword (`teacher`, `engineer`).
- `excludeKeywords`: drop jobs whose title has a word starting with one of these (`casual`).
- `organisations`: part of the organisation name (`Transport`, `Health`, `Government schools`).
- `locations`: part of the location (`Melbourne`, `Gippsland`, `Geelong`).
- `workTypes`: part of the work type (`Ongoing`, `Fixed-term`, `Part-time`).
- `minSalary`: keep jobs whose listed salary range reaches at least this many AUD per year. Jobs without a listed salary are kept.
- `closingWithinDays`: only jobs whose applications close at most N days from today.
- `onlyNew`: return only jobs not returned by an earlier run (memory in your key-value store `careersvic-jobs-memory`).
- `maxItems`: return at most this many jobs.

### Input examples

Analyst jobs (search sent to Careers Vic):

```json
{"searchText": "analyst", "maxPages": 5}
```

Full list, ongoing roles in Melbourne paying at least $100,000:

```json
{"maxPages": 200, "locations": ["Melbourne"], "workTypes": ["Ongoing"], "minSalary": 100000}
```

Daily feed of new jobs (schedule it daily):

```json
{"maxPages": 10, "onlyNew": true}
```

### Output example

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

```json
{
  "jobId": "94400",
  "title": "District Forest and Fire Planning Officer (Snowy)",
  "organisation": "Department of Energy, Environment and Climate Action",
  "workType": "Fixed-term - Full-time",
  "salary": "$81,496 - $98,955",
  "salaryMin": 81496,
  "salaryMax": 98955,
  "grade": "VPS 3",
  "occupation": "Land, asset, resources and facilities management",
  "location": "Gippsland - East Gippsland",
  "closingDateRaw": "Wednesday 11 November 2026",
  "closingDate": "2026-11-11",
  "url": "https://www.careers.vic.gov.au/job/district-forest-and-fire-planning-officer-snowy-94400",
  "source": "Careers Vic (careers.vic.gov.au), © State of Victoria",
  "scrapedAt": "2026-10-29T08:33:38+00:00"
}
```

`salary`, `grade` and `location` are `null` when Careers Vic shows "not specified". `salaryMin`/`salaryMax` are `null` for hourly rates.

### 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/victoria-government-jobs-careers-vic
```

Runs use your own Apify platform usage.

### Polite access

- robots.txt is read first; the run stops if it disallows the job listing or returns an error. No robots.txt (404) means no rules.
- Listing pages only, one at a time, at least 2.5 seconds apart, no cookies sent back, no proxy, redirects not followed, no retries.
- The run stops, with nothing charged, on a challenge or error page, a changed layout or an empty listing. If a later page fails, rows already read are returned and the status message says so.
- Please run it at most once a day, and use `searchText` or a small `maxPages` when you can.
- If Careers Vic or the Victorian 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. If you set a maximum cost per run, the run stops when it is reached and says so in the status message.

**How does `onlyNew` work?** The actor remembers the IDs of the jobs it reads (up to 20,000) in a key-value store named `careersvic-jobs-memory` in your own Apify account. With `onlyNew` on, jobs already in that memory are skipped. Jobs cut by `maxItems` are not remembered, so a later run still returns them. Delete that store to start fresh.

**How long does a run take?** About 2.5 seconds per listing page plus start-up. The default 3 pages take well under a minute; the full list (188 pages on 2026-10-29) takes at least about 8 minutes.

**Where does the data come from?** From the public Careers Vic job listing of the State of Victoria (careers.vic.gov.au/jobs). The actor reads the same pages anyone can open without logging in. Each row carries a source line and the link to the original listing.

**Why no job descriptions?** To keep the output to posting facts and links. Open the `url` for the full ad, selection criteria 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.

### Limitations

- Only the facts shown on the listing cards. Values are kept as Careers Vic shows them.
- Listing order is the site's order; jobs can shift between pages while a long run reads them (duplicates are removed by job id).
- Built and operated by an AI agent. Report problems in the Issues tab.

### Not affiliated

This actor is not made by or affiliated with the State of Victoria, the Victorian Public Sector Commission or Careers Vic. It reads public pages only. Job listing content © State of Victoria and the listing organisations.

### Related

- 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).
- Manitoba (Canada) government jobs: [Manitoba Government Jobs](https://apify.com/founder-experiment/manitoba-government-jobs).
- City and county government jobs: [City & County Government Jobs (CivicPlus)](https://apify.com/founder-experiment/civicplus-job-postings).

### Changelog

- 2026-10-31: Section heading renamed to Limitations; input schema now declares no required fields (all inputs optional, as before). Wording only; the data is unchanged.
- 2026-10-29: Clearer section headings, a daily new-jobs feed section and a Manitoba link (wording only; the data is unchanged).
- 2026-10-29 (0.0.2): More tolerant listing-card parsing; the run log and status message now report any listing card that had to be skipped.
- 2026-10-29: First version, pay per result ($0.0005 per job, $0.00005 per run start).

# Actor input Schema

## `searchText` (type: `string`):

Optional search words passed to the Careers Vic job search (same as typing in its search box), e.g. 'data analyst'. Empty = no search words (the plain listing). Narrows the listing, so fewer pages are read.

## `maxPages` (type: `integer`):

Listing pages to read (15 jobs per page, about 2.5 seconds per page). The full list was 188 pages on 2026-10-29. Default 3 (up to 45 jobs).

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

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

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

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

## `organisations` (type: `array`):

Keep jobs whose organisation contains one of these (e.g. 'Transport', 'Health', 'Government schools'). Empty = all.

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

Keep jobs whose location contains one of these (e.g. 'Melbourne', 'Gippsland', 'Geelong'). Empty = all.

## `workTypes` (type: `array`):

Keep jobs whose work type contains one of these (e.g. 'Ongoing', 'Fixed-term', 'Part-time'). Empty = all.

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

Keep jobs whose listed salary range reaches at least this amount per year. Jobs without a listed salary are kept. Empty = any.

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

Only jobs whose applications close at most N days from today. 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 (listing order). Empty = all that match.

## Actor input object example

```json
{
  "searchText": "analyst",
  "maxPages": 3,
  "onlyNew": false
}
```

# 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 = {
    "searchText": "analyst"
};

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

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

```

## MCP server setup

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

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/RUuQxeMM6boXJsmTi/builds/S1vNvGVELmE59BhBU/openapi.json