# JobStreet Scraper: Jobs in Singapore, Malaysia & Philippines (`accountable_eel/jobstreet-jobs-lookup`) Actor

Scrape JobStreet job listings in Singapore, Malaysia, the Philippines and Indonesia by keyword and location, no login. Salary range, company, work type, posted date and job link for each posting. Filter by title, company or district. Export to Google Sheets.

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

## Pricing

from $0.50 / 1,000 job posting returneds

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

## JobStreet Scraper: Jobs in Singapore, Malaysia & Philippines

**Get JobStreet job postings for Singapore, Malaysia, the Philippines or Indonesia by keyword and location, one row per posting, with pay range, company, work type and posted date.**
Type a job title (or "title @ district"), pick the country, and each matching posting comes back as its own row with a direct job link. No login, no cookies, no key. You are charged per posting returned, and a search with no matches costs nothing.

### Who uses it

- **Recruiters and sourcers** watching which companies in Singapore, Kuala Lumpur, Manila or Jakarta are hiring for a role right now.
- **Salary and market researchers** comparing the pay range posted for the same job title across districts and countries.
- **Sales teams** building lists of companies that are hiring, from the company name and company profile link.
- **Job aggregators and Sheets or n8n workflows** that need fresh JobStreet postings on a schedule.

Pay is only shown on part of the postings (36 to 58 of every 100 postings in the 2026-10-20 checks, depending on the country) and is returned as `null` when the employer did not post one. Full job descriptions are not included: each row carries the posting's one-line teaser and highlight bullets.

### The four countries

| `country` | Site | Example search line |
|---|---|---|
| `sg` Singapore (default) | sg.jobstreet.com | `accountant @ Orchard` |
| `my` Malaysia | my.jobstreet.com | `software engineer @ Kuala Lumpur` |
| `ph` Philippines | ph.jobstreet.com | `customer service @ Metro Manila` |
| `id` Indonesia | id.jobstreet.com | `driver @ Jakarta` |

