# Seek Job Scraper (`zerobreak/seek-job-scraper`) Actor

Searches Seek.com.au by keyword and location and returns structured job listing data including salary, work type, and full descriptions. No scraping code required.

- **URL**: https://apify.com/zerobreak/seek-job-scraper.md
- **Developed by:** [ZeroBreak](https://apify.com/zerobreak) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 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/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.md):

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

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

Scrape job listings from Seek.com.au by keyword and location. Results come back as structured JSON: title, company, salary, work type, full description, and apply link per listing.

### What it does

Give it a keyword (and an optional location), and the actor runs a Seek search, pages through the results, and fetches each job detail page. Or skip the search entirely and pass in direct Seek job URLs if you already know which listings you want.

Data lands in the Apify dataset while the run is still going, so you can spot-check results before it finishes.

### What people use it for

The most common use cases are job market research, feeding listings into a recruitment platform or CRM, and scheduled job alerts. A few things it handles well:

- Seeing what salary ranges are actually being advertised for a given role in a given city (not what survey tools report)
- Pulling competitor job ads to track how they describe requirements or perks
- Setting up a nightly run that pushes new listings to Slack or a spreadsheet

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `keywords` | String | Yes* | Job title or keyword (e.g. `software engineer`) |
| `location` | String | No | City or region (e.g. `Sydney`, `Melbourne`, `Remote`) |
| `dateRange` | Select | No | Filter by post date: Any time, 24h, 3d, 7d, 14d |
| `jobUrls` | String list | Yes* | Direct Seek job URLs to scrape instead of searching |
| `maxItems` | Integer | No | Max listings to return (default 50, max 200) |
| `requestTimeoutSecs` | Integer | No | Per-request timeout in seconds (default 30) |

*Provide either `keywords` or `jobUrls`.

#### Example input

```json
{
    "keywords": "data analyst",
    "location": "Melbourne",
    "dateRange": "7",
    "maxItems": 50
}
````

### Output

Each record in the dataset contains:

```json
{
    "jobId": "84712345",
    "jobTitle": "Data Analyst",
    "company": "Acme Pty Ltd",
    "location": "Melbourne VIC",
    "workType": "Full Time",
    "salary": "AUD 85000 - 100000",
    "classification": "Information & Communication Technology",
    "subClassification": "Business/Systems Analysts",
    "listingDate": "2026-05-10T00:00:00.000Z",
    "jobDescription": "We are looking for a skilled Data Analyst to join our team...",
    "advertiserName": "Acme Pty Ltd",
    "advertiserType": "Direct Employer",
    "bulletPoints": [
        "Competitive salary and flexible working",
        "Opportunity to work with large-scale datasets",
        "Collaborative and supportive team environment"
    ],
    "jobUrl": "https://www.seek.com.au/job/84712345",
    "applyUrl": null,
    "scrapedAt": "2026-05-13T06:45:22.000Z"
}
```

### How to run

#### On the Apify platform

1. Open the actor and click **Try for free**
2. Fill in **Keywords** and optionally **Location**
3. Click **Start** and wait for the run to finish
4. Download results from the **Dataset** tab as JSON, CSV, or Excel

#### Via API

```python
import apify_client

client = apify_client.ApifyClient("YOUR_API_TOKEN")

run = client.actor("websift/seek-job-scraper").call(run_input={
    "keywords": "software engineer",
    "location": "Sydney",
    "dateRange": "7",
    "maxItems": 100
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["jobTitle"], item["company"])
```

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('websift/seek-job-scraper').call({
    keywords: 'software engineer',
    location: 'Sydney',
    dateRange: '7',
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach(item => console.log(item.jobTitle, item.company));
```

### Scheduling

Set up a schedule in Apify Console to keep your data fresh. Go to **Schedules**, create a new schedule with your preferred input, and set a cron expression (e.g. `0 6 * * *` for 6am daily). New results are appended to the dataset automatically.

### Limitations

- Results depend on what Seek.com.au displays publicly for the given search query
- Seek may cap the number of pages returned for broad searches; use `maxItems` to stay within range
- Listings without a salary disclosure will return `null` for the `salary` field

### Legal

This tool collects publicly available job listing data from Seek.com.au. Use it responsibly and in line with Seek's terms of service. Do not use this actor for mass automated applications or anything that violates platform policies.

# Actor input Schema

## `keywords` (type: `string`):

Job title or keywords to search for (e.g. "software engineer", "data analyst", "nurse").

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

Location filter, e.g. "Sydney", "Melbourne", "Brisbane", or "Remote".

## `dateRange` (type: `string`):

Filter jobs by how recently they were posted.

## `jobUrls` (type: `array`):

Specific Seek job listing URLs to scrape directly, instead of running a keyword search. E.g. https://www.seek.com.au/job/12345678

## `fetchDetails` (type: `boolean`):

Visit each job's detail page to retrieve the full description, advertiser type, and apply link. Slower but returns more complete data. Leave off to get summary data only from search results.

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

Maximum number of job listings to return per run.

## `requestTimeoutSecs` (type: `integer`):

Per-request timeout in seconds.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "location": "Sydney",
  "dateRange": "7",
  "jobUrls": [
    "https://www.seek.com.au/job/12345678"
  ],
  "fetchDetails": false,
  "maxItems": 20,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "keywords": "software engineer",
    "location": "Sydney"
};

// Run the Actor and wait for it to finish
const run = await client.actor("zerobreak/seek-job-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 = {
    "keywords": "software engineer",
    "location": "Sydney",
}

# Run the Actor and wait for it to finish
run = client.actor("zerobreak/seek-job-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 '{
  "keywords": "software engineer",
  "location": "Sydney"
}' |
apify call zerobreak/seek-job-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seek Job Scraper",
        "description": "Searches Seek.com.au by keyword and location and returns structured job listing data including salary, work type, and full descriptions. No scraping code required.",
        "version": "0.0",
        "x-build-id": "EnsSC47XDuIrdRfCX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zerobreak~seek-job-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zerobreak-seek-job-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/zerobreak~seek-job-scraper/runs": {
            "post": {
                "operationId": "runs-sync-zerobreak-seek-job-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/zerobreak~seek-job-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-zerobreak-seek-job-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Job title or keywords to search for (e.g. \"software engineer\", \"data analyst\", \"nurse\")."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location filter, e.g. \"Sydney\", \"Melbourne\", \"Brisbane\", or \"Remote\"."
                    },
                    "dateRange": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "1",
                            "3",
                            "7",
                            "14"
                        ],
                        "type": "string",
                        "description": "Filter jobs by how recently they were posted.",
                        "default": "any"
                    },
                    "jobUrls": {
                        "title": "Direct job URLs",
                        "type": "array",
                        "description": "Specific Seek job listing URLs to scrape directly, instead of running a keyword search. E.g. https://www.seek.com.au/job/12345678",
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchDetails": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "Visit each job's detail page to retrieve the full description, advertiser type, and apply link. Slower but returns more complete data. Leave off to get summary data only from search results.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum number of job listings to return per run.",
                        "default": 20
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```