# Foundit Monster India Jobs — 20 Fields, Monitor Mode (`themineworks/foundit-jobs-scraper`) Actor

Scrape Foundit.in (formerly Monster India) job search by keyword, city, experience, salary and job-freshness. Structured JSON: title, company, salary, skills, industry, apply URL. No login, plain HTTP, pay per job. Works in Claude, ChatGPT & any MCP AI agent.

- **URL**: https://apify.com/themineworks/foundit-jobs-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Jobs, Business, MCP servers
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.90 / 1,000 jobs

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## 💼 Foundit (Monster India) Jobs Scraper — Salary & Skills

> **Part of the Recruiting & Jobs MCP.** This actor's data is also available to AI agents through our [Recruiting & Jobs MCP server](https://apify.com/themineworks/recruiting-jobs-mcp) — seven job-market and sourcing tools behind one endpoint. No result, no charge.

### Overview

Foundit.in (rebranded from Monster India in 2023) is one of India's oldest and largest broad-market job boards, spanning IT, sales, operations, BFSI, manufacturing, and government-adjacent roles. This actor turns any Foundit search into structured jobs data — feed it keywords like `python developer` or `sales manager`, filter by city, experience band, salary, employment type, and posting freshness, and get clean JSON rows with title, company, experience range, disclosed salary, skills, industry, and the apply URL.

✅ No login required | ✅ Plain HTTP (no browser, no residential proxy needed) | ✅ Pay per job returned | ✅ MCP-ready for AI agents

### How it works

Foundit's search results page is powered by its own public search API (`/middleware/jobsearch`) — the same endpoint the website's front end calls. The actor calls it directly: no login, no cookies, no session warm-up. The one requirement is a same-origin `Referer` header, which the actor sets automatically. Because this is a plain, unauthenticated JSON endpoint, the actor runs as pure HTTP — no headless browser, no residential proxy tax. Verified live: dozens of sequential requests from a plain datacenter connection with zero blocks or captchas.

Filters are passed straight through to Foundit as query facets, so Foundit does the filtering server-side: experience as a `min~max` year range, salary as an absolute-INR range (the actor converts your lakh inputs automatically), employment type, and posting freshness in days.

The search response does not include the full job description — only a summary. When `includeJobDescription` is enabled, the actor fetches each job's own detail page (one extra request per job) and reads the clean `schema.org JobPosting` JSON-LD block embedded in it, carrying the full description, responsibilities, qualifications, and structured posting/expiry dates.

Each keyword is searched separately; results are merged and deduplicated by Foundit's internal job ID.

### 🧾 Input configuration

```json
{
  "searchKeywords": ["python developer", "data analyst"],
  "location": "Bangalore",
  "experienceMinYears": 2,
  "experienceMaxYears": 6,
  "employmentType": "Full Time",
  "postedWithinDays": "7",
  "maxJobs": 200,
  "includeJobDescription": false
}
```

| Field | Description |
| --- | --- |
| `searchKeywords` | One or more keywords, searched separately and merged |
| `location` | City or comma-separated cities (e.g. `Bangalore,Mumbai`); blank = all India |
| `experienceMinYears` / `experienceMaxYears` | Years of experience band |
| `salaryMinLakhs` / `salaryMaxLakhs` | Annual CTC in ₹ lakhs (most listings mark salary confidential — see FAQ) |
| `employmentType` | `Full Time` or `Part Time` |
| `postedWithinDays` | `1`, `3`, `7`, `15`, or `30` |
| `maxJobs` | Cap on total jobs returned across all keywords (max 1000) |
| `includeJobDescription` | Fetch each job's full description (adds one request per job) |
| `monitorMode` | Deliver only new jobs vs. the previous run (see below) |
| `proxyConfiguration` | Optional; off by default — the search API works over plain datacenter traffic |

### 📤 Output format

