# Foundit Scraper - Jobs, Salaries, Skills & Recruiter Leads (`scrapesage/foundit-scraper`) Actor

Scrape Foundit (formerly Monster) jobs across India, the Gulf & SE Asia — title, salary, experience, skills, company profile & recruiter phone leads. Filters, full descriptions & monitor mode.

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

## Pricing

from $4.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

## Foundit Scraper — Jobs, Salaries, Skills & Recruiter Leads (India, Gulf & SE Asia)

Extract **complete job data from Foundit** (formerly **Monster** — foundit.in, founditgulf.com, foundit.sg/.my/.ph/.id/.hk) — the fields other scrapers leave empty: **structured salary and experience ranges, full skill lists, industry & function taxonomy, company profile, and the recruiter's direct phone number** where the posting exposes it. Optionally add the **full job description** and a **deduplicated recruiter/company lead list** for staffing and B2B outreach.

No login, no cookies, no browser — fast JSON extraction from Foundit's own search API, pinned to in-region residential IPs for reliability.

### Why this Foundit scraper?

Most Foundit/Monster scrapers only parse the search cards and stop at title + company. This actor reads Foundit's internal `middleware/jobsearch` API and ships the **richest dataset in the category** — jobs *and* leads in one run.

| Data | Typical scrapers | This actor |
|---|---|---|
| Job title, company, location | ✅ | ✅ |
| Structured min/max **salary** + currency (annual & monthly) | ❌ partial | ✅ |
| Min/max **experience** range | ❌ | ✅ |
| Full **skills** list (+ synonyms) | ❌ | ✅ |
| Industry / function / designation taxonomy | ❌ | ✅ |
| Company profile + logo + Great-Place-To-Work flag | ❌ | ✅ |
| **Recruiter name + direct phone** (lead) | ❌ | ✅ where exposed |
| Deduplicated **recruiter/company lead list** | ❌ | ✅ opt-in |
| Full job **description** | ❌ | ✅ opt-in |
| Apply URL / external ATS URL | partial | ✅ |
| Posted date, freshness, closing date | partial | ✅ |
| Lead score (0–100) | ❌ | ✅ |
| Monitor mode (only new / changed) | ❌ | ✅ |
| Regions: India + Gulf + SE Asia in one actor | ❌ single site | ✅ 7 markets |

### Use cases

- **Recruitment & sourcing** — pull live openings by title, city, experience, and salary across India, the Gulf, and SE Asia; benchmark compensation and in-demand skills.
- **Staffing & B2B lead generation** — turn postings into leads: recruiter name, company profile, and (on SME/staffing postings) the recruiter's **direct phone number**. Score by `leadScore` and export straight to your CRM.
- **Job boards & aggregators** — feed your board or newsletter with structured, deduplicated job data including salary and skills.
- **Labour-market intelligence** — track hiring volume, salary bands, and skill demand by role, industry, and city over time.
- **Competitor & client monitoring** — schedule daily runs with monitor mode to catch only newly posted or changed jobs for specific companies or queries.

### How to use

