# Foundit Jobs Lookup: foundit jobs scraper from $1.5/1k (`accountable_eel/foundit-jobs-lookup`) Actor

Run keyword + location job searches on foundit (formerly Monster India) and get one clean row per posting: title, company, location, experience, pay range (if stated) and apply link. No login required. You pay per posting returned, and a search that finds nothing is free.

- **URL**: https://apify.com/accountable\_eel/foundit-jobs-lookup.md
- **Developed by:** [Adrian Voss](https://apify.com/accountable_eel) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.75 / 1,000 job posting returneds

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?

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 Jobs Lookup: foundit jobs scraper from $1.5/1k

You write job searches the way you'd type them into foundit — `python developer @ Bengaluru` —
and this actor runs each one against **foundit's own backing search API**, one of India's
largest job boards (formerly Monster India), and returns one clean row per posting: title,
company, location, experience required, pay range (when disclosed), and a permanent link.

No login. No API key. foundit's search-results page renders its listings client-side after load,
but the same-origin JSON endpoint that page calls to fetch them is not — see "Why this one"
below.

### Who it's for

Recruiters, staffing agencies, and outbound teams building an India-market candidate or lead list
who need fresh postings by role and city without clicking through foundit's search pages by hand.
It's also the data layer behind an internal hiring-trends dashboard, or a Clay/n8n workflow that
watches a role for new postings on a schedule. Pricing is pay-per-event: a fraction of a cent for
a posting you actually got, and nothing for a search that finds nothing.

This actor is the India-market counterpart to `seek-jobs-search-lookup` (Australia) and
`xing-jobs-lookup` (DACH): wide-net keyword + location search rather than a per-company listing.
If you already know which companies to target, `company-domain-enrichment`'s hiring-activity
source answers a different question — this one answers "who's hiring for *this role*, in *this
Indian city*" when you don't have the company list yet.

### Why this one

- **Reaches data a plain page-load can't.** foundit's search-results page ships real SEO meta
  tags (title, description) but the job cards themselves are fetched by a JavaScript bundle after
  load — the raw HTML has no listings in it at all. This actor instead calls that bundle's own
  data source directly: `www.foundit.in/middleware/jobsearch`, a same-origin JSON endpoint that
  answers a plain request (with one header set correctly — see the FAQ) with real, live results.
  No proxy, no browser automation, no CAPTCHA-solving.
- **The filters are real.** `query` and `locations` are both genuinely honoured upstream —
  verified by watching the total-match count actually narrow (26,644 → 10,691 across one
  location filter on the same search) and confirming every returned posting's own location field
  matched.
- **You are never billed for the same posting twice.** Every posting is deduplicated by its
  foundit job ID across the pages of one search and, by default, across every search in the run.
- **Honest about apply links.** foundit mixes on-site and off-site postings in the same result
  set — some apply links point back to foundit, others go straight to the employer's own careers
  page or a third-party board. Both `jobUrl` (foundit's own listing page) and `applyUrl` (wherever
  the posting actually sends an applicant) are returned as separate fields rather than assuming
  one covers the other.
- **No fabricated salary data.** foundit reports an undisclosed salary as the literal string
  "0-0 INR" on the majority of postings — this actor nulls that out instead of showing you a fake
  zero.

### What you get

One row per job posting by default. (Turn off "One row per job posting" in the Input tab to get
one row per *search* instead, with the whole posting list nested in `jobs`.) Every row carries
these fields:

| Field | Type / format | Description |
| --- | --- | --- |
| `query` | text | The search line you passed in, unchanged. |
| `found` | boolean | `true` if the search returned at least one posting. `false` rows are never charged. |
| `status` | text | `OK`, `NOT_FOUND` (no postings for that search), `BAD_FORMAT` (the line had neither keywords nor a location), or `BLOCKED`. |
| `searchKeywords` | text | The keywords actually sent to foundit. |
| `searchLocation` | text | The location actually sent to foundit. |
| `jobCount` | number | How many postings this search returned after your filters — this is exactly what you're charged for. |
| `totalAvailable` | number | foundit's own total-match count for the search, before this actor's page/depth limits. |
| `truncated` | boolean | `true` if more postings were available than you asked for, or if paging stopped early. |
| `jobs` | array | The full posting list. Present in every row; it's what gets expanded into separate rows in "one row per posting" mode. |
| `jobId` | text | foundit's own numeric posting ID — stable, and what deduplication keys on. |
| `title` | text | Job title. |
| `companyName` | text | Hiring company (or recruiter) name, as foundit displays it. |
| `location` | text | Location as foundit prints it on the posting (e.g. "Bengaluru, India"). |
| `remote` | boolean | `true` if the location or title reads as remote / work-from-home. |
| `experience` | text | Experience range foundit lists for the role (e.g. "5-7 Years"). |
| `salaryText` | text | Pay range exactly as foundit's advertiser wrote it. Null when undisclosed (foundit's own "0-0 INR" placeholder is nulled out, not shown as a fake zero). |
| `employmentType` | text | e.g. "Full time", "Part time", "Contract", when foundit states one. |
| `skills` | text | Comma-separated skills foundit lists against the posting. |
| `postedAt` | date (ISO) | foundit's own creation timestamp for the listing. |
| `postedAgo` | text | The same thing in foundit's words ("20 hours ago"). |
| `jobUrl` | link | Permanent link to the posting on foundit.in. |
| `applyUrl` | link | Where the posting actually sends an applicant — sometimes foundit itself, sometimes the employer's own site or a third-party board (see "Why this one"). |
| `scrapedAt` | date (ISO) | When this actor fetched the row. |