```json
{
  "job_id": "60809368",
  "title": "Full stack (Python) Developer - Software Engineer II",
  "company": "Deloitte",
  "location": "Bengaluru, India",
  "experience_min_years": 3,
  "experience_max_years": 5,
  "salary_confidential": false,
  "salary_min_lakhs": null,
  "salary_max_lakhs": null,
  "employment_type": "Full time",
  "industries": ["Other"],
  "functions": ["Software Engineering"],
  "skills": ["PostgreSQL", "Redis", "Git", "Docker", "Flask", "FastAPI", "react.js", "Python"],
  "posted_date_text": "a day ago",
  "posted_days_ago": 1,
  "total_applicants": 46,
  "is_urgently_hiring": false,
  "apply_url": "https://www.foundit.in/job/full-stack-python-developer-software-engineer-ii-deloitte-bengaluru-bangalore-india-60809368"
}
```

Every job record contains these fields:

| Field | Description |
| --- | --- |
| 🆔 `job_id` | Foundit internal job ID |
| 📌 `title` | Job title |
| 🏢 `company` | Company / recruiter-listed name |
| 📍 `location` | Job location(s) as listed on Foundit |
| ⌛ `experience_min_years` / `experience_max_years` | Years of experience required |
| 💰 `salary_confidential` | True if the employer hid salary (most listings) |
| 💵 `salary_min_lakhs` / `salary_max_lakhs` | Disclosed salary in ₹ lakhs (null if confidential) |
| 🏠 `employment_type` | Full time or part time |
| 🏭 `industries` / `functions` | Industry and functional-area tags |
| 🛠️ `skills` | Tagged skills as an array |
| 🗓️ `posted_date_text` / `posted_days_ago` | Relative and numeric posting age |
| 👥 `total_applicants` | Applicant count Foundit reports |
| 🔗 `apply_url` | URL to the Foundit job detail / apply page |
| 📝 `description`, `responsibilities`, `qualifications`, `date_posted`, `valid_through` | Only populated when `includeJobDescription: true` |

**One more row at the end of every run:** every run also ends with a final `_type: "info"` record — informational only, never billed — with a two-line nudge: how to put this actor on an automatic schedule, and a link to leave a Store review if it saved you time.

### 💼 Common use cases

**Compensation & role benchmarking** — pull every mid-level analyst role in a city and track how experience bands map to disclosed salary where employers choose to publish it.

**Competitor hiring intelligence** — track how many roles a company has open on Foundit, in which functions, and how urgently they're marked as hiring.

**Talent sourcing** — feed roles into an ATS or sourcing tool, or build a jobs digest for a specific function (finance ops, sales, customer support) refreshed daily.

**Jobs board & aggregator** — power a niche jobs site or newsletter with fresh Foundit listings pulled by keyword, city, or industry.

### 🚀 Getting started

1. Open the actor and add one or more search keywords (`python developer`, `sales manager`).
2. Set a location (`Bangalore`, `Mumbai`, `Delhi NCR`) or leave blank for all India.
3. Optionally add experience, salary, employment-type, and freshness filters.
4. Set max jobs to return.
5. Click Start. Download as JSON, CSV, or Excel, or pull the dataset via API or MCP.

### 🔁 Run on a schedule

Turn this from a one-off pull into a standing feed with Apify's built-in Schedules — no code, no cron server of your own.

1. Run the actor once with the input you want repeated, then click **Save as a task** (top of the run form) — this keeps your exact input attached for every future run.
2. In the Apify Console, go to **Schedules** → **Create new**, pick a frequency (preset or cron, e.g. `0 6 * * *` for daily at 6am).
3. Under **Actors or tasks to run**, add the task from step 1, and save. It now runs unattended, billed the same pay-per-job way as a manual run.

Or automate the setup itself via the API:

```bash
curl -X POST "https://api.apify.com/v2/schedules?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"name":"foundit-jobs-daily","cronExpression":"0 6 * * *","isEnabled":true,
       "actions":[{"type":"RUN_ACTOR","actorId":"themineworks/foundit-jobs-scraper"}]}'
```

Full options — time zones, run notifications, pausing — are in Apify's [Schedules documentation](https://docs.apify.com/platform/schedules).

#### Monitor mode — pay only for NEW jobs

Set `monitorMode: true` and the actor remembers what it delivered last time (keyed on `job_id`) — on the next scheduled run, only genuinely new jobs are pushed and charged, not the whole feed every time. Pairs directly with a daily schedule for a standing "what's new" feed with no duplicate charges. The summary row reports `new_this_run` and `skipped_duplicates`. First run establishes the baseline (everything is "new"); every run after that is incremental.

### FAQ