1. [Sign up for Apify](https://console.apify.com/sign-up) — the free plan is enough to try this actor.
2. Open the **Foundit Scraper**, pick a **region**, enter **search queries** (and optional **locations**), then click **Start**.
3. Watch job records stream into the dataset table.
4. **Export** as JSON, CSV, Excel, or XML — or pull results programmatically via the [Apify API](https://docs.apify.com/api/v2).

### Input

```json
{
    "region": "india",
    "searchQueries": ["software engineer", "data analyst"],
    "locations": ["Bangalore", "Mumbai"],
    "sortBy": "date",
    "freshnessDays": 7,
    "includeRecruiterLeads": true,
    "includeDescription": false,
    "maxResults": 100
}
````

- **region** — `india` (foundit.in), `gulf` (founditgulf.com), `singapore`, `malaysia`, `philippines`, `indonesia`, `hongkong`.
- **searchQueries** — job titles / keywords, combined with every location.
- **locations** — optional cities/regions (e.g. `Bangalore`, `Dubai`, `Singapore`). Leave empty to search the whole region.
- **startUrls** — paste Foundit search-result or individual job URLs; each is auto-detected.
- **sortBy** — `relevance`, `date`, or `salary`. **freshnessDays** — keep only jobs posted within N days (0 = no limit).
- **includeDescription** *(default false)* — fetch each job's page for the full description (one extra request per job).
- **includeRecruiterLeads** *(default false)* — also emit one deduplicated `recruiterLead` record per recruiter/company, with direct phone when the posting exposes it.
- **experienceYears / salaryMin / employmentType / industry / keyword** — client-side filters.
- **maxResults** *(default 100)* — set `0` for no limit (explicit opt-in; use with a run timeout).
- **monitorMode** *(default false)* — output only new/changed jobs across runs; pairs with [Schedules](https://docs.apify.com/platform/schedules).

### Output

One record per job (`type: "job"`), plus optional recruiter/company leads (`type: "recruiterLead"`):

```json
{
    "type": "job",
    "jobId": "57626955",
    "title": "Senior Platform Software Engineer",
    "company": "Oracle",
    "companyProfile": "Oracle Corporation is an American multinational computer technology corporation…",
    "companyLogoUrl": "https://media.foundit.in/logos/…/jdlogo.gif",
    "isGreatPlaceToWork": false,
    "location": "Bengaluru",
    "region": "india",
    "experienceLabel": "6-10 Years",
    "minExperienceYears": 6,
    "maxExperienceYears": 10,
    "salaryLabel": "20-32 Lakhs",
    "salaryCurrency": "INR",
    "minSalary": 2000000,
    "maxSalary": 3200000,
    "salaryConfidential": false,
    "skills": ["Software Architecture", "Debugging", "API versioning", "Software testing"],
    "designations": ["Software Engineer/Programmer"],
    "industries": ["IT/Computers - Hardware & Networking"],
    "functions": ["Software Development"],
    "employmentTypes": ["Full time"],
    "recruiterName": "Priya Sharma",
    "recruiterId": "704548",
    "recruiterPhone": "9876543210",
    "showContactDetails": true,
    "applyUrl": "https://careers.oracle.com/jobs/…",
    "jobUrl": "https://www.foundit.in/job/senior-platform-software-engineer-oracle-india-57626955",
    "isExternalApply": false,
    "postedAt": "2026-07-01T12:25:01.000Z",
    "postedLabel": "5 hours ago",
    "closingAt": "2026-08-15T18:30:00.000Z",
    "isUrgentlyHiring": false,
    "leadScore": 90,
    "searchQuery": "software engineer",
    "searchLocation": "Bangalore",
    "scrapedAt": "2026-07-02T04:00:00.000Z"
}
```

```json
{
    "type": "recruiterLead",
    "recruiterName": "Priya Sharma",
    "recruiterPhone": "9876543210",
    "company": "Acme Staffing LLP",
    "companyProfile": "Recruitment & staffing services across IT and BFSI…",
    "industries": ["Recruitment/Staffing"],
    "regionLabel": "India",
    "sampleJobTitle": "Telecaller",
    "sampleJobUrl": "https://www.foundit.in/job/telecaller-acme-delhi-58120033",
    "jobCountInRun": 6,
    "leadScore": 95,
    "scrapedAt": "2026-07-02T04:00:00.000Z"
}
```

### Automate & schedule

Run this actor on autopilot and pull results into your own stack:

- **[Apify API](https://docs.apify.com/api/v2)** — start runs, fetch datasets, and manage schedules over REST.
- **[apify-client for JavaScript](https://docs.apify.com/api/client/js/)** and **[apify-client for Python](https://docs.apify.com/api/client/python/)** — official SDKs.
- **[Schedules](https://docs.apify.com/platform/schedules)** — run it daily with `monitorMode` + `freshnessDays` to capture only new postings; perfect for job boards and lead pipelines.
- **[Webhooks](https://docs.apify.com/platform/integrations/webhooks)** — trigger downstream actions (CRM import, Slack alert, email sequence) the moment a run finishes.

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

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

const run = await client.actor('scrapesage/foundit-scraper').call({
    region: 'india',
    searchQueries: ['data analyst'],
    locations: ['Bangalore'],
    includeRecruiterLeads: true,
    maxResults: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Got ${items.length} jobs & recruiter leads`);
```

### Integrate with any app

Connect the dataset to 5,000+ apps — no code required:

- **[Make](https://docs.apify.com/platform/integrations/make)** — multi-step automation scenarios.
- **[Zapier](https://docs.apify.com/platform/integrations/zapier)** — push new recruiter leads straight into your CRM.
- **[Slack](https://docs.apify.com/platform/integrations/slack)** — get notified when a monitored search finds new jobs.
- **[Google Drive / Sheets](https://docs.apify.com/platform/integrations/drive)** — auto-export every run to a spreadsheet.
- **[Airbyte](https://docs.apify.com/platform/integrations/airbyte)** — pipe results into your data warehouse.
- **[GitHub](https://docs.apify.com/platform/integrations/github)** — trigger runs from commits or releases.

### Use with AI assistants (MCP)

The output is clean, LLM-ready JSON. You can call this actor from Claude, ChatGPT, or any agent framework through the **[Apify MCP server](https://docs.apify.com/platform/integrations/mcp)** — ask your assistant to "find data-analyst jobs in Bangalore posted this week and list recruiter contacts" and let it run this scraper for you.

### Agent-ready: autonomous payments (x402 & Skyfire)

This actor is **agent-ready** — AI agents can discover it, run it, and **pay for it autonomously**, with no Apify account and no human in the loop. It uses [pay-per-event](https://docs.apify.com/platform/actors/publishing/monetize/pay-per-event) pricing and [limited permissions](https://docs.apify.com/platform/actors/development/permissions), so it qualifies for Apify's agentic-payment standards:

- **[x402](https://docs.apify.com/platform/integrations/x402)** — an open, HTTP-native payment protocol. Agents pay per run in USDC on the Base network directly through the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp) — no account, no API key.
- **[Skyfire](https://docs.apify.com/platform/integrations/skyfire)** — agent-to-service payments for fully autonomous AI-agent workflows.

Building an AI agent, MCP tool, or autonomous data pipeline? This scraper is ready to plug in and pay as it goes.

### More scrapers from scrapesage

Build a complete **hiring, jobs & B2B-lead stack**:

- **[LinkedIn Jobs Scraper](https://apify.com/scrapesage/linkedin-jobs-scraper)** — filter-based job postings, no login.
- **[Multi-ATS Job Scraper](https://apify.com/scrapesage/multi-ats-job-scraper)** — Greenhouse, Lever, Ashby & Workday boards.
- **[Glassdoor Scraper](https://apify.com/scrapesage/glassdoor-scraper)** — company reviews, ratings & interviews.
- **[JobStreet Singapore Scraper](https://apify.com/scrapesage/jobstreet-singapore-scraper)** — SEA jobs, salaries & company leads.
- **[Glints Scraper](https://apify.com/scrapesage/glints-scraper)** — SEA jobs, salaries & company leads.
- **[IndiaMART Scraper](https://apify.com/scrapesage/indiamart-scraper)** — India B2B supplier & product leads.
- **[LinkedIn Company Scraper](https://apify.com/scrapesage/linkedin-company-scraper)** — firmographics & B2B leads.
- **[Google Maps Scraper](https://apify.com/scrapesage/google-maps-scraper)** — local business places, leads & contacts.
- **[Website Contact Scraper](https://apify.com/scrapesage/website-contact-scraper)** — emails, phones & socials from any site.

### Tips

- **Coverage**: Foundit caps deep pagination per query. To exhaust a big market, split runs by query and/or by `locations` (city by city), and use `sortBy: "date"` with `freshnessDays` for recency.
- **Leads**: turn on `includeRecruiterLeads` and sort by `leadScore` — SME/staffing postings are where the recruiter's direct phone appears.
- **Cost control**: leave `includeDescription` off unless you need full JD text — the search record already carries salary, skills, company and recruiter data.
- **Proxies**: keep the default in-region residential proxy for best success.

### FAQ

**Is Foundit the same as Monster?** Yes — Monster's APAC & Middle-East business was rebranded **Foundit**. This actor covers foundit.in (India), founditgulf.com (Gulf/MENA), and foundit.sg/.my/.ph/.id/.hk.

**Do I need a Foundit login or API key?** No. The actor reads Foundit's own public search endpoint — no account, cookies, or browser needed.

**Where do recruiter phone numbers come from?** From the posting itself. Foundit publishes the recruiter's direct number on SME/staffing postings that opt in (`showContactDetails`); large corporates usually hide it, so `recruiterPhone` is populated for the subset that exposes it — never fabricated.

**Why is `salary` sometimes empty?** Many employers mark salary confidential. The actor sets `salaryConfidential: true` and leaves the numbers `null` rather than guessing.

**Can I export to Google Sheets, CSV, or Excel?** Yes — one click in the dataset view, or automatically every run via the [Google Drive integration](https://docs.apify.com/platform/integrations/drive).

**How do I monitor new jobs automatically?** Turn on `monitorMode`, set `freshnessDays`, and create a [Schedule](https://docs.apify.com/platform/schedules); optionally add a [webhook](https://docs.apify.com/platform/integrations/webhooks) to push new leads into your CRM.

**Is scraping Foundit legal?** This actor collects publicly available data only. You are responsible for using the data in compliance with applicable laws (e.g. GDPR/CCPA and India's DPDP Act for personal data) and Foundit's terms.

### Need help?

Open an issue on the actor's **Issues** tab, or visit the [Apify help center](https://help.apify.com/). Feature requests are welcome — this actor is actively maintained.

# Actor input Schema

## `searchQueries` (type: `array`):

Job titles or keywords to search on Foundit, e.g. "software engineer", "data analyst", "accountant". Each query is combined with every location below.

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

Which Foundit market to search. India (foundit.in) and Gulf/Middle East (founditgulf.com) are the largest. SE-Asia sites use the same engine.

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

City / region filters, e.g. "Bangalore", "Mumbai", "Dubai", "Singapore". Leave empty to search the whole region. Each location is combined with every query.

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

Paste Foundit search-result URLs or individual job URLs (…/job/…). Each is auto-detected and scraped.

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

Result ordering requested from Foundit.

## `freshnessDays` (type: `integer`):

Keep only jobs posted within this many days (e.g. 1, 3, 7, 15, 30). 0 = no date limit. Ideal for daily monitoring runs.

## `includeDescription` (type: `boolean`):

Fetch each job's page for the complete job description (one extra request per job). Off by default for faster, cheaper runs — the search record already carries company, salary, skills, recruiter and apply URL.

## `includeRecruiterLeads` (type: `boolean`):

In addition to jobs, emit one deduplicated lead record per recruiter/company — name, company profile, logo and (when the posting exposes it) the recruiter's direct phone number. Great for staffing & B2B outreach.

## `experienceYears` (type: `integer`):

Keep only jobs whose experience range reaches at least this many years.

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

Keep only jobs whose disclosed maximum salary is at least this value (in the region's currency, annual). Confidential-salary jobs are kept.

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

Keep only jobs matching this employment type, e.g. "Full time", "Part time", "Contract", "Internship".

## `industry` (type: `string`):

Keep only jobs whose industry contains this text, e.g. "IT", "Banking", "Healthcare".

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

Keep only jobs whose title, skills, company or role contains this text.

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

Maximum number of job records to return. Set to 0 for no limit (explicit opt-in; use with a run timeout).

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

Track jobs across runs in a key-value store and output only jobs that are new or whose details changed. Works alongside Apify Schedules for daily new-job alerts.

## `monitorStoreName` (type: `string`):

Named key-value store for monitor-mode state (lowercase letters, digits, hyphens).

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

Foundit is reliably reachable on Apify Residential pinned in-region (the default). Keep residential for best success.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer"
  ],
  "region": "india",
  "sortBy": "relevance",
  "freshnessDays": 0,
  "includeDescription": false,
  "includeRecruiterLeads": false,
  "maxResults": 100,
  "monitorMode": false,
  "monitorStoreName": "foundit-scraper-monitor",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All scraped job and recruiter-lead records as JSON items in the default dataset.

# 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 = {
    "searchQueries": [
        "software engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesage/foundit-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 = { "searchQueries": ["software engineer"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesage/foundit-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 '{
  "searchQueries": [
    "software engineer"
  ]
}' |
apify call scrapesage/foundit-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Foundit Scraper - Jobs, Salaries, Skills & Recruiter Leads",
        "description": "Scrape Foundit (formerly Monster) jobs across India, the Gulf & SE Asia — title, salary, experience, skills, company profile & recruiter phone leads. Filters, full descriptions & monitor mode.",
        "version": "0.1",
        "x-build-id": "5YHUhYBwLJk3TiabD"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesage~foundit-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesage-foundit-scraper",
                "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/scrapesage~foundit-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesage-foundit-scraper",
                "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/scrapesage~foundit-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesage-foundit-scraper",
                "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": {
                    "searchQueries": {
                        "title": "Search queries (job titles / keywords)",
                        "type": "array",
                        "description": "Job titles or keywords to search on Foundit, e.g. \"software engineer\", \"data analyst\", \"accountant\". Each query is combined with every location below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "region": {
                        "title": "Region / Foundit site",
                        "enum": [
                            "india",
                            "gulf",
                            "singapore",
                            "malaysia",
                            "philippines",
                            "indonesia",
                            "hongkong"
                        ],
                        "type": "string",
                        "description": "Which Foundit market to search. India (foundit.in) and Gulf/Middle East (founditgulf.com) are the largest. SE-Asia sites use the same engine.",
                        "default": "india"
                    },
                    "locations": {
                        "title": "Locations (optional)",
                        "type": "array",
                        "description": "City / region filters, e.g. \"Bangalore\", \"Mumbai\", \"Dubai\", \"Singapore\". Leave empty to search the whole region. Each location is combined with every query.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Start URLs (optional)",
                        "type": "array",
                        "description": "Paste Foundit search-result URLs or individual job URLs (…/job/…). Each is auto-detected and scraped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "date",
                            "salary"
                        ],
                        "type": "string",
                        "description": "Result ordering requested from Foundit.",
                        "default": "relevance"
                    },
                    "freshnessDays": {
                        "title": "Freshness — only jobs posted within N days",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs posted within this many days (e.g. 1, 3, 7, 15, 30). 0 = no date limit. Ideal for daily monitoring runs.",
                        "default": 0
                    },
                    "includeDescription": {
                        "title": "Include full job description",
                        "type": "boolean",
                        "description": "Fetch each job's page for the complete job description (one extra request per job). Off by default for faster, cheaper runs — the search record already carries company, salary, skills, recruiter and apply URL.",
                        "default": false
                    },
                    "includeRecruiterLeads": {
                        "title": "Also output recruiter / company leads",
                        "type": "boolean",
                        "description": "In addition to jobs, emit one deduplicated lead record per recruiter/company — name, company profile, logo and (when the posting exposes it) the recruiter's direct phone number. Great for staffing & B2B outreach.",
                        "default": false
                    },
                    "experienceYears": {
                        "title": "Filter: minimum experience (years)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs whose experience range reaches at least this many years."
                    },
                    "salaryMin": {
                        "title": "Filter: minimum salary",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Keep only jobs whose disclosed maximum salary is at least this value (in the region's currency, annual). Confidential-salary jobs are kept."
                    },
                    "employmentType": {
                        "title": "Filter: employment type",
                        "type": "string",
                        "description": "Keep only jobs matching this employment type, e.g. \"Full time\", \"Part time\", \"Contract\", \"Internship\"."
                    },
                    "industry": {
                        "title": "Filter: industry contains",
                        "type": "string",
                        "description": "Keep only jobs whose industry contains this text, e.g. \"IT\", \"Banking\", \"Healthcare\"."
                    },
                    "keyword": {
                        "title": "Filter: keyword match",
                        "type": "string",
                        "description": "Keep only jobs whose title, skills, company or role contains this text."
                    },
                    "maxResults": {
                        "title": "Max results (jobs)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of job records to return. Set to 0 for no limit (explicit opt-in; use with a run timeout).",
                        "default": 100
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new / changed)",
                        "type": "boolean",
                        "description": "Track jobs across runs in a key-value store and output only jobs that are new or whose details changed. Works alongside Apify Schedules for daily new-job alerts.",
                        "default": false
                    },
                    "monitorStoreName": {
                        "title": "Monitor store name",
                        "type": "string",
                        "description": "Named key-value store for monitor-mode state (lowercase letters, digits, hyphens).",
                        "default": "foundit-scraper-monitor"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Foundit is reliably reachable on Apify Residential pinned in-region (the default). Keep residential for best success.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
