Track New Foundit Job Postings Every Day With Monitor Mode

A recruiter covering Bangalore Python roles, a staffing agency watching for fresh mandates, or a job seeker who wants first look at new openings all need the same thing from Foundit: the jobs that appeared since yesterday, and nothing they have already read. Foundit’s own search shows everything that matches, old and new together, so every morning starts with scrolling past listings you saw the day before.

Try it live: Foundit Monster India Jobs Scraper. Pay per job delivered. Empty searches, skipped repeats and summary rows are never charged.

The Foundit Jobs Scraper has a monitorMode switch for exactly this. It remembers the job IDs it has already delivered to your account and, on the next run, returns only the ones you have not seen. Because you are charged per job saved, a scheduled run that finds 6 new jobs costs you 6 jobs, not the whole feed again.

What you get and who it is for

Each run gives you one row per new job, with these fields on every row:

Field	What it holds
job_id	Foundit’s job ID, the key monitor mode tracks
title, company, company_id	The role and the employer
location	One or more cities as Foundit lists them
experience_min_years, experience_max_years	The experience range (0 and 0 means not stated)
industries, functions, skills	Foundit’s tags for the job
posted_date_text, posted_days_ago	How old the listing is
total_applicants	The applicant count Foundit shows
apply_url	The job page on foundit.in

Rows also carry salary_min_lakhs and salary_max_lakhs when the employer publishes pay, which most do not.

It suits anyone who acts on new jobs quickly: agency recruiters pitching for a mandate before rivals do, in-house talent teams watching where competitors hire, career coaches sending clients a daily shortlist, and job seekers who want an alert that is more precise than Foundit’s own.

The input

{
  "searchKeywords": ["python developer", "django developer"],
  "location": "Bangalore",
  "employmentType": "Full Time",
  "postedWithinDays": "3",
  "maxJobs": 200,
  "monitorMode": true
}

• monitorMode: true is the whole point. With it off, every run returns every match again.
• postedWithinDays takes a string: "1", "3", "7", "15" or "30". For a daily schedule, "3" gives you a safety margin. If one day’s run fails, the next run still sees those jobs, and monitor mode filters out everything you already have.
• searchKeywords can hold several titles or skills. Each one is searched separately and the results are merged and de-duplicated by job ID, so a job that matches both keywords is delivered and charged once.
• location takes one city or several separated by commas, such as "Bangalore,Hyderabad". Leave it out to search all of India.
• maxJobs is a cap across all keywords together, from 1 to 1,000. Its default is only 5, so always set it. Make it high enough for the first run, which has to deliver the whole baseline.
• employmentType is "Full Time" or "Part Time". Leave it out for both.

Keep the input the same from run to run. The schema says monitor mode expects the same input across runs, and changing keywords halfway through makes the “new” count hard to read.

What the output looks like

[
  {
    "job_id": "69289660",
    "title": "IN_Senior Associate_React.js+Python Developer_GCC_Advisory_Bangalore",
    "company": "PwC India",
    "company_id": "1017627",
    "location": "Bengaluru, India",
    "experience_min_years": 4,
    "experience_max_years": 10,
    "employment_type": "Full time",
    "functions": ["Data Analytics AI"],
    "skills": ["Typescript", "Javascript", "Gcp", "FastAPI", "react.js", "Python"],
    "posted_date_text": "12 hours ago",
    "posted_days_ago": 0,
    "total_applicants": 15,
    "apply_url": "https://www.foundit.in/job/insenior-associatereactjspython-developergccadvisorybangalore-pwc-india-bengaluru-bangalore-india-69289660"
  },
  {
    "job_id": "69280533",
    "title": "Software Engineer III, Python Developer + Prompt Engineering + Agentic AI + AWS",
    "company": "JP Morgan Chase & Co.",
    "company_id": "441814",
    "location": "Bengaluru",
    "experience_min_years": 0,
    "experience_max_years": 0,
    "employment_type": "Full time",
    "functions": ["Software Engineering"],
    "skills": ["LLMs", "Gen AI", "Langchain", "LangGraph", "Django", "FastAPI", "Python", "Flask"],
    "posted_date_text": "8 hours ago",
    "posted_days_ago": 0,
    "total_applicants": 44,
    "apply_url": "https://www.foundit.in/job/software-engineer-iii-python-developer-prompt-engineering-agentic-ai-aws-jp-morgan-chase-co-bengaluru-bangalore-69280533"
  },
  {
    "_type": "summary",
    "keywords_searched": ["python developer"],
    "location": "Bangalore",
    "jobs_requested": 100,
    "jobs_scraped": 49,
    "jobs_failed": 0,
    "charged_for": 49,
    "monitor": false
  }
]

These rows come from our run of September 30, 2026, with "python developer", Bangalore, Full Time, posted within 7 days and maxJobs 100, with monitor mode off. They are trimmed: we dropped the salary flag, industries and part of each skills list, and the JP Morgan title uses a comma where Foundit shows a dash. That run returned 49 jobs, all Foundit had for that week, so the cap of 100 was never reached.

The last row is the summary every run ends with. It is never charged. With monitor mode on, the summary also carries previously_seen, new_this_run, skipped_duplicates and monitor_degraded, so you can tell at a glance how many repeats were filtered out.

