# SEEK Jobs Scraper (`fetch_cat/seek-jobs-scraper`) Actor

Scrape public SEEK Australia and New Zealand job listings by keyword and location for recruiting, lead generation, and labor-market research.

- **URL**: https://apify.com/fetch\_cat/seek-jobs-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.15 / 1,000 item processeds

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/platform/actors/running/actors-in-store#pay-per-event

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

## SEEK Jobs Scraper

Extract public job listings from SEEK search results in Australia and New Zealand. The actor saves structured job data such as title, company, location, salary text, classification, job URL, and source search metadata.

### Value proposition / what it does

SEEK Jobs Scraper turns SEEK search pages into structured datasets for recruiting, labor-market analysis, and automation. What data it returns: job titles, companies, locations, salary text, classifications, job URLs, and source search metadata.

- Searches SEEK Australia or SEEK New Zealand by keyword and location.
- Accepts one search, multiple keyword/location searches, or direct SEEK search URLs.
- Returns clean dataset items for job market research, lead sourcing, recruitment analytics, and role monitoring.
- Stops at your `maxItems` limit to keep runs predictable.

### Who uses it and use cases

Recruiters, hiring teams, labor-market researchers, sales teams, and automation builders use this actor to monitor role demand, collect hiring leads, and feed job listings into spreadsheets, CRMs, or AI workflows.

### Input example

```json
{
  "query": "software engineer",
  "location": "Sydney",
  "country": "au",
  "maxItems": 10
}
````

#### Multiple searches

```json
{
  "queries": [
    { "query": "software engineer", "location": "Sydney", "country": "au" },
    { "query": "accountant", "location": "Auckland", "country": "nz" }
  ],
  "maxItems": 20
}
```

### Input settings

| Field | Type | Description |
| --- | --- | --- |
| `query` | string | Keyword or phrase to search for when `queries` is not provided. |
| `location` | string | City, region, or suburb, such as `Sydney` or `Auckland`. |
| `country` | string | SEEK site: `au` for Australia or `nz` for New Zealand. |
| `queries` | array | Optional list of searches or direct SEEK search URLs. Overrides the single search fields. |
| `maxItems` | integer | Maximum number of job listings to save, from 1 to 50. |

### Output example

```json
{
  "jobId": "123456789",
  "url": "https://www.seek.com.au/job/123456789",
  "title": "Software Engineer",
  "companyName": "Example Company",
  "location": "Sydney NSW",
  "salaryText": "$120k - $140k",
  "classification": "Information & Communication Technology",
  "shortDescription": "Build and maintain production systems...",
  "sourceUrl": "https://www.seek.com.au/jobs?keywords=software+engineer&where=Sydney",
  "sourceQuery": "software engineer",
  "sourceLocation": "Sydney",
  "scrapedAt": "2026-07-15T08:37:26.614Z"
}
```

### Output fields

| Field | Description |
| --- | --- |
| `jobId` | SEEK job identifier when available. |
| `url` | Canonical job listing URL. |
| `title` | Job title. |
| `companyName` | Hiring company name when shown. |
| `location` | Listing location text. |
| `salaryText` | Salary or pay range text when shown. |
| `classification` | SEEK classification/category when shown. |
| `shortDescription` | Short listing description or preview text. |
| `sourceUrl` | Search URL used to collect the item. |
| `sourceQuery` | Keyword used for the source search. |
| `sourceLocation` | Location used for the source search. |
| `scrapedAt` | ISO timestamp when the item was saved. |

### Pricing

This actor uses pay-per-event pricing. Each run has a start event and a per-item event for each saved job listing.

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run start | $0.035 | $0.035 | $0.035 | $0.035 | $0.035 | $0.035 |
| Saved job item | $0.0041175 | $0.0035804 | $0.0027927 | $0.0021482 | $0.0014322 | $0.0010025 |

The exact price for your account is shown on the actor pricing tab before you run it.

### API usage

#### Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/seek-jobs-scraper').call({
  query: 'software engineer',
  location: 'Sydney',
  country: 'au',
  maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('fetch_cat/seek-jobs-scraper').call(run_input={
    'query': 'software engineer',
    'location': 'Sydney',
    'country': 'au',
    'maxItems': 10,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~seek-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"query":"software engineer","location":"Sydney","country":"au","maxItems":10}'
```

### MCP and AI agents

Use this actor from Apify MCP or other AI-agent tools when you need fresh SEEK job listings as structured data. Provide a concise keyword, location, country, and max item limit to keep responses focused.

#### Claude CLI add command

```bash
claude mcp add apify -- npx -y @apify/actors-mcp-server --actors fetch_cat/seek-jobs-scraper
```

