# SEEK & JobStreet Jobs API (6 markets) (`subimpact/seek-jobstreet-jobs-api`) Actor

Job search as JSON for SEEK (Australia, New Zealand) and JobStreet (Malaysia, Singapore, Philippines, Indonesia): title, advertiser, salary text, classification, location and posting date, plus optional full ad text. From $0.80 per 1,000 jobs.

- **URL**: https://apify.com/subimpact/seek-jobstreet-jobs-api.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** Jobs, Lead generation, Developer tools
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 job scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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 Jobs API — 6 markets

Job search as JSON from the leading Asia-Pacific job boards: **SEEK**
(Australia, New Zealand) and **JobStreet** (Malaysia, Singapore, the Philippines, Indonesia).
One input, one row per job ad, no browser, no login.

Search by keyword and location, filter by posting date and work type, and optionally add the full
ad text. Every row carries the same fields in every market, so a single pipeline can cover all six.

### Markets

| `market` | Job board | Site | Country |
| --- | --- | --- | --- |
| `AU` | SEEK | au.seek.com | Australia |
| `NZ` | SEEK | nz.seek.com | New Zealand |
| `MY` | JobStreet | my.jobstreet.com | Malaysia |
| `SG` | JobStreet | sg.jobstreet.com | Singapore |
| `PH` | JobStreet | ph.jobstreet.com | Philippines |
| `ID` | JobStreet | id.jobstreet.com | Indonesia |

Each run searches **one** market. Run the actor again (or schedule one run per market) to cover
several countries.

### Input

```json
{
  "market": "AU",
  "searches": [
    { "keywords": "data engineer", "location": "Melbourne VIC" },
    { "keywords": "site reliability engineer" }
  ],
  "dateRange": 7,
  "workType": "full-time",
  "maxJobsPerSearch": 100,
  "maxTotalJobs": 200,
  "includeDetails": false
}
```

| Field | What it does |
| --- | --- |
| `market` | One of the six markets above. Default `AU`. |
| `searches` | Keyword/location pairs, one search each. `location` may be a suburb, city, state or region (`"Melbourne VIC"`, `"Kuala Lumpur"`, `"Singapore"`); leave it out for the whole country. Default: one search for `data engineer`. |
| `dateRange` | Keep only ads posted in the last N days (the boards' own 1 / 3 / 7 / 14 / 31 day filter). Empty = any age. |
| `workType` | `full-time`, `part-time`, `contract` or `casual`. Empty = all. The board applies it; a minority of advertisers tag their ad differently, so treat it as a strong filter rather than a guarantee. |
| `maxJobsPerSearch` | Cap per search. Default 100. |
| `maxTotalJobs` | Hard cap for the whole run (default 200, max 10000). The run stops there — and stops at the platform's max charge limit too. |
| `includeDetails` | Open each ad and add `description`, the ad's own `salaryText` and expiry date. One extra request per job, $0.0005 extra per job. |
| `proxyConfiguration` | Optional. Only needed if Hong Kong or Thailand runs come back with `status: "error"` — see *Reliability* below. |

### Output

One dataset row per job ad. This is a real row from the live JobStreet Malaysia test
(`description` trimmed here for readability):

```json
{
  "jobId": "95794825",
  "title": "Data Analyst/Data Engineer (Junior/Senior)",
  "companyName": "Upgrowth HR",
  "advertiserId": "61826434",
  "location": "Kuala Lumpur",
  "area": null,
  "country": "MY",
  "market": "MY",
  "classification": "Information & Communication Technology",
  "subClassification": "Engineering - Software",
  "workType": "Full time",
  "salaryText": "RM 5,000 – RM 7,500 per month",
  "listedAt": "2026-11-10T02:46:18.000Z",
  "teaser": "Turn data into actionable insights! Analyse large datasets to support business decisions, improve operations, and drive growth.",
  "bulletPoints": [
    "Competitive Compensation & Comprehensive Benefits",
    "Potential Career Growth",
    "High-Impact Career Growth"
  ],
  "url": "https://my.jobstreet.com/job/95794825",
  "logoUrl": "https://bx-branding-gateway.cloud.seek.com.au/2b3c397e-49ed-4e33-b9cb-d8091c0e1b13.1/jdpLogo",
  "isPremium": false,
  "description": "DATA ANALYST\n\nJOB RESPONSIBILITIES:\n\n• Extract, clean, and analyze data using SQL and Python …",
  "searchKeywords": "data engineer",
  "searchLocation": null,
  "scrapedAt": "2026-11-15T08:44:46.278Z",
  "status": "ok",
  "detailsStatus": "ok",
  "error": null
}
```

| Field | Source |
| --- | --- |
| `jobId` | Board's ad id — addresses the ad: `https://<site>/job/<jobId>` |
| `title`, `teaser`, `bulletPoints`, `companyName` | Search result card |
| `advertiserId` | Advertiser id from the result card (`null` for a private advertiser) |
| `location`, `area`, `country` | Result card location label, the broader area the board files it under, country code |
| `classification`, `subClassification`, `workType`, `salaryText` | Result card taxonomy / advertiser input (`salaryText` is `null` when the advertiser hides pay) |
| `listedAt` | Ad's listing timestamp, ISO 8601 |
| `url`, `logoUrl`, `isPremium` | Ad's public URL, advertiser logo, featured flag |
| `description` | Full ad body as plain text (`includeDetails` only) |
| `searchKeywords`, `searchLocation`, `scrapedAt` | The search that produced the row, and when |
| `status`, `detailsStatus`, `error` | `ok` for a job row, `no_results` / `error` for a search that returned nothing or failed (not charged) |

### Pricing

**$0.80 per 1,000 jobs** ($0.0008 per delivered job). Adding the full ad text with `includeDetails`
adds **$0.50 per 1,000 jobs**. Apify platform usage is included; there are no other charges.

You are charged only for job rows actually written to the dataset. Searches that return nothing,
searches that fail, and jobs whose ad body could not be opened are not charged.

A default run (`data engineer`, 200 jobs) costs about **$0.16**. With `maxTotalJobs` at 10,000 a run
costs $8.00 — the cap is yours to set, and the platform's max charge limit stops the run too.

### Reliability and limits

- **No login, no cookies.** The actor reads the same public JSON endpoints the job boards' own web
  front end uses: `/api/jobsearch/v5/search` for search and `/graphql` (`jobDetails`) for ad bodies.
- **JobsDB (Hong Kong, Thailand) is not supported.** It sits behind Cloudflare and blocked every request in our tests, including through residential proxies, so the actor does not offer those markets. SEEK (AU/NZ) and JobStreet (MY/SG/PH/ID) answer direct requests.
- **Page size** on the boards' search API is 100 ads; the actor pages through until your caps are
  met. Deep result sets are subject to the boards' own relevance cut-off (a search that reports
  5,000 matches usually exposes a few hundred ads).
