# Seek Jobs Scraper — Australia & NZ Job Listings, Salary (`bovi/seek-jobs-scraper`) Actor

Scrape job postings from Seek.com.au (Australia) and Seek.co.nz (New Zealand) via the public v5 search API. Get title, company, location, salary, work type, seniority, remote type, teaser, classification, and parse\_confidence. Multi-query batch, zero auth, zero proxy required.

- **URL**: https://apify.com/bovi/seek-jobs-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 415 total users, 147 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.87 / 1,000 job results

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Seek Jobs Scraper | $0.90/1K — Australia & NZ, Salary + Bullets

For AU/NZ recruiters, job aggregators building Australian boards, and market researchers tracking ANZ hiring trends — Seek is the dominant source with 10,000+ NZ and hundreds of thousands of AU listings.

**Pricing: $0.90/1,000 jobs** — one flat per-result rate; salary, seniority, bullet points and optional descriptions are all included, with no add-on fees.

**Zero auth. Zero proxy.** No scraping — pure official Seek v5 API endpoint, verified live 2026-05-31 at HTTP 200 with no blocking.

Scrape job postings from **Seek.com.au** (Australia) and **Seek.co.nz** (New Zealand) via the public Seek v5 search API. No auth, no proxy, no scraping hacks — pure official-endpoint access.

### Features

- **Dual market**: Australia (`AU-Main`) and New Zealand (`NZ-Main`) in one actor
- **Rich schema**: 23 fields including salary, work type, seniority (11 levels), remote type, classification, teaser, bullet points, and `parse_confidence`
- **Multi-query batch**: run multiple search queries in one actor run
- **Optional descriptions**: toggle full job description HTML + text (extra request per job)
- **Smart filters**: post-fetch keyword, location, remote-only filters
- **`parse_confidence`**: per-result quality score (0.0–1.0) — no competitor offers this

### Output schema

| Field | Description |
|---|---|
| `job_id` | Seek numeric job ID |
| `title` | Job title |
| `company` | Employer name |
| `location` | Full location label (e.g. "Sydney CBD, Sydney NSW") |
| `area` | Broader area (e.g. "All Sydney NSW") |
| `country_code` | AU or NZ |
| `remote_type` | `remote` / `hybrid` / `onsite` / null |
| `seniority` | intern / entry / mid / senior / lead / staff / principal / manager / director / vp / executive |
| `salary` | Salary label (e.g. "$100K – $120K per year") |
| `work_type` | Full time / Part time / Contract / Casual |
| `listing_date` | ISO 8601 date when posted |
| `url` | Job listing URL on seek.com |
| `teaser` | Short job description teaser |
| `classification` | Industry category (e.g. "Information & Communication Technology") |
| `subclassification` | Sub-category (e.g. "Engineering - Software") |
| `is_featured` | True if promoted/sponsored listing |
| `bullet_points` | Up to 3 key selling points from the listing |
| `description_html` | Full HTML description (when `includeDescriptions=true`) |
| `description_text` | Plain text description (when `includeDescriptions=true`) |
| `global_id` | Unique ID across all our actors: `seek:<job_id>` |
| `parse_confidence` | Data quality score 0.0–1.0 |
| `warnings` | List of data quality warning codes |
| `scraped_at` | ISO 8601 run timestamp |

### Pricing

Pay Per Event — one flat rate per job delivered to your dataset.

| Event | Rate / 1K | When charged |
|---|---|---|
| `job-result` | $0.90 | Every job returned — salary, seniority, bullet points and (optional) descriptions all included |

No proxy cost — this actor uses the Seek public JSON API directly.

### Pricing example

| Run | Jobs | Approx cost |
|---|---|---|
| Quick scan (200 jobs, no desc) | 200 | $0.18 |
| Full run (1,000 + descriptions) | 1,000 | $0.90 |
| Salary-focused (500 rows w/ salary) | 500 | $0.45 |

You are only charged for jobs actually delivered. Empty queries and blocked requests are not charged. Turning on `includeDescriptions` fetches an extra page per job (billed by Apify as platform compute, not as an extra per-result fee from us).

### Usage

```json
{
  "searchQueries": ["software engineer", "data scientist"],
  "siteKey": "AU-Main",
  "where": "Sydney NSW",
  "maxItems": 500,
  "includeDescriptions": false
}
```

### Output sample

```json
{
  "job_id": "80123456",
  "title": "Senior Software Engineer",
  "company": "Atlassian",
  "location": "Sydney CBD, Sydney NSW",
  "country_code": "AU",
  "remote_type": "hybrid",
  "seniority": "senior",
  "salary": "$140K - $180K per year",
  "work_type": "Full time",
  "listing_date": "2026-06-01T00:00:00+00:00",
  "classification": "Information & Communication Technology",
  "subclassification": "Engineering - Software",
  "is_featured": false,
  "bullet_points": ["Flexible work model", "Equity package", "5 weeks leave"],
  "parse_confidence": 1.0,
  "scraped_at": "2026-06-05T10:00:00+00:00"
}
```

### FAQ

**Do I need an API key or proxy?**
No. This actor uses Seek's official public v5 API — verified at HTTP 200 with no blocking. Zero credentials needed.

