# Seek Jobs Scraper — Most Comprehensive (AU & NZ) (`scrapersdelight/seek-jobs-scraper`) Actor

From $0.20 per 1,000 jobs — scrape Seek AU & NZ by keyword, location, industry, work type, salary & date posted: company, parsed salary, remote flag, optional full description + contact email. New-job monitor with Slack/email/webhook alerts. No login or API key.

- **URL**: https://apify.com/scrapersdelight/seek-jobs-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 Jobs Scraper — Most Comprehensive (AU & NZ)

**Scrape Seek job listings from Australia (seek.com.au) AND New Zealand (seek.co.nz) — title, company, location, parsed salary min/max, work type, remote flag, posting date, bullet points, advertiser details, and (optionally) the full job description with contact email — at a fraction of what the other Seek actors charge. Then schedule it as a saved-search monitor that pings Slack, email, or webhook the moment a new job is posted.**

### How it compares

| | **This actor** | Leading Seek scraper | Other Seek scraper |
|---|---|---|---|
| **Price per 1,000 jobs** | **$0.20** ($0.40 with full descriptions) | $2.50 | $2.01 (incl. actor-start fee) |
| **Countries** | AU + NZ in one run | AU | AU |
| **Per-job actor-start fee** | None | — | Yes (charged per run) |
| **Parsed salary (min/max/currency/period)** | ✅ | not advertised | not advertised |
| **Full description + contact email/phone** | ✅ optional (+$0.0002/job) | — | — |
| **Remote/hybrid/on-site flag** | ✅ | not advertised | not advertised |
| **New-job monitor + Slack/email/webhook alerts** | ✅ built in | — | — |
| **Raw API payload kept per job** | ✅ (`raw` field — nothing trimmed) | — | — |
| **Failure handling** | per-page retries with fresh proxy sessions; one bad page never kills the run | — | 6% reported run-failure rate |

*Incumbent prices/figures as published on their Apify store pages, June 2026. Feature dashes = not listed on their store page.*

No login, no API key, no browser automation — the actor reads Seek's own public JSON search API and filters **server-side**, so you pull only the jobs you actually want, fast.

---

### What does Seek Jobs Scraper do?