- **Salary** is the advertiser's own text and is often absent — `salaryText: null` means "not
  disclosed", not "failed".
- **`area`** is `null` where the board only returns a single-level location (common on JobStreet
  Malaysia/Singapore city searches).
- **Ad bodies** are public ads; expired ads may still be served by the details endpoint and are
  returned as-is with `detailsStatus: "ok"`.
- Results are pushed in batches of 10, so a run that times out still delivers what it collected.

### Usage notes

- One run = one market. For multi-country coverage, schedule one run per market (or use a task with
  the same actor and different `market` inputs).
- Give `maxTotalJobs` as the cost ceiling and `maxJobsPerSearch` as the per-keyword ceiling; the run
  stops at whichever comes first, plus the platform's max charge limit
  (`ACTOR_MAX_PAID_DATASET_ITEMS` / `maxTotalChargeUsd`).
- Rows are deduplicated by nothing: the same ad found by two searches appears twice (with different
  `searchKeywords`). Dedupe on `market + jobId` if you need one row per ad.

### Development

```bash
npm install
npm test               # offline, runs against saved fixtures in test/fixtures/
node test/live.mjs AU 12          # live smoke test against SEEK Australia
node test/live.mjs MY 3 true      # JobStreet Malaysia with full ad text
```

`npm test` never touches the network.

### Run monitoring and privacy

If a run fails or times out, this Actor tells its developer the run ID and status, so we can fix problems fast. It never sends your input, your results or your account data.

# Actor input Schema

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

Keyword and location pairs. Each pair is one job search on the chosen market. Example: \[{"keywords":"data engineer","location":"Melbourne VIC"}]. Location may be a city, a state or region, or left empty for the whole country.

## `market` (type: `string`):

Which job board to search. AU = SEEK Australia (au.seek.com), NZ = SEEK New Zealand (nz.seek.com), MY/SG/PH/ID = JobStreet. Each market only returns jobs in its own country. JobsDB (Hong Kong, Thailand) is not offered: it blocks automated access, including through residential proxies.

## `dateRange` (type: `integer`):

Only return jobs posted in the last N days. Leave empty for any age. The job board applies this filter server-side; 1, 3, 7, 14 and 31 are the values the sites themselves offer.

## `workType` (type: `string`):

Restrict to one employment type. Leave empty for all. The board's own filter is advisory for some employers: most rows match, a few are classified differently by the advertiser.

## `maxJobsPerSearch` (type: `integer`):

Cap on delivered jobs for each keyword/location pair (1-1000). Default 100.

## `maxTotalJobs` (type: `integer`):

Global cap across every search in one run, the hard cost ceiling (1-10000, default 200). Set it as high as you like, up to 10000; runs stop charging when Actor.maxTotalChargeUsd / ACTOR_MAX_PAID_DATASET_ITEMS is reached.

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

Open every job ad and add the full description text, salary label and expiry date. One extra request per job and an extra $0.50 per 1,000 jobs ($0.0005 each). Off by default.

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

Optional. SEEK and JobStreet answer direct requests, so no proxy is needed. Set one only if your runs report HTTP 403 errors.

## Actor input object example

```json
{
  "searches": [
    {
      "keywords": "data engineer"
    }
  ],
  "market": "AU",
  "maxJobsPerSearch": 100,
  "maxTotalJobs": 200,
  "includeDetails": false
}
```

# Actor output Schema

## `results` (type: `string`):

One dataset item per job ad: jobId, title, companyName, advertiserId, location, area, country, market, classification, subClassification, workType, salaryText, listedAt (ISO), teaser, bulletPoints, url, logoUrl, isPremium, description (only with includeDetails), searchKeywords, searchLocation, scrapedAt, status and detailsStatus. Searches that returned nothing and searches that failed are pushed too, with status=no_results or status=error, and are not charged.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searches": [
        {
            "keywords": "data engineer"
        }
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "searches": [{ "keywords": "data engineer" }] }

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

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

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

```

## CLI example

```bash
echo '{
  "searches": [
    {
      "keywords": "data engineer"
    }
  ]
}' |
apify call subimpact/seek-jobstreet-jobs-api --silent --output-dataset

```

## MCP server setup

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

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/0idwe7s3B4lZK4lXT/builds/wody4ySlnsZZbWXHg/openapi.json
