The Company
CareerMode has been exclusively engaged by ...",
"roleId": "management-accountant",
"badges": [],
"isFeatured": false,
"logoUrl": "https://bx-branding-gateway.cloud.seek.com.au/b5e2dffd-e37a-4bc3-b1a4-2e72d5a5c30d.1/jdpLogo",
"companyProfile": null,
"sourceUrl": "https://www.seek.com.au/jobs?where=Brisbane&keywords=accountant&sortmode=ListedDate",
"scrapedAt": "2026-11-02T11:15:39.246Z"
}
```
More real items are in [`samples/sample-output.json`](samples/sample-output.json) (contact details in the descriptions are redacted there; the Actor outputs descriptions as published).
Notes on the fields:
- `id` is stable across runs. Use it to de-duplicate.
- `company` is the name shown on the ad. `advertiserName` is the advertiser account, often the legal name or a recruitment agency. Private advertisers show `"Private Advertiser"` with `isPrivateAdvertiser: true`.
- `salary` is `null` when the ad shows no salary. When the text has no numbers (`"Competitive salary + super"`), `min` and `max` are `null` and `text` keeps the wording. A bare `$` is read as AUD on seek.com.au and NZD on seek.co.nz.
- `employmentType` maps SEEK's work type: Full time β `FULL_TIME`, Part time β `PART_TIME`, Contract/Temp β `CONTRACT`, Casual/Vacation β `TEMPORARY`. `workType` keeps SEEK's wording.
- `workplaceType` is `onsite`, `hybrid` or `remote` from the advertiser's work arrangement; `isRemote` is true only for remote.
- `expiresAt`, `isExternalApply`, `isVerifiedAdvertiser`, `area`, `companyProfile` and the descriptions need **Include full job description**.
- Recruiter phone numbers and other contact fields that SEEK holds separately are **not** collected. Descriptions are output as the advertiser published them.
A `RUN_SUMMARY` record in the run's key-value store lists, for every search: jobs output, jobs listed, the total SEEK reported, already-seen and duplicate jobs, requests, and any warnings or errors.
### How much does it cost to scrape SEEK jobs?
This Actor uses **pay-per-event** pricing. You pay **$1.50 per 1,000 jobs** ($0.0015 per job) for jobs that appear in your dataset. There is no start fee. Already-seen jobs in incremental mode, duplicates and failed searches cost nothing.
| Jobs | Price |
|---|---|
| 100 | $0.15 |
| 1,000 | $1.50 |
| 10,000 | $15.00 |
Your Apify plan's free monthly credit applies. To cap spending, set **Maximum cost per run** in the run options. The scraper stops cleanly when the budget is reached and tells you so in the status message.
### Scheduling and incremental monitoring of new jobs
Use this to get **alerts for new jobs** on SEEK, or to keep a job board in sync:
1. Set up your search (form or URLs) and turn on **Only new jobs**. Give the monitor a name in **Monitor name** (e.g. `nurses-auckland`).
2. Save the configuration as a **Task** and add a **Schedule** (e.g. every morning).
3. The first run outputs all current matching jobs and saves them as the baseline.
4. Every later run outputs **only jobs listed since**. Results are sorted newest first, and paging stops at the first page that was entirely seen before, so a run with nothing new makes one request and outputs nothing.
The memory is kept per search in a named key-value store (`seek-jobs-scraper-state` by default), under the key you choose. Changing a search's keywords, location or filters starts a new memory for it (changing only the date range or sort order does not). If you also set **Max jobs per search**, jobs beyond the limit are not remembered, so older ones can show up in a later run; for a clean "new since yesterday" feed, leave the limit at 0. Don't run two runs with the same monitor name at the same time.
### SEEK's 550-result limit
SEEK's search returns at most **550 jobs for any one search**, both on the website and in its API. When a search matches more, the log and `RUN_SUMMARY` say so. To get more jobs, split the search into narrower ones, for example by location, classification, work type or date listed, and add each as a separate start URL. Jobs that appear in several of your searches in one run are output (and charged) only once.
### Blocking and proxies
SEEK is protected by Cloudflare. In testing (November 2026, from a home connection), every SEEK HTML page was challenged for non-browser clients, while SEEK's JSON API answered normally to this scraper's browser-like HTTP client. How Cloudflare treats a request depends on the IP address and the client, and **Apify's datacenter IPs may be treated differently** from the IPs we tested from.
- The scraper runs **without a proxy** by default.
- If SEEK answers with a challenge, the run **stops at once** (no hammering, no retries from the same IP), keeps any jobs already scraped, and the status message says so. You are not charged for jobs that weren't output.
- If that happens, enable **Proxy configuration** with Apify Proxy, the **RESIDENTIAL** group and country **AU** (or NZ), and run again. With a proxy, the scraper also rotates to a new IP a few times before giving up.
### Integrations and API
- **API.** Start runs and fetch results with the [Apify API](https://docs.apify.com/api/v2), or the JavaScript and Python clients:
```bash
curl -X POST "https://api.apify.com/v2/acts/rjmacarthy~seek-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"keywords":"nurse","location":"Auckland","country":"NZ","maxJobs":50,"includeDescription":false}'
```
- **Webhooks.** Get notified (or trigger your pipeline) when a run finishes.
- **Zapier, Make, n8n.** Send new jobs to Google Sheets, Airtable, Slack, email or your CRM with no code.
- **Google Sheets, Slack, Airbyte, Keboola and more** through Apify integrations.
- **AI agents.** Use the Actor as a tool through the Apify MCP server.
### FAQ
**Do I need a SEEK account, cookies or a proxy?**
No account or cookies. A proxy is off by default and only needed if SEEK blocks the run (see "Blocking and proxies").
**How fast is it?**
Without descriptions, 550 jobs take about 6 requests and a few seconds. With descriptions, each job needs one more request; at the default polite rate of 3 requests per second that is roughly 2β3 jobs per second.
**Does it get more than 550 jobs per search?**
No. That's SEEK's own limit. Split large searches into narrower ones (see above).
**Why does a job show no salary even though I filtered by salary?**
SEEK filters on the salary range the advertiser entered, even when the advertiser chose to hide it on the ad.
**What does `salary.source: "description"` mean?**
The ad's salary field had no numbers, so the salary was taken from the description text (only with full descriptions on, and only when a dollar amount appears next to pay wording).
**What happens with a URL that isn't a SEEK search or job?**
It's skipped with a clear warning in the log, and the other URLs continue.
**Is it legal to scrape SEEK?**
The scraper collects job ads that employers publish to attract applicants, at a polite request rate, and doesn't collect contact fields beyond the published ad. SEEK's terms of use and its robots.txt restrict automated access to parts of the site, including the search API this Actor uses. Check that your use complies with SEEK's terms and the laws that apply to you, especially if you store or republish the data.
### Limits
- At most 550 jobs per search (SEEK's limit).
- Descriptions need one request per job; large runs with descriptions are slower than listing-only runs.
- Location is free text matched by SEEK. Check the log line "SEEK matched location ..." if results look off.
- SEEK can change its private API at any time. The job-details query falls back to a minimal version (description only) if SEEK changes its schema, and the log says so.
- Incremental state lives in a named key-value store in your account, created by the Actor itself. Deleting that store resets the monitor.
### Ready-to-run examples
- [Scrape registered nurse jobs in Melbourne from SEEK](https://apify.com/rjmacarthy/seek-jobs-scraper/examples/registered-nurse-jobs-melbourne)
- [Scrape data analyst jobs in Auckland from SEEK NZ](https://apify.com/rjmacarthy/seek-jobs-scraper/examples/data-analyst-jobs-auckland-nz)
### More scrapers by the same developer
- [ATS Jobs Scraper: Greenhouse, Lever, Ashby & Workday](https://apify.com/rjmacarthy/ats-jobs-scraper)
- [Dice Jobs Scraper](https://apify.com/rjmacarthy/dice-jobs-scraper)
- [Workday Jobs Scraper](https://apify.com/rjmacarthy/workday-jobs-scraper)
- [Google Ads Transparency Scraper](https://apify.com/rjmacarthy/google-ads-transparency-scraper)
- [Substack Scraper](https://apify.com/rjmacarthy/substack-scraper)
- [Telegram Channel Scraper](https://apify.com/rjmacarthy/telegram-channel-scraper)
Browse all my Actors on [my Apify Store profile](https://apify.com/rjmacarthy).
### Support
Found a search that doesn't work, or need an extra field? Open an issue on the **Issues** tab with the input or URL. Fixes are usually quick.
# Actor input Schema
## `keywords` (type: `string`):
What you would type into SEEK's "What" box: a job title, skill or company (e.g. "data engineer", "registered nurse"). Leave empty for all jobs.
## `location` (type: `string`):
SEEK's "Where" box: a suburb, city, region, state or postcode (e.g. "Sydney", "All Melbourne VIC", "Auckland", "2000"). Leave empty for the whole country. The run log shows which location SEEK matched.
## `country` (type: `string`):
Which SEEK site to search: seek.com.au (Australia) or seek.co.nz (New Zealand). Start URLs use the site in their own address.
## `maxJobs` (type: `integer`):
Stop after this many jobs from each search (the form search, or each start URL). Default 100. Set 0 for all jobs SEEK returns, which is at most 550 per search.
## `includeDescription` (type: `boolean`):
Fetch each job's details for the full description (HTML and plain text), expiry date, external-apply flag and company profile. This is one extra request per job. Turn off for a faster scrape of the listing data only (title, company, salary, classification, work type, bullet points, teaser).
## `startUrls` (type: `array`):
Instead of the form, paste SEEK URLs copied from the browser, e.g. https://www.seek.com.au/developer-jobs-in-information-communication-technology/in-All-Melbourne-VIC?daterange=7\&worktype=242 or https://www.seek.co.nz/nurse-jobs/in-Auckland. Single job links (https://www.seek.com.au/job/12345678) work too. When you add URLs, the search form fields above and the filters below are ignored; each URL keeps its own filters.
## `classifications` (type: `array`):
SEEK job classifications (industries). Several are OR-ed.
## `workTypes` (type: `array`):
Full time, part time, contract/temp or casual/vacation. Several are OR-ed.
## `workArrangements` (type: `array`):
On-site, hybrid or remote, as set by the advertiser. Several are OR-ed.
## `dateRange` (type: `string`):
Only jobs listed within this many days.
## `salaryMin` (type: `integer`):
Minimum pay, in the unit chosen under "Salary type" (e.g. 100000 annual, or 40 hourly). SEEK also filters on salary ranges that advertisers hide, so some matching jobs show no salary.
## `salaryMax` (type: `integer`):
Maximum pay, in the same unit. Leave empty for no upper limit.
## `salaryType` (type: `string`):
Unit for the salary filter.
## `sortBy` (type: `string`):
Newest first (date) or SEEK's relevance ranking. Matters when you set "Max jobs per search". Incremental mode always sorts by date.
## `onlyNewJobs` (type: `boolean`):
Remember which jobs were already output and only output (and charge for) jobs that are new since the previous run. The first run outputs all matching jobs and saves them as the baseline. Ideal for scheduled monitoring.
## `stateKey` (type: `string`):
Name of this monitor's memory. Runs with the same name share the list of already-seen jobs (kept separately for each search). Use different names for independent monitors.
## `stateStoreName` (type: `string`):
Named key-value store in your account where incremental state is kept (letters, digits and dashes).
## `maxConcurrency` (type: `integer`):
Maximum parallel requests (job details are fetched in parallel). The default is polite; there is rarely a reason to raise it.
## `maxRequestsPerSecond` (type: `integer`):
Upper limit on how fast requests are sent to SEEK.
## `proxyConfiguration` (type: `object`):
Off by default. If SEEK's Cloudflare protection blocks the run (the log and status say so), enable Apify Proxy with the RESIDENTIAL group and country AU or NZ.
## Actor input object example
```json
{
"keywords": "software engineer",
"location": "All Sydney NSW",
"country": "AU",
"maxJobs": 50,
"includeDescription": true,
"dateRange": "any",
"salaryType": "annual",
"sortBy": "date",
"onlyNewJobs": false,
"stateKey": "default",
"stateStoreName": "seek-jobs-scraper-state",
"maxConcurrency": 3,
"maxRequestsPerSecond": 3,
"proxyConfiguration": {
"useApifyProxy": false
}
}
```
# Actor output Schema
## `jobs` (type: `string`):
One item per job: title, company, location, work type, classification, salary and job URL.
## `jobsFull` (type: `string`):
Every field for each job, including bullet points, parsed salary and the full description in HTML and plain text.
## `summary` (type: `string`):
Per-search status, counts and any warnings (e.g. SEEK's 550-result cap or a Cloudflare block).
# 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 '