#### JSON config block

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/actors-mcp-server", "--actors", "fetch_cat/seek-jobs-scraper"],
      "env": { "APIFY_TOKEN": "YOUR_APIFY_TOKEN" }
    }
  }
}
```

#### Example prompts

- "Find recent software engineer jobs in Sydney on SEEK and summarize the hiring companies."
- "Collect 10 accountant roles in Auckland from SEEK and return title, company, location, and URL."
- "Monitor SEEK for data analyst roles in Melbourne and save the dataset for spreadsheet export."

### Input recipes

- **Sydney software hiring:** `query="software engineer"`, `location="Sydney"`, `country="au"`.
- **Auckland finance roles:** `query="accountant"`, `location="Auckland"`, `country="nz"`.
- **Multi-city monitoring:** use `queries` with several keyword/location objects and one shared `maxItems` cap.

### FAQ

**Can I scrape both Australia and New Zealand?** Yes. Set `country` to `au` or `nz`, or provide per-search `country` values in `queries`.

**Why are some fields null?** SEEK does not show every field on every listing. Missing salary, classification, or company values are returned as `null`.

**Can I use direct SEEK search URLs?** Yes. Add objects with a `url` field inside `queries`.

### Related Actors

- [Google Jobs Scraper](https://apify.com/fetch_cat/google-jobs-scraper)
- [LinkedIn Jobs Scraper](https://apify.com/fetch_cat/linkedin-jobs-scraper)
- [Greenhouse Jobs Scraper](https://apify.com/fetch_cat/greenhouse-jobs-scraper)
- [Lever Jobs Scraper](https://apify.com/fetch_cat/lever-jobs-scraper)

### Support

If a run does not return the jobs you expected, include the run ID or run URL, the input JSON, expected output, actual output, and a reproducible public URL such as `https://www.seek.com.au/jobs?keywords=software+engineer&where=Sydney` when contacting support.

# Actor input Schema

## `query` (type: `string`):

Job keyword or phrase to search for.

## `location` (type: `string`):

City, region, or suburb, such as Sydney or Auckland.

## `country` (type: `string`):

SEEK country site to search.

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

Optional list of searches or direct SEEK search URLs. If set, these override the single keyword/location fields.

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

Maximum number of job listings to save.

## Actor input object example

```json
{
  "query": "software engineer",
  "location": "Sydney",
  "country": "au",
  "queries": [
    {
      "query": "software engineer",
      "location": "Sydney",
      "country": "au"
    },
    {
      "query": "nurse",
      "location": "Melbourne",
      "country": "au"
    },
    {
      "query": "accountant",
      "location": "Auckland",
      "country": "nz"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "query": "software engineer",
    "location": "Sydney",
    "queries": [
        {
            "query": "software engineer",
            "location": "Sydney",
            "country": "au"
        },
        {
            "query": "nurse",
            "location": "Melbourne",
            "country": "au"
        },
        {
            "query": "accountant",
            "location": "Auckland",
            "country": "nz"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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 = {
    "query": "software engineer",
    "location": "Sydney",
    "queries": [
        {
            "query": "software engineer",
            "location": "Sydney",
            "country": "au",
        },
        {
            "query": "nurse",
            "location": "Melbourne",
            "country": "au",
        },
        {
            "query": "accountant",
            "location": "Auckland",
            "country": "nz",
        },
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/seek-jobs-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 '{
  "query": "software engineer",
  "location": "Sydney",
  "queries": [
    {
      "query": "software engineer",
      "location": "Sydney",
      "country": "au"
    },
    {
      "query": "nurse",
      "location": "Melbourne",
      "country": "au"
    },
    {
      "query": "accountant",
      "location": "Auckland",
      "country": "nz"
    }
  ]
}' |
apify call fetch_cat/seek-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SEEK Jobs Scraper",
        "description": "Scrape public SEEK Australia and New Zealand job listings by keyword and location for recruiting, lead generation, and labor-market research.",
        "version": "0.1",
        "x-build-id": "jd4bFrflxwteqC6PB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~seek-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-seek-jobs-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/fetch_cat~seek-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-seek-jobs-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/fetch_cat~seek-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-seek-jobs-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": {
                    "query": {
                        "title": "Keyword",
                        "type": "string",
                        "description": "Job keyword or phrase to search for."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, region, or suburb, such as Sydney or Auckland."
                    },
                    "country": {
                        "title": "Country site",
                        "enum": [
                            "au",
                            "nz"
                        ],
                        "type": "string",
                        "description": "SEEK country site to search.",
                        "default": "au"
                    },
                    "queries": {
                        "title": "Multiple searches",
                        "type": "array",
                        "description": "Optional list of searches or direct SEEK search URLs. If set, these override the single keyword/location fields.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "query": {
                                    "title": "Keyword",
                                    "description": "Job keyword or phrase.",
                                    "type": "string"
                                },
                                "location": {
                                    "title": "Location",
                                    "description": "City, region, or suburb.",
                                    "type": "string"
                                },
                                "country": {
                                    "title": "Country",
                                    "description": "SEEK country site.",
                                    "type": "string",
                                    "enum": [
                                        "au",
                                        "nz"
                                    ],
                                    "enumTitles": [
                                        "Australia",
                                        "New Zealand"
                                    ]
                                },
                                "url": {
                                    "title": "Search URL",
                                    "description": "Direct SEEK search URL.",
                                    "type": "string"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of job listings to save.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
