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

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