It extracts **job listings** from [Seek](https://www.seek.com.au) — the dominant job board for Australia & New Zealand, with 160k+ live Australian listings — and returns clean, structured rows you can export to **JSON, CSV, Excel, or push to your app via API**.

- 🔎 **Search the way Seek does** — keywords, location ("Sydney", "All Auckland"…), classification (industry), sub-classification, work type, salary band, date posted. All server-side.
- 🌏 **Both countries** — Australia, New Zealand, or both in a single run.
- 💰 **Salary, parsed** — the advertised label (`"$120,000 – $140,000 per year"`) PLUS numeric `salary_min`, `salary_max`, `salary_currency` (AUD/NZD), `salary_period` (year/hour/day/week/month).
- 🏠 **Remote flag** — `is_remote` from Seek's own On-site / Hybrid / Remote work-arrangement data.
- 🏢 **Advertiser intel** — advertiser id + name, employer company-profile URL, verified-advertiser flag and registration date (with descriptions on).
- 📝 **Full descriptions** *(optional)* — complete HTML job ad + plaintext, expiry date, and the **contact email / phone** when the ad includes one (recruiter lead-gen gold).
- 🔔 **Saved-search monitor** — schedule it and get **Slack / email / webhook alerts** for newly posted jobs matching your query.
- 📦 **Nothing thrown away** — every job keeps the full raw API payload under `raw` (branding, tracking ids, SEO hierarchy, the lot).

---

### What data does it extract?

For every job listing:

- 🆔 `id`, 🔗 `job_url`, 🌏 `country` (AU/NZ)
- 🏷️ `title`, `teaser`, `bullet_points[]`
- 🏢 `company_name`, `advertiser_id`, `advertiser_name`, `employer_company_url`, `advertiser_verified`*, `advertiser_registered`*
- 📍 `location`, `country_code`, `area_hierarchy[]` (suburb → region)
- 🗂️ `classification` + `classification_id`, `subclassification` + `subclassification_id`
- 💼 `work_types[]`, `work_arrangements[]` (On-site/Hybrid/Remote), `is_remote`
- 💰 `salary_label`, `salary_min`, `salary_max`, `salary_currency`, `salary_period`
- 📅 `listing_date` (ISO UTC), `listing_date_display`, `expires_at`*, `is_expired`*
- ⭐ `is_featured`, `display_type`, `role_id`, 🖼️ `logo_url`
- 📝 `description_html`*, `description_text`*, `abstract`*
- 📧 `contact_email`*, 📞 `contact_phone`*
- 🗃️ `raw` (the complete untouched API payload), ✨ `is_new` (monitor mode), 🕒 `scraped_at`

*\* = filled by the optional `fetchDescriptions` enrichment.*

---

### Who is it for?

- 🎯 **Recruiters & agencies** mapping open roles, clients' competitors, and which ads include direct contact emails.
- 📊 **Labour-market & salary analysts** tracking demand, advertised salary bands, and remote-work share by industry or city.
- 🤖 **Job-alert builders** wiring fresh postings into Slack, Discord (via webhook), or their own apps within minutes of posting.
- 🛠️ **Job aggregators & boards** backfilling AU/NZ inventory with structured, deduplicated rows.
- 💡 **Sales & GTM teams** using job postings as buying signals ("hiring 5 DevOps engineers" = infrastructure budget).

---

### Two ways to use it

1. **Bulk scrape** — pull every job for a keyword, city, industry, salary band, or work type into one clean dataset.
2. **Saved-search monitor** *(the recurring play)* — set `monitorMode: true`, attach an **Apify Schedule** (e.g. hourly), and the actor emits/alerts **only jobs new since the last run**. Pair with `dateRange: 3` and the default `Newest first` sort so each run stays tiny and cheap.

---

### How to use it (step by step)

1. Click **Try for free**.
2. Enter **Keywords** (e.g. `engineer`) and/or a **Location** (e.g. `Sydney`) — or leave both empty and pick a classification to sweep a whole industry.
3. Pick the **Country**: Australia, New Zealand, or both.
4. *(Optional)* add filters: work type, salary range, posted-within days.
5. *(Optional)* turn on **Fetch full descriptions** for the complete ad, expiry date, advertiser verification, and contact email/phone.
6. Click **Start**, then open the **Dataset** tab to view/export.
7. *(Optional)* set **monitorMode** + a **Schedule** + an alert channel to get pinged on new postings.

#### Quick start

```json
{ "keywords": "engineer", "location": "Sydney", "maxItems": 50 }
````

#### Saved-search monitor example

```json
{
  "keywords": "data engineer",
  "location": "Melbourne VIC",
  "dateRange": 3,
  "monitorMode": true,
  "alertOnNewJob": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/…"
}
```

#### Recruiter lead-gen example (full ads + contact emails, both countries)

```json
{
  "keywords": "registered nurse",
  "country": "both",
  "fetchDescriptions": true,
  "maxItems": 500
}
```

***

### Input

| Field | What it does |
|-------|--------------|
| `keywords` | search keywords, like the Seek search box (empty = all jobs) |
| `location` | free-text "Where" — `Sydney`, `Melbourne VIC`, `All Auckland`… (empty = whole country) |
| `country` | `AU` · `NZ` · `both` |
| `classification` / `subclassification` | Seek industry ids, comma-separated (e.g. `1209` = Engineering, `6281` = ICT) |
| `workType` | `242` Full time · `243` Part time · `244` Contract/Temp · `245` Casual/Vacation (comma list) |
| `salaryMin` / `salaryMax` + `salaryType` | advertised salary band filter, annual or hourly |
| `dateRange` | only jobs posted in the last N days (server-side) |
| `sortMode` | `ListedDate` (newest first, default) · `KeywordRelevance` |
| `fetchDescriptions` | add full HTML/plaintext description, expiry, advertiser verification, contact email/phone |
| `maxItems` | hard cap per run (0 = everything the query can reach) |
| `monitorMode`, `alertOnNewJob` | recurring watcher + alerts |
| `webhookUrl`, `slackWebhookUrl`, `emailRecipients` | alert channels |
| `proxyConfiguration`, `requestConcurrency` | proxy + parallelism (datacenter is enough) |

**Common classification ids:** 1200 Accounting · 1203 Admin & Office Support · 1209 Engineering · 1211 Construction · 1223 Healthcare & Medical · 6281 Information & Communication Technology · 6304 Trades & Services · 6251 Education & Training · 1225 Hospitality & Tourism · 6205 Sales. (Pick a category on seek.com.au and copy the id from the URL for the rest.)

***

### Output

Each job is one dataset record (fields listed above). Export to **JSON, CSV, Excel, HTML, or RSS**, or fetch via the **Apify API**. `listing_date`/`expires_at` are ISO UTC; salary numbers are in AUD (AU) or NZD (NZ).

Example record (truncated):

```json
{
  "id": "92643651",
  "job_url": "https://www.seek.co.nz/job/92643651",
  "country": "NZ",
  "title": "Production Engineer",
  "company_name": "PEC",
  "location": "Marton, Manawatu",
  "country_code": "NZ",
  "classification": "Engineering",
  "subclassification": "Industrial Engineering",
  "work_types": ["Full time"],
  "work_arrangements": ["On-site"],
  "is_remote": false,
  "salary_label": "$65,000 – $80,000 per year",
  "salary_min": 65000,
  "salary_max": 80000,
  "salary_currency": "NZD",
  "salary_period": "year",
  "listing_date": "2026-06-10T21:37:13Z",
  "listing_date_display": "2d ago",
  "bullet_points": ["Great team culture", "Career progression", "Competitive salary"],
  "contact_email": "careers@pec.co.nz",
  "description_text": "PEC is a leading New Zealand manufacturer…"
}
```

***

### How much does it cost?

Pay-per-event — you pay for what you pull, no subscription, **no per-run actor-start fee**. Intended rates:

| Event | What it covers | Price |
|-------|----------------|-------|
| `lot-scraped` | each job returned | **$0.0002 / job** |
| `lot-detail-enriched` | each full-description fetch | **$0.0002 / job** |
| `monitor-run-completed` | each scheduled watch run | $0.01 / run |
| `new-lot-detected` | each newly posted job found | $0.0005 / job |
| `alert-delivered` | each Slack/email/webhook push | $0.002 / alert |

*(Final per-event prices are set on the actor's pricing page.)*

That's **$0.20 per 1,000 jobs** ($0.40/1k with full descriptions) — vs **$2.50/1k** and **$2.01/1k** for the other Seek scrapers on the store. An hourly monitor on a niche search costs roughly a quarter a day plus the new jobs it actually finds.

#### Why so much cheaper?

Seek serves its own search results from a public structured JSON API — no browser, no rendering, no proxies burned on anti-bot. 100 jobs per request means 1,000 jobs ≈ 10 requests ≈ a few seconds of compute. We pass that through.

***

### ⚖️ Is it legal to scrape Seek?

This actor only reads **publicly available job listings** — the same data anyone sees without logging in. Job ads are business postings, published by employers *to be seen*; contact emails/phones surfaced are the ones advertisers chose to print in their own ads. That said, scraping may conflict with **Seek's Terms of Service** (a ToS-gray area common to all job-board scrapers, including the incumbents): you are responsible for how you use the data — review Seek's current ToS before commercial use, honor takedown requests, and handle any personal contact data per applicable privacy law (Australian Privacy Act / NZ Privacy Act / GDPR where it applies).

***

### FAQ

**What is Seek?**
Seek is the #1 employment marketplace for Australia and New Zealand — the default place AU/NZ employers post jobs, with 160k+ live Australian listings at any time.

**Do I need an account, login, or API key?**
No. The actor reads Seek's public job-search data directly — no account, cookies, or API key required.

**Can I scrape both Australia and New Zealand?**
Yes — set `country` to `AU`, `NZ`, or `both`. Each job row carries its `country` so you can split them downstream.

**Does it parse salaries into numbers?**
Yes — alongside the advertised `salary_label`, you get numeric `salary_min` / `salary_max`, the `salary_currency` (AUD/NZD), and the `salary_period` (year, hour, day, week, month). Note many ads simply don't advertise a salary; those stay null.

**Can I get the full job description?**
Yes — turn on `fetchDescriptions` to add the complete HTML ad, a plaintext version, the expiry date, advertiser verification details, and any contact email/phone printed in the ad. It's one extra request per job, billed at $0.0002.

**Can I filter to remote jobs?**
Filter the output on `is_remote` (from Seek's own On-site/Hybrid/Remote data). You can also put "remote" in `keywords` to narrow server-side first.

**How do I monitor a saved search and get alerts?**
Turn on `monitorMode`, attach an Apify **Schedule**, and add a Slack/webhook/email channel. Each run emits and alerts **only jobs new since the last run** for that exact search scope — state persists in a named key-value store.

**How many jobs can one query return?**
Seek's API serves roughly **500–550 results deep per query** (the same limit applies in the browser). For bigger pulls, slice by `classification`, `location`, `workType`, or `dateRange` and run the slices — the actor logs a warning with this advice whenever it hits the wall.

**How do I find classification / work-type ids?**
The most common ones are listed in the Input section above; for the rest, pick the filter on seek.com.au and copy the id from the URL.

**How fast is it?**
The search API returns 100 jobs per request in ~0.5 s — 1,000 jobs typically lands in well under a minute without descriptions.

**What about jobs posted today only?**
Set `dateRange: 1` (server-side "posted in the last day") — ideal for daily digests and monitors.

**How do I export the data?**
JSON, CSV, Excel, HTML, or RSS from the Dataset tab, or via the Apify API.

**Can I integrate with Make, Zapier, n8n, or my backend?**
Yes — use the webhook/Slack channels for alerts, or the Apify API to pipe the dataset anywhere.

***

### You might also like

- 💼 Job-posting & hiring-signal scrapers (ATS boards, layoffs, licenses)
- 🌏 Other country-specific job-board scrapers
- 📊 Company-enrichment and lead-gen actors

***

### Feedback

Found a missing field or want a new filter? Open an issue on the actor — fast fixes and feature requests welcome.

# Actor input Schema

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

Search keywords, exactly like the Seek search box (e.g. 'engineer', 'registered nurse', 'data analyst'). Leave empty to sweep ALL jobs (combine with location/classification filters).

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

Free-text location, exactly like Seek's 'Where' box — e.g. 'Sydney', 'Melbourne VIC', 'All Auckland', 'Christchurch Canterbury'. Leave empty for the whole country.

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

Which Seek site to search: Australia (seek.com.au), New Zealand (seek.co.nz), or both.

## `classification` (type: `string`):

Seek classification (industry) ids, comma-separated — e.g. '1209' = Engineering, '6281' = ICT, '1223' = Healthcare & Medical. Find ids in the seek.com.au URL after picking a classification, or in this actor's README.

## `subclassification` (type: `string`):

Seek sub-classification ids, comma-separated (e.g. '6035' = Civil/Structural Engineering). Narrower than classification.

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

Comma-separated work-type ids: 242 = Full time, 243 = Part time, 244 = Contract/Temp, 245 = Casual/Vacation. Empty = all.

## `salaryMin` (type: `integer`):

Lower bound of the advertised salary band (in AUD/NZD, per the Salary type below). Leave empty for no floor.

## `salaryMax` (type: `integer`):

Upper bound of the advertised salary band. Leave empty for no cap.

## `salaryType` (type: `string`):

Whether the salary range above is annual or hourly.

## `dateRange` (type: `integer`):

Only jobs posted in the last N days (server-side, like Seek's 'Listed any time' menu). 0 = any time. Great for monitors: 1 or 3.

## `sortMode` (type: `string`):

Result order. 'Newest first' (ListedDate) is deterministic and best for monitors; 'Relevance' mirrors the Seek default for keyword searches.

## `fetchDescriptions` (type: `boolean`):

Enrich every job with the full HTML job description (+ plaintext), exact salary label, advertiser verification + registration date, expiry date, and the contact email/phone when the ad includes one. One extra request per job.

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

Hard cap on jobs scraped this run (cost/safety guard). Defaults to 50 for a fast first run — set 0 to take everything the query can reach (Seek serves ~500-550 results deep per query; slice by classification/location/date to get more).

## `monitorMode` (type: `boolean`):

Recurring watcher: diff against the prior run's seen jobs (per search scope) and output/alert ONLY newly posted jobs. Pair with an Apify Schedule, 'Newest first' sort, and dateRange 1-3.

## `alertOnNewJob` (type: `boolean`):

In monitor mode, deliver an alert for each newly posted job via the channels below.

## `webhookUrl` (type: `string`):

POST endpoint for new-job alert payloads (Make / Zapier / n8n / custom). One JSON body per alert.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for formatted new-job cards.

## `emailRecipients` (type: `array`):

Email addresses for the new-job digest (sent via apify/send-mail).

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

Proxy settings. Datacenter rotation is enough — Seek's job-search API is public JSON with no anti-bot.

## `requestConcurrency` (type: `integer`):

Max parallel requests for description fetches. Keep modest to be polite.

## `diagnose` (type: `boolean`):

Dev only. Dumps the raw search + detail JSON to the key-value store (DEBUG\_SEARCH\_JSON / DEBUG\_DETAIL\_JSON) and logs the parsed first row + pagination check, then exits. Leave off for normal runs.

## Actor input object example

```json
{
  "keywords": "engineer",
  "location": "Sydney",
  "country": "AU",
  "salaryType": "annual",
  "dateRange": 0,
  "sortMode": "ListedDate",
  "fetchDescriptions": false,
  "maxItems": 50,
  "monitorMode": false,
  "alertOnNewJob": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestConcurrency": 5,
  "diagnose": false
}
```

# Actor output Schema

## `items` (type: `string`):

The dataset of scraped Seek AU/NZ job listings (one job per row).

# 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": "engineer",
    "location": "Sydney",
    "maxItems": 50
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seek Jobs Scraper — Most Comprehensive (AU & NZ)",
        "description": "From $0.20 per 1,000 jobs — scrape Seek AU & NZ by keyword, location, industry, work type, salary & date posted: company, parsed salary, remote flag, optional full description + contact email. New-job monitor with Slack/email/webhook alerts. No login or API key.",
        "version": "0.1",
        "x-build-id": "aJ4J1u83BGLvsr9Tb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~seek-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-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/scrapersdelight~seek-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-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/scrapersdelight~seek-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "string",
                        "description": "Search keywords, exactly like the Seek search box (e.g. 'engineer', 'registered nurse', 'data analyst'). Leave empty to sweep ALL jobs (combine with location/classification filters)."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Free-text location, exactly like Seek's 'Where' box — e.g. 'Sydney', 'Melbourne VIC', 'All Auckland', 'Christchurch Canterbury'. Leave empty for the whole country."
                    },
                    "country": {
                        "title": "Country",
                        "enum": [
                            "AU",
                            "NZ",
                            "both"
                        ],
                        "type": "string",
                        "description": "Which Seek site to search: Australia (seek.com.au), New Zealand (seek.co.nz), or both.",
                        "default": "AU"
                    },
                    "classification": {
                        "title": "Classification IDs",
                        "type": "string",
                        "description": "Seek classification (industry) ids, comma-separated — e.g. '1209' = Engineering, '6281' = ICT, '1223' = Healthcare & Medical. Find ids in the seek.com.au URL after picking a classification, or in this actor's README."
                    },
                    "subclassification": {
                        "title": "Sub-classification IDs",
                        "type": "string",
                        "description": "Seek sub-classification ids, comma-separated (e.g. '6035' = Civil/Structural Engineering). Narrower than classification."
                    },
                    "workType": {
                        "title": "Work type IDs",
                        "type": "string",
                        "description": "Comma-separated work-type ids: 242 = Full time, 243 = Part time, 244 = Contract/Temp, 245 = Casual/Vacation. Empty = all."
                    },
                    "salaryMin": {
                        "title": "Min salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Lower bound of the advertised salary band (in AUD/NZD, per the Salary type below). Leave empty for no floor."
                    },
                    "salaryMax": {
                        "title": "Max salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Upper bound of the advertised salary band. Leave empty for no cap."
                    },
                    "salaryType": {
                        "title": "Salary type",
                        "enum": [
                            "annual",
                            "hourly"
                        ],
                        "type": "string",
                        "description": "Whether the salary range above is annual or hourly.",
                        "default": "annual"
                    },
                    "dateRange": {
                        "title": "Posted within (days)",
                        "minimum": 0,
                        "maximum": 31,
                        "type": "integer",
                        "description": "Only jobs posted in the last N days (server-side, like Seek's 'Listed any time' menu). 0 = any time. Great for monitors: 1 or 3.",
                        "default": 0
                    },
                    "sortMode": {
                        "title": "Sort by",
                        "enum": [
                            "ListedDate",
                            "KeywordRelevance"
                        ],
                        "type": "string",
                        "description": "Result order. 'Newest first' (ListedDate) is deterministic and best for monitors; 'Relevance' mirrors the Seek default for keyword searches.",
                        "default": "ListedDate"
                    },
                    "fetchDescriptions": {
                        "title": "Fetch full descriptions",
                        "type": "boolean",
                        "description": "Enrich every job with the full HTML job description (+ plaintext), exact salary label, advertiser verification + registration date, expiry date, and the contact email/phone when the ad includes one. One extra request per job.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max jobs per run",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on jobs scraped this run (cost/safety guard). Defaults to 50 for a fast first run — set 0 to take everything the query can reach (Seek serves ~500-550 results deep per query; slice by classification/location/date to get more).",
                        "default": 50
                    },
                    "monitorMode": {
                        "title": "Monitor mode (saved-search watcher)",
                        "type": "boolean",
                        "description": "Recurring watcher: diff against the prior run's seen jobs (per search scope) and output/alert ONLY newly posted jobs. Pair with an Apify Schedule, 'Newest first' sort, and dateRange 1-3.",
                        "default": false
                    },
                    "alertOnNewJob": {
                        "title": "Alert on new jobs",
                        "type": "boolean",
                        "description": "In monitor mode, deliver an alert for each newly posted job via the channels below.",
                        "default": true
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "POST endpoint for new-job alert payloads (Make / Zapier / n8n / custom). One JSON body per alert."
                    },
                    "slackWebhookUrl": {
                        "title": "Slack webhook URL",
                        "type": "string",
                        "description": "Slack incoming-webhook URL for formatted new-job cards."
                    },
                    "emailRecipients": {
                        "title": "Email recipients",
                        "type": "array",
                        "description": "Email addresses for the new-job digest (sent via apify/send-mail).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy settings. Datacenter rotation is enough — Seek's job-search API is public JSON with no anti-bot.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "requestConcurrency": {
                        "title": "Request concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Max parallel requests for description fetches. Keep modest to be polite.",
                        "default": 5
                    },
                    "diagnose": {
                        "title": "Diagnostic mode (dev)",
                        "type": "boolean",
                        "description": "Dev only. Dumps the raw search + detail JSON to the key-value store (DEBUG_SEARCH_JSON / DEBUG_DETAIL_JSON) and logs the parsed first row + pagination check, then exits. Leave off for normal runs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
