# Seek Job Listings Scraper (`rambunctious_fingerprint/seek-jobs-scraper`) Actor

Scrape Australian job listings from Seek.com.au — extract job titles, companies, salaries, locations, descriptions, and posting dates by keyword.

- **URL**: https://apify.com/rambunctious\_fingerprint/seek-jobs-scraper.md
- **Developed by:** [Casey Marsh](https://apify.com/rambunctious_fingerprint) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 66.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 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.

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.com.au Job Listings Scraper

Scrape job listings from Seek.com.au — Australia's #1 employment marketplace with over 180,000 live job ads at any time. Extract job titles, companies, locations, salary ranges, classifications, work types, and detailed descriptions. Ideal for recruitment intelligence, salary benchmarking, labour market analysis, and lead generation for HR tech businesses.

### Summary

The Seek Job Listings Scraper is a production-grade Apify actor that extracts job postings from [seek.com.au](https://www.seek.com.au), which serves over 30 million visits per month and lists more jobs than any other Australian platform. This actor lets you search by keyword, location, work type, salary range, and industry classification — then receive structured JSON with all available job metadata including company logos, advertiser type (direct employer vs recruiter), listing freshness, and description excerpts.

Built on Crawlee's CheerioCrawler with Apify residential proxy rotation and automatic session management, this actor handles Seek's anti-scraping measures, paginates through multi-page results, and gracefully recovers from blocks or rate limits. It uses multiple CSS selector fallbacks keyed to Seek's `data-automation` attributes as well as class-based selectors, maintaining reliability across frontend changes.

### How It Works

1. **Input**: Provide a keyword (e.g., "software engineer", "registered nurse"), location, and optional filters like salary range or work type.
2. **URL Construction**: The actor builds a Seek search URL with your parameters properly encoded, including any filter query strings.
3. **Proxy Rotation**: Each request goes through Apify's residential proxy pool with automatic IP rotation to avoid detection.
4. **Card Extraction**: The actor finds all job cards using Seek's `data-automation` attributes as primary selectors, with class-based fallbacks for robustness.
5. **Field Extraction**: For each card, it extracts title, company, location, salary, classification, description, advertiser info, work type, company logo URL, and the internal Seek job ID.
6. **Pagination**: If more results are needed, the actor follows Seek's pagination controls (Next button or page links) automatically until `maxResults` is reached.
7. **Error Handling**: Failed cards are logged and skipped; failed requests after all retries are saved as error records; rate limit blocks trigger automatic proxy rotation and retry.

### Input Parameters

| Field | Type | Required | Default | Description |
|-------|------|----------|---------|-------------|
| `keyword` | string | No | `software-engineer` | Job title or skill to search (e.g. `data-analyst`, `electrician`, `project-manager`) |
| `location` | string | No | `All-Australia` | Location in Seek format (e.g. `Sydney`, `Melbourne-3000`, `All-Perth`, `All-Brisbane`) |
| `maxResults` | integer | No | `100` | Maximum job listings to return (1–500) |
| `workType` | string | No | — | Filter by work type (e.g. `full-time`, `part-time`, `contract-temp`, `casual-vacation`) |
| `salaryRange` | string | No | — | Salary range filter code |
| `dateRange` | string | No | — | Listing date range (e.g. `1`, `3`, `7`, `14`, `30` for days) |
| `classification` | string | No | — | Industry classification code (e.g. `information-communication-technology`) |

### Output Example

```json
{
  "title": "Senior Full Stack Developer",
  "company": "TechCorp Australia",
  "location": "Sydney NSW 2000",
  "salary": "$140,000 - $170,000",
  "link": "https://www.seek.com.au/job/12345678",
  "classification": "Information & Communication Technology",
  "description": "Join a fast-growing SaaS company... React, Node.js, AWS experience required...",
  "listedDate": "3d ago",
  "advertiser": "TechCorp Australia",
  "workType": "Full Time",
  "logoUrl": "https://seekcdn.com/company-logos/techcorp.png",
  "jobId": "12345678",
  "searchKeyword": "software-engineer",
  "searchLocation": "All-Australia",
  "scrapedAt": "2026-07-04T10:30:00.000Z"
}
````

### Pricing

This actor operates on Apify's pay-per-result pricing: you only pay for the jobs you successfully extract. There are no monthly fees, no minimum commitments, and no Seek API subscription required. A typical run extracting 100 job listings costs a small fraction of an Apify platform credit, even with residential proxies enabled.

Residential proxies are the default configuration because Seek.com.au actively blocks datacenter IP ranges. You can switch to datacenter proxies for lower per-request costs by modifying the `proxyConfig` input parameter, but expect frequent blocks and reduced reliability on Seek.

CheerioCrawler (not Playwright/headless browser) keeps costs minimal — each page request completes in 1–3 seconds without the CPU and memory overhead of a full browser.

### Use Cases

- **Job Market Analysis**: Track hiring volumes by keyword, location, and industry over time. Analyze which skills are in demand and how salary ranges are trending across Australian cities.
- **Salary Benchmarking**: Aggregate salary data from job listings to understand market rates for specific roles, experience levels, and locations. Feed this into compensation planning tools.
- **Recruitment Intelligence**: Monitor competitor hiring activity, identify companies expanding in specific markets, and track which recruiters dominate certain sectors.
- **Lead Generation for HR Tech**: Build prospect lists of companies actively hiring for roles your product or service addresses. Enrich CRM data with real-time hiring signals.
- **Career Research**: Build job alert systems that notify candidates when relevant positions appear. Power job-matching algorithms with structured, up-to-date listing data.
- **Labour Market Trend Tracking**: Supply government agencies, think tanks, and research organisations with structured data on employment market dynamics.

### FAQ

**Q: Do I need a Seek account or API key?**
A: No. This actor scrapes publicly visible job listings. No Seek account, login, or API key is required.

**Q: Can I scrape all of Australia or just specific cities?**
A: Both. Use `All-Australia` for nationwide search, or specific regions like `Sydney`, `Melbourne-3000`, `All-Perth`, etc. Seek uses a hybrid location format — see their URL structure for exact values.

**Q: How fresh is the data?**
A: The actor scrapes whatever appears in Seek's live search results. Listings are typically updated in near-real-time. The `listedDate` field tells you how recently each job was posted (e.g., "Just posted", "3d ago").

**Q: What if Seek changes their page structure?**
A: The actor uses Seek's `data-automation` attributes (their internal testing/data selectors) which are less likely to change than CSS classes. Multiple fallback selectors are used for each field. If all selectors fail, that field is left empty rather than crashing.

**Q: Can I get the full job description?**
A: The search results page provides a short description/teaser. For full job descriptions, you would need to follow each job link and scrape the detail page. This actor provides the link field so you can build a second-stage scraper if needed.

**Q: How does the actor handle Seek's anti-bot measures?**
A: The actor uses Apify residential proxies, rotates user agents via Crawlee's session pool, detects block/rate-limit pages by page title, and automatically retries with a fresh IP when blocked. Up to 5 retries are attempted per request.

***

**Actor ID**: `seek-jobs-scraper` · **Runtime**: Node.js 20 · **Type**: CheerioCrawler

# Actor input Schema

## `keyword` (type: `string`):

Job title or keyword to search

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

City or region (e.g. Sydney, Melbourne-3000)

## `maxResults` (type: `integer`):

Maximum job listings to return

## Actor input object example

```json
{
  "keyword": "software",
  "location": "Australia",
  "maxResults": 100
}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("rambunctious_fingerprint/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 = {}

# Run the Actor and wait for it to finish
run = client.actor("rambunctious_fingerprint/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 '{}' |
apify call rambunctious_fingerprint/seek-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seek Job Listings Scraper",
        "description": "Scrape Australian job listings from Seek.com.au — extract job titles, companies, salaries, locations, descriptions, and posting dates by keyword.",
        "version": "0.0",
        "x-build-id": "SwTEQIrhs0PQ8LJme"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/rambunctious_fingerprint~seek-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-rambunctious_fingerprint-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/rambunctious_fingerprint~seek-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-rambunctious_fingerprint-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/rambunctious_fingerprint~seek-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-rambunctious_fingerprint-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": {
                    "keyword": {
                        "title": "Job Keyword",
                        "type": "string",
                        "description": "Job title or keyword to search",
                        "default": "software"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region (e.g. Sydney, Melbourne-3000)",
                        "default": "Australia"
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum job listings to return",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```