# Foundit Jobs Scraper (`shahidirfan/foundit-jobs-scraper`) Actor

Introducing the Foundit Jobs Scraper, a lightweight actor for efficiently scraping job listings from Foundit (formerly Monster). Fast and robust. For best results and reliable data extraction, the use of residential proxies is strongly advised. Streamline your recruitment data gathering today!

- **URL**: https://apify.com/shahidirfan/foundit-jobs-scraper.md
- **Developed by:** [Shahid Irfan](https://apify.com/shahidirfan) (community)
- **Categories:** Jobs, Developer tools, Other
- **Stats:** 159 total users, 37 monthly users, 100.0% runs succeeded, 4 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 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.

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

### What does Foundit Jobs Scraper do?

Foundit Jobs Scraper collects structured job listings from Foundit.in, formerly Monster India. Search by job keyword and location, or provide a Foundit search URL, then receive job records with titles, companies, locations, salary details, experience, skills, descriptions, posting dates, and direct links.

The Actor is useful for recruitment research, hiring intelligence, job-board monitoring, salary analysis, career research, and employment datasets. Results are saved to an Apify dataset that you can inspect, export, schedule, or connect to another workflow.

### Why use Foundit Jobs Scraper?

- **Build hiring datasets** - Collect structured listings for specific roles, locations, industries, or experience levels.
- **Support recruitment research** - Compare employers, required skills, compensation text, and job requirements across current postings.
- **Monitor the Indian job market** - Schedule repeat runs to track new opportunities and changing demand.
- **Start with simple inputs** - Enter a keyword and location, or reuse a public Foundit search URL with its existing filters.
- **Use the results anywhere** - Download JSON, CSV, Excel, or XML files, or send completed runs to connected tools through Apify integrations.

### What data can you extract from Foundit.in?

Each dataset item represents one job listing. The Actor returns core job information together with available classification and description fields.

| Field | Type | Description |
|-------|------|-------------|
| `job_id` | String | Unique job identifier from the listing. |
| `title` | String | Job title. |
| `company` | String | Hiring company name. |
| `location` | String | Job city, region, or other location text. |
| `salary` | String | Salary or compensation text when published. |
| `experience` | String | Required experience range when available. |
| `skills` | Array | Skills associated with the job listing. |
| `employment_type` | String | Employment or job type, such as full time. |
| `industry` | String | Industry classification when available. |
| `function` | String | Job function or functional area. |
| `occupational_category` | String | Occupational category associated with the job. |
| `description_html` | String | Job description in the source's formatted representation. |
| `description_text` | String | Plain-text job description for analysis and search. |
| `url` | String | Direct Foundit listing URL. |
| `apply_url` | String | Application link when published by the source. |
| `date_posted` | String | Job posting date when available. |
| `valid_through` | String | Application or listing expiry date when available. |
| `source` | String | Source website identifier. |
| `page_no` | Number | Search result page where the listing was found. |
| `keyword` | String | Keyword used for the search. |
| `input_location` | String | Location filter used for the search. |
| `scraped_at` | String | ISO timestamp for when the record was collected. |

Some source postings do not publish every field. Missing values reflect the original listing and are not necessarily an indication of a failed run.

### How to use Foundit Jobs Scraper

1. Open the Actor on Apify.
2. Enter a job keyword and location, or paste a Foundit search URL.
3. Set the maximum number of jobs and search pages.
4. Add proxy settings when your run needs them, especially for larger collections.
5. Start the run and review the dataset preview.
6. Export the results or connect the dataset to your recruitment or analytics workflow.

### Input Parameters

All parameters are optional. If no search values are supplied, the Actor uses the prefilled software engineer search for Bangalore.

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `url` | String | No | `https://www.foundit.in/search/software-engineer-jobs-in-bangalore` | Foundit search URL. The Actor can derive the search filters from this URL. |
| `keyword` | String | No | `software engineer` | Job title, skill, or search phrase, such as `data analyst` or `Java developer`. |
| `location` | String | No | `Bangalore` | Location filter, such as Bangalore, Mumbai, Delhi, Chennai, or Hyderabad. |
| `results_wanted` | Integer | No | `20` | Maximum number of jobs to collect. Minimum: `1`. |
| `max_pages` | Integer | No | `20` | Maximum number of search result pages to process. Minimum: `1`. |
| `proxyConfiguration` | Object | No | - | Optional Apify Proxy settings for the run. Residential proxies can help with larger collections. |

### Output Data

The default dataset contains one JSON object per job listing. Use `description_text` for plain-text analysis and `url` or `apply_url` for source and application links.

| Field | Type | Description |
|-------|------|-------------|
| `title` | String | Position title. |
| `company` | String | Employer or recruiting company. |
| `location` | String | Location shown in the listing. |
| `experience` | String | Experience requirement. |
| `salary` | String | Salary information when available. |
| `skills` | Array | Extracted skill names. |
| `employment_type` | String | Employment type. |
| `date_posted` | String | Posting date. |
| `valid_through` | String | Closing or expiry date. |
| `url` | String | Job listing URL. |
| `apply_url` | String | Application URL when available. |
| `description_html` | String | Formatted description value from the listing. |
| `description_text` | String | Plain-text description. |
| `job_id` | String | Unique job identifier. |
| `keyword` | String | Search keyword used. |
| `input_location` | String | Search location used. |
| `scraped_at` | String | Collection timestamp. |

### Usage Examples

#### Basic Job Search

Collect software engineering jobs in Bangalore with a small result limit for an initial test.

```json
{
  "keyword": "software engineer",
  "location": "Bangalore",
  "results_wanted": 20
}
```

#### Search From a Foundit URL

Use a public Foundit search page when you already have the required search filters in the URL.

```json
{
  "url": "https://www.foundit.in/search/data-scientist-jobs-in-mumbai",
  "results_wanted": 100,
  "max_pages": 5
}
```

#### Larger Collection With Proxy Settings

Collect a larger set of marketing roles from Delhi and route the run through Apify Proxy.

```json
{
  "keyword": "marketing manager",
  "location": "Delhi",
  "results_wanted": 500,
  "max_pages": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Sample Output

The following example shows one dataset item. Optional values may be empty when they are not present in the source listing.

```json
{
  "source": "foundit.in",
  "url": "https://www.foundit.in/job/senior-software-engineer-12345",
  "apply_url": "https://www.foundit.in/apply/12345",
  "title": "Senior Software Engineer",
  "company": "Tech Solutions Pvt Ltd",
  "location": "Bangalore, Karnataka",
  "salary": "₹8,00,000 - ₹15,00,000 P.A.",
  "experience": "3-5 years",
  "skills": ["Java", "Spring Boot", "Microservices"],
  "employment_type": "Full Time",
  "industry": "IT Services",
  "function": "Engineering",
  "occupational_category": "Software Development",
  "description_text": "Join our team as a Senior Software Engineer and build services for business applications.",
  "date_posted": "2026-01-15T00:00:00.000Z",
  "valid_through": "2026-02-15T00:00:00.000Z",
  "job_id": "12345",
  "page_no": 1,
  "keyword": "software engineer",
  "input_location": "Bangalore",
  "scraped_at": "2026-01-15T10:30:00.000Z"
}
```

### Tips for Best Results

- Use a specific job title or skill phrase instead of a broad term when you need focused results.
- Test a keyword and location with `20` to `50` results before increasing the collection size.
- Use `url` when you need to preserve filters from an existing Foundit search page.
- Increase `max_pages` when the requested result count is larger than one page of results.
- Use proxy settings for larger runs and review the dataset preview before scheduling recurring collections.
- Check `date_posted` and `scraped_at` when comparing results from multiple scheduled runs.

### Integrations

- **Google Sheets** - Export job results for filtering, reporting, and review.
- **Webhooks** - Trigger a downstream workflow when a run finishes.
- **Make or Zapier** - Send new job records to alerts, databases, or internal tools.
- **Apify API** - Start runs and retrieve dataset items programmatically.
- **CSV, Excel, JSON, and XML** - Download results in formats suitable for analysis or data exchange.

### Frequently Asked Questions

#### Can I search for jobs by keyword and location?

Yes. Provide `keyword` and `location` to build a targeted Foundit search, or provide `url` to use an existing search page.

#### Can I collect jobs from multiple locations?

Yes. Run the Actor separately for each location and combine the datasets, or use location terms supported by the Foundit search page.

#### How many jobs can I collect?

You can request up to the number of matching listings available, subject to `results_wanted`, `max_pages`, source availability, and run limits.

#### Can I export Foundit data to CSV or Excel?

Yes. Apify datasets can be downloaded as CSV, Excel, JSON, XML, and other supported formats.

#### Can I schedule regular job searches?

Yes. Create an Apify schedule to run the Actor hourly, daily, weekly, or at a custom interval for monitoring workflows.

#### Why is a field empty?

Some job postings do not publish salary, experience, application, or expiry information. The Actor returns the data available in each listing.

#### Is it legal to collect Foundit data?

Public data collection can be subject to laws, privacy requirements, and website terms. You are responsible for using the Actor lawfully and respecting Foundit.in's rules and applicable limits.

### Related Actors

For other job-data workflows from the same developer profile, see:

- [TotalJobs Scraper](https://apify.com/shahidirfan/total-jobs-scraper) - Collect UK job listings for recruitment research and market monitoring.
- [Kununu Jobs Scraper](https://apify.com/shahidirfan/kununu-jobs-scraper) - Gather job and employer information from Kununu.
- [Stepstone Job Scraper 🔥](https://apify.com/shahidirfan/stepstone-job-scraper) - Collect structured job listings from Stepstone.de.
- [Ausbildung Jobs Scraper](https://apify.com/shahidirfan/ausbildung-jobs-scraper) - Collect apprenticeship and vocational training listings from Ausbildung.de.

### Support

For issues, feature requests, or target-specific questions, use the Issues tab on the Actor page or contact the developer through Apify.

### Legal Notice

This Actor is intended for legitimate collection of publicly available job information. Users are responsible for complying with Foundit.in terms, applicable laws, privacy requirements, and any restrictions that apply to their intended use of the data.

# Actor input Schema

## `url` (type: `string`):

Foundit search URL to derive filters from.

## `keyword` (type: `string`):

Job search keyword(s), for example: Software Engineer, Java Developer, Data Analyst.

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

Location filter, e.g., 'Bangalore', 'Mumbai', 'Delhi', 'Chennai', 'Hyderabad'.

## `results_wanted` (type: `integer`):

Maximum number of jobs to collect across all searches.

## `max_pages` (type: `integer`):

A safety cap on the number of search result pages to visit.

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

Use Apify Proxy when needed. Residential group is recommended for reliability.

## Actor input object example

```json
{
  "url": "https://www.foundit.in/search/software-engineer-jobs-in-bangalore",
  "keyword": "software engineer",
  "location": "Bangalore",
  "results_wanted": 20,
  "max_pages": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "url": "https://www.foundit.in/search/software-engineer-jobs-in-bangalore",
    "keyword": "software engineer",
    "location": "Bangalore",
    "results_wanted": 20,
    "max_pages": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("shahidirfan/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 = {
    "url": "https://www.foundit.in/search/software-engineer-jobs-in-bangalore",
    "keyword": "software engineer",
    "location": "Bangalore",
    "results_wanted": 20,
    "max_pages": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("shahidirfan/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 '{
  "url": "https://www.foundit.in/search/software-engineer-jobs-in-bangalore",
  "keyword": "software engineer",
  "location": "Bangalore",
  "results_wanted": 20,
  "max_pages": 20
}' |
apify call shahidirfan/foundit-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Z6Xi3IMluQiLOO0eR/builds/tEY6vSC1a64tBuhFT/openapi.json