# Seek Jobs Scraper — Real-Time Job Data (AU, NZ & APAC) (`b2b_leads/seek-jobs-real-time-data`) Actor

Seek jobs data for Australia, New Zealand, UK & APAC. Search by role, location & employer. Export titles, salaries, descriptions & apply links as clean JSON. Real-time streaming, webhooks, LLM-ready output for recruiting automation, job aggregators & talent intelligence.

- **URL**: https://apify.com/b2b\_leads/seek-jobs-real-time-data.md
- **Developed by:** [Chidubem Aneke](https://apify.com/b2b_leads) (community)
- **Categories:** Jobs, Developer tools, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Seek Jobs Real-Time Data

**The fastest way to collect Seek job postings on Apify.** Turn any job search into clean, structured JSON — ready for spreadsheets, dashboards, automations, and AI workflows. Results land in your dataset **in real time**, as each job is found.

Built for recruiters, talent teams, job boards, market researchers, and builders who need **reliable hiring data across Australia, New Zealand, and Asia-Pacific markets** — without slow setups or messy exports.

---

### Why this Actor

| | Seek Jobs Real-Time Data | Typical job data tool |
|---|--------------------------|------------------------|
| **Speed** | Fast per-job collection | Often 5–15 s per job |
| **Memory** | **256–512 MB** default | 2–4 GB+ |
| **Setup** | Run in seconds | Often complex configuration |
| **Cost** | Low compute, efficient runs | High |
| **Output** | Structured JSON, LLM-ready | Often messy or incomplete |
| **Scale** | Up to **1,000 jobs** per keyword | Often capped lower |
| **Filters** | Full Seek Jobs filters | Often keyword-only |
| **Modes** | Search · Company jobs · Job links | Usually one mode only |
| **Markets** | AU, NZ, UK, SG, HK, ID, TH, MY, PH | Often single region |

---

### Three ways to collect jobs

| Mode | What it does | Best for |
|------|--------------|----------|
| **Job search** | Keyword + location search with full Seek filters | Market scans, role tracking, location-based hiring |
| **Company jobs** | All open roles from specific employers | Competitor monitoring, account-based recruiting |
| **Job links** | Structured data from individual Seek job URLs | Enriching a list you already have |

Enable one or combine all three in a single run.

---

### What you get — every job, fully structured

Each record is one job posting with `featureType`, `jobKey`, and `scrapedAt` so you can sort, filter, and join with your own data.

| Field | What it tells you |
|-------|-------------------|
| `title`, `company`, `location`, `workplaceType` | Role, employer, place, on-site/remote/hybrid |
| `jobUrl`, `applyUrl`, `companyUrl`, `companyLogo` | Direct links and company branding |
| `descriptionText`, `descriptionHtml` | Full job description (when detail fetch is on) |
| `classification`, `subClassification` | How Seek categorises the role |
| `salary`, `bulletPoints`, `jobTypes` | Compensation signals, highlights, and employment type |
| `listedAtISO`, `postedTimeAgo` | How fresh the listing is |
| `searchQuery`, `searchLocation`, `searchCompany`, `position` | Which search produced this row and its rank |
| `isFeatured`, `isSponsored` | Listing prominence signals |
| `advertiserId`, `employerId`, `roleId` | Stable identifiers for joins and deduplication |

Set `includeRaw: true` if you need extended record data for custom processing.

**`featureType` values:** `job` (search) · `company_job` (company jobs) · `scrape_by_url` (job links)

---

### Search like Seek Jobs — get data like a database

Use the **same filters job seekers use on Seek**:

- **Keywords** — one search per keyword (e.g. `software engineer`, `registered nurse`)
- **Title** — narrow to a specific role name
- **Company** — jobs at Atlassian, Canva, or any employer
- **Location** — Sydney NSW 2000, Melbourne VIC, Auckland, and more
- **Employment type** — full-time, part-time, contract, casual
- **Workplace** — on-site, remote, hybrid
- **Date posted** — any time, past month, week, 3 days, or 24 hours
- **Sort** — relevance or most recent
- **Volume** — up to **1,000 jobs per keyword**
- **Full details** — toggle rich descriptions and enriched fields on or off

#### Supported markets (`country`)

| Code | Market |
|------|--------|
| `au` | Australia (seek.com.au) |
| `nz` | New Zealand (seek.co.nz) |
| `uk` | United Kingdom (seek.co.uk) |
| `sg` | Singapore |
| `hk` | Hong Kong |
| `id` | Indonesia |
| `th` | Thailand |
| `my` | Malaysia (JobStreet) |
| `ph` | Philippines (JobStreet) |

---

### Use cases — real outcomes

- **Recruiting pipelines** — build candidate-ready job lists by role, location, and seniority
- **Job boards and aggregators** — feed your product with fresh Seek listings daily
- **Market and salary research** — track who is hiring, where, and for what skills across APAC
- **Competitive intelligence** — monitor competitor hiring by company and function
- **Sales and BD** — spot companies in hiring mode for timely outreach
- **Staffing agencies** — track demand by region, role, and employer
- **AI assistants and agents** — summarize listings, score fit, draft outreach, or answer hiring questions
- **Data warehouses and CRMs** — push JSON into Snowflake, BigQuery, HubSpot, Airtable, or your stack via API

---

### LLM and MCP integration

Output is **structured JSON** — ideal for ChatGPT, Claude, Gemini, LangChain, LlamaIndex, CrewAI, and custom agents. No cleanup step. No manual formatting. Just records your model can read.

#### Recommended workflow

1. Run the Actor with your keywords, companies, or job links.
2. Pull dataset items via [Apify API](https://docs.apify.com/api/v2), webhook, or export JSON/CSV.
3. Pass records to your LLM, vector store, or automation — one job per row.

#### Example: one job record for an LLM prompt

```json
{
  "featureType": "job",
  "jobKey": "93190629",
  "title": "Software Engineer",
  "company": "Atlassian",
  "location": "Sydney NSW",
  "workplaceType": "Hybrid",
  "jobTypes": ["Full time"],
  "descriptionText": "Join our engineering team building scalable products for millions of users...",
  "salary": "$120,000 – $150,000 per year",
  "classification": "Information & Communication Technology",
  "subClassification": "Engineering - Software",
  "bulletPoints": ["Flexible working", "Career growth", "Global team"],
  "listedAtISO": "2026-07-08T03:50:44.091Z",
  "postedTimeAgo": "2d ago",
  "jobUrl": "https://www.seek.com.au/job/93190629",
  "searchQuery": "software engineer",
  "searchLocation": "Sydney NSW 2000",
  "position": 1,
  "scrapedAt": "2026-07-11T12:00:00.000Z"
}
````

#### Apify MCP (Model Context Protocol)

Connect the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) so AI assistants can:

- **Run** this Actor from natural-language instructions
- **Read** job results directly in the chat
- **Chain** with other Actors — enrich contacts, send alerts, update spreadsheets

**Example MCP conversation:**

```
User: "Find 50 software engineer jobs in Sydney posted this week and summarize top employers"

→ MCP runs Seek Jobs Real-Time Data with jobKeywords, jobLocation=Sydney NSW 2000, jobDatePosted=week
→ MCP reads dataset items
→ LLM summarizes hiring trends and top companies
```

#### API quick start

```bash
curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "enableJobSearch": true,
    "jobKeywords": ["software engineer"],
    "jobLocation": "Sydney NSW 2000",
    "jobDatePosted": "week",
    "jobsPerQuery": 50,
    "fetchJobDetails": true,
    "country": "au"
  }'
```

**Fetch results:** `GET https://api.apify.com/v2/datasets/{datasetId}/items?format=json`

**Dataset views in Apify Console:** Overview (core fields) and Full details (includes descriptions)

Export as **JSON**, **CSV**, **Excel**, **RSS**, or via **API**.

***

### Input reference

#### Job search

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `enableJobSearch` | boolean | `true` | Turn keyword search on or off |
| `jobKeywords` | string\[] | `["software engineer"]` | Search keywords — one run per keyword |
| `jobTitle` | string | — | Title filter |
| `jobCompany` | string | — | Company filter |
| `jobLocation` | string | `"Sydney NSW 2000"` | Location |
| `jobTypes` | enum\[] | all | fulltime, parttime, contract, casual |
| `jobRemote` | enum\[] | all | onsite, remote, hybrid |
| `jobDatePosted` | enum | `any` | any, month, week, 3days, day |
| `jobSort` | enum | `relevance` | relevance or date |
| `jobsPerQuery` | integer | `25` | Max jobs per keyword (1–1000) |

#### Company jobs

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `enableCompanyJobs` | boolean | `false` | Collect jobs from company profiles |
| `companyNames` | string\[] | `[]` | Company names (e.g. Atlassian, Canva) |
| `jobsPerCompany` | integer | `25` | Max jobs per company (1–1000) |

#### Job links

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `enableScrapeByUrl` | boolean | `false` | Collect data from individual job links |
| `jobUrls` | string\[] | `[]` | Seek job page URLs |

#### Output and global

| Input | Type | Default | Description |
|-------|------|---------|-------------|
| `fetchJobDetails` | boolean | `true` | Full description and enriched fields |
| `includeRaw` | boolean | `false` | Attach extended record data |
| `webhookUrl` | string | — | Optional URL for real-time record delivery (Zapier, Slack, CRM) |
| `webhookFormat` | enum | `json` | `json` (full record) or `slack` (message) |
| `country` | string | `au` | Target market (au, nz, uk, sg, hk, id, th, my, ph) |
| `maxItems` | integer | `10000` | Max total records across all modes |
| `proxyConfiguration` | object | residential AU | Connection settings (target-market residential recommended) |

Full schema: **Input** tab on Apify Console or `.actor/input_schema.json` in this repository.

***

### Output reference

Each dataset row is one job record. Filter by `featureType`:

| `featureType` | Description |
|---------------|-------------|
| `job` | Job from keyword search |
| `company_job` | Job from company jobs mode |
| `scrape_by_url` | Job from job links mode |

**Traceability fields on search results:**

- `searchQuery` — keyword that produced this row
- `searchLocation` — location used in the search
- `position` — rank in results for that query

Export formats: **JSON**, **CSV**, **Excel**, **RSS**, or via **API**.

***

### Webhook delivery (optional)

Every record is **always saved to the Apify dataset** first. If you set `webhookUrl` in the **Output** section, each new record is **also POSTed in real time** to your endpoint — useful for CRMs, Slack, Zapier, Make, or custom pipelines.

| Setting | Description |
|---------|-------------|
| `webhookUrl` | Your endpoint (https). Leave empty to use dataset only. |
| `webhookFormat` | `json` — full job object. `slack` — compact Slack incoming-webhook message. |

Webhook delivery is **best-effort**: a failed webhook never stops the run or prevents dataset writes.

**Example — search with Slack alerts**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["data analyst"],
  "jobLocation": "Melbourne VIC",
  "jobsPerQuery": 50,
  "webhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/URL",
  "webhookFormat": "slack"
}
```

**Example — search with JSON webhook to your CRM**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["product manager"],
  "jobLocation": "Sydney NSW 2000",
  "fetchJobDetails": true,
  "webhookUrl": "https://your-crm.example.com/api/jobs",
  "webhookFormat": "json"
}
```