**Does it log in to Foundit?**
No. The actor calls Foundit's own public search API directly, the same one the website's front end uses. No account, no cookies, no captcha.

**Why is `salary_min_lakhs` null on most jobs?**
Foundit lets employers mark salary "confidential", and most listings do — `salary_confidential: true` flags those rows. Numeric salary only appears when the employer chose to disclose it. This mirrors what you'd see browsing the site directly.

**Does it need a residential proxy like Naukri?**
No. Foundit's search endpoint is unauthenticated and worked over plain datacenter connections in extensive testing, with no blocks. A `proxyConfiguration` input is still available if you scale up volume and want the option, but it's off by default to keep runs cheap.

**How do I get the full job description?**
Set `includeJobDescription: true`. This fetches each job's own detail page and reads its embedded structured data — one extra request per job, so it's off by default for speed.

**Can I use it in an AI agent?**
Yes. It's exposed as an MCP tool. See below.

### Use in Claude, ChatGPT & any MCP agent

```
https://mcp.apify.com/?tools=themineworks/foundit-jobs-scraper
```

Or call it programmatically with the Apify client:

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('themineworks/foundit-jobs-scraper').call({
  searchKeywords: ['python developer'],
  location: 'Bangalore',
  maxJobs: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### 🛠️ Complete your hiring intelligence pipeline

Found the roles. Now enrich and act on them with the rest of the suite:

- **[Naukri Jobs Scraper](https://apify.com/themineworks/naukri-jobs)**: cross-reference the same role against India's largest job board for salary and demand comparison.
- **[LinkedIn Company Scraper](https://apify.com/themineworks/linkedin-company-details)**: profile the hiring company: size, industry, HQ.
- **[LinkedIn Employees Scraper](https://apify.com/themineworks/linkedin-employees)**: find the recruiters and hiring managers at any of the companies.

Typical flow: foundit-jobs surfaces broad-market roles, linkedin-company-details profiles the employer, linkedin-employees finds the hiring team.

Questions or need a custom field set? Reach out through the Apify profile.

# Actor input Schema

## `searchKeywords` (type: `array`):

One or more job-search keywords. Each keyword is searched separately and results are merged and deduplicated.

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

City or region, e.g. 'Bangalore', 'Mumbai', 'Delhi NCR'. Comma-separate multiple cities, e.g. 'Bangalore,Mumbai'. Leave blank for all India.

## `experienceMinYears` (type: `integer`):

Minimum years of experience. 0 = fresher.

## `experienceMaxYears` (type: `integer`):

Maximum years of experience.

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

Minimum annual CTC in INR Lakhs. Note most Foundit listings mark salary 'confidential' and will not match a salary filter — leave blank unless you specifically want salary-disclosed roles.

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

Maximum annual CTC in INR Lakhs.

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

Full-time or part-time roles only. Leave blank for all.

## `postedWithinDays` (type: `string`):

Only show jobs posted within the last N days.

## `maxJobs` (type: `integer`):

Maximum number of jobs to scrape across all keywords. Hard cap 1000.

## `includeJobDescription` (type: `boolean`):

If true, fetch each job's detail page (one extra HTTP request per job) for the full description, responsibilities, and qualifications. If false (default), results return fast from the search API alone without a description field.

## `monitorMode` (type: `boolean`):

Run on a schedule and deliver ONLY results not seen in a previous run. You are charged per new result, not for the whole feed each time. Ideal for daily monitoring. Requires the same input across runs.

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

Optional. Foundit's search API works over a plain datacenter connection in testing — no residential proxy is required. Leave this off for the cheapest run; add a proxy only if you scale up volume and start seeing blocks.

## Actor input object example

```json
{
  "searchKeywords": [
    "python developer",
    "data analyst"
  ],
  "location": "Bangalore",
  "maxJobs": 5,
  "includeJobDescription": false,
  "monitorMode": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "searchKeywords": [
        "python developer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/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 = { "searchKeywords": ["python developer"] }

# Run the Actor and wait for it to finish
run = client.actor("themineworks/foundit-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchKeywords": [
    "python developer"
  ]
}' |
apify call themineworks/foundit-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/BbMAA26fIKV7U5g4v/builds/gpyLrV3S4jgONAtXS/openapi.json