Why bother with monitor mode at all? Because new and old listings mix more than you would guess. We run a small daily check of this actor: an all-India "python developer" search capped at 5 jobs, with monitor mode off. Across the first run of each day from September 7 to October 6, 2026 (27 days), it delivered 135 rows, of which 28 were jobs an earlier day had already returned. On September 26, all 5 rows were repeats. Without monitor mode you pay for those repeats and have to filter them yourself.

Run it in Apify Console

1. Open https://apify.com/themineworks/foundit-jobs-scraper and click Try for free.
2. In Search keywords, enter one keyword per line.
3. Set Location, Employment type and Posted within (days). The form starts with python developer, Bangalore, Full time and the last 7 days filled in, so change those to your own search.
4. Set Max jobs high enough for the first full load, for example 200.
5. Tick Monitor mode (only new results).
6. Click Save as a new task, then Start. The first run delivers the baseline. Start it again and the second run delivers only jobs that are new since the first.
7. Click Export for CSV, JSON or Excel. In CSV and Excel, list fields such as skills are split into numbered columns.

Run it from Python

pip install apify-client

import csv
from datetime import date
from pathlib import Path
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run_input = {
    "searchKeywords": ["python developer", "django developer"],
    "location": "Bangalore",
    "employmentType": "Full Time",
    "postedWithinDays": "3",
    "maxJobs": 200,
    "monitorMode": True,
}
run = client.actor("themineworks/foundit-jobs-scraper").call(run_input=run_input)

jobs, summary = [], {}
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("_type") == "summary":
        summary = item
    elif "_type" not in item:
        jobs.append(item)  # skip info and error rows

if summary.get("monitor_degraded"):
    print("Seen list could not be read; this run delivered every match.")

fields = ["found_on", "job_id", "title", "company", "location",
          "experience_min_years", "experience_max_years",
          "posted_date_text", "total_applicants", "skills", "apply_url"]
log = Path("foundit_new_jobs.csv")
is_new_file = not log.exists()
with log.open("a", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=fields, extrasaction="ignore")
    if is_new_file:
        writer.writeheader()
    for job in jobs:
        job["found_on"] = date.today().isoformat()
        job["skills"] = ", ".join(job.get("skills", []))
        writer.writerow(job)

print(f"{len(jobs)} new jobs today, "
      f"{summary.get('skipped_duplicates', 0)} skipped as already seen")
for job in sorted(jobs, key=lambda j: j.get("total_applicants", 0))[:10]:
    print(f"{job['total_applicants']:>4} applicants  {job['title']}  ({job['company']})")

The script appends each day’s new jobs to one CSV with the date they first appeared, so the file becomes a running log of the market. After a few weeks that log is the raw material for a hiring dashboard built from free job data. It then prints the new jobs with the fewest applicants first, which is where an early application or an early pitch to the employer counts most.

Run it every day

Monitor mode only pays off on a schedule. In Apify Console, open the task you saved, go to Schedules, click Create new schedule, set a cron expression such as 0 7 * * * for 07:00 every day, and add the task. Each run then starts with the same input, and the seen list carries over from one run to the next on its own.

To get the new jobs somewhere you will look, add an integration to the task. Apify’s Google Sheets integration appends every run’s rows to a sheet, Make, Zapier and n8n can post them to Slack or email, and a webhook can call your own endpoint when the run finishes. Since each dataset holds only new jobs, you can forward it as is without any diffing on your side.

One habit worth keeping: run test searches with monitor mode off. The seen list is shared by every run of this actor on your account, whatever the input, so a job you pulled in a quick test would be skipped by your real daily task later.

What it costs

You pay per job saved to your dataset: $2.00 per 1,000 jobs on the Bronze plan, $1.75 on Silver, and $1.50 on Gold and above. There is no start fee and no separate compute charge.

For the input above, the first run delivers the whole baseline. At the full cap of 200 jobs that is $0.40 on Bronze. After that you pay only for new jobs. Our September 30 run found 49 full time Bangalore Python developer jobs posted in one week, about 7 a day. Add a second keyword and say 10 new jobs a day, and a month of daily runs delivers about 300 jobs: $0.60 on Bronze, $0.53 on Silver or $0.45 on Gold. Skipped repeats, cross-keyword duplicates and summary rows cost nothing.

Without monitor mode, a daily run with a 3-day window would deliver each job up to three times before it ages out, and you would pay for each copy.

Limits worth knowing

• The seen list is per account, not per task. It holds up to 50,000 job IDs and every run of the actor reads it. Keep tests separate by leaving monitor mode off for them.
• The first run is a full load. Set maxJobs high enough for it, or the baseline will be partial and older matches can surface as “new” later.
• If the seen list cannot be read, a run delivers everything. The summary row then shows monitor_degraded: true. Check for it in your script, as the code above does.
• Posting age fields can disagree. In our runs, one listing showed “2 hours ago” in posted_date_text while posted_days_ago was 563, and another showed “15 days ago” next to 25. Treat both as hints and trust monitor mode, not the age, to decide what is new to you.
• Up to 1,000 jobs per run. Each keyword also stops after 40 pages of 100. For a large market, split the watch into one task per city or keyword.
• Some searches return nothing. A very specific keyword with narrow filters can return zero jobs. Our run for "data analyst python sql", freshers, full time, posted in the last day, returned none. Empty runs are not charged; broaden the keywords if it keeps happening.

Related

• How to Monitor Competitor Job Postings to Predict Their Strategy
• Naukri API: How to Programmatically Access India’s Largest Job Board
• Foundit Jobs Scraper