***

### Quick start examples

**Software roles in Sydney — full details**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["software engineer"],
  "jobLocation": "Sydney NSW 2000",
  "jobDatePosted": "week",
  "jobSort": "date",
  "jobsPerQuery": 50,
  "fetchJobDetails": true,
  "country": "au"
}
```

**Jobs at a specific company**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["engineer"],
  "jobCompany": "Atlassian",
  "jobLocation": "Sydney NSW 2000",
  "jobsPerQuery": 100
}
```

**All jobs from employer profiles**

```json
{
  "enableCompanyJobs": true,
  "companyNames": ["Atlassian", "Canva", "Xero"],
  "jobsPerCompany": 50,
  "fetchJobDetails": true,
  "country": "au"
}
```

**Import specific job links**

```json
{
  "enableScrapeByUrl": true,
  "jobUrls": [
    "https://www.seek.com.au/job/93190629"
  ],
  "fetchJobDetails": true
}
```

**Fresh listings only — fast summary mode**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["nurse"],
  "jobLocation": "Brisbane QLD",
  "jobDatePosted": "day",
  "jobSort": "date",
  "jobsPerQuery": 75,
  "fetchJobDetails": false,
  "country": "au"
}
```

**High-volume APAC market scan**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["machine learning", "data scientist", "AI engineer"],
  "jobLocation": "Sydney NSW 2000",
  "jobsPerQuery": 500,
  "fetchJobDetails": true,
  "country": "au"
}
```

