# SEEK Scraper ($0.84/1K): Jobs & Salaries in Australia & NZ (`tsutseisoftware/seek-scraper`) Actor

Scrape SEEK jobs from seek.com.au and seek.co.nz: title, company, location, classification, work type, salary per year and hour, listed date. All website filters, past 550 jobs per search, details with applicants and company profile, monitoring of new and removed jobs, notifications. Unofficial.

- **URL**: https://apify.com/tsutseisoftware/seek-scraper.md
- **Developed by:** [Tsutsei Software](https://apify.com/tsutseisoftware) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.81 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## SEEK Scraper: Jobs & Salaries in Australia & New Zealand

Get job ads from **SEEK** (seek.com.au and seek.co.nz) as clean, ready-to-use data. Search by **job title or keyword**, **location with a radius**, **classification**, **work type** (full time, part time, contract, casual), **work arrangement** (on-site, hybrid, remote), **date listed** and **salary**, or paste any SEEK search, company or job URL. For each job you get the title, company, location and state, classification and sub-classification, work type and arrangement, the **salary as shown and as numbers per year, month and hour** (with super or KiwiSaver on top or included), the listing date, the teaser and the ad's selling points.

**$0.84 per 1 000 jobs**, $1.72 with the full description and details. Proxy included, no extra platform costs.

Built for **watching the Australian and New Zealand job market**: schedule it daily in monitoring mode and you get only jobs that are new or changed, plus, if you want, the jobs that **disappeared**. Every run also saves a free **market summary**: yearly salary quartiles by state, classification, work type and work arrangement, top companies and classifications.

### Why use this SEEK scraper?

- 📈 **More than 550 jobs per search.** SEEK shows at most 550 jobs of one search. With **Read past 550 jobs** the actor reads a bigger search in parts and returns (nearly) all of its jobs, e.g. every nursing job in Australia, for a small extra charge.
- 💰 **Salaries you can compare.** The salary as the ad shows it ("$85,000 – $90,000 per year plus super") and as **yearly, monthly and hourly** numbers in AUD or NZD, plus whether super or KiwiSaver comes on top.
- 🔎 **All the website's filters** (filtered-out jobs cost nothing): location and radius, 30 classifications, work type, work arrangement, listed today or in the last 3, 7, 14 or 30 days, salary range (annual, monthly or hourly), newest first.
- 🧮 **Plus filters the website doesn't have:** only jobs with a salary, shown salary from (per year), listed in the last N days, title must (not) contain, company, exclude companies, exclude promoted jobs.
- 📝 **Details (optional):** the full ad in text, Markdown or HTML, when the ad closes, the **applicant volume** (and, as a small extra, the **number of applicants**), the employer's **screening questions**, whether the advertiser is verified, and the **company profile**: industry, size, rating, number of reviews and website.
- 🇦🇺🇳🇿 **Two countries, one actor:** Australia and New Zealand; mix URLs of both in one run.
- 📬 **Monitoring mode:** a daily feed of new and changed jobs (`changeType`, `changedFields`), optionally with **removed jobs** (`expired` or `noLongerMatches`, with `daysOnline`).
- 📊 **Market summary for free** (SUMMARY record) and **hiring signals** (optional): employer's open positions, days online, hard to fill, reposts under a new ID.
- 🔔 **Job alerts without any integration:** send the saved jobs to **Slack, Discord, Telegram, WhatsApp** or your own **webhook** (Zapier, Make, n8n) after each run.
- 🔒 **Privacy first.** No contacts unless you turn them on (**Contacts**, a paid option); e-mails, phone numbers and the names next to them are always removed from the texts, and private advertisers are never named.

#### How it compares with other SEEK scrapers

An honest comparison with the SEEK scrapers most used in the Store (checked 2026-11-15), without naming them:

| Capability | This actor | Other scrapers |
|---|---|---|
| Keyword, location, classification, work type, arrangement, date and salary filters, URLs | yes | yes |
| seek.com.au and seek.co.nz | yes | yes |
| More than 550 jobs of one search | yes | no, at most 550 |
| Salary as numbers per year, month and hour, super on top or included | yes | as text, or a range only |
| Applicants, screening questions, company profile | with details (number of applicants a small extra) | some |
| Monitoring of new, changed and removed jobs, notifications | yes | some |
| Market summary, hiring signals, compact output for AI agents | yes | partly |
| Private advertisers never named, contacts only on request | yes | contacts by default in some |
| Price per 1 000 jobs (Free plan) | $0.84, $1.72 with details | $0.90 to $2.50, up to $2.70 with details |

### What data can you get?

| Field | Example |
|---|---|
| Title, job ID, URL | Junior Software Developer (PHP), 95855838 |
| Company, advertiser, logo | Axion SD; Axion SD Pty Ltd |
| Location, area, state, country | Melbourne VIC; All Melbourne VIC; VIC; AU |
| Classification, sub-classification | Information & Communication Technology; Developers/Programmers |
| Work type, work arrangement | Part time; hybrid |
| Salary as shown | $30 – $40 per hour |
| Salary per year, month and hour | 59 280–79 040; 4 940–6 587; 30–40 (AUD) |
| Listed at, labels, promoted | 2026-11-12; EARLY_APPLICANT, URGENT |
| Teaser and selling points | the ad's short summary and its three key points |
| With details | description, closes at, applicant volume (number of applicants as an option), screening questions, verified advertiser, company industry, size, rating, reviews and website |

**Fill rates** (2026-11-15, 1 540 jobs in Sydney and Melbourne): title, company, location, state, classification, work type and listing date 100 % (company empty only for private advertisers, about 1.5 %), work arrangement about 95 %, **a salary text for about half of the jobs and an amount for about 36 %** (fewer in IT, more in healthcare and trades; the rest show no salary or only words like "Competitive salary"). With details (30 nursing ads): description and closing date 100 %, applicant volume and number of applicants about 85 %, screening questions about 80 %, company profile about 25 %.

### How to scrape SEEK

1. Open the actor and type a search query (e.g. `developer`) and a location (e.g. `Sydney NSW`).
2. Set **Max jobs** (20 for a quick test).
3. Turn on **Add description and details** if you need the full ad, and **Read past 550 jobs** for a big search.
   **Retry rejected requests from a new IP address** is on by default, so runs finish reliably ($0.003 per new address used, see below).
4. Click **Start** and download the data as JSON, CSV or Excel, or get it from the API.

### Use cases

#### Software developer jobs in Sydney with a salary

```json
{
  "searchQueries": ["software developer"],
  "locations": ["All Sydney NSW"],
  "onlyWithSalary": true,
  "maxItems": 200
}
```

#### Every nursing job in Australia, read past 550

```json
{
  "searchQueries": ["registered nurse"],
  "deepSearch": true,
  "maxItems": 0
}
```

#### New remote ICT jobs every morning, with the removed ones

```json
{
  "classifications": ["6281"],
  "workArrangements": ["remote"],
  "maxItems": 0,
  "onlyNewOrChanged": true,
  "includeRemovedJobs": true,
  "monitoringKey": "remote-ict",
  "slackWebhookUrl": "https://hooks.slack.com/services/..."
}
```

#### Electrician jobs from $45 an hour in Brisbane, with details

```json
{
  "searchQueries": ["electrician"],
  "locations": ["All Brisbane QLD"],
  "salaryType": "hourly",
  "salaryMin": 45,
  "includeDetails": true,
  "maxItems": 100
}
```

#### Jobs in Auckland, New Zealand

```json
{
  "country": "nz",
  "locations": ["Auckland"],
  "postedWithin": "7",
  "maxItems": 100
}
```

#### A search or a company from the website

```json
{
  "startUrls": [
    { "url": "https://www.seek.com.au/data-analyst-jobs/in-All-Melbourne-VIC?worktype=242" },
    { "url": "https://www.seek.com.au/Department-of-Health-Tasmania-jobs/at-this-company" }
  ],
  "maxItems": 200
}
```

#### Website filters

Location and radius, classification, work type, work arrangement, listed within, salary range and sort order are applied by the website itself: filtered-out jobs cost nothing. Several values of a filter mean "any of them". Locations are written as the website suggests them ("Sydney NSW", "All Melbourne VIC", "Parramatta NSW 2150", "Queensland", "Auckland"); a place the website doesn't know stops the run with a clear message. The website's **salary filter** also matches ads that don't show their salary (by the range the employer gave it); add **Only jobs with a salary** to keep only ads that show one.

#### Filters applied by the actor

Only jobs with a salary, shown salary from (per year), listed in the last N days, title must (not) contain, company, exclude companies and exclude promoted jobs are checked on the jobs read. You don't pay for filtered-out jobs; when a filter keeps few of many jobs, the pages read beyond the saved jobs are charged as **Extra page**.

#### Read past 550 jobs

SEEK shows the first 550 jobs of any search; the status tells you when a search has more. With **Read past 550 jobs** such a search is read in smaller parts that SEEK shows in full, and each job is saved once. Jobs found this way are charged as **Deep search**. A part that still has more than 550 jobs (very rare) is read up to 550, and the status says so.

#### Monitoring mode

With **Monitoring: only new or changed jobs** the actor remembers the jobs of the previous run with the same **Monitoring key** and saves only new jobs and jobs whose title, company, location, work type, arrangement or salary changed (`changedFields` lists them). With **Monitoring: include removed jobs** you also get the jobs that left the search, each one checked: `expired` (the ad ended) or `noLongerMatches` (still online, no longer in the search). Unchanged jobs are free; every listing page read in this mode is a **Monitoring page**.

#### Number of applicants (optional, small extra charge)

**Number of applicants** (with **Add description and details**) adds `applicantCount`, the number of applicants SEEK reports for an ad applied for on SEEK. SEEK shows this number mainly to signed-in users; the applicant volume label (`applicantVolume`, e.g. "High application volume") comes with the details at no extra cost. Without the option `applicantCount` is empty. Price: $0.10 per 1 000 jobs that got the number, from 2026-11-15.

#### Contacts (optional, personal data)

**Contacts** adds the e-mails and phone numbers written in the ad (`contactEmails`, `contactPhones`), only with **Add description and details** and never for private advertisers. They can be personal data: you are responsible for using them lawfully (e.g. the Australian Privacy Act and Spam Act, no unsolicited marketing). In our sample of 57 nursing ads about 3 in 10 had an e-mail or phone. Descriptions always have their contacts removed.

#### Market summary (SUMMARY)

Every run saves a free SUMMARY record in its key-value store: number of jobs, yearly salary median and quartiles (AUD and NZD apart) overall and by state, classification, work type and work arrangement, top companies, classifications, sub-classifications, work types and work arrangements.

#### Retry rejected requests from a new IP address (on by default)

SEEK refuses some proxy IP addresses (in our tests about 1 in 25). With **Retry rejected requests from a new IP address** (on by default), a request that is still refused after the usual second attempt is repeated from a new proxy address, up to three times: **$0.003 per new address used**, nothing when the website answers normally. It never solves a verification and keeps the same pace. Most runs pay nothing for it; a run whose address is refused usually pays $0.003. Your maximum cost per run is respected: when it does not allow another new address, the run goes on as with the option off, and the status message says so. Turn it off to never pay it, at the risk of a failed run.

#### Fast mode (optional, small extra charge)

Fast mode reads up to about 2× faster and drops back to the normal speed for the rest of the run at the first sign of load. It never changes IP address to get around a limit. It matters mostly with **Add description and details**.

### How much does it cost to scrape SEEK?

Pay per event; the prices are also on the **Pricing** tab.

| Event | Price | When |
|---|---|---|
| Job saved in the dataset | **$0.84 / 1 000** (Bronze $0.83, Silver $0.82, Gold and higher $0.81) | every saved row |
| Job details | + $0.88 / 1 000 | a job saved with **Add description and details** |
| Actor start | $0.005 per run | once per run |
| Deep search | + $0.10 / 1 000 | a job found in the parts of a search read with **Read past 550 jobs** |
| Monitoring page | $0.50 / 1 000 pages | monitoring mode: every listing page read (up to 100 jobs), so unchanged jobs cost little |
| Extra page | $0.50 / 1 000 pages | pages beyond what the saved jobs explain (one listing page per 100 jobs saved from each search, one detail per job with details): a search that finds nothing, a filter that keeps few jobs, job URLs of ended ads. If the saved jobs don't cover a run's cost (e.g. a run that waits long because the website delays requests), the difference is charged as extra pages; the log says how many. A normal run pays nothing here. |
| Hiring signals | + $0.20 / 1 000 | a saved job that got hiring signals (option) |
| Contact details | + $0.40 / 1 000 | a saved job with at least one contact (option) |
| New IP address | $0.003 (from 2026-11-15) | with **Retry rejected requests from a new IP address** (on by default): each new proxy address used for a request the website kept refusing; nothing when the website answers normally |
| Applicant count | + $0.10 / 1 000 (from 2026-11-15) | a saved job that got the number of applicants (option **Number of applicants**, with details) |
| Fast mode | + $0.01 / 1 000 | a job saved while fast mode was on |
| Notification | $0.001 per run | a run that sent its notification (all channels together) |

| Typical run | Price (Free plan) | Typical time |
|---|---|---|
| 20 jobs (the example input) | $0.022 | under 15 s |
| 1 000 jobs | $0.85 | under 1 minute |
| 1 000 jobs with details | $1.73 | about 15 minutes (about 7 in fast mode) |
| 5 000 jobs of one big search with **Read past 550 jobs** | $4.70 | about 2 minutes |
| Daily monitoring of a search with 300 jobs, 20 new | $0.023 | under 30 s |

You can set a maximum cost per run; the actor stops when it is reached. Jobs whose details could not be read are saved with their list data and not charged the details price.

### Input example

```json
{
  "searchQueries": ["developer"],
  "locations": ["Sydney NSW"],
  "maxItems": 20
}
```

### Output example

```json
{
  "id": "seek.com.au:95855838",
  "source": "seek.com.au",
  "url": "https://www.seek.com.au/job/95855838",
  "jobId": "95855838",
  "title": "Junior Software Developer (PHP)",
  "company": "Axion SD",
  "advertiserName": "Axion SD Pty Ltd",
  "location": "Melbourne VIC",
  "state": "VIC",
  "country": "AU",
  "classification": "Information & Communication Technology",
  "subClassification": "Developers/Programmers",
  "workType": "Part time",
  "workArrangement": "hybrid",
  "salaryText": "$30 – $40 per hour",
  "salaryMin": 30,
  "salaryMax": 40,
  "salaryCurrency": "AUD",
  "salaryPeriod": "hour",
  "salaryYearlyMin": 59280,
  "salaryYearlyMax": 79040,
  "salaryHourlyMin": 30,
  "salaryHourlyMax": 40,
  "postedAt": "2026-11-12T13:44:24Z",
  "teaser": "Build and enhance a real-world SaaS platform while gaining experience across backend, cloud, APIs and modern web technologies.",
  "bulletPoints": ["Flexibility", "Gain experience with a real world system across a range of technologies"],
  "description": "Junior Software Developer @Altora\n- Type: Part-time / Casual (4 days per week with potential to grow) …",
  "expiresAt": "2026-12-13T12:59:59Z",
  "applicantCount": 303,
  "applicantVolume": "High application volume",
  "screeningQuestions": ["Which of the following statements best describes your right to work in Australia?", "How many years' experience do you have as a PHP developer?"],
  "advertiserVerified": true,
  "detailScraped": true,
  "scrapedAt": "2026-11-15T09:00:00Z"
}
```

(Shortened: the row has more fields, see the dataset schema. The description, closing date, applicant volume, screening questions and company profile are filled with **Add description and details**, the number of applicants with **Number of applicants**.)

### Limitations

- SEEK shows at most 550 jobs of one search; turn on **Read past 550 jobs** to get more (see above).
- Salaries are what the ad shows. About half of the ads show no salary and some more only words ("Competitive salary"), so their amount fields are empty. Yearly, monthly and hourly equivalents use standard full-time hours (38 a week).
- The number of applicants is known only for ads applied for on SEEK (and SEEK shows it mainly to signed-in users); ads that send applicants to the employer's own site have `applyOnExternalSite: true`.
- The company profile (industry, size, rating) exists only for employers that have one on SEEK (about a quarter of the ads).
- A job given by its URL or ID has no work arrangement, area or sub-classification code (the other fields are the same as from a search).
- `state` is filled for Australia only; New Zealand jobs have the region in `location` and `area`.
- Free text may name a contact person in an unusual form: e-mails, phone numbers and the names written next to them are removed.
- The proxy is set by default and included in the price. A request the website rejects is retried once a little later from the same address, then (with **Retry rejected requests from a new IP address**, on by default) from a new one; if rejections continue, the run stops with what it has saved and says so. The actor never solves challenges.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/seek-scraper").call(run_input={
    "searchQueries": ["data analyst"], "locations": ["All Melbourne VIC"], "maxItems": 100,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["salaryYearlyMin"], job["salaryYearlyMax"], job["workArrangement"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")["value"]
print(summary["salary"]["byCurrency"]["AUD"]["yearly"], summary["topCompanies"][:10])
```

**Compact output** keeps the core fields (title, company, location, classification, work type and arrangement, salary, date, link) plus the fields of the options you turned on: smaller rows for AI agents, MCP clients and spreadsheets.

### Troubleshooting

- **"Your maximum cost per run … does not cover the start of the run"**: raise the maximum cost per run in the run options.
- **"does not know the place …"**: write the location as the website suggests it, e.g. "Sydney NSW", "All Melbourne VIC" or "Auckland".
- **"job URLs or IDs of ended or unknown ads, nothing was saved"**: the ads are no longer published; use the URL of an open job.
- **"no jobs: …"**: the website found nothing for the search; try fewer filters.
- **"the website shows only the first 550 jobs of a search"**: turn on **Read past 550 jobs**.
- **"rejecting requests"**: keep **Retry rejected requests from a new IP address** on (the default) and the default **Proxy configuration**, then try again later.
- **"… is off, so this run will most likely fail if SEEK refuses its IP"** (start of the run): you turned **Retry rejected requests from a new IP address** off; turn it back on for reliable results.

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### More job scrapers

Jobs from another source, with salaries and monitoring:

- [StepStone Scraper](https://apify.com/tsutseisoftware/stepstone-scraper): jobs from StepStone in Germany, Austria, Belgium and the Netherlands: salary as numbers, hiring signals, monitoring
- [Welcome to the Jungle Scraper](https://apify.com/tsutseisoftware/welcome-to-the-jungle-scraper): jobs from Welcome to the Jungle in France, Europe and the US: salary as numbers, company profile, closed jobs, alerts
- [XING Jobs Scraper](https://apify.com/tsutseisoftware/xing-jobs-scraper): jobs from XING in Germany, Austria and Switzerland: full description, salary as numbers, past the 1,000-job limit, removed jobs, alerts
- [Arbeitsagentur Jobbörse Scraper](https://apify.com/tsutseisoftware/arbeitsagentur-scraper): jobs from the Jobbörse of the Bundesagentur für Arbeit, Germany's largest job board: salary as numbers, employer profiles, removed jobs, alerts
- [LinkedIn Jobs Scraper](https://apify.com/tsutseisoftware/linkedin-jobs-scraper): public LinkedIn jobs in any country without login: salary as numbers, seniority, applicants, hiring signals, new and removed jobs, alerts
- [Career Site Job Search & Scraper](https://apify.com/tsutseisoftware/ats-jobs-scraper): jobs straight from company career sites on Greenhouse, Workday, Lever, Ashby and SmartRecruiters in any country, including the jobs that just closed

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### FAQ

#### Is it legal to scrape SEEK?

It reads only publicly available data, without logging in, at most 90 requests per minute (200 in fast mode), slows down when the website asks, never solves captchas or other challenges. It returns contacts only if you turn on **Contacts (personal data)** (then you are responsible for using them lawfully) and always removes e-mails, phone numbers and the names next to them from the texts. The website's terms of use may restrict extracting its data; you are responsible for how you use the data (privacy laws, database rights and the website's terms). If in doubt, consult a lawyer. This actor is not affiliated with SEEK.

#### Why is the company empty for some jobs?

The ad was posted by a **private advertiser**, or the employer name is a private person's name. For privacy the name, logo and company profile are left out.

#### How does "Read past 550 jobs" find all jobs?

It reads the search in smaller parts that SEEK shows in full and puts them together, each job once. The status reports how many jobs the website counted and how many were read.

#### Do I need a proxy?

No setup needed: the proxy is set by default and its cost is included in the price.

#### Can I use it from an AI agent or through MCP?

Yes. Use **Compact output** for smaller rows, and call the actor through the Apify API or Apify's MCP server.

Also known as a SEEK API, SEEK job scraper, SEEK jobs export, Australian jobs scraper or New Zealand jobs scraper.

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/seek-scraper/changelog.md

# Actor input Schema

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

Job titles or keywords to search for, e.g. "developer", "registered nurse", "electrician", "data analyst". Each query is a separate search (combined with every location and the filters below). Empty = all jobs (of the locations).

## `locations` (type: `array`):

Suburbs, cities, regions or states as the website suggests them, e.g. "Sydney NSW", "All Melbourne VIC", "Parramatta NSW 2150", "Queensland", "Auckland". Each location is a separate search with every query. Empty = the whole country.

## `radius` (type: `integer`):

With a suburb in "Locations": include jobs up to this distance, e.g. 5, 10 or 50. Empty or 0 = the website's default.

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

The SEEK website the searches and job IDs are for. SEEK URLs keep their own website.

## `startUrls` (type: `array`):

Search URLs from seek.com.au or seek.co.nz, e.g. https://www.seek.com.au/developer-jobs/in-All-Sydney-NSW?worktype=242 (set the search and filters on the website and paste the URL), a company's job list (https://www.seek.com.au/…-jobs/at-this-company), or job URLs (https://www.seek.com.au/job/95855838). The filters of this form are added to search URLs too, unless the URL already sets them.

## `jobIds` (type: `array`):

SEEK job IDs (the number at the end of a job URL, e.g. 95855838) of the website in "Country", read one by one. At most 2000.

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

Maximum number of jobs saved. You pay per saved job. 0 = no limit.

## `maxItemsPerStartUrl` (type: `integer`):

Limit for each search and each URL separately, so one large search doesn't use up the whole Max jobs. 0 = no limit.

## `deepSearch` (type: `boolean`):

The website shows at most 550 jobs of one search. With this on, a bigger search is read in smaller parts that the website shows in full, so you get (nearly) all of its jobs. Extra charge "Deep search": $0.10 per 1,000 jobs found in the parts. Off = the first 550 jobs of each search.

## `includeDetails` (type: `boolean`):

Adds the full description (e-mails, phone numbers and names next to them removed), when the ad closes, the applicant volume (when applying goes through the website), the screening questions, whether the advertiser is verified, and the employer's company profile: industry, size, rating, reviews and website. Extra charge "Job details": $0.88 per 1,000 jobs with details.

## `includeApplicantCount` (type: `boolean`):

With "Add description and details": adds the number of applicants (applicantCount) for ads applied for on SEEK. SEEK shows this number mainly to signed-in users; the applicant volume label (applicantVolume) comes with the details anyway. Extra charge "Applicant count": $0.10 per 1,000 jobs (from 2026-11-15) that got the number.

## `descriptionMaxLength` (type: `integer`):

With "Add description and details": shorten the description to about this many characters (e.g. 300 for a snippet). 0 = full text.

## `descriptionFormat` (type: `string`):

Format of "description" (with "Add description and details"): plain text, Markdown (headings and lists, good for AI agents and Notion) or simple HTML.

## `classifications` (type: `array`):

Only jobs of these classifications (several = any of them).

## `workTypes` (type: `array`):

Only full time, part time, contract/temp or casual/vacation jobs (several = any of them).

## `workArrangements` (type: `array`):

Only on-site, hybrid or remote jobs (several = any of them).

## `postedWithin` (type: `string`):

Only jobs the website listed recently.

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

What "Salary from" and "Salary up to" mean: per year, per month or per hour.

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

The website's own salary filter, e.g. 100000 (annual) or 40 (hourly). The website also matches ads that don't show their salary, by the range the employer gave it; use "Only jobs with a salary" to skip those.

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

Upper bound of the website's salary filter, e.g. 150000. Empty = no upper bound.

## `onlyWithSalary` (type: `boolean`):

Skip jobs that show no salary amount.

## `minYearlySalary` (type: `integer`):

Only jobs whose shown salary reaches at least this amount per year (hourly, daily and monthly amounts at full-time hours), e.g. 120000. Jobs that show no amount are skipped.

## `postedWithinDays` (type: `integer`):

Only jobs listed in the last N days (any number, unlike "Listed within"). 0 = any time.

## `titleKeywords` (type: `array`):

Keep only jobs whose title contains at least one of these words (case doesn't matter).

## `excludeKeywords` (type: `array`):

Skip jobs whose title contains any of these words, e.g. "Senior", "Manager".

## `companies` (type: `array`):

Keep only jobs of companies whose name contains one of these texts.

## `excludeCompanies` (type: `array`):

Skip jobs of companies whose name contains any of these texts (e.g. recruitment agencies).

## `excludePromoted` (type: `boolean`):

Skip ads the website shows as promoted (featured).

## `onlyNewOrChanged` (type: `boolean`):

Return only jobs that are new or whose title, company, location, work type, work arrangement or salary changed since the previous run with the same Monitoring key. Unchanged jobs are free; every listing page read in this mode is the "Monitoring page" event ($0.50 per 1,000 listing pages; one page = up to 100 jobs).

## `monitoringKey` (type: `string`):

Name of the saved state. Use a different key for each watched search (e.g. "nurse-sydney"). Empty = "default". The value is stored encrypted.

## `includeRemovedJobs` (type: `boolean`):

With "Monitoring: only new or changed jobs": also return jobs of the previous run that are no longer in the search, as rows with changeType "removed" and removedReason "expired" (the ad ended) or "noLongerMatches" (the ad is live but no longer matches the search), each one checked. Checked only when the run reads every search completely (limits, unread pages or rejected requests skip the check, and the status message says why). Removed rows are charged like any other job.

## `includeHiringSignals` (type: `boolean`):

Adds to every job how many open positions its employer has (companyOpenPositions), days online (daysOnline) and hardToFill; with monitoring also reposts of the same position under a new job ID (isRepost, repostOf, repostCount). At no extra run time; $0.20 per 1,000 jobs that got the signals (the "Hiring signals" event).

## `includeContacts` (type: `boolean`):

Adds the e-mails and phone numbers written in the ad (contactEmails, contactPhones). Needs "Add description and details". Never for private advertisers. These can be personal data: you are responsible for using them lawfully (e.g. the Australian Privacy Act and Spam Act, no unsolicited marketing). Descriptions keep their contacts removed. $0.40 per 1,000 jobs that got at least one contact (the "Contact details" event).

## `compactOutput` (type: `boolean`):

Only the core fields (title, company, location, classification, work type and arrangement, salary, date, URL) plus the fields of the options you turned on. Smaller rows for AI agents, MCP clients and spreadsheets.

## `telegramBotToken` (type: `string`):

Token of your Telegram bot (from @BotFather), e.g. 123456789:AA... Used with "Telegram chat ID".

## `telegramChatId` (type: `string`):

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

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

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...).

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

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

Any HTTPS URL: gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many jobs are listed in one notification (the rest as "…and N more").

## `notifyOnlyChanges` (type: `boolean`):

Send nothing when the run saved no job (e.g. a monitoring run without new jobs).

## `fastMode` (type: `boolean`):

Reads up to about 2 times faster, which helps most with "Add description and details". It drops back to the normal speed for the rest of the run at the first sign of load, and it never changes IP address to get around a limit. Extra charge "Fast mode": $0.01 per 1,000 jobs saved while the fast speed was on.

## `sortBy` (type: `string`):

Order of the website's search results (matters with Max jobs). SEEK URLs keep their own order unless you choose "Newest first". A run that reads whole searches (Max jobs 0, no other limit) reads them newest first.

## `maxPages` (type: `integer`):

Safety limit for each search or URL (100 jobs per page, at most 6 pages). 0 = no limit.

## `retryFromNewIp` (type: `boolean`):

On by default. SEEK refuses some proxy IP addresses (in our tests about 1 in 25). On: a request that is still refused after the usual second attempt is repeated from a new proxy address, $0.003 per new address used (from 2026-11-15), nothing when the website answers normally; it never solves a verification and keeps the same pace. Your maximum cost per run is respected. Off: a few tenths of a cent cheaper, but a run whose IP is refused will most likely fail. Needs a proxy (the default one is fine).

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

Apify Proxy (automatic) by default, included in the price. Keep the default: without a proxy the website refuses the platform's servers.

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "searchQueries": [
    "developer"
  ],
  "locations": [
    "Sydney NSW"
  ],
  "country": "au",
  "maxItems": 20,
  "maxItemsPerStartUrl": 0,
  "deepSearch": false,
  "includeDetails": false,
  "includeApplicantCount": false,
  "descriptionMaxLength": 0,
  "descriptionFormat": "text",
  "postedWithin": "any",
  "salaryType": "annual",
  "onlyWithSalary": false,
  "excludePromoted": false,
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "includeHiringSignals": false,
  "includeContacts": false,
  "compactOutput": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "fastMode": false,
  "sortBy": "relevance",
  "maxPages": 0,
  "retryFromNewIp": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "sendErrorReports": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

The saved jobs (one row per job), in the run's default dataset.

## `summary` (type: `string`):

Free summary of the jobs the run found: yearly salary quartiles in AUD and NZD (by state, classification, work type and work arrangement), top companies, classifications, work types and work arrangements.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchQueries": [
        "developer"
    ],
    "locations": [
        "Sydney NSW"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/seek-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["developer"],
    "locations": ["Sydney NSW"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/seek-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "developer"
  ],
  "locations": [
    "Sydney NSW"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call tsutseisoftware/seek-scraper --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/ekU0E4b8CefW3fMCS/builds/PLYudIIO7xZJs1FUP/openapi.json