A search that returns no postings comes back as a single `found: false` row with a
`status`/`message` explaining why, and is never charged. So does a blank line.

### Pricing

- **Job posting returned**: $1.5 per 1,000 job postings

Plus a $0.00005 start fee per run. Each event above is billed independently, only when it actually returns data — misses (`found:false`) are never charged.

You're charged **per posting returned**, not per search — a search that returns 30 postings
costs thirty, a genuinely empty search costs nothing, and a `BAD_FORMAT` line costs nothing.

Because you pay per posting, "Most postings to return per search" is your budget control: leave
it at 40 (two pages) and a ten-search run costs at most 400 postings' worth.

1,000 postings through this actor: **~$1.55** if every search finds results. The same list built
by hand-paginating foundit's search pages and copying fields: hours of manual work per 1,000 rows.

### How to use

1. **In the Apify Console.** Open the actor page and click **Start** — the `searches` field is already pre-filled with a working example. Results land in the run's dataset as soon as each item is found.
2. **Via the API.** Call it directly with a POST request — no Console needed once you have an API token:
   ```bash
   curl "https://api.apify.com/v2/acts/accountable_eel~foundit-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
     -X POST \
     -H "Content-Type: application/json" \
     -d '{"searches":["python developer @ Bengaluru"]}'
   ```
3. **On a schedule.** Save this actor as an Apify **Task** with the input you want, then add a **Schedule** (hourly, daily, weekly) so it runs on its own — no server of your own required.

Paste one search per line:

```
python developer @ Bengaluru
data analyst
sales manager @ Mumbai
```

A line with no `@ location` uses the location you set once in **🔍 Search settings** — leave that
blank too and the search covers all of India.

**🔍 Search settings:**

| Input | What it does |
| --- | --- |
| `defaultLocation` | Location for any line that doesn't name one. Write it the way foundit does — a city name, e.g. "Bengaluru", "Mumbai", "Pune". |
| `maxJobsPerQuery` | Most postings to return per search. Default 40 (two pages). |

**🎯 Narrow the results** — applied here, to the postings after they arrive. They combine with
AND across fields and OR within a field:

| Input | What it does |
| --- | --- |
| `titleKeywords` | Keep only titles containing one of these — `["engineer","analyst"]`. |
| `excludeTitleKeywords` | Drop titles containing one of these — `["intern","trainee"]`. Applied after the include list. |
| `companies` | Keep only these companies — partial names match. |
| `excludeCompanies` | Drop these companies — useful for filtering out recruitment agencies you already know. |
| `locations` | Narrow a wide search to particular areas — e.g. "Whitefield", "Andheri". |
| `remoteOnly` | Keep only roles whose location or title reads as remote / work-from-home. |
| `skipDuplicateJobs` | On by default. Each posting is returned, and billed, once per run even if two searches overlap. |

### Input

```json
{
  "searches": [
    "python developer @ Bengaluru"
  ]
}
```

One search per line. Write it as "keywords @ location", or just the keywords and set a location below. foundit is India-focused — locations are Indian cities, e.g. "Bengaluru", "Mumbai", "Pune". Accepted formats: python developer @ Bengaluru, data analyst, sales manager @ Mumbai.

### Output

| query | found | status | searchKeywords | searchLocation | jobCount | totalAvailable | truncated | jobs | jobId | title | companyName | location | remote | experience | salaryText | employmentType | skills | postedAt | postedAgo | jobUrl | applyUrl | scrapedAt |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| python developer @ Bengaluru | true | OK | python developer | Bengaluru | 40 | 232 | true | \<all postings found (full list)> | 34056108 | Senior Python Developer | Arun Thiyagarajan (Proprietor of Swathi Business Solutions) | Bengaluru, Chennai | false | 10-15 Years |  | Full time | Azure, Python, Sql, Aws | 2025-02-21T17:36:00.000Z | 11 hours ago | https://www.foundit.in/job/senior-python-developer-arun-thiyagarajan-proprietor-of-swathi-business-solutions-bengaluru-bangalore-34056108 |  | 2026-09-08T17:44:33.798Z |

A miss comes back as a row with `"found": false` and is never charged.

### Use it from Clay, n8n, Make, or an AI agent

This actor runs synchronously over plain HTTP — call it directly from a script, a workflow tool, or an AI agent, no Apify Console needed once you have an API token.

```bash
curl "https://api.apify.com/v2/acts/accountable_eel~foundit-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{"searches":["python developer @ Bengaluru"]}'
```

**n8n.** Add an HTTP Request node: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~foundit-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body Content Type `JSON`, JSON Body `{"searches":["python developer @ Bengaluru"]}` (swap in an expression from an earlier node for a real value).

**Clay.** Add an "HTTP API" column: Method `POST`, URL `https://api.apify.com/v2/acts/accountable_eel~foundit-jobs-lookup/run-sync-get-dataset-items?token=<YOUR_TOKEN>`, Body `{"searches":["{{search}}"]}`, mapping the row's search into the `searches` array.

**MCP.** In Claude, Cursor, or any MCP client with the Apify MCP server, ask for "Foundit Jobs Scraper API from $1.5/1k | Apify" — the agent will find and run this actor.

### Tips