One country per run. Hong Kong and Thailand are on JobsDB, a separate actor.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `keywords` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~jobstreet-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"keywords":["sales"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

### Input

```json
{
  "keywords": [
    "sales"
  ]
}
```

One search per line. Write "keywords @ location", or just the keywords and pick a location below. Pick Singapore, Malaysia, the Philippines or Indonesia under Search settings. Accepted formats: sales, accountant @ Orchard, software engineer @ Kuala Lumpur, customer service @ Metro Manila, driver @ Jakarta.

### Output

One row per job posting. Missing values are `null`, never `0` or an empty string. Every row carries `jobUrl` (the posting's link), `scrapedAt`, and the search that produced it.

Example row (real posting, Singapore, 2026-10-20):

```json
{
  "jobId": "95346790",
  "title": "No Need Experience! Branch Sales Executive ($3600 + Commission)",
  "companyName": "Talents Connect",
  "country": "SG",
  "location": "Singapore",
  "classification": "Sales",
  "workTypes": [
    "Full time"
  ],
  "workArrangement": null,
  "salaryLabel": "$3,600 – $4,400 per month",
  "postedAt": "2026-10-19T04:23:12Z",
  "jobUrl": "https://sg.jobstreet.com/job/95346790"
}
```

Fields: `jobId`, `title`, `companyName`, `advertiser` (may be a recruiter), `companyUrl`, `location`, `country`, `remote`, `classification`, `subClassification`, `workTypes`, `workArrangement` (Remote / Hybrid when JobStreet says so), `salaryLabel` (as JobStreet words it), `teaser`, `bulletPoints`, `isFeatured`, `postedAt`, `postedAgo`, `jobUrl`, `companyLogoUrl`.

Column reference:

| query | found | status | searchKeywords | searchLocation | jobCount | totalAvailable | truncated | jobs | jobId | title | companyName | advertiser | companyUrl | location | country | remote | classification | subClassification | workTypes | workArrangement | salaryLabel | teaser | bulletPoints | isFeatured | postedAt | postedAgo | jobUrl | companyLogoUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| sales | true | OK | <keywords searched> | <location searched> | <postings returned> | <total matching on jobstreet> | <more results were available> | \<all postings found (full list)> | <jobstreet job id> | <job title> | <company> | \<advertiser (may be a recruiter)> | <company profile link> | <location> | <country> | \<remote?> | <category> | <sub-category> | <work type> | <work arrangement> | \<pay range (as jobstreet displays it)> | \<teaser (the posting's one-line summary)> | <highlight bullets> | <featured listing> | <posted on> | \<posted (as jobstreet words it)> | <job link> | <company logo> | 1970-01-01T00:00:00.000Z |

A search with no matching postings comes back as one row with `"found": false` and is never charged.

### Limits

- **Search depth.** JobStreet hands out 100 postings per page. This actor reads up to 30 pages, so at most 3,000 postings per search; "Most postings to return per search" (default 50) is your budget control. When a search has more matches than you asked for, `truncated` is `true` and `totalAvailable` says how many JobStreet counts.
- **Pace.** The actor sends at most one request per second, so a 3,000-posting search takes about 45 seconds.
- **Filters.** Keywords, location (`where`) and "Posted within" are applied by JobStreet itself. Title, company, district and remote filters are applied by the actor after the postings arrive.
- **No job descriptions.** Only the one-line teaser and highlight bullets are returned; job pages are never opened.

### Pricing

Pay-per-event. A flat per-run fee covers session/proxy warmup; you're billed
per item only when data is actually found and returned — see
`.actor/pay_per_event.json` for exact prices. A miss is never charged.

One billable event, **job-returned**, charged once per posting returned. A search with no matches, or whose matches are all filtered out, is never charged. The "Most postings to return per search" and "Stop after this many results" fields cap your spend.

### Example runs

Paste any of these into the Input tab and press Start.

**Sales jobs in Singapore.** The default shape.

```json
{
  "country": "sg",
  "keywords": ["sales"],
  "maxResults": 20
}
```

**Software engineers in Kuala Lumpur, posted in the last week.**

```json
{
  "country": "my",
  "keywords": ["software engineer @ Kuala Lumpur"],
  "postedWithin": "week",
  "maxJobsPerQuery": 100
}
```

**Customer service roles in Metro Manila, remote only, skipping staffing agencies.**

```json
{
  "country": "ph",
  "keywords": ["customer service @ Metro Manila"],
  "remoteOnly": true,
  "excludeCompanies": ["recruit", "staffing"]
}
```

**Drivers in Jakarta.**

```json
{
  "country": "id",
  "keywords": ["driver @ Jakarta"],
  "maxJobsPerQuery": 50
}
```

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~jobstreet-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"keywords":["sales"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~jobstreet-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"keywords":["sales"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~jobstreet-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"keywords":["{{search}}"]}`, mapping the row's search into the `keywords` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "jobstreet scraper" — the agent will find and run this actor.

# Actor input Schema

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

One search per line. Write "keywords @ location", or just the keywords and pick a location below. Pick Singapore, Malaysia, the Philippines or Indonesia under Search settings. Accepted formats: sales, accountant @ Orchard, software engineer @ Kuala Lumpur, customer service @ Metro Manila, driver @ Jakarta. You're only charged for the ones we actually find — a miss costs nothing.

## `country` (type: `string`):

Which JobStreet site to search. One country per run.

## `defaultLocation` (type: `string`):

Used for any line that's just keywords. Write it the way JobStreet does — "Orchard", "Kuala Lumpur", "Metro Manila", "Jakarta". Leave empty to search the whole country.

## `maxJobsPerQuery` (type: `integer`):

JobStreet hands out 100 postings per page and this actor stops at 30 pages (3,000 postings) per search. You pay per posting returned, so this is also your budget control.

## `postedWithin` (type: `string`):

Ask JobStreet for recent postings only. This is applied by JobStreet itself before results are sent, so it makes runs cheaper as well as fresher.

## `titleKeywords` (type: `array`):

Optional. Keep only roles whose title contains at least one of these words — e.g. "engineer", "account executive". Case doesn't matter and partial words work. Leave empty to keep every role.

## `excludeTitleKeywords` (type: `array`):

Optional. Drop any role whose title contains one of these words — e.g. "intern", "senior". Applied after the include list above, so a role matching both is dropped.

## `companies` (type: `array`):

Optional. Keep only roles at companies whose name contains one of these. Partial matches work.

## `excludeCompanies` (type: `array`):

Optional. Drop roles at companies whose name contains one of these — handy for filtering out recruitment agencies you already know.

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

Optional. Narrow a wide search down to particular districts — e.g. "Jurong", "Petaling Jaya". Applied to the location JobStreet prints on each posting.

## `remoteOnly` (type: `boolean`):

Keep only roles whose location, work arrangement, or title reads as remote. Applied to the postings after they arrive — treat it as a strong filter, not a guarantee.

## `skipDuplicateJobs` (type: `boolean`):

On by default. Overlapping searches routinely surface the same role — with this on, each posting is returned, and billed, exactly once per run.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each job posting found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "keywords": [
    "sales"
  ],
  "country": "sg",
  "defaultLocation": "",
  "maxJobsPerQuery": 50,
  "postedWithin": "",
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "companies": [],
  "excludeCompanies": [],
  "locations": [],
  "remoteOnly": false,
  "skipDuplicateJobs": true,
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "columns": [
    "searchKeywords",
    "searchLocation",
    "jobCount",
    "totalAvailable",
    "truncated",
    "jobs",
    "jobId",
    "title",
    "companyName",
    "advertiser",
    "companyUrl",
    "location",
    "country",
    "remote",
    "classification",
    "subClassification",
    "workTypes",
    "workArrangement",
    "salaryLabel",
    "teaser",
    "bulletPoints",
    "isFeatured",
    "postedAt",
    "postedAgo",
    "jobUrl",
    "companyLogoUrl"
  ],
  "expandRows": true,
  "maxConcurrency": 1,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "keywords": [
        "sales"
    ],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "companies": [],
    "excludeCompanies": [],
    "locations": [],
    "includeKeywords": [],
    "excludeKeywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/jobstreet-jobs-lookup").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": ["sales"],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "companies": [],
    "excludeCompanies": [],
    "locations": [],
    "includeKeywords": [],
    "excludeKeywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/jobstreet-jobs-lookup").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 '{
  "keywords": [
    "sales"
  ],
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "companies": [],
  "excludeCompanies": [],
  "locations": [],
  "includeKeywords": [],
  "excludeKeywords": []
}' |
apify call accountable_eel/jobstreet-jobs-lookup --silent --output-dataset

```

## MCP server setup

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

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/M5uj8kHyiqyUkbhJ4/builds/M6lrrM3J5FUtPXwnu/openapi.json