**Australia or New Zealand?**
Set `siteKey` to `AU-Main` for Seek.com.au or `NZ-Main` for Seek.co.nz. Both in one actor.

**Can I filter by industry?**
Yes — use `classificationId` (e.g. `6281` for ICT). Get category IDs from Seek's facet response or their public sitemap.

**What if a query returns 0 results?**
The actor logs the query as empty and exits cleanly — no crash, no charge for empty pages.

### Technical notes

- Endpoint: `https://www.seek.com.au/api/jobsearch/v5/search` — public, no auth required
- Verified live 2026-05-31: 10 rapid requests served with HTTP 200, no blocking
- Australia: 780+ results for "python developer"; New Zealand: 10,000+ total jobs
- Job descriptions sourced from `data-automation="jobAdDetails"` on individual job pages
- Not affiliated with Seek Limited. For commercial scraping at scale, review Seek's Terms of Service.

### Use with AI agents (MCP)

This actor is available via Apify's MCP server. Connect it to any MCP-compatible agent (Claude, n8n, Make) to pull live AU/NZ job data on demand — no code required.

```
https://mcp.apify.com/?tools=bovi/seek-jobs-scraper
```

### Vs. competitors

| Feature | This actor | Generic AU job scrapers |
|---|---|---|
| Australia + New Zealand in one | Yes | Usually one country |
| Salary label (structured) | Yes | Rarely |
| Bullet points (selling points) | Yes (up to 3) | No |
| Featured/sponsored flag | Yes | No |
| Industry classification | Yes (2-level) | No |
| `parse_confidence` | Yes | No |
| Zero proxy / official API | Yes | Often HTML scrape |
| Price | $0.90/1K | $3–5/1K |

Seek's v5 API reflects live listings. Schedule daily runs and compare `job_id` sets to detect new openings in your target classification automatically.

### Integrations

Built for AU/NZ recruiters, job aggregators, and labor-market researchers tracking hiring trends across Australia and New Zealand — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

- [Greenhouse, Lever & Ashby Job Scraper](https://apify.com/bovi/greenhouse-lever-ashby-job-scraper)
- [Glassdoor Scraper](https://apify.com/bovi/glassdoor-scraper)
- [Naukri Jobs Scraper](https://apify.com/bovi/naukri-jobs-scraper)
- [Indeed Employer Intelligence](https://apify.com/bovi/indeed-employer-intelligence)
- [Hiring Signal Monitor](https://apify.com/bovi/hiring-signal-monitor)
- [Ashby Job Scraper](https://apify.com/bovi/ashby-job-scraper)

Chain any of them together from the **Integrations** tab (the *Run succeeded* trigger) to build a multi-step workflow — one actor's output feeds the next.

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search for on Seek. Each item is one search query. Examples: "python developer", "nurse", "project manager remote". Runs one paginated search per query.

## `siteKey` (type: `string`):

Which Seek site to search. AU-Main = Seek.com.au (Australia). NZ-Main = Seek.co.nz (New Zealand).

## `where` (type: `string`):

Seek location text filter. Examples: "All Australia", "Sydney NSW", "Melbourne VIC", "All New Zealand". Leave blank to search all locations.

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

Maximum total jobs to push across all queries. Default 200 keeps trial runs cheap. Set to 0 for unlimited (may be thousands).

## `includeDescriptions` (type: `boolean`):

Fetch full job description HTML + plain text from each job's detail page. Requires one extra HTTP request per job — slower but richer output. Off by default to keep runs fast.

## `titleKeyword` (type: `string`):

Post-fetch filter: keep only jobs whose title contains this text (case-insensitive). Example: "engineer". Leave blank to return all.

## `locationKeyword` (type: `string`):

Post-fetch filter: keep only jobs whose location label contains this text (case-insensitive). Example: "Sydney". Leave blank for all locations.

## `remoteOnly` (type: `boolean`):

When enabled, only jobs with remote\_type="remote" are returned (inferred from Seek workArrangements and location text).

## `workType` (type: `string`):

Filter by Seek work type: Full time, Part time, Contract, Casual. Leave blank for all.

## `classificationId` (type: `string`):

Seek classification ID to filter by industry category (e.g. '6281' for ICT). Advanced — get IDs from Seek facets. Leave blank to search all.

## `proxyConfiguration` (type: `object`):

Apify's automatic (datacenter) proxy by default — cheap, reaches Seek's public search API, and available on every plan. Auto-falls back to Residential if a request is blocked. You can override with your own proxy groups.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer",
    "data analyst"
  ],
  "siteKey": "AU-Main",
  "maxItems": 200,
  "includeDescriptions": false,
  "remoteOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Dataset containing Seek Jobs Scraper records (job\_id, title, company, location, remote\_type, seniority, salary, work\_type, listing\_date, classification, url, parse\_confidence).

# 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 = {
    "searchQueries": [
        "software engineer",
        "data analyst"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/seek-jobs-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 = {
    "searchQueries": [
        "software engineer",
        "data analyst",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/seek-jobs-scraper").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 '{
  "searchQueries": [
    "software engineer",
    "data analyst"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call bovi/seek-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/vewdUX0xT82kKEPPd/builds/1N6I2BZezigF4znz4/openapi.json