# Jobstreet Jobs Scraper | $1.50/1K — SEA: MY, SG, PH, ID, TH, HK (`bovi/jobstreet-jobs-scraper`) Actor

Scrape job postings from Jobstreet & JobsDB (Malaysia, Singapore, Philippines, Indonesia, Thailand, Hong Kong) via the public v5 search API. Get title, company, location, salary, work type, seniority, remote type, classification, parse\_confidence. Multi-query, keyword filters.

- **URL**: https://apify.com/bovi/jobstreet-jobs-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Jobs, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.45 / 1,000 job results

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/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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

## Jobstreet Jobs Scraper — Malaysia, Singapore & Southeast Asia

Scrape job postings from **Jobstreet** and **JobsDB** across Southeast Asia — Malaysia, Singapore, Philippines, Indonesia, Thailand and Hong Kong — straight from the official SEEK-platform v5 search API. Run one or many keyword searches, paginate the full result set, and get a clean, flat, 24-field record per job: title, company, location, salary, work type, seniority, remote type, classification, posting date, job URL, and a machine-readable `parse_confidence` score on every row.

This **Jobstreet Jobs Scraper** is built for recruiters, job-market analysts, HR-tech products, and lead-generation pipelines that need structured SEA hiring data without maintaining a fragile in-house scraper.

### What Jobstreet job data you get

Every result row contains:

- **title** — the job title (e.g. "Senior Software Engineer")
- **company** — hiring company name
- **location**, **area**, **country_code** — where the job is based
- **salary** — the salary label exactly as Jobstreet displays it (e.g. `RM 8,000 – RM 12,000 per month`), when disclosed
- **work_type** — Full time, Part time, Contract, Casual
- **seniority** — canonical level inferred from the title: executive, vp, director, manager, principal, staff, lead, senior, intern, entry, mid
- **remote_type** — remote, hybrid, or onsite (from Jobstreet `workArrangements`)
- **classification** / **subclassification** — Jobstreet's own industry taxonomy
- **listing_date** — ISO-8601 posting timestamp
- **url** — canonical link to the job on the correct regional site
- **teaser** + **bullet_points** — the short summary and highlight bullets
- **description_html** / **description_text** — full job description (optional, enable "Include full job descriptions")
- **parse_confidence** + **warnings** — quality signal per row, so you can filter low-quality records programmatically

### How to scrape Jobstreet jobs

1. Add one or more **search queries** (e.g. `software engineer`, `accountant`, `sales manager`).
2. Pick the **country / market** — Malaysia, Singapore, Philippines, Indonesia, Thailand or Hong Kong.
3. Optionally set a **location filter**, **work type**, **title/location keyword filters**, or **remote-only**.
4. Set **Max total items** to cap cost (default 200), or `0` for the full result set.
5. Run. Results stream into the dataset as they are scraped.

The actor paginates automatically until every matching job for each query is collected or your `maxItems` cap is reached.

### Which countries does this Jobstreet scraper cover?

| Market | Site |
|---|---|
| Malaysia | my.jobstreet.com |
| Singapore | sg.jobstreet.com |
| Philippines | ph.jobstreet.com |
| Indonesia | id.jobstreet.com |
| Thailand | th.jobsdb.com |
| Hong Kong | hk.jobsdb.com |

Each market is selected with the **Country / market** input and returns localized results, including local salary currencies (RM, S$, ₱, Rp, ฿, HK$).

### Why this Jobstreet Jobs Scraper

- **Official internal API, not HTML scraping** — fast, stable, and resilient to front-end redesigns. The same SEEK v5 search backend powers Jobstreet, JobsDB and Seek.
- **Clean unified schema** — one consistent record shape across all six SEA markets, ready to push straight into a database, spreadsheet, or ATS.
- **Enriched fields** — seniority and remote-type are derived for you, not left as raw strings.
- **Quality signal built in** — `parse_confidence` lets you trust the data and drop incomplete rows automatically.
- **Apify Proxy** — runs on Apify's RESIDENTIAL proxy by default for reliable access; you pay only per result.

### Pricing

Pay per result. You are billed `$1.50 / 1,000 jobs` returned. Optional premium events apply when you enable full descriptions or have salary-disclosed rows.

### Related job scrapers

Pair this with our **Seek Jobs Scraper** (Australia & New Zealand) and **Dice Tech Jobs Scraper** (US tech) for full-coverage cross-region hiring intelligence on the same unified schema.

### FAQ

**Do I need a Jobstreet login or API key?** No. The actor uses Jobstreet's public search API.

**Can I get full job descriptions?** Yes — enable "Include full job descriptions". Each job then makes one extra request to its detail page (slower, richer output). Teaser and bullet points are always included even without it.

**How fresh is the data?** It is fetched live on every run, directly from Jobstreet's search backend.

**Is salary always present?** No — only when the employer discloses it. Indonesia and Hong Kong listings disclose salary most often; check `salary` (null when not disclosed).

# Actor input Schema

## `searchQueries` (type: `array`):

Keywords to search for on Jobstreet. Each item is one search query. Examples: "software engineer", "accountant", "sales manager". Runs one paginated search per query.
## `siteKey` (type: `string`):

Which Jobstreet / JobsDB market to search. Each maps to a regional site (e.g. Malaysia = my.jobstreet.com).
## `where` (type: `string`):