**New Zealand search**

```json
{
  "enableJobSearch": true,
  "jobKeywords": ["software developer"],
  "jobLocation": "Auckland",
  "jobsPerQuery": 100,
  "country": "nz"
}
```

***

### Performance and reliability

- **Residential proxy (target market recommended)** — best results and consistent throughput. Default is AU; match proxy country to your `country` input.
- **Default memory: 512 MB** — enough for high-volume runs with multiple keywords and companies.
- **Streaming output** — each job is written to the dataset immediately; nothing is buffered in memory for long runs.
- **Webhook delivery** — optionally POST each new record to your URL in real time (dataset is always the primary output).
- **Smart search expansion** — automatically broadens coverage when you request large result sets.
- **Concurrent collection** — multiple keywords, companies, and job details are processed efficiently for faster results at 512 MB memory.

***

### Limitations and compliance

- This is an unofficial tool — not affiliated with Seek or JobStreet.
- Use responsibly and comply with applicable laws and Seek's Terms of Service.
- Some fields (e.g. salary) appear only when employers publish them.
- Listing availability can change; expired postings may return summary data only.

***

### Contact and custom work

Need something beyond this Actor? I design and build **custom data solutions** and **full-stack products** for teams that want results — not experiments.

**Email:** <dubem115@gmail.com>\
**GitHub:** [github.com/DrunkCodes](https://github.com/DrunkCodes)

Reach out for:

- **Custom Apify Actors** — any website, job board, or data source
- **Seek and hiring data projects** — pipelines, alerts, and dashboards at scale
- **LLM and MCP integrations** — connect your data to ChatGPT, Claude, and agent workflows
- **Web apps and automation** — data tools, internal platforms, SaaS products, and client-facing apps
- **Any data collection project** — lead generation, market research, monitoring, and enrichment at scale

Whether you need a one-off data feed or a production system, I can help you ship it.

***

*Seek Jobs Real-Time Data · by [DrunkCodes](https://github.com/DrunkCodes)*

# Actor input Schema

## `enableJobSearch` (type: `boolean`):

Search Seek Jobs by keyword, title, company, and location with filters — the same way you would in the Seek app.

## `jobKeywords` (type: `array`):

Main job search keywords. One search per keyword — e.g. software engineer, data analyst, project manager.

## `jobTitle` (type: `string`):

Optional title filter (e.g. Software Engineer). Combined with keywords for more precise results.

## `jobCompany` (type: `string`):

Optional company filter — jobs at a specific employer (e.g. Atlassian, Canva). Leave empty for any company.

## `jobLocation` (type: `string`):

Location to search jobs in (e.g. Sydney NSW 2000, Melbourne VIC, Auckland).

## `jobTypes` (type: `array`):

Filter jobs by employment type. Leave empty for all types.

## `jobRemote` (type: `array`):

Filter jobs by on-site, remote, or hybrid.

## `jobDatePosted` (type: `string`):

Only return jobs posted within this window.

## `jobSort` (type: `string`):

Relevance or most recent.

## `jobsPerQuery` (type: `integer`):

Maximum jobs to return per keyword (1–1000).

## `enableCompanyJobs` (type: `boolean`):

Collect open positions from specific employers on Seek.

## `companyNames` (type: `array`):

Employer names as listed on Seek (e.g. Atlassian, Canva, Xero).

## `jobsPerCompany` (type: `integer`):

Maximum jobs to return per company (1–1000).

## `enableScrapeByUrl` (type: `boolean`):

Collect structured data from individual Seek job page links you already have.

## `jobUrls` (type: `array`):

Seek job page URLs you want to collect (e.g. https://www.seek.com.au/job/93190629).

## `fetchJobDetails` (type: `boolean`):

Include each job's full description and enriched fields. Slightly slower but much richer output.

## `includeRaw` (type: `boolean`):

Attach extended record data under the raw field. Larger output — for advanced users.

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

Optional. Every record is always saved to the run's dataset — this webhook is an additional real-time push. When set, each new record is also sent to this URL (CRM, Slack, Zapier, Make, Google Sheets).

## `webhookFormat` (type: `string`):

json = full record object; slack = Slack-friendly message payload.

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

Target market: au (Australia), nz (New Zealand), uk, sg, hk, id, th, my (Malaysia), ph (Philippines).

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

Maximum total job records across all enabled modes (up to 10,000).

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

Residential connection in the target market recommended for best results and consistent throughput.

## Actor input object example

```json
{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer"
  ],
  "jobTitle": "",
  "jobCompany": "",
  "jobLocation": "Sydney NSW 2000",
  "jobTypes": [],
  "jobRemote": [
    "onsite",
    "remote",
    "hybrid"
  ],
  "jobDatePosted": "any",
  "jobSort": "relevance",
  "jobsPerQuery": 25,
  "enableCompanyJobs": false,
  "companyNames": [],
  "jobsPerCompany": 25,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "fetchJobDetails": true,
  "includeRaw": false,
  "webhookUrl": "",
  "webhookFormat": "json",
  "country": "au",
  "maxItems": 10000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "AU"
  }
}
```

# Actor output Schema

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

Complete dataset with every job field from this run.

## `overview` (type: `string`):

Core job fields table view.

## `full` (type: `string`):

All job fields including descriptions.

# 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 = {
    "enableJobSearch": true,
    "jobKeywords": [
        "software engineer"
    ],
    "jobTitle": "",
    "jobCompany": "",
    "jobLocation": "Sydney NSW 2000",
    "jobTypes": [],
    "jobRemote": [
        "onsite",
        "remote",
        "hybrid"
    ],
    "jobDatePosted": "any",
    "jobSort": "relevance",
    "jobsPerQuery": 25,
    "enableCompanyJobs": false,
    "companyNames": [],
    "jobsPerCompany": 25,
    "enableScrapeByUrl": false,
    "jobUrls": [],
    "fetchJobDetails": true,
    "includeRaw": false,
    "webhookUrl": "",
    "country": "au",
    "maxItems": 10000
};

// Run the Actor and wait for it to finish
const run = await client.actor("b2b_leads/seek-jobs-real-time-data").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 = {
    "enableJobSearch": True,
    "jobKeywords": ["software engineer"],
    "jobTitle": "",
    "jobCompany": "",
    "jobLocation": "Sydney NSW 2000",
    "jobTypes": [],
    "jobRemote": [
        "onsite",
        "remote",
        "hybrid",
    ],
    "jobDatePosted": "any",
    "jobSort": "relevance",
    "jobsPerQuery": 25,
    "enableCompanyJobs": False,
    "companyNames": [],
    "jobsPerCompany": 25,
    "enableScrapeByUrl": False,
    "jobUrls": [],
    "fetchJobDetails": True,
    "includeRaw": False,
    "webhookUrl": "",
    "country": "au",
    "maxItems": 10000,
}

# Run the Actor and wait for it to finish
run = client.actor("b2b_leads/seek-jobs-real-time-data").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "enableJobSearch": true,
  "jobKeywords": [
    "software engineer"
  ],
  "jobTitle": "",
  "jobCompany": "",
  "jobLocation": "Sydney NSW 2000",
  "jobTypes": [],
  "jobRemote": [
    "onsite",
    "remote",
    "hybrid"
  ],
  "jobDatePosted": "any",
  "jobSort": "relevance",
  "jobsPerQuery": 25,
  "enableCompanyJobs": false,
  "companyNames": [],
  "jobsPerCompany": 25,
  "enableScrapeByUrl": false,
  "jobUrls": [],
  "fetchJobDetails": true,
  "includeRaw": false,
  "webhookUrl": "",
  "country": "au",
  "maxItems": 10000
}' |
apify call b2b_leads/seek-jobs-real-time-data --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Seek Jobs Scraper — Real-Time Job Data (AU, NZ & APAC)",
        "description": "Seek jobs data for Australia, New Zealand, UK & APAC. Search by role, location & employer. Export titles, salaries, descriptions & apply links as clean JSON. Real-time streaming, webhooks, LLM-ready output for recruiting automation, job aggregators & talent intelligence.",
        "version": "0.0",
        "x-build-id": "o0ApCev0XEX9rT4Tp"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/b2b_leads~seek-jobs-real-time-data/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-b2b_leads-seek-jobs-real-time-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/b2b_leads~seek-jobs-real-time-data/runs": {
            "post": {
                "operationId": "runs-sync-b2b_leads-seek-jobs-real-time-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/b2b_leads~seek-jobs-real-time-data/run-sync": {
            "post": {
                "operationId": "run-sync-b2b_leads-seek-jobs-real-time-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "enableJobSearch": {
                        "title": "Job search",
                        "type": "boolean",
                        "description": "Search Seek Jobs by keyword, title, company, and location with filters — the same way you would in the Seek app.",
                        "default": true
                    },
                    "jobKeywords": {
                        "title": "Job keywords",
                        "type": "array",
                        "description": "Main job search keywords. One search per keyword — e.g. software engineer, data analyst, project manager.",
                        "default": [
                            "software engineer"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobTitle": {
                        "title": "Job title",
                        "type": "string",
                        "description": "Optional title filter (e.g. Software Engineer). Combined with keywords for more precise results.",
                        "default": ""
                    },
                    "jobCompany": {
                        "title": "Company",
                        "type": "string",
                        "description": "Optional company filter — jobs at a specific employer (e.g. Atlassian, Canva). Leave empty for any company.",
                        "default": ""
                    },
                    "jobLocation": {
                        "title": "Job location",
                        "type": "string",
                        "description": "Location to search jobs in (e.g. Sydney NSW 2000, Melbourne VIC, Auckland).",
                        "default": "Sydney NSW 2000"
                    },
                    "jobTypes": {
                        "title": "Job types",
                        "type": "array",
                        "description": "Filter jobs by employment type. Leave empty for all types.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "fulltime",
                                "parttime",
                                "contract",
                                "casual"
                            ],
                            "enumTitles": [
                                "Full-time",
                                "Part-time",
                                "Contract",
                                "Casual"
                            ]
                        },
                        "default": []
                    },
                    "jobRemote": {
                        "title": "Workplace type",
                        "type": "array",
                        "description": "Filter jobs by on-site, remote, or hybrid.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "onsite",
                                "remote",
                                "hybrid"
                            ],
                            "enumTitles": [
                                "On-site",
                                "Remote",
                                "Hybrid"
                            ]
                        },
                        "default": [
                            "onsite",
                            "remote",
                            "hybrid"
                        ]
                    },
                    "jobDatePosted": {
                        "title": "Date posted",
                        "enum": [
                            "any",
                            "month",
                            "week",
                            "3days",
                            "day"
                        ],
                        "type": "string",
                        "description": "Only return jobs posted within this window.",
                        "default": "any"
                    },
                    "jobSort": {
                        "title": "Sort jobs by",
                        "enum": [
                            "relevance",
                            "date"
                        ],
                        "type": "string",
                        "description": "Relevance or most recent.",
                        "default": "relevance"
                    },
                    "jobsPerQuery": {
                        "title": "Jobs per keyword",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum jobs to return per keyword (1–1000).",
                        "default": 25
                    },
                    "enableCompanyJobs": {
                        "title": "Company jobs",
                        "type": "boolean",
                        "description": "Collect open positions from specific employers on Seek.",
                        "default": false
                    },
                    "companyNames": {
                        "title": "Company names",
                        "type": "array",
                        "description": "Employer names as listed on Seek (e.g. Atlassian, Canva, Xero).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "jobsPerCompany": {
                        "title": "Jobs per company",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum jobs to return per company (1–1000).",
                        "default": 25
                    },
                    "enableScrapeByUrl": {
                        "title": "Job links",
                        "type": "boolean",
                        "description": "Collect structured data from individual Seek job page links you already have.",
                        "default": false
                    },
                    "jobUrls": {
                        "title": "Job URLs",
                        "type": "array",
                        "description": "Seek job page URLs you want to collect (e.g. https://www.seek.com.au/job/93190629).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "fetchJobDetails": {
                        "title": "Fetch full job details",
                        "type": "boolean",
                        "description": "Include each job's full description and enriched fields. Slightly slower but much richer output.",
                        "default": true
                    },
                    "includeRaw": {
                        "title": "Include extended data",
                        "type": "boolean",
                        "description": "Attach extended record data under the raw field. Larger output — for advanced users.",
                        "default": false
                    },
                    "webhookUrl": {
                        "title": "Webhook URL",
                        "type": "string",
                        "description": "Optional. Every record is always saved to the run's dataset — this webhook is an additional real-time push. When set, each new record is also sent to this URL (CRM, Slack, Zapier, Make, Google Sheets).",
                        "default": ""
                    },
                    "webhookFormat": {
                        "title": "Webhook format",
                        "enum": [
                            "json",
                            "slack"
                        ],
                        "type": "string",
                        "description": "json = full record object; slack = Slack-friendly message payload.",
                        "default": "json"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Target market: au (Australia), nz (New Zealand), uk, sg, hk, id, th, my (Malaysia), ph (Philippines).",
                        "default": "au"
                    },
                    "maxItems": {
                        "title": "Max total items",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum total job records across all enabled modes (up to 10,000).",
                        "default": 10000
                    },
                    "proxyConfiguration": {
                        "title": "Connection settings",
                        "type": "object",
                        "description": "Residential connection in the target market recommended for best results and consistent throughput.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "AU"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
