# Foundit Jobs Scraper — Skills, Salary & Applicant Demand (`corvuslab/foundit-jobs-scraper`) Actor

Search foundit (formerly Monster) job listings across India, the Gulf, Singapore, Malaysia, Hong Kong and Indonesia. Get full skills, functions, industries, salary, experience, company and applicant-demand data per job in one fast request — with incremental monitoring and notifications.

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

## Pricing

from $0.80 / 1,000 results

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

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

### What does Foundit Jobs Scraper do?

Search **[foundit](https://www.foundit.in/)** job listings across **India, the Gulf, Singapore, Malaysia, Hong Kong and Indonesia** and get the full job record, **complete description included**: required **skills**, job **functions** and **industries**, structured **salary** (min / max / currency / confidential flag), **experience** band, the live **applicant-demand count**, and full **company** details (name, logo, profile URL, industry, recruiter). No code needed, and results export to JSON, CSV, Excel or the API — ready for spreadsheets, apps and AI agents.

**Why this scraper**

- 📝 **Full descriptions included** — every job comes with its complete description (text + HTML) at one flat per-result price; no add-ons.
- ⚡ **Fast mode when you need it** — switch descriptions off and the structured record comes back in a single request per search page, thousands of jobs in seconds.
- 🧾 **Rich, typed records** — up to 35 structured fields per job, not raw HTML.
- ♻️ **Cheap to monitor** — incremental mode re-scrapes only what changed (see below).
- 🔔 **Notifications built in** — Telegram, Slack, Discord or any webhook.
- 🤖 **AI- & API-ready** — compact output, MCP-friendly, one-click integrations.

***

### 📚 What data can you extract from foundit?

- **Core** — `id`, `title`, `url`, `applyUrl`, `location`, `country`, `source` (market), `searchKeyword`, `scrapedAt`.
- **Job details** — `skills[]`, `functions[]`, `industries[]`, `employmentTypes[]`, and the experience band (`experienceMin` / `experienceMax` / `experienceText`).
- **Salary** — `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryConfidential` and `salaryText`.
- **Company** — `company`, `companyId`, `companyUrl`, `companyLogo`, `companyIndustry`, `recruiterName` and `employerType`.
- **Demand & freshness** — `applicantCount`, `applicantVolumeLabel`, `isUrgentlyHiring`, `isFresh`, `postedText`, `postedAt`, `updatedAt` and `expiresAt`.
- **Change tracking** (incremental mode) — `changeType`, repost detection (`isRepost`, `repostOfId`, `repostDetectedAt`) and a `contentHash`.
- **Full description** (included by default, `includeDetails`) — `description` (plain text) and `descriptionHtml` (formatted), fetched from each job's page; `detailFetched` flags which records were enriched.

Every field is present in standard mode (missing values are `null`); **compact mode** returns the core fields only (title, company, location, salary, experience, skills, apply URL — plus `description` when you enabled it), for lean AI/MCP payloads.

***

### ✨ Key features

- 🌍 **6 markets, one actor** — India (foundit.in), the Gulf / Middle East, Singapore, Malaysia, Hong Kong and Indonesia, each with its own jobs and local salary currency.
- 🧾 **Richest listing-only record in the category** — `skills[]`, `functions[]`, `industries[]`, structured salary, experience band, applicant demand **and** company logo & profile URL all come back in the search pass, with **no extra per-job fetch** and no extra cost.
- 🧠 **Structured skills, functions & industries** — every job carries a typed list of required skills, its job functions and its industries, not a wall of description text.
- 📝 **Full job descriptions, no extra charge** — each job's complete description (plain text **and** HTML) is included by default at the same flat per-result price. Turn `includeDetails` off for a much faster listing-only run.
- 💰 **Structured salary** — `salaryMin`, `salaryMax`, `salaryCurrency`, a `salaryConfidential` flag and the display text, so you can filter and chart pay directly.
- 📊 **Applicant-demand signals** — the live `applicantCount` plus a derived `applicantVolumeLabel` (low / moderate / high competition) and an `isUrgentlyHiring` flag — spot low-competition and urgent roles fast.
- 🎚️ **Rich filters** — keyword, market, location(s), experience band, salary, employment type, job function and posted-within-N-days, all applied on the site and combinable.
- ♻️ **Incremental monitoring** — schedule it and get only what changed (NEW / UPDATED / UNCHANGED / EXPIRED), with **repost detection** — unchanged jobs are skipped before their record is even built.
- 🔔 **Notifications** — Telegram, Slack, Discord or any webhook (n8n / Make / Zapier).
- 🤖 **AI-ready** — compact + drop-empty output modes keep payloads small for LLMs and MCP.

***

### 🚀 How to scrape foundit

1. Open the actor and enter a **search keyword** (e.g. `data analyst`), pick a **market** and any filters — or paste a foundit search URL.
2. Set **Max results** and choose your **sort order**.
3. (Optional) Turn on **incremental mode** and a **notification** channel, then **Schedule** it.
4. Click **Start**.
5. Download the data as **JSON, CSV or Excel**, or pull it from the **API**.

New to Apify? Create a free account — it comes with monthly credit, no credit card required.

***

### ⚙️ Input

Configure it in the visual editor — no code needed — or pass JSON via the API.

| Field | What it does |
|---|---|
| `query` | Keyword search — job title, skill or company (comma-separate for multiple searches, merged & de-duplicated). |
| `region` | Which market to search: India, Gulf, Singapore, Malaysia, Hong Kong or Indonesia. |
| `startUrls` | Scrape specific foundit search-results URLs directly. |
| `locations` | Filter by city / region (e.g. Bengaluru, Mumbai, Dubai). |
| `experienceMin` / `experienceMax` | Restrict to an experience band, in years. |
| `salaryMinLakhs` / `salaryMaxLakhs` | Filter by annual salary in INR Lakhs (India). |
| `employmentTypes` | Full-time and/or part-time only. |
| `functions` | Filter by foundit job function (e.g. Data Analysis). |
| `jobFreshness` | Only jobs posted within the last 1 / 3 / 7 / 15 / 30 days. |
| `sortBy` | Order by relevance or most recent. |
| `includeDetails` | Include each job's full description (text + HTML). On by default, no extra cost; turn off for a faster run. |
| `incrementalMode` | Emit only what changed since the last run. |
| `maxResults` | Cap the number of jobs per search (0 = unlimited). |
| `proxyConfiguration` | Optional — runs fine with no proxy at typical volumes. |

…and **31 inputs** in total — the table shows the essentials; the rest cover full-description tuning (max length), compact / drop-empty output, incremental tuning (state key, include unchanged / expired), notification channels and advanced options, all in the visual editor.

**Example inputs**

Newest data-analyst jobs in Bengaluru, 2–5 years' experience:

```json
{ "query": "data analyst", "region": "in", "locations": "Bengaluru", "experienceMin": 2, "experienceMax": 5, "sortBy": "date", "maxResults": 100 }
```

Full-time roles in the Gulf market, posted in the last week:

```json
{ "query": "sales manager", "region": "gulf", "employmentTypes": ["Full time"], "jobFreshness": "7", "maxResults": 200 }
```

Scheduled monitor — only what changed, with a Telegram ping:

```json
{ "query": "java developer, product manager", "region": "in", "incrementalMode": true, "telegramToken": "123:ABC", "telegramChatId": "@yourchannel" }
```

***

### 📤 Output

```json
{
  "id": "62692327",
  "title": "Data Analyst Senior II",
  "url": "https://www.foundit.in/job/data-analyst-senior-ii-fedex-bengaluru-bangalore-india-62692327",
  "applyUrl": "https://www.linkedin.com/jobs/view/4454001914/",
  "source": "www.foundit.in",
  "searchKeyword": "data analyst",
  "company": "FedEx",
  "companyId": "488066",
  "companyUrl": "https://www.foundit.in/search/fedex-488066-jobs-career",
  "companyLogo": "https://media.monsterindia.com/logos/xSP_fedexinx/jdlogo.gif",
  "companyIndustry": "Other",
  "recruiterName": "FedEx",
  "employerType": "Company",
  "location": "Bengaluru, India",
  "country": "India",
  "employmentTypes": ["Full time"],
  "industries": ["Other"],
  "functions": ["Data Analysis"],
  "skills": ["Teradata", "Advanced Statistics", "SAS", "SQL Server", "Big Data",
    "Predictive Modelling", "Tableau", "Power BI", "Azure", "Python"],
  "experienceMin": 2,
  "experienceMax": 5,
  "experienceText": "2-5 Years",
  "salaryMin": 0.0,
  "salaryMax": 0.0,
  "salaryCurrency": "INR",
  "salaryConfidential": false,
  "applicantCount": 41,
  "applicantVolumeLabel": "Moderate (10-49 applicants)",
  "isUrgentlyHiring": false,
  "isFresh": true,
  "postedText": "15 hours ago",
  "postedAt": "2026-08-14T18:10:25+00:00",
  "updatedAt": "2026-08-14T18:10:25+00:00",
  "expiresAt": "2026-09-27T18:30:00+00:00",
  "scrapedAt": "2026-08-15T09:34:42Z"
}
```

***

### ♻️ How to monitor foundit with incremental mode

Schedule the actor and turn on **incremental mode**: each run compares against the last and emits only **NEW / UPDATED / EXPIRED** records — unchanged jobs are skipped *before* their record is built, so a daily watch costs a fraction of a full re-scrape. Reposted jobs are tagged too, so you don't count the same vacancy twice.

| Daily churn | of 1,000 tracked | billable records | you save |
|---|---|---|---|
| 5 % | 1,000 | 50 | **95 %** |
| 15 % | 1,000 | 150 | **85 %** |
| 30 % | 1,000 | 300 | **70 %** |

The first run seeds the baseline and bills in full; every run after that bills only the delta.

***

### 🔔 How to set up foundit alerts

Get pinged the moment a matching record appears. Fill in only the channels you want:

| Channel | What to configure |
|---|---|
| ✈️ **Telegram** | `telegramToken` (from @BotFather) + `telegramChatId` |
| 💬 **Slack** | `slackWebhookUrl` (Incoming Webhook URL) |
| 🎮 **Discord** | `discordWebhookUrl` (channel webhook URL) |
| 🪝 **Webhook** | `webhookUrl` receives structured JSON — ideal for n8n / Make / Zapier |

Credentials are secret inputs — encrypted at rest, masked in the UI and never written to the
run log. Every channel fires independently, so a broken channel can't stop the scrape or the
others. Pair **incremental mode** with **notify only about changes** to hear only about
genuinely new records, with no duplicates across runs.

### 💡 What can you do with foundit data?

- **Recruiting & market intelligence** — track which companies are hiring, for which skills and functions, at what experience and salary bands across six markets.
- **Salary & skills research** — analyse structured pay bands and the most-demanded skills by role, city and industry.
- **Low-competition sourcing** — use `applicantCount`, `applicantVolumeLabel` and `isUrgentlyHiring` to find fresh, low-competition or urgent roles first.
- **Vacancy monitoring** — schedule it with incremental mode + notifications for a live feed of new and updated postings.
- **Job boards & aggregation** — feed clean, typed job data into your own app, sheet or warehouse.
- **AI agents & pipelines** — compact output plugs straight into LLM/MCP workflows.

***

### 💰 How much does it cost to scrape foundit?

This Actor uses Apify's **pay-per-event** model: a small fee when a run starts, plus a
per-record fee. See the Actor's **Pricing** tab for the current numbers — they're rendered
live, so this page never goes stale.

Two things cut your bill further:

- **Site-side filters** — records you filtered out are never fetched and never billed.
- **Incremental mode** — after the baseline run you pay only for what actually changed.

| Daily churn | of 1,000 tracked | billable records | you save |
|---|---|---|---|
| 5 % | 1,000 | 50 | **95 %** |
| 15 % | 1,000 | 150 | **85 %** |
| 30 % | 1,000 | 300 | **70 %** |

### 🔌 Integrations & export

Export to **JSON, CSV, Excel** or an HTML table, or pull from the **REST API** and the **JavaScript / Python** clients. Runs on a **schedule**, connects to **Google Sheets, Slack, Make, Zapier and n8n**, and works as an **MCP tool** for AI agents — compact mode keeps token usage small.

***

### 🔗 Using the API

Run this Actor from your own code. Example with the Apify Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run = client.actor("corvuslab/foundit-jobs-scraper").call(run_input={
        "query": "example",
        "maxResults": 50,
    })

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

It also works with the JavaScript/TypeScript client, the Apify CLI and the REST API.

### ❓ FAQ

**Which markets are covered?** India (foundit.in), the Gulf / Middle East, Singapore, Malaysia, Hong Kong and Indonesia — pick one per run with the `region` setting; each returns its own jobs and local salary currency.

**Do I need a proxy or login?** No — it runs out of the box with no login and no proxy; Apify Proxy is available under Advanced for high-volume runs.

**Do I get skills and salary without a second fetch?** Yes — skills, functions, industries, structured salary, experience and applicant demand all come back in the search pass, with no extra per-job request.

**Do I get the full job description?** Yes, by default — every job includes its complete `description` (text) and `descriptionHtml` at the same flat per-result price. Reading each job's page takes a few seconds per job; turn `includeDetails` off when you only need the structured fields and want the run to finish in seconds.

**Can I get only new items on a schedule?** Yes — turn on incremental mode and schedule it; each run emits only what changed and can notify your channel.

**What formats can I export?** JSON, CSV, Excel, HTML table, or via the API.

**Is it good for AI agents?** Yes — enable compact mode; the output is MCP-friendly.

**How many records can I get?** As many as the search returns — set `maxResults` (0 = unlimited).

**Is scraping this legal?** The actor collects only **publicly available** data. You are responsible for how you use it, including any personal data and GDPR-style obligations.

***

### ⚖️ Is it legal to scrape foundit?

This actor accesses only publicly available data on foundit. You are responsible for how you use the extracted data — in particular any personal information — and for complying with the site's terms and applicable law (including the GDPR where it applies). Not affiliated with, endorsed by, or sponsored by foundit or Monster.

***

**Keywords:** foundit scraper · foundit api · foundit.in scraper · foundit jobs scraper · monster jobs scraper · india jobs scraper · gulf jobs scraper · singapore jobs data · job listings scraper · recruitment data · salary data scraper · skills data · job market research · applicant demand · job monitoring · export jobs to CSV · export to Excel · no-code scraper · MCP tool for AI agents

# Changelog

This Actor's version history is a separate document: https://apify.com/corvuslab/foundit-jobs-scraper/changelog.md

# Actor input Schema

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

Job keywords, e.g. 'data analyst' or 'java developer'. Separate multiple searches with commas — each runs on its own and results are merged and de-duplicated.

## `region` (type: `string`):

Which foundit regional site to search. Each market has its own jobs and local currency.

## `startUrls` (type: `array`):

Paste foundit search-results URLs to scrape directly (e.g. a filtered search page). The keyword and market above are ignored for these.

## `sortBy` (type: `string`):

Order results by keyword relevance or by most recently posted.

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

Maximum number of jobs to return per search. Set 0 for unlimited (bounded by how many the search has).

## `locations` (type: `string`):

City or region name, e.g. 'Bengaluru' or 'Mumbai'. Comma-separate several cities. Leave blank for the whole market.

## `experienceMin` (type: `integer`):

Only jobs asking for at least this many years of experience. 0 = fresher.

## `experienceMax` (type: `integer`):

Only jobs whose experience band tops out at or below this many years.

## `salaryMinLakhs` (type: `integer`):

Minimum annual salary in INR Lakhs (India). Most listings mark salary confidential and won't match a salary filter — leave blank unless you specifically want salary-disclosed roles. Ignored for non-INR markets.

## `salaryMaxLakhs` (type: `integer`):

Maximum annual salary in INR Lakhs (India).

## `employmentTypes` (type: `array`):

Restrict to full-time or part-time roles. Leave empty for all.

## `jobFreshness` (type: `string`):

Only jobs posted within the last N days.

## `functions` (type: `string`):

Optional job-function filter, e.g. 'Data Analysis' or 'Software Development'. Comma-separate several. Must match foundit's function names; unknown values simply return nothing.

## `ignoreUrlFailures` (type: `boolean`):

Skip start URLs that cannot be interpreted instead of failing the whole run.

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

Include each job's complete description (plain text + HTML). On by default at no extra cost; switch off for a faster run without descriptions.

## `descriptionMaxLength` (type: `integer`):

Truncate each description to at most this many characters (0 = no limit). Only applies when full descriptions are on.

## `compact` (type: `boolean`):

Emit only the core fields (title, company, location, salary, experience, skills, apply URL). Ideal for AI agents and MCP clients.

## `excludeEmptyFields` (type: `boolean`):

Remove null, empty-string and empty-array fields from each record.

## `incrementalMode` (type: `boolean`):

Track state between runs and tag every job with a changeType (NEW / UPDATED / UNCHANGED / EXPIRED). You are billed per new/changed job, not for the whole feed each run.

## `stateKey` (type: `string`):

Stable name for the tracked search. Leave empty to derive one automatically from your search settings.

## `emitUnchanged` (type: `boolean`):

Also emit jobs that have not changed since the previous run.

## `emitExpired` (type: `boolean`):

Emit records for jobs present last run but gone now.

## `telegramToken` (type: `string`):

Bot token from @BotFather.

## `telegramChatId` (type: `string`):

Chat or channel ID, e.g. "-100123456789" or "@yourchannel".

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL.

## `discordWebhookUrl` (type: `string`):

Discord incoming-webhook URL.

## `webhookUrl` (type: `string`):

Any HTTPS endpoint. Receives a JSON POST with the matched jobs — works with n8n, Make and Zapier.

## `webhookHeaders` (type: `object`):

Extra headers for the webhook request, e.g. {"Authorization": "Bearer xyz"}.

## `notificationLimit` (type: `integer`):

How many jobs to include in each notification message.

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

Optional. foundit's search API works over a plain direct connection — no proxy is needed for the cheapest run. Add a proxy only if you scale up volume and start seeing blocks.

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed request before giving up on it.

## Actor input object example

```json
{
  "query": "data analyst",
  "region": "in",
  "sortBy": "relevance",
  "maxResults": 25,
  "jobFreshness": "",
  "ignoreUrlFailures": true,
  "includeDetails": true,
  "descriptionMaxLength": 0,
  "compact": false,
  "excludeEmptyFields": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "notificationLimit": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `allItems` (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 = {
    "query": "data analyst"
};

// Run the Actor and wait for it to finish
const run = await client.actor("corvuslab/foundit-jobs-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "query": "data analyst" }

# Run the Actor and wait for it to finish
run = client.actor("corvuslab/foundit-jobs-scraper").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 '{
  "query": "data analyst"
}' |
apify call corvuslab/foundit-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

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/srNSP54DzD6mgJmJP/builds/iaL7FjbIrBhkQkVSo/openapi.json