Location text filter. Examples: "Kuala Lumpur", "Singapore", "Metro Manila". Leave blank to search the whole country.
## `maxItems` (type: `integer`):

Maximum total jobs to push across all queries. Default 200 keeps trial runs cheap. Set to 0 for unlimited (may be thousands).
## `includeDescriptions` (type: `boolean`):

Fetch full job description HTML + plain text from each job's detail page. Requires one extra HTTP request per job — slower but richer. Off by default; teaser + bullet points are always included.
## `titleKeyword` (type: `string`):

Post-fetch filter: keep only jobs whose title contains this text (case-insensitive). Example: "engineer". Leave blank to return all.
## `locationKeyword` (type: `string`):

Post-fetch filter: keep only jobs whose location label contains this text (case-insensitive). Example: "Selangor". Leave blank for all locations.
## `remoteOnly` (type: `boolean`):

When enabled, only jobs with remote_type="remote" are returned (inferred from workArrangements and location text).
## `workType` (type: `string`):

Filter by work type: Full time, Part time, Contract, Casual. Leave blank for all.
## `classificationId` (type: `string`):

Classification ID to filter by industry category (advanced — get IDs from Jobstreet facets). Leave blank to search all.
## `proxyConfiguration` (type: `object`):

Apify proxy used for all requests. Defaults to the Apify RESIDENTIAL group for reliable access from the cloud. Billed to the run owner.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer",
    "data analyst"
  ],
  "siteKey": "MY-Main",
  "maxItems": 200,
  "includeDescriptions": false,
  "remoteOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# Actor output Schema

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

Dataset containing Jobstreet Jobs Scraper records (job\_id, title, company, location, country\_code, remote\_type, seniority, salary, work\_type, listing\_date, classification, url, parse\_confidence).

# 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 = {
    "searchQueries": [
        "software engineer",
        "data analyst"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/jobstreet-jobs-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 = { "searchQueries": [
        "software engineer",
        "data analyst",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("bovi/jobstreet-jobs-scraper").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 '{
  "searchQueries": [
    "software engineer",
    "data analyst"
  ]
}' |
apify call bovi/jobstreet-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bovi/jobstreet-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobstreet Jobs Scraper | $1.50/1K — SEA: MY, SG, PH, ID, TH, HK",
        "description": "Scrape job postings from Jobstreet & JobsDB (Malaysia, Singapore, Philippines, Indonesia, Thailand, Hong Kong) via the public v5 search API. Get title, company, location, salary, work type, seniority, remote type, classification, parse_confidence. Multi-query, keyword filters.",
        "version": "0.1",
        "x-build-id": "r8gRvDLxwZ9llswg7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~jobstreet-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-jobstreet-jobs-scraper",
                "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/bovi~jobstreet-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-jobstreet-jobs-scraper",
                "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/bovi~jobstreet-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-jobstreet-jobs-scraper",
                "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": {
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords to search for on Jobstreet. Each item is one search query. Examples: \"software engineer\", \"accountant\", \"sales manager\". Runs one paginated search per query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "siteKey": {
                        "title": "Country / market",
                        "enum": [
                            "MY-Main",
                            "SG-Main",
                            "PH-Main",
                            "ID-Main",
                            "TH-Main",
                            "HK-Main"
                        ],
                        "type": "string",
                        "description": "Which Jobstreet / JobsDB market to search. Each maps to a regional site (e.g. Malaysia = my.jobstreet.com).",
                        "default": "MY-Main"
                    },
                    "where": {
                        "title": "Location filter",
                        "type": "string",
                        "description": "Location text filter. Examples: \"Kuala Lumpur\", \"Singapore\", \"Metro Manila\". Leave blank to search the whole country."
                    },
                    "maxItems": {
                        "title": "Max total items",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total jobs to push across all queries. Default 200 keeps trial runs cheap. Set to 0 for unlimited (may be thousands).",
                        "default": 200
                    },
                    "includeDescriptions": {
                        "title": "Include full job descriptions",
                        "type": "boolean",
                        "description": "Fetch full job description HTML + plain text from each job's detail page. Requires one extra HTTP request per job — slower but richer. Off by default; teaser + bullet points are always included.",
                        "default": false
                    },
                    "titleKeyword": {
                        "title": "Title keyword filter",
                        "type": "string",
                        "description": "Post-fetch filter: keep only jobs whose title contains this text (case-insensitive). Example: \"engineer\". Leave blank to return all."
                    },
                    "locationKeyword": {
                        "title": "Location keyword filter",
                        "type": "string",
                        "description": "Post-fetch filter: keep only jobs whose location label contains this text (case-insensitive). Example: \"Selangor\". Leave blank for all locations."
                    },
                    "remoteOnly": {
                        "title": "Remote jobs only",
                        "type": "boolean",
                        "description": "When enabled, only jobs with remote_type=\"remote\" are returned (inferred from workArrangements and location text).",
                        "default": false
                    },
                    "workType": {
                        "title": "Work type filter",
                        "type": "string",
                        "description": "Filter by work type: Full time, Part time, Contract, Casual. Leave blank for all."
                    },
                    "classificationId": {
                        "title": "Classification ID",
                        "type": "string",
                        "description": "Classification ID to filter by industry category (advanced — get IDs from Jobstreet facets). Leave blank to search all."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy used for all requests. Defaults to the Apify RESIDENTIAL group for reliable access from the cloud. Billed to the run owner.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```