# SEEK, JobStreet & JobsDB Scraper | $1.5/1K — 8 Countries (`gangary/seek-jobstreet-jobsdb-scraper`) Actor

One scraper for SEEK (AU, NZ), JobStreet (MY, SG, PH, ID) and JobsDB (HK, TH): full description, salary min/max, applicant count, screening questions, company profile. Beats the 550-result cap, only-new mode for daily alerts. $1.50 per 1,000 jobs with full details, no proxy costs.

- **URL**: https://apify.com/gangary/seek-jobstreet-jobsdb-scraper.md
- **Developed by:** [Gangary](https://apify.com/gangary) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 job with full details

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

![seek-jobstreet-jobsdb-scraper](https://empresas-por-cnae.vercel.app/covers/seek-jobstreet-jobsdb-scraper.png)

## SEEK, JobStreet & JobsDB Scraper | $1.5/1K — 8 Countries

**US$1.50 per 1,000 jobs with full details, US$0.60 per 1,000 without details, plus US$0.01 per run. Proxies included; failed searches, unknown locations, duplicates and jobs skipped by `onlyNew` are never charged.**

- **8 countries, 3 brands, one output format:** SEEK (AU, NZ), JobStreet (MY, SG, PH, ID) and JobsDB (HK, TH) in the same run, one pipeline instead of three.
- **Up to 10,000 jobs per search**, past the sites' ~550-result cap, by splitting the search into categories, sub-categories and work types.
- **Only-new mode** remembers up to 50,000 delivered jobs per search, so a daily schedule returns (and charges) only fresh ads.

Scrape job listings from **SEEK** (Australia and New Zealand), **JobStreet** (Malaysia, Singapore, Philippines and Indonesia) and **JobsDB** (Hong Kong and Thailand) with one actor and one output format. The three brands run on the same platform, so you get the same fields for all 8 countries.

Each job comes with the **full description** (plain text, Markdown or HTML), **salary as min / max / currency / period** next to the original salary text, **applicant count** when the site shows it, **screening questions**, the expiry date and the **company profile** (size, website, rating and number of reviews). Search by keyword, location, category, work type, work arrangement, salary and date posted. You can also paste search or job URLs.

What it does that other SEEK scrapers don't:

- **More than 550 results per search.** SEEK, JobStreet and JobsDB stop paging at about 550 results. When a search has more, the actor splits it by category, sub-category and work type, then merges the slices and removes duplicates.
- **Only new jobs.** Turn on `onlyNew` and schedule the actor. Each run returns only the jobs it hasn't delivered before, and jobs it already delivered are skipped at no charge.
- **Full details in the base price.** Description, applicant count and company data don't cost extra.

Built for **job market research, salary benchmarking, recruitment and sales lead generation, job boards and aggregators, and hiring-signal monitoring** across Australia, New Zealand and Southeast Asia.

### Countries

| Country | Site | Code |
|---|---|---|
| Australia | SEEK (seek.com.au) | `AU` |
| New Zealand | SEEK (seek.co.nz) | `NZ` |
| Malaysia | JobStreet (my.jobstreet.com) | `MY` |
| Singapore | JobStreet (sg.jobstreet.com) | `SG` |
| Philippines | JobStreet (ph.jobstreet.com) | `PH` |
| Indonesia | JobStreet (id.jobstreet.com) | `ID` |
| Hong Kong | JobsDB (hk.jobsdb.com) | `HK` |
| Thailand | JobsDB (th.jobsdb.com) | `TH` |

### What you get

One row per job. Real output from an "engineer" search in Australia (description shortened):

```json
{
  "id": "95611598",
  "url": "https://www.seek.com.au/job/95611598",
  "title": "Business Development Manager - Translation and Impact",
  "site": "SEEK",
  "country": "AU",
  "companyName": "Curtin University",
  "companyId": "432427",
  "companyProfileUrl": "https://www.seek.com.au/companies/curtin-university-432427",
  "advertiserId": "559343",
  "advertiserName": "Curtin University",
  "location": "Bentley, Perth WA",
  "locationCountry": "AU",
  "salaryLabel": "$122,699 - $130,758 (G08) pro rata + 17% super",
  "salaryMin": 122699,
  "salaryMax": 130758,
  "salaryCurrency": "AUD",
  "salaryPeriod": "year",
  "workType": "Contract/Temp",
  "workArrangement": "On-site",
  "classification": "Science & Technology",
  "classificationId": "1223",
  "subclassification": "Other",
  "subclassificationId": "6225",
  "listedAt": "2026-10-30T13:24:51Z",
  "teaser": "Take world-leading radio astronomy expertise beyond astronomy and help create real-world impact across industry, Defence and Space with CIRA.",
  "bulletPoints": [
    "Fixed term role until 30 June 2028. Part-time or full-time (minimum 0.7 FTE);",
    "Translate specialist STEM capability into meaningful real-word opportunities",
    "Competitive remuneration, leave, super & salary packaging provisions"
  ],
  "tags": ["Be an early applicant"],
  "detailsIncluded": true,
  "description": "**Reference Number: 1701413**\n\n**About the Team:**\nRadio Astronomy applies 'STEM' based disciplines to capture and analyse ultra-faint signals from the universe...",
  "descriptionFormat": "markdown",
  "status": "Active",
  "isExpired": false,
  "expiresAt": "2026-11-15T12:45:00.000Z",
  "applyOnExternalSite": true,
  "isVerified": true,
  "screeningQuestions": [],
  "applicantCount": null,
  "companySize": "5,001-10,000 employees",
  "companyWebsite": "http://www.curtin.edu.au/",
  "companyRating": 3.6,
  "companyReviewCount": 141,
  "advertiserVerified": true,
  "advertiserRegisteredAt": "2007-06-25T09:36:08.000Z",
  "searchKeywords": "engineer",
  "scrapedAt": "2026-10-30T17:47:02.435Z"
}
```

| Field | Meaning |
|---|---|
| `salaryLabel` | Salary text exactly as the advertiser wrote it (empty when not disclosed) |
| `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod` | The same salary as numbers. Period is `hour`, `day`, `week`, `fortnight`, `month` or `year`. Left empty when the text has no amount |
| `workType` / `workArrangement` | Full time, part time, contract, casual / on-site, hybrid, remote |
| `classification` / `subclassification` | SEEK category and sub-category, with their ids |
| `description` | Full ad in the format you chose. Email addresses and phone numbers in the text are masked |
| `applicantCount` | Number of applicants, when the site shows it for that ad |
| `screeningQuestions` | Questions the employer asks applicants (common in Asia) |
| `companySize` / `companyWebsite` / `companyRating` / `companyReviewCount` | Company profile, when the employer has one |
| `applyOnExternalSite` | `true` when applications go to the employer's own site |
| `detailsIncluded` | `false` on rows collected without full details (cheaper) |
| `error` / `ok` | Only on rows for searches or URLs that failed. Those rows are **not charged** |

### Use cases

- **Salary benchmarking:** `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod` as numbers, per role, city and country.
- **Recruitment and sales leads:** who is hiring, for what and how often, with the company profile (size, website, rating) on every row.
- **Daily job monitor:** schedule a search with `onlyNew` and get only the ads posted since the last run.
- **Job boards and aggregators:** one schema for 8 countries, with the full description in text, Markdown or HTML.
- **Labour market research:** count ads by category, work type and work arrangement across AU, NZ and Southeast Asia.

### How to use it

1. Pick one or more **Countries**.
2. Add **Keywords** (one search per line). Leave the list empty to collect every job that matches the other filters.
3. Optionally add **Locations** ("Sydney", "Auckland", "Kuala Lumpur", "Jakarta", "Kowloon", "Bangkok") and filters: date posted, work type, work arrangement, salary range and category.
4. Set **Max jobs per search** and run. Export from the **Jobs** view as JSON, CSV or Excel.

| Input | Type | Default | Notes |
|---|---|---|---|
| `country` | array | — | `AU`, `NZ`, `MY`, `SG`, `PH`, `ID`, `HK`, `TH` |
| `keywords` | array of strings | empty | One search per keyword, up to 50 |
| `locations` | array of strings | empty | Up to 20; each one is searched in each selected country |
| `maxResults` | integer | 100 | Max jobs per search, 1 to 10,000 |
| `includeDetails` | boolean | `true` | `false` = list only, cheaper and faster |
| `descriptionFormat` | string | `text` | `text`, `markdown` or `html` |
| `onlyNew` | boolean | `false` | Deliver each job once across runs |
| `datePosted` | string | `any` | `any`, `today`, `3d`, `7d`, `14d`, `30d` |
| `workTypes` / `workArrangements` | arrays | empty | `full-time`, `part-time`, `contract`, `casual` / `on-site`, `hybrid`, `remote` |
| `salaryMin` / `salaryMax` / `salaryType` | integer / string | empty | `annual`, `monthly` or `hourly` |
| `classifications` | array | empty | 30 SEEK category ids |
| `sortBy` | string | `date` | `date` or `relevance` |
| `startUrls` | array | empty | Search or job URLs, up to 500 |

A run covers up to 200 searches (countries × keywords × locations, plus pasted search URLs).

Software engineers in Sydney posted in the last 7 days, only new ones on each run (schedule it daily):

```json
{
  "country": ["AU"],
  "keywords": ["software engineer"],
  "locations": ["Sydney"],
  "datePosted": "7d",
  "onlyNew": true,
  "sortBy": "date",
  "maxResults": 500
}
```

Nurses in Sydney posted in the last 7 days, full details in Markdown:

```json
{
  "country": ["AU"],
  "keywords": ["registered nurse"],
  "locations": ["Sydney"],
  "datePosted": "7d",
  "maxResults": 500,
  "descriptionFormat": "markdown"
}
```

Software engineers in four Southeast Asian markets, remote or hybrid, list only (cheapest):

```json
{
  "country": ["MY", "SG", "PH", "ID"],
  "keywords": ["software engineer"],
  "workArrangements": ["remote", "hybrid"],
  "maxResults": 1000,
  "includeDetails": false
}
```

Daily monitor of new accounting jobs in Hong Kong. Schedule it, and each run returns only new ads:

```json
{
  "country": ["HK"],
  "classifications": ["1200"],
  "onlyNew": true,
  "sortBy": "date",
  "maxResults": 300
}
```

Paste search or job URLs. Filters in the URL are kept:

```json
{
  "startUrls": [
    { "url": "https://www.seek.com.au/data-analyst-jobs/in-All-Melbourne-VIC?daterange=14" },
    { "url": "https://th.jobsdb.com/job/95568192" }
  ]
}
```

### Getting past the 550-result cap

SEEK, JobStreet and JobsDB show at most about 550 results per search, even when the counter says 18,000. When you ask for more than 550 and the search has more, the actor:

1. reads the result counts per category (one request),
2. runs each category as its own search,
3. splits any category still above 550 into sub-categories, then into work types, and as a last resort collects both the newest and the most relevant 550 of that slice,
4. merges everything and drops duplicates by job id.

The log shows how many slices were used and how many unique jobs they covered. In our tests, a "nurse" search in Australia (7,863 results) with `maxResults: 1500` returned 1,500 unique jobs from 5 slices, with no duplicates, instead of stopping at 550.

### Only new jobs (incremental mode)

With `onlyNew` on, the actor keeps a history per search (country, keywords, location and filters) in your account. Each job is delivered once. On the next run, jobs that were already delivered are skipped at no charge and only new ads come back. Each saved task keeps its own history. For a monitor, sort by **Newest first** and set **Max jobs per search** above the number of jobs posted between runs.

### Pricing

Pay per event, with no subscription and no proxy costs:

| Event | Price |
|---|---|
| Run start | $0.01 per run |
| Job with full details (description, applicants, company profile) | **$1.50 per 1,000 jobs** ($0.0015 each) |
| Job without details (`includeDetails: false`) | **$0.60 per 1,000 jobs** ($0.0006 each) |

| Scenario | Approximate cost |
|---|---|
| 100 jobs with full details | ~$0.16 |
| 1,000 jobs with full details | ~$1.51 |
| 10,000 jobs, list only | ~$6.01 |
| Daily "only new" monitor, 50 new jobs a day | ~$0.09 per day |

You are never charged for failed searches, locations that can't be found, jobs skipped by `onlyNew`, or duplicates. Every run respects the spending limit (`maxTotalChargeUsd`) you set on Apify and stops at that exact amount.

### Run it from code

Replace `<YOUR_APIFY_TOKEN>` with your token from **Apify Console → Settings → API & Integrations**.

**cURL** (waits for the run and returns the items):

```bash
curl -X POST "https://api.apify.com/v2/acts/gangary~seek-jobstreet-jobsdb-scraper/run-sync-get-dataset-items"   -H "Authorization: Bearer <YOUR_APIFY_TOKEN>"   -H "Content-Type: application/json"   -d '{"country": ["AU"], "keywords": ["data analyst"], "locations": ["Melbourne"], "maxResults": 50}'
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("gangary~seek-jobstreet-jobsdb-scraper").call(
    run_input={"country": ["MY", "SG"], "keywords": ["software engineer"], "maxResults": 200}
)
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job.get("country"), job.get("title"), job.get("salaryMin"), job.get("salaryMax"))
```

**Node.js** (`npm install apify-client`):

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('gangary~seek-jobstreet-jobsdb-scraper').call({
    country: ['HK'],
    keywords: ['accountant'],
    onlyNew: true,
    maxResults: 300,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0]);
```

The synchronous endpoint waits up to 300 seconds; for big runs (thousands of jobs with details) start the run asynchronously and read the dataset when it finishes.

### Integrations

Everything below is built into Apify, no extra setup on our side:

- **[Schedules](https://docs.apify.com/platform/schedules):** run a saved task daily with `onlyNew` on for a new-jobs alert.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks):** get a call to your own endpoint when a run finishes.
- **[Make](https://docs.apify.com/platform/integrations/make), [n8n](https://docs.apify.com/platform/integrations/n8n) and [Zapier](https://docs.apify.com/platform/integrations/zapier):** send each run's new jobs to Slack, email, Google Sheets, your ATS or CRM.
- **[Google Drive](https://docs.apify.com/platform/integrations/drive):** drop each run's export into a shared folder.
- **Exports:** JSON, CSV, Excel, XML or HTML from the dataset, or straight from the API.

### Use with AI agents (MCP)

Apify runs a hosted MCP server, so Claude, Cursor, VS Code and other MCP clients can call this actor as a tool. Add this server URL to your client (it signs in with OAuth on first use, or send `Authorization: Bearer <YOUR_APIFY_TOKEN>`):

```
https://mcp.apify.com?tools=gangary/seek-jobstreet-jobsdb-scraper
```

Then ask in plain words, e.g. *"Get this week's data engineer jobs in Singapore and Kuala Lumpur and compare the salary ranges."* Setup details for each client: **[Apify MCP server docs](https://docs.apify.com/platform/integrations/mcp)**.

### FAQ

**Which sites does it cover?**
All eight sites of the SEEK platform: SEEK Australia and New Zealand, JobStreet Malaysia, Singapore, Philippines and Indonesia, and JobsDB Hong Kong and Thailand. Pick several countries in one run and the output format stays the same.

**How many jobs can I get per search?**
Up to 10,000 per search. Above the platform's ~550 cap the actor splits the search automatically (see above). Very broad searches may still have slices above the cap even after splitting. The log tells you how many jobs were reached.

**Is the salary always there?**
No. Many advertisers hide the salary. When it is shown, you get the original text and the numbers (min, max, currency, period). Some ads put free text in the salary field (for example "Attractive package"). Those keep the text, and the number fields stay empty.

**Do I get recruiter emails or phone numbers?**
No. Personal contact details are never collected, and email addresses and phone numbers inside descriptions are masked.

**Why is `applicantCount` empty on some jobs?**
The sites show the applicant count only for some ads. When an ad has no count, the field is `null`.

**Can I use a location from another country?**
Each location is searched on the site of each selected country. If a location belongs to a different country (for example "Sydney" with Malaysia selected), that search is skipped with a free `location-outside-country` row. A location the site doesn't recognise gives a free `location-not-found` row.

**Are duplicates removed?**
Yes. A job that appears in several searches or slices of the same run is delivered and charged once.

**How do I get a daily alert of new jobs?**
Save the input as a task with `onlyNew` on and `sortBy: "date"`, add a daily [schedule](https://docs.apify.com/platform/schedules), and connect the run to Slack or email through Make, n8n or Zapier. Each run delivers and charges only jobs it hasn't delivered before.

**What if Apify restarts my run in the middle?**
Jobs already delivered are saved in the run's state and are not delivered or charged again when it resumes. The start fee is charged once.

**Do I need proxies or an account?**
No. Proxies are included and no login is used. The actor reads only public job ads.

**Is it legal to scrape SEEK, JobStreet and JobsDB?**
The actor collects publicly listed job ads without logging in or bypassing a paywall, and leaves out personal contact details. Check your use case against the sites' terms and the privacy laws that apply to you, such as Australia's Privacy Act, Malaysia's PDPA and Singapore's PDPA.

### Honest limitations

- Applicant count, company profile and salary depend on what each ad shows.
- With full details on, each job needs one extra request: expect about 10 jobs per second (600 jobs took about a minute in our tests). List-only runs are several times faster.
- `onlyNew` remembers up to 50,000 jobs per search. Older ones fall off first.
- Job ads that expire between the search and the detail request are delivered without details, charged at the list-only price, with `detailsError: "job-not-found"`.

### Changelog

- **0.1.8 (2026-10-30):** cover image and links to related actors in this README.
- **0.1.7 (2026-10-30):** first public release: 8 countries, full details, 550-cap splitting, `onlyNew`.

### From the same maker

- **[Hiring Signals Scanner](https://apify.com/gangary/hiring-signals-scanner)**: who is hiring, how hard and for what, from company job boards on Greenhouse and Lever.
- **[Website Contact Extractor](https://apify.com/gangary/website-contact-extractor)**: emails, phones and social links from the websites of the companies you found hiring.

***

If this actor helped you, a rating on its Store page helps others find it. Something broke or a field is missing? Open an issue on the actor's **Issues** tab.

*Keywords: seek scraper, seek jobs scraper, seek.com.au scraper, jobstreet scraper, jobsdb scraper, seek api, jobstreet api, jobsdb api, australia jobs scraper, new zealand jobs, malaysia jobs scraper, singapore jobs scraper, philippines jobs, indonesia lowongan kerja, hong kong jobs, thailand jobs, job listings data, salary data, job postings api, recruitment data.*

# Actor input Schema

## `country` (type: `array`):

Which sites to search. Every keyword and location below runs in each selected country. Leave empty when you only paste Start URLs.

## `keywords` (type: `array`):

Job titles, skills or companies, one search per line (e.g. "nurse", "data analyst", "forklift"). Leave empty to list every job that matches the other filters. Up to 50.

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

Optional. City, region or suburb as you would type it on the site (e.g. "Sydney", "Auckland", "Kuala Lumpur", "Jakarta", "Kowloon", "Bangkok"). Each location is searched in every selected country, so pick locations from the countries you selected. Up to 20.

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

Upper limit of jobs per search (one keyword x location x country). SEEK shows at most ~550 results per search; above that the actor splits the search by category, sub-category and work type on its own to go further.

## `includeDetails` (type: `boolean`):

Fetch each job ad: full description, applicant count, screening questions, expiry date and company profile (size, website, rating). Turn off for a cheaper list with title, company, location, salary and teaser only.

## `descriptionFormat` (type: `string`):

Format of the full description (only with full job details on). Email addresses and phone numbers in the ad are masked.

## `onlyNew` (type: `boolean`):

Remember the jobs delivered by each search and, on later runs, return only jobs that were not delivered before. Already-seen jobs are skipped for free. Ideal for scheduled runs; the history is kept per search and per task.

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

Only jobs listed within this period.

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

Only these work types. Leave empty for all.

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

Only on-site, hybrid or remote jobs. Leave empty for all.

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

In the local currency of each country, per the salary type below. Leave empty for no minimum.

## `salaryMax` (type: `integer`):

In the local currency, per the salary type below. Leave empty for no maximum.

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

How the salary range above is read. Default: annual in Australia and New Zealand, monthly in Asia.

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

Only jobs in these SEEK categories (classifications). Leave empty for all.

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

Order in which jobs are collected. Newest first works best with "Only new jobs".

## `startUrls` (type: `array`):

Optional. Paste search result pages or job ads from seek.com.au, seek.co.nz, jobstreet.com or jobsdb.com (e.g. https://www.seek.com.au/nurse-jobs/in-All-Sydney-NSW?daterange=7 or https://my.jobstreet.com/job/95603877). Filters in a search URL are kept. Job ad URLs always come with full details.

## Actor input object example

```json
{
  "country": [
    "AU"
  ],
  "keywords": [
    "software engineer"
  ],
  "maxResults": 100,
  "includeDetails": true,
  "descriptionFormat": "text",
  "onlyNew": false,
  "datePosted": "any",
  "sortBy": "date"
}
```

# 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 = {
    "country": [
        "AU"
    ],
    "keywords": [
        "software engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("gangary/seek-jobstreet-jobsdb-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "country": ["AU"],
    "keywords": ["software engineer"],
}

# Run the Actor and wait for it to finish
run = client.actor("gangary/seek-jobstreet-jobsdb-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "country": [
    "AU"
  ],
  "keywords": [
    "software engineer"
  ]
}' |
apify call gangary/seek-jobstreet-jobsdb-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gangary/seek-jobstreet-jobsdb-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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