# Jobstreet Jobs Search Scraper (`jobsapi/jobstreet-jobs-search-scraper`) Actor

Scrape job listings from Jobstreet.com.my, Malaysia and Southeast Asia's leading job platform. Extract job titles, companies, locations, salaries, and job types for regional recruitment and market analysis.

- **URL**: https://apify.com/jobsapi/jobstreet-jobs-search-scraper.md
- **Developed by:** [Jobs API](https://apify.com/jobsapi) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

Extract job listings from JobStreet - Southeast Asia's leading job platform. Collect job titles, companies, locations, and descriptions across ASEAN markets.

### Features

- **Keyword search** — find jobs by keyword, search term, or role
- **Location filtering** — narrow results to specific cities, regions, or countries

### Use Cases

- **Southeast Asian job market analysis** — track hiring demand across Singapore, Malaysia, Philippines, Indonesia, and Thailand with keyword-based search
- **Regional recruitment sourcing** — aggregate job listings across multiple JobStreet country domains from a single actor run
- **Cross-border hiring in ASEAN** — compare job availability and employer demand across neighboring markets for workforce planning
- **Local salary benchmarking** — collect advertised salary ranges by role and location to inform compensation strategy

### Sample Input

```json
{
  "mode": "search",
  "keywords": "software engineer",
  "location": "Singapore",
  "country": "sg",
  "jobType": "",
  "workArrangement": "",
  "salaryMin": 0,
  "maxJobs": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  },
  "maxItems": 50,
  "scrapeJobDescription": false
}
````

### Sample Output

```json
{
  "jobTitle": "Senior Software Engineer",
  "companyName": "TechCorp Asia Pte Ltd",
  "location": "Singapore",
  "postedDate": "2025-06-15T00:00:00.000Z",
  "jobUrl": "https://www.jobstreet.com.sg/job/123456",
  "description": "We are looking for a Senior Software Engineer to join our growing team in Singapore...",
  "searchQuery": "software engineer",
  "searchLocation": "Singapore",
  "scrapedAt": "2025-06-16T08:30:00.000Z"
}
```

### Input

| Field | Type | Default | Required | Description |
|-------|------|---------|----------|-------------|
| `query` | string | `developer` |  | Job search query from raw input. |
| `keywords` | string | `software engineer` |  | Job title or keywords to search for (e.g. 'software engineer', 'data analyst'). |
| `jobSearchUrls` | array | `["https://ph.jobstreet.com/ai-jobs-in-accounting/full-time"]` |  | List of JobStreet search URLs from any supported country domain. |
| `maxItems` | integer | `50` |  | Maximum number of jobs to scrape. |
| `proxyConfiguration` | object | `{"useApifyProxy":true,"apifyProxyGroups":["RESIDENTIAL"]}` |  | Proxy configuration for the crawler (RESIDENTIAL recommended). |

### Output

| Field | Description |
|-------|-------------|
| `title` | Job title |
| `company` | Company name |
| `location` | Job location |
| `country` | Country code |
| `jobType` | Type of job |
| `jobUrl` | Direct URL to the job listing |
| `scrapedAt` | ISO timestamp when the job was scraped |
| `description` | Full job description |
| `jobId` | Unique job identifier |
| `companyUrl` | Company profile URL |
| `workArrangement` | Work arrangement (onsite/hybrid/remote) |
| `careerLevel` | Career level |
| `url` | Job URL |
| `salary` | Salary information |
| `datePosted` | Date the job was posted |

### Notes

- **Proxy**: Residential proxy is highly recommended — set `proxyConfiguration: { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"] }`
- **Rate limits**: Keep result limits reasonable per run to avoid IP bans
- **Scheduling**: Use Apify Scheduler to run this actor on a recurring basis for a consistently fresh dataset

# Actor input Schema

## `keywords` (type: `string`):

Job title or keywords to search for (e.g. 'software engineer', 'data analyst')

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

Optionally, use Apify Proxy or custom HTTP proxy to avoid IP address-based blocking.

## `jobSearchUrls` (type: `array`):

List of JobStreet search URLs from any supported country domain (au|hk|id|my|nz|ph|sg|th).jobstreet.com

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

Maximum number of jobs to scrape (default: 50)

## `query` (type: `string`):

Job search query from raw input.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  },
  "jobSearchUrls": [
    "https://ph.jobstreet.com/ai-jobs-in-accounting/full-time"
  ],
  "maxItems": 10,
  "query": "developer"
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": "software engineer",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "IN"
    },
    "jobSearchUrls": [
        "https://ph.jobstreet.com/ai-jobs-in-accounting/full-time"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("jobsapi/jobstreet-jobs-search-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 = {
    "keywords": "software engineer",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "IN",
    },
    "jobSearchUrls": ["https://ph.jobstreet.com/ai-jobs-in-accounting/full-time"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("jobsapi/jobstreet-jobs-search-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 '{
  "keywords": "software engineer",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "IN"
  },
  "jobSearchUrls": [
    "https://ph.jobstreet.com/ai-jobs-in-accounting/full-time"
  ],
  "maxItems": 10
}' |
apify call jobsapi/jobstreet-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobstreet Jobs Search Scraper",
        "description": "Scrape job listings from Jobstreet.com.my, Malaysia and Southeast Asia's leading job platform. Extract job titles, companies, locations, salaries, and job types for regional recruitment and market analysis.",
        "version": "0.0",
        "x-build-id": "IqVgFFM6SFCnYNjRd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/jobsapi~jobstreet-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-jobsapi-jobstreet-jobs-search-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/jobsapi~jobstreet-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-jobsapi-jobstreet-jobs-search-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/jobsapi~jobstreet-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-jobsapi-jobstreet-jobs-search-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": {
                    "keywords": {
                        "title": "Job Keywords",
                        "type": "string",
                        "description": "Job title or keywords to search for (e.g. 'software engineer', 'data analyst')"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optionally, use Apify Proxy or custom HTTP proxy to avoid IP address-based blocking.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "IN"
                        }
                    },
                    "jobSearchUrls": {
                        "title": "JobStreet Search URLs",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "List of JobStreet search URLs from any supported country domain (au|hk|id|my|nz|ph|sg|th).jobstreet.com",
                        "default": [
                            "https://ph.jobstreet.com/ai-jobs-in-accounting/full-time"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum Items",
                        "minimum": 10,
                        "type": "integer",
                        "description": "Maximum number of jobs to scrape (default: 50)",
                        "default": 50
                    },
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Job search query from raw input.",
                        "default": "developer"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
