# SEEK Jobs Scraper + Hiring Company Leads (AU & NZ) (`snappytools/seek-jobs-scraper`) Actor

Search SEEK Australia and New Zealand by keyword, location and filters. One row per job with parsed salaries, plus one row per hiring company with website, emails and phone numbers.

- **URL**: https://apify.com/snappytools/seek-jobs-scraper.md
- **Developed by:** [Snappy](https://apify.com/snappytools) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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 Jobs Scraper + Hiring Company Leads (AU & NZ)

Search SEEK Australia (seek.com.au) and SEEK New Zealand (seek.co.nz) the same way you would on the website, and get every matching job as a clean table. Salaries are split into minimum, maximum and pay period, and converted to an annual figure so you can compare hourly, daily and yearly ads.

It can also give you **one row per hiring company**: how many jobs they have open, what they're hiring for and where, their website, and (if you turn it on) the emails, phone numbers and social links from their website and job ads. Recruitment agencies are flagged, or you can leave them out.

Put it on a schedule with **Only new jobs since my last run** and each run returns only jobs you haven't seen before.

### Why this one

- **Hiring companies as leads, not just job rows.** Twenty ads from the same company become one row with their website, emails, phone numbers and socials. In a real test (payroll jobs in Melbourne, 17 Oct 2026), 14 of 19 companies came back with an email or phone number.
- **Contact details from the company's own website.** Not only what's written in the ad: the tool finds their site (SEEK profile, the ad, or their name) and checks the homepage and contact page.
- **Leave out recruitment agencies** so your list is companies hiring for themselves.
- **Pay once per lead.** "Only companies I haven't had before" skips companies an earlier run already gave you.
- **Salaries you can compare.** Hourly, daily and yearly ads converted to an annual figure, with super noted.
- **$1 per 1,000 jobs.** No charge for empty searches or status rows.

### Quick start: a lead list in one run

Paste this into the Input tab (JSON view) and click Start. Change the search to your own market.

```json
{
    "searches": ["payroll officer | All Melbourne VIC"],
    "output": "companies",
    "findCompanyContacts": true,
    "skipRecruiters": true,
    "datePosted": "14",
    "maxJobsPerSearch": 200
}
```

You get one row per company hiring a payroll officer in Melbourne in the last two weeks, with their contact details. Turn on **Only companies I haven't had before** and schedule it weekly to get only new companies each time.

### What you can use it for

| Who | What for |
| --- | --- |
| B2B sales teams | A company that's hiring is growing or changing. Find businesses hiring for roles your product supports (for example payroll, IT support, fleet drivers) and contact them while it's relevant |
| Recruitment agencies | Find employers advertising directly, without an agency, and offer to help. Turn on "Leave out recruitment agencies" |
| Job boards and aggregators | A daily feed of new jobs in your niche or region |
| Salary research | Advertised salaries by role, classification and location, all converted to annual figures |
| Market and workforce research | Hiring demand by classification, location, work type and remote/hybrid |

### How to use it

1. Click **Try for free**.
2. In **Searches**, add one search per line: the keywords, then a `|` and a location. For example:
   - `accountant | Melbourne`
   - `electrician | All Brisbane QLD`
   - `registered nurse` (no location means all of Australia)
   - Or paste the address of a SEEK results page. Its keywords, location and filters are used as they are.
3. Choose **What to return**: Jobs, Jobs and hiring companies, or Hiring companies only.
4. Optionally set filters: listed in the last N days, classification, work type, remote or hybrid, minimum salary.
5. Click **Start**.

For a daily feed, go to **Schedules**, use the same input, and tick **Only new jobs since my last run**.

### Input example

```json
{
    "searches": [
        "payroll officer | All Melbourne VIC",
        "https://au.seek.com/it-support-jobs/in-All-Sydney-NSW?daterange=7"
    ],
    "output": "jobsAndCompanies",
    "findCompanyContacts": true,
    "skipRecruiters": true,
    "maxJobsPerSearch": 200,
    "datePosted": "7",
    "workTypes": ["fulltime"]
}
```

### What data you get

The Output has four tabs: **Jobs**, **Salaries**, **Hiring companies** and **Run status**.

#### Job rows

| Field | What it is | Example |
| --- | --- | --- |
| `jobId`, `title`, `jobUrl` | SEEK job ID, title and link | `94423725`, `Accounts Payable Officer` |
| `companyName`, `advertiserName` | Company name, and the advertiser name SEEK shows (they can differ) | `YWCA Australia` |
| `isRecruitmentAgency` | `true` if the advertiser looks like a recruitment or labour-hire agency | `false` |
| `isPrivateAdvertiser` | `true` when the ad says "Private Advertiser" | `false` |
| `location`, `suburb`, `state`, `postcode`, `area` | Where the job is | `Surry Hills, Sydney NSW`, `NSW`, `2010`, `All Sydney NSW` |
| `workType`, `workArrangement` | Full time, part time, contract or casual. Remote/hybrid when the advertiser set it | `Full time` |
| `classification`, `subClassification`, `allClassifications` | SEEK categories | `Accounting`, `Accounts Payable` |
| `salaryText` | Salary exactly as advertised | `$70,000 + super + salary up to $18,550!` |
| `salaryMin`, `salaryMax`, `salaryPeriod` | Parsed numbers and period (`hour`, `day`, `week`, `month`, `year`) | `70000`, `70000`, `year` |
| `salaryAnnualMin`, `salaryAnnualMax` | Converted to a yearly figure | `70000` |
| `superannuation` | `plus super`, `included`, or empty | `plus super` |
| `listedAt`, `daysAgo` | When it was listed | `2026-09-04T07:21:09.000Z`, `1` |
| `teaser`, `bulletPoints` | The short description and selling points from the search results | |
| `isPromoted`, `logoUrl` | Paid placement, and the advertiser logo | |
| `seekCompanyProfileUrl` | The company's SEEK profile page, when it has one | `https://au.seek.com/companies/ywca-australia-434885` |
| `isNew` | Only with "Only new jobs since my last run" | `true` |

With **Include full job descriptions** you also get `description` (the full ad as plain text), `phoneNumber` (if the advertiser listed one), `adEmails`, `adPhones` and `adWebsites` (contact details written in the ad), `applyType` (`quick apply` on SEEK or `external`), `isVerifiedAdvertiser` and `expiresAt`.

The salary conversion uses 38 hours × 52 weeks for hourly rates, 260 working days for daily rates, 52 for weekly and 12 for monthly. When an ad doesn't say the period, it's worked out from the amount and `salaryPeriodGuessed` is `true`.

#### Hiring company rows

One row per company across all your searches (jobs from "Private Advertiser" can't be linked to a company, so they're left out).

| Field | What it is |
| --- | --- |
| `companyName` | The company |
| `openJobs`, `jobTitles`, `locations`, `states`, `classifications`, `workTypes` | What they're hiring for in this run's results |
| `newestListingDate`, `salaryAnnualRange` | Their most recent ad and the range of advertised salaries |
| `isRecruitmentAgency` | `true` if any of their ads look like an agency's |
| `website`, `websiteSource` | Their website, and where it came from: their SEEK company profile, their SEEK company page, a web address in the job ad, the domain of an email in the ad, or (with contact finding on) an address made from the company name whose homepage shows that name |
| `industry`, `companySize`, `seekRating`, `seekReviewCount` | From their SEEK company profile, when they have one |
| `emails`, `phones`, `socials`, `contactPageUrl` | With **Find company emails and phone numbers** on: found on their homepage and contact page, plus any in their job ads. The company's own-domain emails come first |
| `jobAdEmails`, `jobAdPhones` | The contact details that were written in their job ads (often the hiring manager or recruiter) |
| `contactStatus` | `found`, `no website found`, `none found on website`, `website unreachable (...)`, or `not requested` |
| `seekCompanyProfileUrl`, `jobUrls` | Links back to SEEK |

Example from a real run (search `payroll officer | All Melbourne VIC`, 17 Oct 2026, trimmed):

```json
{
    "type": "company",
    "companyName": "Liquip Victoria",
    "website": "http://www.liquipvictoria.com.au/",
    "websiteSource": "SEEK company profile",
    "emails": ["sales@liquipvictoria.com.au"],
    "phones": ["(03) 9311 7822"],
    "socials": { "facebook": "https://facebook.com/liquipvictoria", "linkedin": "https://linkedin.com/company/6375544" },
    "jobTitles": ["Finance Officer"],
    "contactStatus": "found",
    "openJobs": 1,
    "isRecruitmentAgency": false,
    "seekRating": 2.5
}
```

In that run, 14 of the 19 hiring companies came back with an email or phone number.

#### Run status

One free row per search saying what happened, for example: "Delivered 300 jobs. SEEK shows 1,433 for this search. Stopped at your limit of 300." Searches with no results, links that can't be used, and searches SEEK refused each get their own row, and you aren't charged for jobs from them. There's one more row for the hiring companies. A run summary is saved as `OUTPUT` in the key-value store.

### Pricing

You pay per result, nothing for empty searches or status rows.

| Event | Price |
| --- | --- |
| Job | $1.00 per 1,000 jobs |
| Full job description (only if you turn it on) | $0.50 per 1,000 jobs |
| Hiring company row | $0.002 per company |
| Contact details found for a company (only if you turn it on, and only when at least one email or phone number is found) | $0.008 per company |

So a company lead with contact details costs $0.01, and one where nothing was found costs $0.002. Some real examples:

| Run | Cost |
| --- | --- |
| 1,000 jobs | $1.00 |
| 1,000 jobs with full descriptions | $1.50 |
| 20 jobs plus their 19 hiring companies, 14 with contacts (the test above) | about $0.17 |
| 100 hiring companies only, with contacts found for 70 | $0.76 |
If you set a maximum cost per run, the run stops cleanly at that limit and the status row says so.

### Good to know

- **SEEK lists at most 500 jobs per search.** If you ask for more and haven't picked a classification, the search is split by classification automatically. If you have picked one, narrow the search with a location or date filter, or split it into several lines.
- **Locations** work like the SEEK search box. "All Sydney NSW" covers the whole Sydney region, while "Sydney NSW" on its own means the Sydney CBD and the area around it.
- **Recruitment agency detection** is based on the advertiser's name (agency brands and words like "Recruitment", "Staffing" and "Labour Hire"). SEEK doesn't label agencies, so a few will slip through either way.
- **Only new jobs** remembers job IDs per search and filter combination, for about four months. Changing a search or its filters starts fresh. **Only companies I haven't had before** works the same way for companies, so a daily lead feed doesn't charge you twice for the same company.
- **Contact details** come only from public pages: the company's own website and the job ad. Nothing behind a login is accessed. Use them in line with Australia's Spam Act and privacy rules (or New Zealand's), which apply to how you contact people.
- This tool isn't affiliated with or endorsed by SEEK.

### Getting the data out

Download results as Excel, CSV or JSON from the Output tab, or send them on automatically: Google Sheets, Slack, Zapier, Make and webhooks are all in the **Integrations** tab, and every run is available through the Apify API.

### Questions or problems

Open an issue on the **Issues** tab and include the run link. I reply within one business day.

# Actor input Schema

## `searches` (type: `array`):

One search per line: keywords, then a | and a location. For example "accountant | Melbourne", "electrician | All Brisbane QLD" or "nurse" for all of Australia. You can also paste a link from a SEEK results page; its filters are kept.

## `site` (type: `string`):

Which SEEK to search. A pasted SEEK link uses its own country.

## `output` (type: `string`):

Jobs only, jobs plus one row per hiring company, or just the hiring companies (for lead lists).

## `findCompanyContacts` (type: `boolean`):

For each hiring company, find its website (from its SEEK profile or the job ad) and check its homepage and contact page for emails, phone numbers and social links. Needs "Jobs and hiring companies" or "Hiring companies only". Slower: allow about 1 to 3 seconds per company.

## `skipRecruiters` (type: `boolean`):

Skip ads whose advertiser looks like a recruitment or labour-hire agency (Hays, Randstad, "... Recruitment" and so on), so you only get companies hiring for themselves. Based on the advertiser name, so a few may slip through.

## `maxJobsPerSearch` (type: `integer`):

The most jobs to collect for each search line. SEEK lists at most 500 jobs per search; above that the search is split by classification automatically.

## `datePosted` (type: `string`):

Only jobs listed in this many days.

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

Only jobs in these SEEK classifications. Leave empty for all.

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

Leave empty for all.

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

Leave empty for all. Many advertisers don't set this, so picking one leaves those jobs out.

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

Only jobs paying at least this much, using SEEK's own salary filter (it includes jobs whose salary isn't shown). Leave at 0 for no minimum.

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

Whether the minimum above is per year or per hour.

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

Newest first is best for schedules.

## `includeDescriptions` (type: `boolean`):

Adds the full ad text, the recruiter phone number if listed, emails and websites written in the ad, and whether applying goes to an external site. Costs a little extra per job.

## `onlyNewSinceLastRun` (type: `boolean`):

For schedules. Remembers the jobs each search has already returned and skips them next time. The first run returns everything, as usual.

## `newCompaniesOnly` (type: `boolean`):

Skip hiring companies that an earlier run already delivered (with the same searches, or the same watch name). Stops you paying twice for the same lead.

## `watchName` (type: `string`):

Optional. Runs with the same searches share their memory automatically. Give a name to keep two schedules separate, or to share one company memory across different searches.

## Actor input object example

```json
{
  "searches": [
    "accountant | Melbourne"
  ],
  "site": "au",
  "output": "jobs",
  "findCompanyContacts": false,
  "skipRecruiters": false,
  "maxJobsPerSearch": 20,
  "datePosted": "any",
  "classifications": [],
  "workTypes": [],
  "workArrangements": [],
  "salaryMin": 0,
  "salaryType": "annual",
  "sortBy": "newest",
  "includeDescriptions": false,
  "onlyNewSinceLastRun": false,
  "newCompaniesOnly": false
}
```

# Actor output Schema

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

No description

## `salaries` (type: `string`):

No description

## `companies` (type: `string`):

No description

## `status` (type: `string`):

No description

## `allResults` (type: `string`):

No description

## `runSummary` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searches": [
        "accountant | Melbourne"
    ],
    "output": "jobs",
    "maxJobsPerSearch": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("snappytools/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 = {
    "searches": ["accountant | Melbourne"],
    "output": "jobs",
    "maxJobsPerSearch": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("snappytools/seek-jobs-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 '{
  "searches": [
    "accountant | Melbourne"
  ],
  "output": "jobs",
  "maxJobsPerSearch": 20
}' |
apify call snappytools/seek-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,snappytools/seek-jobs-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/B8jN9RJXHBnORuhxU/builds/fOyOogUrabCHafa2o/openapi.json