# Foundit Jobs Scraper | foundit.in (Monster India) Jobs API (`data_daemon/foundit-jobs-scraper`) Actor

$0.80 per 1,000 jobs, full description included | Scrape foundit.in (Monster India) jobs by keyword, city, experience and freshness. Only-new mode + skipJobIds for daily schedules. JSON API, no login, no proxy.

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

## Pricing

from $0.56 / 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Foundit Jobs Scraper | foundit.in (Monster India) Jobs API with Full Descriptions

**Turn foundit.in (formerly Monster India) into a clean, scheduled job feed.** foundit is one of India's largest job boards, about **223,000 open listings** across IT, sales, finance, healthcare, engineering and BPO roles, from freshers to senior management, with **2,900 new postings a day** (counted 18 Oct 2026). This Actor searches foundit by **keyword, city, experience band, salary, job type and posting date** and returns one JSON row per job with the **full job description** (HTML + plain text), **salary band in INR and LPA** when the recruiter discloses it, **experience range, skills, industries, functions, applicant and view counts, company profile with coordinates**, the foundit job URL and the **direct apply URL** (the employer's own career site for syndicated jobs).

**$0.80 per 1,000 jobs, full description included**, plus $0.001 per run. No login, cookies, proxy or browser: the Actor reads the JSON API behind the foundit website. Apify's free plan ($5 credit every month) covers about **6,000 jobs with full descriptions**. Built for schedules: switch on **Only new jobs since the last run** and a daily run returns, and charges for, only the jobs you have not received before. Jobs you already have can also be passed in `skipJobIds`.

> Live check, 18 Oct 2026: `data analyst` matched **1,192** open foundit listings (354 in Bangalore, 183 in Delhi NCR, 174 in Hyderabad); **83** of them were posted in the last 7 days. The default run (50 newest `data analyst` jobs with descriptions) finished in 30 seconds on the Apify platform and cost $0.04 plus the $0.001 start fee.

### Who buys foundit data, and what for

| You are | What this Actor gives you |
|---|---|
| **Staffing agencies and recruiters** | A daily list of new openings by role, city and experience band, with applicant counts, so you see which mandates are crowded and which companies are hiring right now. |
| **Job aggregators and HR-tech products** | foundit as a source with stable job IDs (`dedupKey`), full JD text, de-duplication across keywords and runs, a `syndicated` flag to avoid re-importing postings that originate elsewhere, and an API you can call on a schedule. |
| **Compensation and salary-benchmark teams** | INR salary bands by role, experience and city on every posting that discloses pay, with `salaryHidden` on the ones that don't. |
| **B2B sales and lead generation** | Companies hiring 20 Java developers or a finance controller are buying tooling and services. Each row carries the company name, profile, industry and foundit company page. |
| **Workforce and market analysts** | Demand by skill, city and experience band over time; fresher vs experienced hiring; share of remote and contract roles. |
| **AI agents (MCP)** | Ask Claude or ChatGPT "fresher data analyst jobs in Pune posted this week" and let it call this Actor through Apify's MCP server. |

### Quick start (about a minute)

1. Click **Try for free**. The form is pre-filled with `data analyst`.
2. Optionally add keywords (`java developer`, `sales manager`, `chartered accountant`), cities (`Bangalore`, `Mumbai`, `Delhi`, `Remote`), an experience band and **Posted within (days)** = `7`.
3. Click **Start**. 50 jobs with full descriptions take well under a minute and cost **$0.04**.
4. Download the results as JSON, CSV or Excel, or save the input as a task, tick **Only new jobs since the last run** and **schedule it daily** to get a fresh feed in Google Sheets, a webhook, Make, Zapier or n8n.

**From code** (returns the jobs in one call):

```bash
curl -X POST "https://api.apify.com/v2/acts/data_daemon~foundit-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["java developer"], "locations": ["Bangalore"], "postedWithinDays": 7, "maxJobs": 100}'
```

**From an AI assistant:** add the MCP connector `https://mcp.apify.com/?tools=data_daemon/foundit-jobs-scraper` in Claude, ChatGPT, Cursor or VS Code.