- Set a city in `locations` or `defaultLocation` whenever you can — foundit's own location filter
  is real (verified against every returned posting's location field) and narrows the result set
  before you pay for it, rather than after.
- `salaryText` is empty on most postings — most Indian job ads don't disclose pay. Don't rely on
  this field being populated for filtering; use `titleKeywords`/`excludeTitleKeywords` instead.
- Keep "Max concurrency" conservative on a large list of searches. This target has no browser
  fallback, so getting rate-limited costs more in wasted requests than a slower, steadier crawl.
- `applyUrl` sometimes points off-site (the employer's own careers page, or another job board) —
  don't assume every posting's apply flow stays on foundit.in.

### vs. alternatives

| | What it costs | What you get | Trade-off |
|---|---|---|---|
| **This actor** (`foundit-jobs-lookup`) | $0.0015 per posting returned (FREE tier, less on paid tiers), $0.00005 actor start, nothing for a genuinely empty search | One row per foundit job posting — title, company, location, experience, pay range and apply link, filterable by title keyword, company, location and remote | India-focused (foundit's own coverage); no full job description, only the fields the search API itself returns. |
| **themineworks/foundit-jobs-scraper** | Community actor, 172 users in the last 30 days, $2.50 per 1,000 results | Also scrapes foundit job search results | An established incumbent with more users; this actor prices lower per posting and never charges for a miss. |
| **Doing it yourself** | Your time + finding foundit's undocumented `/middleware/jobsearch` endpoint, working out the Referer requirement, handling pagination and dedup | The same data | This actor's endpoint discovery, dedup, and filtering logic is the maintenance burden it absorbs. |

Prices for third-party tools are as researched in September 2026 and are not tracked here — check
the vendor before relying on the comparison.

### FAQ

**Why do some postings have no salary?**
foundit reports an undisclosed salary as the literal string "0-0 INR" on the majority of
postings — this actor treats that as no data and returns `null` rather than showing a fake zero.
Expect `salaryText` to be empty on most rows.

**Why does `applyUrl` sometimes point somewhere other than foundit.in?**
foundit's own search results mix postings foundit hosts directly with postings it aggregates from
elsewhere — the aggregated ones send applicants straight to the employer's own careers page or a
third-party board. `jobUrl` always stays on foundit.in; `applyUrl` is wherever the posting itself
actually sends an applicant.

**Does this handle rate limits or blocking?**
Each request goes through Apify's proxy configuration and retries up to twice on failure. A
`BLOCKED` status means foundit returned HTTP 403, 429, or 503 — lowering "Max concurrency" can
help; no proxy has been needed for this target as of the last live check.

**Do I need to configure proxies?**
No. The actor uses Apify's default proxy configuration out of the box; foundit's search endpoint
has not required anything beyond a plain HTTP request (with the right Referer header, which this
actor sets automatically) in testing.

**Is this GDPR-relevant?**
The data returned is business/professional information already published publicly by employers on
foundit's job board (job title, company, location, pay range) — not personal data about private
individuals.

**Can I schedule this to re-check the same searches on a cadence?**
Yes — set up an Apify Task with a schedule and point it at this actor with a saved input.
`skipDuplicateJobs` keeps a single run's overlapping searches from double-billing, but each
scheduled run is independent — a role that appeared in yesterday's run will appear again today if
it's still listed.

**Can an AI agent call this directly?**
Yes. It's registered on the Apify MCP server — an agent in Claude, Cursor, or another MCP client
can find and run it by name ("Foundit Jobs Scraper API from $1.5/1k | Apify"), or you can call the
REST endpoint shown above from any script or workflow tool.

### Related actors

- [SEEK Jobs Search Lookup](https://apify.com/accountable_eel/seek-jobs-search-lookup) — the same
  keyword + location search shape, against Australia's largest job board.
- [XING Jobs Lookup](https://apify.com/accountable_eel/xing-jobs-lookup) — the DACH-region
  equivalent, against XING's professional network.
- [Company Domain Enrichment](https://apify.com/accountable_eel/company-domain-enrichment) —
  broader firmographic and hiring-activity enrichment once you know which companies to target.

# Actor input Schema

## `searches` (type: `array`):

One search per line. Write it as "keywords @ location", or just the keywords and set a location below. foundit is India-focused — locations are Indian cities, e.g. "Bengaluru", "Mumbai", "Pune". Accepted formats: python developer @ Bengaluru, data analyst, sales manager @ Mumbai. You're only charged for the ones we actually find — a miss costs nothing.

## `testRun` (type: `boolean`):

Turn this on to test your input on a small sample before running the full list. Turn it off to process everything.

## `onlyFound` (type: `boolean`):

Only keep rows where something was actually found. Misses are always free, whether or not you show them here.

## `includeKeywords` (type: `array`):

Optional. Only keep results that mention at least one of these words (e.g. a job title, a city, a product name). Leave empty to keep everything.

## `excludeKeywords` (type: `array`):

Optional. Drop any result that mentions one of these words. Leave empty to skip nothing.

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

Optional. Stop the run once this many results have been found — useful for a quick, cheap sample. Leave blank for no limit.

## `defaultLocation` (type: `string`):

Used for any line that's just keywords. Write it the way foundit does — "Bengaluru", "Mumbai", "Pune". Leave empty to search all of India.

## `maxJobsPerQuery` (type: `integer`):

foundit hands out 20 postings per page and this actor stops at 5 pages (100 postings) by default — a cost-control cap, not a limit foundit imposes. You pay per posting returned, so this is also your budget control.

## `titleKeywords` (type: `array`):

Optional. Keep only roles whose title contains at least one of these words — e.g. "engineer", "analyst". Case doesn't matter and partial words work. Leave empty to keep every role.

## `excludeTitleKeywords` (type: `array`):

Optional. Drop any role whose title contains one of these words — e.g. "intern", "senior". Applied after the include list above, so a role matching both is dropped.

## `companies` (type: `array`):

Optional. Keep only roles at companies whose name contains one of these. Partial matches work.

## `excludeCompanies` (type: `array`):

Optional. Drop roles at companies whose name contains one of these — handy for filtering out recruitment agencies you already know.

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

Optional. Narrow a wide search down to particular areas — e.g. "Whitefield", "Andheri". Applied to the location foundit prints on each posting.

## `remoteOnly` (type: `boolean`):

Keep only roles whose location or title reads as remote. Applied to the postings after they arrive — treat it as a strong filter, not a guarantee.

## `skipDuplicateJobs` (type: `boolean`):

On by default. Overlapping searches routinely surface the same role — with this on, each posting is returned, and billed, exactly once per run.

## `columns` (type: `array`):

Choose which pieces of information to include in each result row. All are included by default.

## `expandRows` (type: `boolean`):

When on, each job posting found gets its own row instead of being grouped under its search. You're still only charged once per search, no matter how many rows it produces.

## `maxConcurrency` (type: `integer`):

Parallel requests. Keep conservative — this target has no browser fallback, so getting blocked costs more than slow-and-steady.

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

Apify Proxy config. Residential recommended for anti-bot-sensitive targets.

## Actor input object example

```json
{
  "searches": [
    "python developer @ Bengaluru"
  ],
  "testRun": false,
  "onlyFound": false,
  "includeKeywords": [],
  "excludeKeywords": [],
  "defaultLocation": "",
  "maxJobsPerQuery": 40,
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "companies": [],
  "excludeCompanies": [],
  "locations": [],
  "remoteOnly": false,
  "skipDuplicateJobs": true,
  "columns": [
    "searchKeywords",
    "searchLocation",
    "jobCount",
    "totalAvailable",
    "truncated",
    "jobs",
    "jobId",
    "title",
    "companyName",
    "location",
    "remote",
    "experience",
    "salaryText",
    "employmentType",
    "skills",
    "postedAt",
    "postedAgo",
    "jobUrl",
    "applyUrl"
  ],
  "expandRows": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searches": [
        "python developer @ Bengaluru"
    ],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "companies": [],
    "excludeCompanies": [],
    "locations": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("accountable_eel/foundit-jobs-lookup").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 = {
    "searches": ["python developer @ Bengaluru"],
    "includeKeywords": [],
    "excludeKeywords": [],
    "titleKeywords": [],
    "excludeTitleKeywords": [],
    "companies": [],
    "excludeCompanies": [],
    "locations": [],
}

# Run the Actor and wait for it to finish
run = client.actor("accountable_eel/foundit-jobs-lookup").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 '{
  "searches": [
    "python developer @ Bengaluru"
  ],
  "includeKeywords": [],
  "excludeKeywords": [],
  "titleKeywords": [],
  "excludeTitleKeywords": [],
  "companies": [],
  "excludeCompanies": [],
  "locations": []
}' |
apify call accountable_eel/foundit-jobs-lookup --silent --output-dataset

```

## MCP server setup

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

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/KR8NSkXugyeu0shbG/builds/94w2HgaYo6Bchh5p6/openapi.json