# SEEK Jobs Search Lookup — Postings by Keyword & Location (`accountable_eel/seek-jobs-search-lookup`) Actor

Run keyword + location job searches on SEEK, Australia's largest job board, and get one clean row per posting — title, company, location, category, pay range (if stated) and link. No login required. You pay per posting returned, and a search that finds nothing is free.

- **URL**: https://apify.com/accountable\_eel/seek-jobs-search-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 job posting returneds

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?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Search Lookup — Postings by Keyword & Location

You write job searches the way you'd type them into SEEK — `developer @ Melbourne VIC` — and this
actor runs each one against **SEEK's own public search API**, Australia's largest job board, and
returns one clean row per posting: title, company, location, category, pay range (when SEEK
displays one), and a permanent link.

No login. No API key. SEEK's search-results page itself is behind a bot wall, but the JSON
endpoint that page calls under the hood is not — see "Why this one" below.

### Who it's for

The accountable\_eel catalogue sells company and hiring intelligence columns for outbound and
recruiting. Each actor takes a list of identifiers — domains, company slugs, and here, job
searches — and returns one flat, stably-named row per result: the shape a Clay table, an n8n
workflow, or an AI agent can consume without post-processing. Pricing is pay-per-event: a
fraction of a cent for a row you actually got, and nothing at all for a search that finds
nothing. No seat licence, no monthly minimum, no credit system to decode.

This actor is the Australian counterpart to `linkedin-jobs-search-lookup`: wide-net keyword +
location search rather than a per-company listing. The ATS lookups in the same family
(`greenhouse-jobs-lookup`, `lever-jobs-lookup` and friends) answer "what is *this company*
hiring for" — you bring the company list. This one answers "who is hiring for *this role*, in
*this part of Australia*" when you don't have the list yet.

### Why this one

- **Reaches data a plain page-load can't.** `seek.com.au`'s search-results page and every
  individual job page return HTTP 403 to a direct request — a bot wall. The page's own backing
  API, `www.seek.com.au/api/jobsearch/v5/search`, does not: it's the same JSON call your browser
  makes to render the page, and it answers a plain unauthenticated request with real, live
  results. No proxy, no browser automation, no CAPTCHA-solving — a control this catalogue will
  not build regardless (see the top-level rules this portfolio operates under).
- **The filters are real.** `keywords`, `where` (location) and "posted within" are all genuinely
  honoured upstream — verified by watching the total-match count actually change per filter
  (2,495 → 494 → 19 across three narrowing steps on the same search) — not decorative parameters
  the endpoint silently ignores.
- **You are never billed for the same posting twice.** Every posting is deduplicated by its SEEK
  job ID across the pages of one search and, by default, across every search in the run — an
  overlapping pair of searches returns, and bills, each posting once.
- **Honest about what's NOT here.** SEEK's job-detail page is behind the same bot wall as its
  search page, with no working JSON alternative found — so there is no full-description
  enrichment on this actor. `teaser`, SEEK's own one-line summary, is what every row carries
  instead, and it's labelled as a teaser, not sold as a full posting.
- **A real depth ceiling, stated rather than hit blind.** SEEK stops serving new results after
  about 500 postings per search regardless of how many more it claims exist — `totalAvailable`
  and `truncated` tell you when a search hit that wall.

### What you get

One row per job posting by default. (Turn off "One row per job posting" in the Input tab to get
one row per *search* instead, with the whole posting list nested in `jobs`.) Every row carries
these fields:

| Field | Type / format | Description |
| --- | --- | --- |
| `query` | text | The search line you passed in, unchanged. |
| `found` | boolean | `true` if the search returned at least one posting. `false` rows are never charged. |
| `status` | text | `OK`, `NOT_FOUND` (no postings for that search), `BAD_FORMAT` (the line had neither keywords nor a location), or `BLOCKED`. |
| `searchKeywords` | text | The keywords actually sent to SEEK. |
| `searchLocation` | text | The location actually sent to SEEK. |
| `jobCount` | number | How many postings this search returned after your filters — this is exactly what you're charged for. |
| `totalAvailable` | number | SEEK's own total-match count for the search, before this actor's page/depth limits. |
| `truncated` | boolean | `true` if more postings were available than you asked for, or if paging stopped early (SEEK's own 500-result depth cap, or a mid-run rate limit). |
| `jobs` | array | The full posting list. Present in every row; it's what gets expanded into separate rows in "one row per posting" mode. |
| `jobId` | text | SEEK's own numeric posting ID — stable, and what deduplication keys on. |
| `title` | text | Job title. |
| `companyName` | text | Hiring company as SEEK names it. |
| `advertiser` | text | The listing's advertiser — often the same as `companyName`, but a recruitment agency's name when one is posting on the employer's behalf. |
| `location` | text | Location as SEEK prints it on the posting (e.g. "Sydney NSW", "Melbourne VIC"). |
| `remote` | boolean | `true` if the location, work arrangement, or title reads as remote. |
| `classification` | text | SEEK's top-level job category (e.g. "Information & Communication Technology"). |
| `subClassification` | text | SEEK's sub-category (e.g. "Engineering - Software"). |
| `workTypes` | array | e.g. `["Full time"]`, `["Contract/Temp"]`. |
| `workArrangement` | text | e.g. "Hybrid", "Remote", "On-site", when SEEK states one. |
| `salaryLabel` | text | The pay range or rate exactly as SEEK's advertiser wrote it (e.g. "$120,000 – $140,000 per year"). Present only when the advertiser chose to disclose one. |
| `teaser` | text | SEEK's own one-line summary of the posting — the only description-shaped field this actor offers (see "Why this one"). |
| `bulletPoints` | array | Short highlight bullets SEEK shows on some cards. Empty on most postings. |
| `isFeatured` | boolean | `true` if SEEK marks this a featured/promoted listing. |
| `postedAt` | date (ISO) | SEEK's own listing timestamp. |
| `postedAgo` | text | The same thing in SEEK's words ("17m ago", "2 days ago"). |
| `jobUrl` | link | Permanent link to the posting on seek.com.au. |
| `companyLogoUrl` | image | Company/advertiser logo image URL, when SEEK has one on file. |
| `scrapedAt` | date (ISO) | When this actor fetched the row. |

A search that returns no postings comes back as a single `found: false` row with a
`status`/`message` explaining why, and is never charged. So does a blank line.

### Pricing

- **Job posting returned**: $1 per 1,000 job postings

Plus a $0.00005 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

You're charged **per posting returned**, not per search — a search that returns 12 postings
costs twelve, a search that returns none costs nothing, and a `BAD_FORMAT` line costs nothing.

Because you pay per posting, "Most postings to return per search" is your budget control: leave
it at 50 and a ten-search run costs at most 500 postings' worth. SEEK stops serving new results
past roughly 500 per search regardless, so that is the real ceiling per line.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `searches` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~seek-jobs-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"searches":["developer @ Melbourne VIC"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

Paste one search per line:

```
developer @ Melbourne VIC
registered nurse
marketing manager @ Sydney NSW
```

A line with no `@ location` uses the location you set once in **🔍 Search settings** — leave that
blank too and the search covers all of Australia.

**🔍 Search settings** — these are sent to SEEK, so they narrow the search before results are
returned, which makes runs cheaper as well as more relevant:

| Input | What it does |
| --- | --- |
| `defaultLocation` | Location for any line that doesn't name one. Write it as SEEK does — "Sydney NSW", "Melbourne VIC". |
| `maxJobsPerQuery` | Most postings to return per search. Default 50, capped at SEEK's own ~500-result depth limit. |
| `postedWithin` | Past 24 hours / 3 days / week / 2 weeks. |

**🎯 Narrow the results** — applied here, to the postings after they arrive, so you can filter on
things SEEK's own search box doesn't expose. They combine with AND across fields and OR within a
field:

| Input | What it does |
| --- | --- |
| `titleKeywords` | Keep only titles containing one of these — `["engineer","analyst"]`. |
| `excludeTitleKeywords` | Drop titles containing one of these — `["intern","trainee"]`. Applied after the include list. |
| `companies` | Keep only these companies — partial names match. |
| `excludeCompanies` | Drop these companies — useful for filtering out recruitment agencies you already know. |
| `locations` | Narrow a wide search to particular suburbs or regions. |
| `remoteOnly` | Keep only roles whose location, work arrangement, or title reads as remote. |
| `skipDuplicateJobs` | On by default. Each posting is returned, and billed, once per run even if two searches overlap. |

### Input

```json
{
  "searches": [
    "developer @ Melbourne VIC"
  ]
}
```

One search per line. Write it as "keywords @ location", or just the keywords and set a location below. Accepted formats: developer @ Melbourne VIC, registered nurse, marketing manager @ Sydney NSW.

### Output

| query | found | status | searchKeywords | searchLocation | jobCount | totalAvailable | truncated | jobs | jobId | title | companyName | advertiser | location | remote | classification | subClassification | workTypes | workArrangement | salaryLabel | teaser | bulletPoints | isFeatured | postedAt | postedAgo | jobUrl | companyLogoUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| actuary @ Canberra ACT | true | OK | actuary | Canberra ACT | 10 | 10 | false | \<all postings found (full list)> | 94044064 | 2027 Technology Consulting Graduate Consultant | SEEK Grad | SEEK Grad | Canberra ACT | false | Consulting & Strategy | Other | \["Full time"] |  |  | MinterEllison is currently recruiting for Technology Consulting Graduates in our Canberra office. | \[] | false | 2026-08-18T04:51:46Z | 13d ago | https://www.seek.com.au/job/94044064 | https://bx-branding-gateway.cloud.seek.com.au/f9e136a9-04ad-4f08-bf58-5d62cd652db0.1/jdpLogo | 2026-08-31T06:50:13.710Z |

A miss comes back as a row with `"found": false` and is never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~seek-jobs-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"searches":["developer @ Melbourne VIC"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~seek-jobs-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"searches":["developer @ Melbourne VIC"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~seek-jobs-search-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"searches":["{{search}}"]}`, mapping the row's search into the `searches` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "SEEK Jobs Search Lookup | Apify" — the agent will find and run this actor.

# Actor input Schema

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

One search per line. Write it as "keywords @ location", or just the keywords and set a location below. Accepted formats: developer @ Melbourne VIC, registered nurse, marketing manager @ Sydney NSW. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

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

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `defaultLocation` (type: `string`):

Used for any line that's just keywords. Write it the way SEEK does — "Sydney NSW", "Melbourne VIC", "Brisbane QLD". Leave empty to search all of Australia.

## `maxJobsPerQuery` (type: `integer`):

SEEK hands out 100 postings per page and this actor stops at 5 pages (500 postings) — SEEK's own result depth cap, not a limit this actor imposes. You pay per posting returned, so this is also your budget control.

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

Ask SEEK for recent postings only. This is applied by SEEK itself before results are sent, so it makes runs cheaper as well as fresher.

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

Optional. Keep only roles whose title contains at least one of these words — e.g. "engineer", "account executive". Case doesn't matter and partial words work. Leave empty to keep every role.

## `excludeTitleKeywords` (type: `array`):

Optional. Drop any role whose title contains one of these words — e.g. "intern", "senior". Applied after the include list above, so a role matching both is dropped.

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

Optional. Keep only roles at companies whose name contains one of these. Partial matches work.

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

Optional. Drop roles at companies whose name contains one of these — handy for filtering out recruitment agencies you already know.

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

Optional. Narrow a wide search down to particular suburbs or regions — e.g. "Parramatta", "Inner West". Applied to the location SEEK prints on each posting.

## `remoteOnly` (type: `boolean`):

Keep only roles whose location, work arrangement, or title reads as remote. Applied to the postings after they arrive — treat it as a strong filter, not a guarantee.

## `skipDuplicateJobs` (type: `boolean`):

On by default. Overlapping searches routinely surface the same role — with this on, each posting is returned, and billed, exactly once per run.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each job posting found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "searches": [
    "developer @ Melbourne VIC"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "defaultLocation": "",
  "maxJobsPerQuery": 50,
  "postedWithin": "",
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "companies": [],
  "excludeCompanies": [],
  "locations": [],
  "remoteOnly": false,
  "skipDuplicateJobs": true,
  "columns": [
    "searchKeywords",
    "searchLocation",
    "jobCount",
    "totalAvailable",
    "truncated",
    "jobs",
    "jobId",
    "title",
    "companyName",
    "advertiser",
    "location",
    "remote",
    "classification",
    "subClassification",
    "workTypes",
    "workArrangement",
    "salaryLabel",
    "teaser",
    "bulletPoints",
    "isFeatured",
    "postedAt",
    "postedAgo",
    "jobUrl",
    "companyLogoUrl"
  ],
  "expandRows": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (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": [
        "developer @ Melbourne VIC"
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "companies": [],
    "excludeCompanies": [],
    "locations": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/seek-jobs-search-lookup").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": ["developer @ Melbourne VIC"],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "companies": [],
    "excludeCompanies": [],
    "locations": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/seek-jobs-search-lookup").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": [
    "developer @ Melbourne VIC"
  ],
  "includeKeywords": [],
  "excludeKeywords": [],
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "companies": [],
  "excludeCompanies": [],
  "locations": []
}' |
apify call accountable_eel/seek-jobs-search-lookup --silent --output-dataset

```

## MCP server setup

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

```

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/QRfAliIdM4Ydrq9df/builds/3ptg6qAPQtpjeZdLm/openapi.json