# Singapore MyCareersFuture Jobs Scraper (`nexgendata/singapore-mycareersfuture-jobs`) Actor

Live Singapore job postings from MyCareersFuture (WSG / gov.sg) — title, company, UEN, sector, location, SGD salary band, employment type, seniority, posting/expiry date, required skills, full job URL. Filter by keyword, sector, location, employment type, salary band, recency.

- **URL**: https://apify.com/nexgendata/singapore-mycareersfuture-jobs.md
- **Developed by:** [Stephan Corbeil](https://apify.com/nexgendata) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $30.00 / 1,000 job listings

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

Learn more: https://docs.apify.com/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

## Singapore MyCareersFuture Jobs Scraper

**Live job market data from Singapore's national government-run job portal, delivered as clean JSON — keyword search, sector filter, salary band, employment type, seniority, recency window.** This actor pulls active job postings from [MyCareersFuture (mycareersfuture.gov.sg)](https://www.mycareersfuture.gov.sg/), the country's central job-matching portal operated by Workforce Singapore (WSG), and returns one structured record per posting with the title, company name, UEN (Unique Entity Number), sector / industry category, formatted Singapore address, monthly SGD salary band, employment type, seniority level, posting and expiry dates, required skills list, and the direct posting URL.

If you are recruiting in Singapore, running an HR-tech or staffing agency, scraping leads from job boards for B2B outreach, or doing labour-market research, this actor gives you the most authoritative public dataset for the SG market — without scraping LinkedIn (paid, captcha-gated, weak SG-specific search), Indeed (aggregator with stale postings), or JobStreet (region-wide noise that drowns out SG signal).

[**Try it on Apify →**](https://apify.com/nexgendata/singapore-mycareersfuture-jobs?fpr=2ayu9b)

### Why MyCareersFuture is the canonical Singapore job dataset

Under Singapore's **Fair Consideration Framework (FCF)**, every Singapore employer that wants to hire a foreign professional on an Employment Pass (EP) must first advertise the role on MyCareersFuture for a minimum window (currently 14 days for most roles). The portal is therefore not an optional employer board — it is the de-facto compliance layer for the entire formal job market in Singapore for jobs paying SGD 5,000/month or more.

That regulatory requirement has two huge implications for data buyers:

1. **Coverage is unmatched.** Almost every white-collar role in Singapore at SGD 5,000+ monthly will pass through the portal at some point in its hiring cycle. There is no equivalent regulatory funnel forcing roles onto LinkedIn or Indeed.
2. **Data is structured.** Unlike scraped HTML from third-party aggregators, MyCareersFuture data is keyed by **UEN** (Singapore's national company identifier) and uses ACRA's official **SSIC industry codes** + Singapore's **SSOC occupation taxonomy**. That means the records you pull here are joinable to ACRA company data, MAS financial-institution filings, IRAS tax records, and any other Singapore government dataset that uses UEN as the primary key.

### What you get — schema

Each run produces one dataset row per matching job. Fields:

| Field | Type | Notes |
|---|---|---|
| `job_id` | string | MyCareersFuture UUID — stable per posting (use as deduplication key). |
| `title` | string | Job title as posted. |
| `company` | string | Posted company legal name. |
| `company_uen` | string | Singapore Unique Entity Number — joins to ACRA, IRAS, MAS datasets. |
| `company_url` | string | Company website if disclosed. |
| `sector` | array&lt;string&gt; | MyCareersFuture categories (e.g. `["Information Technology", "Engineering"]`). |
| `location` | string | Formatted Singapore address: block + street + building, `#floor-unit`, postal code, optional district. |
| `is_overseas` | boolean | True for the handful of foreign-based roles posted by SG employers. |
| `salary_min_sgd` | integer | Lower bound of advertised band, in SGD per `salary_type` period. |
| `salary_max_sgd` | integer | Upper bound. |
| `salary_type` | string | `Monthly`, `Annual`, `Hourly`, `Daily`. |
| `employment_type` | array&lt;string&gt; | One or more of `Full Time`, `Part Time`, `Contract`, `Permanent`, `Temporary`, `Flexi Work`, `Internship`, `Freelance`. |
| `seniority` | array&lt;string&gt; | One or more position-level tags (Manager, Executive, Senior Management, etc.). |
| `minimum_years_experience` | integer | As declared by the employer. |
| `posting_date` | string | ISO date — the *current* posting date (`metadata.newPostingDate`, refreshed on repost). |
| `original_posting_date` | string | ISO date — first time the job ID appeared. |
| `expiry_date` | string | ISO date — when the listing expires. |
| `vacancies` | integer | Number of openings under this posting. |
| `job_url` | string | Direct URL to the MyCareersFuture posting page. |
| `skills_required` | array&lt;string&gt; | Skill taxonomy — the employer's tagged skills, useful for skills-gap analysis and recommender systems. |
| `ssoc_code` | string | Singapore Standard Occupational Classification 2020. |
| `occupation_id` | string | MyCareersFuture-internal occupation identifier. |
| `description_summary` | string | First ~600 chars of the job description with HTML stripped. |
| `data_source` | string | Provenance string. |

### Input parameters

| Parameter | Type | Notes |
|---|---|---|
| `searchQuery` | string | Free-text keyword passed to the upstream search endpoint. Matches title, description, and skill fields. |
| `sector` | string | Optional sector filter — must match a MyCareersFuture category exactly (`Information Technology`, `Banking and Finance`, `Engineering`, etc.). |
| `location` | string | Substring match on the assembled address (region name, building, postal code). Applied client-side. |
| `salaryMin` | integer | Minimum monthly SGD salary. Sent as the API's `salary` floor. |
| `salaryMax` | integer | Maximum monthly SGD salary. Applied client-side as a band-overlap test. |
| `employmentType` | enum | `ALL` / `FULL_TIME` / `PART_TIME` / `CONTRACT` / `PERMANENT` / `TEMPORARY` / `FLEXI_WORK` / `INTERNSHIP` / `FREELANCE`. |
| `seniorityLevel` | string | Exact-match position-level. |
| `postedWithinDays` | integer | Restrict to jobs posted within the last N days based on `newPostingDate`. |
| `maxResults` | integer | Hard cap (1–500). Default 100, prefilled 50. |

### How it compares — Singapore-specific job data sources

| | This actor | LinkedIn Jobs | Indeed SG | JobStreet | Glassdoor SG |
|---|---|---|---|---|---|
| **Government-issued data?** | Yes (MyCareersFuture / WSG) | No | No | No | No |
| **Coverage of EP-mandated roles** | 100% (regulatory requirement) | Partial | Partial | Partial | Partial |
| **Salary band disclosed** | Yes (structured min/max SGD) | Rare, scraped from text | Rare | Rare | Rare |
| **Company UEN included** | Yes (joinable to ACRA) | No | No | No | No |
| **Captcha / login required** | No (public REST API) | Yes | Frequent | Yes | Yes |
| **Cost** | $0.03 per job | LinkedIn Jobs Scraper $0.02/job | Free scrapers exist but break | Subscription | Subscription |
| **Update frequency** | Live (per-run) | Daily | Daily | Daily | Weekly |
| **Skills taxonomy** | Yes (employer-tagged) | Yes | No | No | No |

The **LinkedIn Jobs Scraper** in our fleet is the top earner per result-count for global job data and excellent for cross-market analysis, but if your operating geography is Singapore specifically, MyCareersFuture is the higher-signal source — the dataset where every formally-advertised EP-eligible role must surface by law, and where the records are pre-joined to Singapore's national identifier system.

### Use cases

#### 1. Singapore recruiting agencies — pipeline sourcing

If you run a recruitment desk, the bread-and-butter workflow is "find every open role in my vertical, in my client's salary band, posted in the last 7 days, that we are not already pitching." MyCareersFuture is uniquely good for this because:

- The salary band is structured (min/max in SGD), not free-text in a job description.
- The posting date is the *current* date (the portal forces a repost on edits), so you can prove freshness.
- The UEN lets you join against your existing CRM by national company identifier without name-fuzzy-matching.

A 5-minute run with `searchQuery="data engineer"`, `salaryMin=8000`, `postedWithinDays=7`, `maxResults=200` pulls every senior data engineering role posted in Singapore in the last week at SGD 8k+/month. Pair it with the [Singapore ACRA Companies actor](https://apify.com/nexgendata/singapore-acra-companies?fpr=2ayu9b) to enrich each hiring company with directors, paid-up capital, and SSIC business classification.

#### 2. HR teams and TA leaders — market intelligence

Internal talent acquisition teams use this dataset to benchmark their own compensation bands against the live market. Pull every posting for `Software Engineer` titles in the IT sector over the last 90 days, group by seniority, and you have a real distribution of advertised SGD salary bands — not the smoothed self-reported numbers on Glassdoor or the headcount-filtered survey data from Mercer / Aon.

Combine the skills list with the salary band to answer questions like *"do Singapore employers pay more for Rust + Kubernetes than for Python + AWS at the senior level?"* in concrete dollar terms.

#### 3. B2B sales / lead-gen agencies — buyer-intent signals

A new MyCareersFuture posting is a **direct buyer-intent signal**. A company posting three new DevOps roles is buying cloud infrastructure. A company posting a Head of Compliance is buying compliance software. A company posting an in-house counsel is buying legal tech.

Cross-link the company_uen back to [Singapore MAS Financial Institutions](https://apify.com/nexgendata/singapore-mas-financial-institutions?fpr=2ayu9b) to enrich the regulated-entity context, or to [Singapore ACRA Companies](https://apify.com/nexgendata/singapore-acra-companies?fpr=2ayu9b) for paid-up capital and director profiles. The combination is a Singapore-specific signal-to-account flow that beats generic intent vendors (Bombora, G2 buyer-intent) for SG-only ICPs.

#### 4. Labour-market researchers and policymakers

Because MyCareersFuture is the regulatory funnel, longitudinal pulls give you a real-time read on Singapore's formal job market — vacancy growth by sector, salary inflation by occupation, skill-demand shifts. Pull weekly into your warehouse, key by `job_id` for deduplication, and join against ACRA company data and IRAS tax filings to build a real labour-market dashboard.

#### 5. Investment analysts — Singapore equity coverage

If you cover SGX-listed companies, hiring is a leading indicator. A bank ramping up its private credit team, a manufacturer ramping up its automation engineers, or a fintech hiring a Head of Risk all signal capital allocation choices before they show up in earnings. Pull every posting from your watch-list of UENs (you have UEN already — Singapore lists every SGX issuer's UEN in its profile) and you have a structured hiring tracker.

### Pairs well with

- [LinkedIn Jobs Scraper](https://apify.com/nexgendata/linkedin-jobs-scraper?fpr=2ayu9b) — global coverage for cross-market pulls.
- [WeWorkRemotely Jobs Scraper](https://apify.com/nexgendata/weworkremotely-jobs-scraper?fpr=2ayu9b) — remote-only role discovery.
- [Singapore ACRA Companies](https://apify.com/nexgendata/singapore-acra-companies?fpr=2ayu9b) — enrich each `company_uen` with directors, address, paid-up capital, SSIC code.
- [Singapore MAS Financial Institutions](https://apify.com/nexgendata/singapore-mas-financial-institutions?fpr=2ayu9b) — regulated-entity context for banking / asset-management roles.
- [Singapore Rental Market Tracker](https://apify.com/nexgendata/singapore-rental-market-tracker?fpr=2ayu9b) — residential rental data for relocation cost-modelling.
- [Singapore URA Commercial Property](https://apify.com/nexgendata/singapore-ura-commercial-property?fpr=2ayu9b) — commercial property data to triangulate office expansion vs hiring signals.

### Example input

```json
{
  "searchQuery": "software engineer",
  "sector": "Information Technology",
  "location": "",
  "salaryMin": 6000,
  "salaryMax": 0,
  "employmentType": "FULL_TIME",
  "seniorityLevel": "",
  "postedWithinDays": 30,
  "maxResults": 50
}
````

### Example output (one record)

```json
{
  "job_id": "551cdfbe5ee60286be0a6d243c02cc03",
  "title": "Day 2 Software Engineer (AMK)",
  "company": "MAESTRO TECHNOLOGY SOLUTIONS PTE. LTD.",
  "company_uen": "201734933C",
  "company_url": "https://www.maestrosolutions.com.sg",
  "sector": ["Information Technology"],
  "location": "30 Ang Mo Kio Industrial Park 2, Singapore 569508",
  "is_overseas": false,
  "salary_min_sgd": 4500,
  "salary_max_sgd": 7500,
  "salary_type": "Monthly",
  "employment_type": ["Full Time", "Permanent"],
  "seniority": ["Executive"],
  "minimum_years_experience": 2,
  "posting_date": "2026-05-19",
  "original_posting_date": "2026-05-19",
  "expiry_date": "2026-06-18",
  "vacancies": 2,
  "job_url": "https://www.mycareersfuture.gov.sg/job/information-technology/day-2-software-engineer-...",
  "skills_required": ["MongoDB", "Kubernetes", "Customer Support", "Software Engineering", "Docker"],
  "ssoc_code": "25121",
  "occupation_id": "OCC002119",
  "description_summary": "Day 2 Software Engineer. Job Description: As a Day 2 Software Engineer, you will be responsible for ensuring the smooth operation of our software products post-deployment...",
  "data_source": "mycareersfuture.gov.sg public API"
}
```

### Pricing

This actor uses Apify's **pay-per-event** model. You pay only for what you pull — there is no monthly subscription, no minimum spend, no per-seat fee.

- Actor start: a flat micro-charge per run.
- Per job posting: a per-row charge for each posting pushed to the dataset.

Pricing for this actor is calibrated to sit slightly above the LinkedIn Jobs Scraper per-row price ($0.02/job), because Singapore-specific job data is rarer than global LinkedIn coverage and the regulatory funnel (FCF) makes MyCareersFuture a higher-signal source for the SG market. A representative 50-row pull costs well under USD 2.

If your monthly spend would justify a flat subscription, contact us — large Singapore recruiting and HR-tech buyers usually move to a private fork with custom price brackets.

### Limits and edge cases

- **Hard ceiling:** the actor caps pulls at 500 rows per run regardless of `maxResults` to prevent runaway pagination. For deeper backfills, run multiple jobs with disjoint `postedWithinDays` windows or non-overlapping `searchQuery` keywords and dedupe by `job_id` downstream.
- **Sector / seniority strings are case-sensitive.** Use the exact taxonomy values (e.g. `Information Technology`, not `IT`). Leave empty if unsure — the upstream API will return everything and you can filter post-hoc.
- **Salary fields are integers in SGD.** The `salary_type` field tells you whether the band is monthly, annual, hourly, or daily — you must read both fields when comparing roles.
- **Graceful degradation:** if the MyCareersFuture API is rate-limited or unreachable, the actor emits a single placeholder row `{ "_blocked": true, ... }` describing the failure mode and exits cleanly. Your downstream pipeline can detect this and retry after a few minutes.
- **Overseas roles** posted by SG-registered employers (`is_overseas: true`) show foreign address fields. Filter them out client-side if you only want SG-domestic jobs.

### Frequently asked questions

#### How fresh is the data?

Every run hits the live MyCareersFuture REST API. `posting_date` is the portal's `newPostingDate` field, which is refreshed every time the employer edits the listing. For a true first-listed date, use `original_posting_date`.

#### Is this scraping or an official API?

MyCareersFuture exposes a public, unauthenticated REST endpoint at `api.mycareersfuture.gov.sg/v2/jobs`. The actor calls it the same way the consumer-facing site does. There is no scraping of HTML, no captcha bypass, no headless browser — just clean JSON in and out.

#### What about rate limits?

The upstream API is generous for occasional pulls — we have not observed hard blocks at reasonable cadences. If you need 10K+ rows per day, run multiple smaller pulls spaced through the day rather than one huge pagination loop, and the actor's `_blocked: true` placeholder will surface any block immediately if it does happen.

#### Can I get historical postings?

MyCareersFuture exposes only currently-active roles via the public API. For historical longitudinal data, run this actor on a daily schedule and snapshot the results into your own warehouse — over 12 months you build the historical dataset that does not exist as a backfill anywhere else.

#### Will my pulled data go stale?

Each posting has an `expiry_date` (typically 30–90 days after first posting). After expiry, the posting falls off the public API. Pull frequently and snapshot if you need a permanent archive.

#### How does this compare to using the consumer-facing site?

The consumer site shows ~25 jobs per page, captures interaction events, and is designed for individual job seekers. This actor hits the same data layer that powers the site, returns up to 500 structured records per run, and gives you skills + UEN + SSOC code in the response — none of which are exposed on the rendered page.

#### Can I cross-join the company\_uen to other Singapore datasets?

Yes — that is the main reason to use this actor over LinkedIn Jobs. Every `company_uen` is a primary key into ACRA's corporate registry, IRAS tax filings, MAS financial-institution disclosures, and BCA construction-licence data. Pair this actor with [Singapore ACRA Companies](https://apify.com/nexgendata/singapore-acra-companies?fpr=2ayu9b) and [Singapore MAS Financial Institutions](https://apify.com/nexgendata/singapore-mas-financial-institutions?fpr=2ayu9b) for a deep enrichment graph.

### Compliance and lawful use

MyCareersFuture is a public-data portal operated by Workforce Singapore (WSG) under the Singapore government. The job listings are published by employers explicitly for public consumption and the API endpoint that this actor uses is the same public endpoint the consumer-facing portal uses. You can lawfully use this data for talent sourcing, market research, recruitment outreach, and competitive intelligence, subject to Singapore's PDPA (Personal Data Protection Act) where individual person-data is involved — note that this actor returns *company* records and job postings, not personal candidate data, so PDPA concerns are minimal for typical use cases.

If you intend to use this data at scale, we recommend (a) respecting upstream cadence (run hourly at most for the same query), (b) attributing the source as MyCareersFuture / WSG in any published derived dataset, and (c) consulting your own counsel for use cases that involve onward distribution.

### Get the data

**[Run on Apify →](https://apify.com/nexgendata/singapore-mycareersfuture-jobs?fpr=2ayu9b)**

Singapore is a high-density, high-signal market for B2B sourcing, recruiting, and labour-market research. MyCareersFuture is the canonical dataset — and this actor is the cleanest path to it.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text keyword passed to the MyCareersFuture search endpoint. Matches job title, description, and skill fields. Example: 'software engineer', 'cybersecurity analyst', 'financial controller', 'AWS'. Leave empty to scrape the full feed filtered only by the other parameters.

## `sector` (type: `string`):

Optional sector / job-category filter — must match a MyCareersFuture category exactly. Common values: 'Information Technology', 'Banking and Finance', 'Healthcare / Pharmaceutical', 'Engineering', 'Marketing / Public Relations', 'Sales / Retail', 'Education and Training', 'Manufacturing', 'Logistics / Supply Chain', 'Consulting', 'Legal', 'Human Resources', 'Accounting / Auditing / Taxation', 'Customer Service', 'Hospitality', 'Real Estate / Property Management'. Leave empty to span all sectors.

## `location` (type: `string`):

Optional substring filter applied client-side against the formatted job location (street, building, district, postal code). Useful for narrowing to a region (e.g. 'Raffles Place', 'Jurong East', 'Changi', 'CBD', '038987'). MyCareersFuture itself does not expose a structured location search, so this is a contains-match on the assembled address string.

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

Minimum monthly salary in SGD. Sent to the MyCareersFuture API as the salary floor; only jobs whose salary band overlaps with this minimum are returned. Leave 0 / blank for no minimum.

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

Maximum monthly salary in SGD. Filters out jobs whose advertised band starts above this ceiling. Applied client-side after the API call. Leave 0 / blank for no maximum.

## `employmentType` (type: `string`):

Filter by employment type. ALL returns every job. FULL\_TIME / PART\_TIME / CONTRACT / PERMANENT / TEMPORARY / FLEXI\_WORK / INTERNSHIP / FREELANCE are passed directly to the MyCareersFuture API.

## `seniorityLevel` (type: `string`):

Optional seniority filter — must match a MyCareersFuture position-level value exactly. Common values: 'Senior Management', 'Manager', 'Executive', 'Senior Executive', 'Professional', 'Junior Executive', 'Non-executive', 'Fresh/entry level', 'Middle Management'. Leave empty for any level.

## `postedWithinDays` (type: `integer`):

Restrict results to jobs first posted within the last N days (based on MyCareersFuture's newPostingDate field). 7 = past week, 30 = past month, 90 = past quarter. Leave 0 / blank for no recency filter.

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

Hard cap on jobs returned in this run (1-500). Each job is one dataset row. Premium pricing applies per row.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "employmentType": "ALL",
  "postedWithinDays": 30,
  "maxResults": 50
}
```

# 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 = {
    "searchQuery": "software engineer",
    "sector": "",
    "location": "",
    "salaryMin": 0,
    "salaryMax": 0,
    "employmentType": "ALL",
    "seniorityLevel": "",
    "postedWithinDays": 30,
    "maxResults": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("nexgendata/singapore-mycareersfuture-jobs").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 = {
    "searchQuery": "software engineer",
    "sector": "",
    "location": "",
    "salaryMin": 0,
    "salaryMax": 0,
    "employmentType": "ALL",
    "seniorityLevel": "",
    "postedWithinDays": 30,
    "maxResults": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("nexgendata/singapore-mycareersfuture-jobs").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 '{
  "searchQuery": "software engineer",
  "sector": "",
  "location": "",
  "salaryMin": 0,
  "salaryMax": 0,
  "employmentType": "ALL",
  "seniorityLevel": "",
  "postedWithinDays": 30,
  "maxResults": 50
}' |
apify call nexgendata/singapore-mycareersfuture-jobs --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Singapore MyCareersFuture Jobs Scraper",
        "description": "Live Singapore job postings from MyCareersFuture (WSG / gov.sg) — title, company, UEN, sector, location, SGD salary band, employment type, seniority, posting/expiry date, required skills, full job URL. Filter by keyword, sector, location, employment type, salary band, recency.",
        "version": "0.0",
        "x-build-id": "4yhOgTg7TPhL229Yr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/nexgendata~singapore-mycareersfuture-jobs/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-nexgendata-singapore-mycareersfuture-jobs",
                "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/nexgendata~singapore-mycareersfuture-jobs/runs": {
            "post": {
                "operationId": "runs-sync-nexgendata-singapore-mycareersfuture-jobs",
                "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/nexgendata~singapore-mycareersfuture-jobs/run-sync": {
            "post": {
                "operationId": "run-sync-nexgendata-singapore-mycareersfuture-jobs",
                "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": {
                    "searchQuery": {
                        "title": "Search query (keyword / job title / skill)",
                        "type": "string",
                        "description": "Free-text keyword passed to the MyCareersFuture search endpoint. Matches job title, description, and skill fields. Example: 'software engineer', 'cybersecurity analyst', 'financial controller', 'AWS'. Leave empty to scrape the full feed filtered only by the other parameters."
                    },
                    "sector": {
                        "title": "Sector / industry filter",
                        "type": "string",
                        "description": "Optional sector / job-category filter — must match a MyCareersFuture category exactly. Common values: 'Information Technology', 'Banking and Finance', 'Healthcare / Pharmaceutical', 'Engineering', 'Marketing / Public Relations', 'Sales / Retail', 'Education and Training', 'Manufacturing', 'Logistics / Supply Chain', 'Consulting', 'Legal', 'Human Resources', 'Accounting / Auditing / Taxation', 'Customer Service', 'Hospitality', 'Real Estate / Property Management'. Leave empty to span all sectors."
                    },
                    "location": {
                        "title": "Location keyword (substring match)",
                        "type": "string",
                        "description": "Optional substring filter applied client-side against the formatted job location (street, building, district, postal code). Useful for narrowing to a region (e.g. 'Raffles Place', 'Jurong East', 'Changi', 'CBD', '038987'). MyCareersFuture itself does not expose a structured location search, so this is a contains-match on the assembled address string."
                    },
                    "salaryMin": {
                        "title": "Minimum monthly salary (SGD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Minimum monthly salary in SGD. Sent to the MyCareersFuture API as the salary floor; only jobs whose salary band overlaps with this minimum are returned. Leave 0 / blank for no minimum."
                    },
                    "salaryMax": {
                        "title": "Maximum monthly salary (SGD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum monthly salary in SGD. Filters out jobs whose advertised band starts above this ceiling. Applied client-side after the API call. Leave 0 / blank for no maximum."
                    },
                    "employmentType": {
                        "title": "Employment type",
                        "enum": [
                            "ALL",
                            "FULL_TIME",
                            "PART_TIME",
                            "CONTRACT",
                            "PERMANENT",
                            "TEMPORARY",
                            "FLEXI_WORK",
                            "INTERNSHIP",
                            "FREELANCE"
                        ],
                        "type": "string",
                        "description": "Filter by employment type. ALL returns every job. FULL_TIME / PART_TIME / CONTRACT / PERMANENT / TEMPORARY / FLEXI_WORK / INTERNSHIP / FREELANCE are passed directly to the MyCareersFuture API.",
                        "default": "ALL"
                    },
                    "seniorityLevel": {
                        "title": "Seniority / position level",
                        "type": "string",
                        "description": "Optional seniority filter — must match a MyCareersFuture position-level value exactly. Common values: 'Senior Management', 'Manager', 'Executive', 'Senior Executive', 'Professional', 'Junior Executive', 'Non-executive', 'Fresh/entry level', 'Middle Management'. Leave empty for any level."
                    },
                    "postedWithinDays": {
                        "title": "Posted within last N days",
                        "minimum": 0,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Restrict results to jobs first posted within the last N days (based on MyCareersFuture's newPostingDate field). 7 = past week, 30 = past month, 90 = past quarter. Leave 0 / blank for no recency filter."
                    },
                    "maxResults": {
                        "title": "Max jobs returned",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on jobs returned in this run (1-500). Each job is one dataset row. Premium pricing applies per row.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