Need management or IT-specialist boards too? [IIMJobs Jobs Scraper](https://apify.com/data_daemon/iimjobs-jobs-scraper) and [Hirist.tech Jobs Scraper](https://apify.com/data_daemon/hirist-jobs-scraper) by the same publisher use the same `onlyNewSinceLastRun` / `skipJobIds` / `RUN-SUMMARY` conventions, so one pipeline handles all three India boards.

### Input

```json
{
    "queries": ["data analyst", "business analyst"],
    "locations": ["Bangalore", "Hyderabad"],
    "minExperience": 2,
    "maxExperience": 6,
    "postedWithinDays": 7,
    "includeDescription": true,
    "maxJobsPerQuery": 50
}
```

| Field | Type | Description |
| --- | --- | --- |
| `queries` | array | Search keywords, one foundit search per item (role or skill words; put cities in `locations`). A job found by two keywords is saved and charged once. Required; `query`, `keywords` and `search` are accepted as aliases. |
| `locations` | array | Optional cities as foundit lists them: `Bangalore`, `Mumbai`, `Delhi` (covers Delhi NCR: Gurugram, Noida), `Hyderabad`, `Chennai`, `Pune`, `Kolkata`, `Ahmedabad`, `Remote`. Several cities = any of them. Applied by the site; the Actor also drops the remote-only rows foundit returns for a city it does not know and tells you in the status message. Common alternative spellings (`Bengaluru`, `Gurugram`, `Bombay`, `Delhi NCR`) are mapped. |
| `minExperience` / `maxExperience` | integer | Experience band in years (0-30), overlap semantics: a 3-6 year job matches `minExperience: 5`. A `minExperience` of 1 or more also excludes jobs that do not state a range; `0` keeps them. |
| `postedWithinDays` | integer | Only jobs posted or refreshed in the last N days (1-365). Use `1` with a daily schedule, `7` for a weekly report. Applied by the site and checked again on each job's `postedAt`. |
| `jobTypes` | array | Any of `Permanent Job`, `Contract Job`, `Work From Home`, `Internship`, `Temporary`. |
| `minSalaryLpa` / `maxSalaryLpa` | integer | Disclosed annual salary band in lakh INR (10 = 10 LPA = 1,000,000 INR). Most foundit jobs do not disclose pay and are excluded when a salary filter is set. |
| `includeDescription` | boolean | Fetch the full description (HTML + text), company profile, skills, views and exact city/state/coordinates for each job (default `true`, one extra request per job, same price). Off = listing fields only, about twice as fast. |
| `sort` | string | `newest` (default) or `relevance` (the site's own ranking, useful when you take only the first few dozen jobs of a broad keyword). |
| `maxJobsPerQuery` | integer | Stop a keyword after this many new jobs (default 50). The site serves 100 jobs per page, so 1,000 jobs are 10 search requests. |
| `maxJobs` | integer | Hard cap on saved jobs for the whole run (0 = no cap). |
| `onlyNewSinceLastRun` | boolean | Deliver only jobs that an earlier run with the same `stateKey` has not delivered; skipped jobs are not charged (default `false`). Sets `postedWithinDays` to 3 when it is empty. |
| `stateKey` | string | Name of this saved search's memory for `onlyNewSinceLastRun`. Derived from the keywords, cities and filters when empty. Use a new key to start over. |
| `skipJobIds` | array | Job `id`s you already have, as an array of strings or numbers. Skipped before any detail fetch and never charged. Large arrays are fine. |
| `proxyConfiguration` | object | Optional (Advanced). foundit's JSON API answers Apify's datacenter IPs directly, so none is needed. |

Bad input never fails the run: unknown fields are ignored with a warning, a reversed experience range is swapped, a keyword with no matches or an unknown city ends with `Saved 0 jobs` and an explanation in the status message, and an empty keyword list with a city still searches that city.

### Output

One record per job. Example from a real run on 18 Oct 2026 (description shortened):

```json
{
    "id": 69497289,
    "dedupKey": "foundit:69497289",
    "url": "https://www.foundit.in/job/senior-data-analyst-microchip-technology-bengaluru-bangalore-india-69497289",
    "applyUrl": "https://wd5.myworkdaysite.com/en-US/recruiting/microchiphr/External/job/India---Bangalore/Senior-Data-Analyst_R4051-26",
    "title": "Senior Data Analyst",
    "company": {
        "id": 488097,
        "name": "Microchip Technology",
        "confidential": false,
        "logo": null,
        "url": "https://www.foundit.in/search/microchip-technology-488097-jobs-career",
        "employerType": "company",
        "about": "Microchip Technology Inc. is a publicly-listed American corporation that manufactures microcontroller, mixed-signal, analog and Flash-IP integrated circuits.",
        "greatPlaceToWork": false
    },
    "locations": ["Bengaluru / Bangalore"],
    "locationDetails": [{ "city": "Bengaluru / Bangalore", "state": "Karnataka", "country": "India", "lat": 12.971599, "lon": 77.594563 }],
    "remote": false,
    "experienceMinYears": null,
    "experienceMaxYears": null,
    "salaryMinInr": null,
    "salaryMaxInr": null,
    "salaryMinLpa": null,
    "salaryMaxLpa": null,
    "salaryCurrency": "INR",
    "salaryHidden": false,
    "jobTypes": ["Permanent Job"],
    "employmentTypes": ["Full time"],
    "industries": ["Electronic Components/Semiconductors"],
    "functions": ["Marketing Analytics"],
    "designations": ["Data Analyst"],
    "skills": ["Tableau", "Adobe Analytics", "Python", "Sql"],
    "applicants": 7,
    "views": 10,
    "postedAt": "2026-10-17T10:46:38.000Z",
    "createdAt": "2026-10-17T10:46:38.000Z",
    "updatedAt": "2026-10-17T10:46:38.000Z",
    "closesAt": "2026-11-30T18:30:00.000Z",
    "isActive": true,
    "syndicated": true,
    "urgentlyHiring": false,
    "descriptionHtml": "<div><p>Are you looking for a unique opportunity to be a part of something great…",
    "description": "Are you looking for a unique opportunity to be a part of something great…",
    "query": "data analyst",
    "scrapedAt": "2026-10-18T03:24:22.175Z"
}
```

| Field | Notes |
| --- | --- |
| `id`, `dedupKey`, `url` | foundit job id, a stable `foundit:<id>` key for your own de-duplication, and the public job page. |
| `applyUrl` | Where "Apply" leads: the employer's own career site for syndicated jobs, otherwise the foundit page. |
| `title`, `designations`, `skills` | As tagged by the recruiter; `skills` merges the free-text skills and foundit's normalised IT-skill tags. |
| `company.*` | `name` (`null` with `confidential: true` when the recruiter hides it), `logo`, foundit company page `url`, `employerType` (`company` = direct employer, `consultant` = staffing agency), `about` and `greatPlaceToWork`. |
| `locations`, `locationDetails`, `remote` | City names as foundit spells them (`Bengaluru / Bangalore`, `Gurgaon / Gurugram`), the detail's city/state/country/coordinates, and a remote flag. |
| `experienceMinYears`, `experienceMaxYears` | Experience band in years; `null` when the recruiter did not state one (about 60% of syndicated postings). |
| `salaryMinInr`, `salaryMaxInr`, `salaryMinLpa`, `salaryMaxLpa`, `salaryCurrency`, `salaryHidden` | Annual salary band when disclosed. `salaryHidden: true` means the recruiter hides it on the site; the Actor respects that and does not output the numbers. |
| `jobTypes`, `employmentTypes`, `industries`, `functions` | foundit's taxonomy (`Permanent Job`, `Contract Job`, `Work From Home`; `Full time`; industry and function names). |
| `applicants`, `views` | Applicant and view counts from the listing and the detail page. |
| `postedAt`, `createdAt`, `updatedAt`, `closesAt` | ISO timestamps. `postedAt` is what the site shows as "Posted X ago" (reposts refresh it); `createdAt` is the original posting date. |
| `isActive`, `syndicated`, `urgentlyHiring` | Site flags. `syndicated` postings are aggregated from the employer's career site; `false` means the recruiter posted directly on foundit. |
| `descriptionHtml`, `description` | Full JD as HTML and plain text (`includeDescription: true`); `null` when the site has none. |
| `query`, `scrapedAt` | The keyword that found the job and the collection time. |

Recruiter names and phone numbers that the API carries are not output. Download as JSON, CSV, Excel, or push to Google Sheets, webhooks and other Apify integrations. Field names are stable; new fields are only added, so your Sheets, Zapier or Make mappings keep working.

### Scheduling & automation

The heavy users of this Actor run it on a schedule with a short keyword list, a city list and a short posting window, and let the Actor remember what it has already delivered.

**Recipe: keywords × cities × last 3 days, only new jobs, every morning**

```json
{
    "queries": ["data analyst", "business analyst", "power bi"],
    "locations": ["Bangalore", "Hyderabad", "Pune"],
    "postedWithinDays": 3,
    "onlyNewSinceLastRun": true,
    "stateKey": "analysts-south-daily",
    "maxJobsPerQuery": 200
}
```

1. Paste the input, click **Save as task**, then **Schedules → Create schedule → Daily** (for example `0 8 * * *`, 08:00 IST) and add the task.
2. The first run delivers every matching job from the last 3 days. Every later run delivers only the jobs that were not delivered before, and **skipped jobs are not charged**. The memory lives in a key-value store named `foundit-jobs-state` in your own Apify account, one record per `stateKey`, and forgets ids after 120 days.
3. Give each saved search its own `stateKey` (or leave it empty and the Actor derives one from the keywords, cities and filters). Change the key to start over.
4. Already de-duplicating on your side? Pass the `id`s you have in `skipJobIds` instead; they are skipped before any detail fetch and never charged.

**Where the results go**

- **Integrations tab of the task**: Google Sheets (append rows), Slack or email (a message per run), or a **webhook** to your backend when the run finishes.
- **Make, Zapier, n8n**: use the Apify module/node with the task id, or poll the dataset with the API call below.
- **Every run writes a `RUN-SUMMARY` record** to its key-value store: keywords, jobs found, new, filtered, skipped (already delivered / `skipJobIds`) and charged counts, so a webhook consumer can decide what to do without opening the dataset.

**Synchronous API call** (waits for the run and returns the new jobs):

```bash
curl -X POST "https://api.apify.com/v2/acts/data_daemon~foundit-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"queries": ["data analyst"], "postedWithinDays": 1, "onlyNewSinceLastRun": true, "stateKey": "analyst-daily"}'
```

### Pricing and what a month costs

Pay per event. Platform compute is included; the Actor runs in 512 MB, so the start fee is always a single event.

| Event | Price | When it is charged |
|---|---|---|
| Job | $0.0008 | Each job saved to your dataset, full description included |
| Actor start | $0.001 | Once per run |

That is **$0.80 per 1,000 jobs with full descriptions**. Jobs skipped by **Only new jobs since the last run**, `skipJobIds`, de-duplication across keywords or your filters are never charged.

**Plan discounts:** prices above are for the Free and Starter plans; Scale plans pay 15% less ($0.68 per 1,000) and Business plans 30% less ($0.56 per 1,000).

| How teams use it | Volume (measured 18 Oct 2026) | Cost |
|---|---|---|
| Quick look: the 50 newest `data analyst` jobs with descriptions | 50 jobs, 1 run | $0.041 |
| One-off export: every open `data analyst` job in Bangalore | 354 jobs, 1 run | $0.28 |
| Full export of one keyword: all open `data analyst` jobs in India | 1,192 jobs, 1 run | $0.95 |
| Daily feed, only new jobs: `data analyst`, all of India | about 4-6 new jobs a day, 30 runs | about $0.15 a month |
| Daily feed, only new jobs: 10 keywords × 5 cities, about 60 new jobs a day | 1,800 jobs, 30 runs | about $1.50 a month |

Apify's free plan includes $5 of usage a month: about 6,000 jobs with descriptions, enough for a trial and several small daily feeds.

### Tips

- Use several specific keywords instead of one broad one; the Actor de-duplicates across keywords and a job found twice is charged once.
- `postedWithinDays` is applied by the site before anything is fetched, so a 1-day or 3-day window makes scheduled runs fast and cheap.
- Set `includeDescription: false` when you only need titles, companies, salary bands and skills; it halves the run time.
- `minExperience: 0, maxExperience: 1` is a good fresher filter; `jobTypes: ["Work From Home"]` or `locations: ["Remote"]` gives remote roles.
- Set a **maximum cost per run** on the task; the Actor stops cleanly at the limit and says so in the status message.

### FAQ

**How much does it cost to scrape foundit?**

$0.0008 per job with its full description plus $0.001 per run, so 100 jobs cost about $0.08 and a 50-jobs-a-day feed about $1.25 a month.

**Is there an official foundit API?**

No public one. This Actor reads the JSON that the foundit.in website itself loads and exposes it as a REST API with schedules, webhooks and only-new-jobs runs.

**Does it return the full job description?**

Yes, as HTML and plain text, plus skills, industries, functions, applicant and view counts, salary band when disclosed, the company profile and the direct apply URL.

**Why are so many salaries and experience ranges `null`?**

Most postings on foundit are syndicated from employers' career sites without a salary or stated experience band. When the recruiter hides a salary the site does too, and the Actor keeps it hidden (`salaryHidden: true`). Filter on `salaryHidden: false` and non-null `salaryMinLpa` for benchmarking.

**Is foundit the same as Monster India?**

Yes. Monster India was renamed foundit in 2022; the site is foundit.in and the data is the same board.

**Does it cover foundit Gulf, Singapore, Malaysia or Indonesia?**

Not yet; this Actor covers foundit.in (India, including remote and the occasional overseas posting listed there). Open an issue if you need another region.

**Why does a city return remote jobs only?**

foundit answers an unknown city name with its remote jobs. The Actor drops those rows, charges nothing and tells you in the status message; use the spelling foundit uses (`Bangalore`, `Delhi`, `Mumbai`, `Hyderabad`, `Chennai`, `Pune`, `Kolkata`, `Ahmedabad`, `Remote`).

**Do I need a proxy or login?**

No.

### Related Actors by Daemon Data

- [IIMJobs Jobs Scraper](https://apify.com/data_daemon/iimjobs-jobs-scraper) – India's MBA, finance, consulting and management jobs with full descriptions and only-new mode
- [Hirist.tech Jobs Scraper](https://apify.com/data_daemon/hirist-jobs-scraper) – India IT and tech jobs with full descriptions, same scheduling conventions as this Actor
- [Oracle Jobs Scraper](https://apify.com/data_daemon/oracle-hcm-jobs-scraper) – every job on any Oracle Recruiting Cloud (Oracle HCM) career site
- [India IPO Tracker](https://apify.com/data_daemon/india-ipo-tracker) – live IPO GMP, subscription and listing data for India
- [Tickertape India Stocks Scraper](https://apify.com/data_daemon/tickertape-stocks-scraper) – NSE/BSE fundamentals, shareholding and screener
- [Dubai Property Transactions](https://apify.com/data_daemon/dubai-property-transactions) – Dubai Land Department sales, mortgages and gifts
- [UK Gazette Insolvency Notices](https://apify.com/data_daemon/uk-gazette-insolvency-notices) – winding-up petitions, administrations and liquidations
- [Luma Events Scraper](https://apify.com/data_daemon/luma-events-scraper) – lu.ma events by city, topic or organiser calendar, with hosts and ticket info

### Support

Found a bug or need another field, filter or foundit region? Open an issue on the Issues tab; issues are usually answered within a day. Custom variants of this Actor are available on request.

A quick review on the actor page helps other users find it.

### Disclaimer

This Actor collects publicly available job listings for informational purposes and deliberately leaves out recruiters' personal contact details. Respect the source website's terms of use and applicable data-protection laws when using the data.

# Actor input Schema

## `queries` (type: `array`):

One foundit.in search per keyword, e.g. `data analyst`, `java developer`, `sales manager`, `chartered accountant`, `nurse`. Use role or skill words; put cities in `locations`. A job found by two keywords is saved and charged once. Leave the list with one item for a quick first run.

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

Optional. Cities as foundit lists them: `Bangalore`, `Mumbai`, `Delhi` (covers Delhi NCR: Gurugram, Noida), `Hyderabad`, `Chennai`, `Pune`, `Kolkata`, `Ahmedabad`, `Remote`. Several cities = any of them. Applied by the site, then checked on each job. Leave empty for all of India.

## `minExperience` (type: `integer`):

Only jobs whose experience range reaches at least this many years (0-30). From 1 upwards this also excludes jobs that do not state an experience range; 0 keeps them.

## `maxExperience` (type: `integer`):

Only jobs whose experience range starts at or below this many years (0-30). `0` or `1` is a good fresher filter.

## `postedWithinDays` (type: `integer`):

Only jobs posted or refreshed in the last N days (1-365), e.g. `1` with a daily schedule or `7` for a weekly report. Applied by the site and checked again on each job. Leave empty for all open jobs.

## `jobTypes` (type: `array`):

Optional. Any of `Permanent Job`, `Contract Job`, `Work From Home`, `Internship`, `Temporary`. Several values = any of them. Leave empty for all types.

## `minSalaryLpa` (type: `integer`):

Only jobs whose disclosed annual salary range reaches at least this many lakh INR, e.g. `10` = 10 LPA = 1,000,000 INR. Most foundit jobs do not disclose pay and are excluded when this is set.

## `maxSalaryLpa` (type: `integer`):

Only jobs whose disclosed annual salary range starts at or below this many lakh INR. Jobs without a disclosed salary are excluded when this is set.

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

On (default): one extra request per job adds the full description (HTML and plain text), the company profile, skills with the site's own tags, view count and exact city/state/coordinates. The price per job is the same either way. Off: listing fields only, about twice as fast, enough for counting jobs or sizing a market.

## `sort` (type: `string`):

`newest` (default): newest postings first, best for feeds and schedules. `relevance`: the site's own ranking, best when you only take the first few dozen jobs of a broad keyword.

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

Stop a keyword after this many new jobs (default 50). Cost: $0.0008 per job with its description, so 50 jobs = $0.04. Raise it for full exports: `data analyst` alone has about 1,200 open jobs and the site serves 100 per page.

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

Hard cap on saved jobs for the whole run across all keywords (0 = no cap).

## `onlyNewSinceLastRun` (type: `boolean`):

On: deliver only jobs that an earlier run with the same `stateKey` has not already delivered, and skip the rest without charging. If `postedWithinDays` is empty it is set to 3 so each run stays small. Off (default): return every matching job.

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

Optional name for this search's memory when `onlyNewSinceLastRun` is on, e.g. `analyst-bangalore-daily`. Leave empty to derive it from the keywords, cities and filters. Use a new key to start over.

## `skipJobIds` (type: `array`):

Array of job IDs you already have (the `id` field from earlier runs), e.g. `["69495391", "69497219"]`. They are skipped before any detail fetch and never charged. Large arrays are fine.

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

Optional, none by default. foundit's JSON API answers Apify's datacenter IPs directly, so no proxy is needed; set one only if your own network policy requires it.

## Actor input object example

```json
{
  "queries": [
    "data analyst"
  ],
  "locations": [],
  "jobTypes": [],
  "includeDescription": true,
  "sort": "newest",
  "maxJobsPerQuery": 50,
  "maxJobs": 0,
  "onlyNewSinceLastRun": false,
  "skipJobIds": []
}
```

# Actor output Schema

## `dataset` (type: `string`):

Jobs as JSON items in the default dataset (also downloadable as CSV, Excel, XML).

## `runSummary` (type: `string`):

RUN-SUMMARY record: keywords, jobs found, new, filtered, skipped (already delivered / skipJobIds) and charged counts.

# 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 = {
    "queries": [
        "data analyst"
    ],
    "locations": [],
    "jobTypes": [],
    "skipJobIds": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("data_daemon/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 = {
    "queries": ["data analyst"],
    "locations": [],
    "jobTypes": [],
    "skipJobIds": [],
}

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

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

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

```

## CLI example

```bash
echo '{
  "queries": [
    "data analyst"
  ],
  "locations": [],
  "jobTypes": [],
  "skipJobIds": []
}' |
apify call data_daemon/foundit-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

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