Find the Skills Employers Ask for Most in a Role on Foundit

What should a Python developer in Bangalore learn next? Which tools should a training company put in its Java course? What should a recruiter screen for when a client says “the usual stack”? All three questions have the same answer source: the skills employers tag on the jobs they post right now. Foundit.in, the job board that used to be Monster India, attaches a list of skills to almost every listing. Counting them across a few dozen jobs gives you a demand ranking that is current to the week.

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

The Foundit Jobs Scraper returns those tags as a skills array on every row, straight from the search results. The work is in the counting: the same skill arrives spelled three ways, some tags are filler, and one big employer can drown out everyone else. This guide covers all three.

What you get and who it is for

Field	What it holds
skills	The employer’s skill tags, as a list of strings (can be empty)
title	The job title as posted
company, company_id	The employer, used here to count each employer once
functions, industries	Foundit’s functional area and industry tags
experience_min_years, experience_max_years	The experience range, to split juniors from seniors
location	One or more cities as listed
posted_days_ago	How old the listing is

It is useful for learning and development teams planning courses, bootcamps and training companies deciding what to teach, recruiters writing screening checklists, career coaches, and developers who want evidence before picking their next framework.

The input

{
  "searchKeywords": ["python developer"],
  "location": "Bangalore",
  "employmentType": "Full Time",
  "postedWithinDays": "7",
  "maxJobs": 100
}

• searchKeywords is the role. Use the title the way employers write it. Several titles for the same role, such as "python developer" and "python engineer", are merged and de-duplicated by job ID.
• location narrows to one city. Leave it out for all of India, or separate cities with commas to pool them.
• postedWithinDays is a string, one of "1", "3", "7", "15" or "30". Seven days gives a current snapshot; use "30" for a niche role that does not post often.
• employmentType is "Full Time" or "Part Time". Leave it out for both.
• maxJobs caps the run, from 1 to 1,000. The default is 5, so set it.
• Leave includeJobDescription at its default of false. The skills array comes from the search results, and the description adds one request per job without changing the count.

What the output looks like

[
  {
    "job_id": "69175021",
    "title": "Snowflake (Python, SQL) Developer",
    "company": "Infosys Limited",
    "company_id": "446110",
    "location": "Bengaluru, India",
    "functions": ["Data Engineering"],
    "skills": ["Technology", "snowflake", "Data on Cloud-DataStore", "SQL SSIS",
               "OpenSystem", "SQL Server", "Python"],
    "posted_days_ago": 1
  },
  {
    "job_id": "69139429",
    "title": "Snowflake (Python, SQL) Developer",
    "company": "Infosys Limited",
    "company_id": "639690",
    "location": "Bengaluru, India",
    "functions": ["Data Engineering"],
    "skills": ["snowflake", "Data quality frameworks", "Python", "Sql", "Etl",
               "ELT", "Data Modeling", "Performance Tuning"],
    "posted_days_ago": 1
  },
  {
    "job_id": "69316157",
    "title": "Python Developer (Gen AI)",
    "company": "Infrrd",
    "company_id": "909431",
    "location": "Bengaluru, India",
    "functions": ["Technology"],
    "skills": ["OpenAI API", "LangChain", "GenAI LLM", "NLP utilities", "Python 3.x",
               "LLM orchestration", "PGVector", "Observability", "Debugging", "MongoDB"],
    "posted_days_ago": 0
  }
]

These rows come from our run of September 30, 2026, with exactly the input above, trimmed to the fields this guide uses (the first row also had one more Python tag, covered below). That run returned 49 jobs, which was every match Foundit had for that week, from 32 employers, with an average of about 12 skill tags per job and none with an empty list.

The three rows show each problem you have to handle:

• Filler tags. “Technology” and “OpenSystem” are internal labels, not skills. In this run they appeared on 5 jobs, all from Infosys.
• Spelling variants. “Python 3.x”, “Python development” and “OpenSystem Python” all mean Python, and Infosys rows add a fourth form that joins Python and OpenSystem with a hyphen. Before clean-up, the exact tag “Python” appeared on 41 of 49 jobs, which would suggest one Python developer job in six does not ask for Python. After merging variants it is 48 of 49. The same goes for “FastAPI” and “Fast API”, “LangChain” and “Langchain”, “Spring Boot” and “Springboot”.
• One employer, many IDs and names. Both Snowflake rows are Infosys Limited, under two different company_id values. Other runs list the same firm as “Infosys” and “Infosys Limited”. Count employers by a cleaned-up name, not by ID.

Run it in Apify Console

1. Open https://apify.com/themineworks/foundit-jobs-scraper and click Try for free.
2. In Search keywords, enter the role, one title 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, which is this guide’s example.
4. Set Max jobs to 100 or more and click Start.
5. Export the dataset as JSON for the script below. If you prefer a spreadsheet, note that CSV and Excel split skills into numbered columns (skills/0, skills/1 and so on), so you would need to stack those columns before counting.

Run it from Python

pip install apify-client

import csv
import re
from collections import Counter, defaultdict
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

ALIASES = {
    "python 3.x": "python", "python development": "python",
    "python opensystem": "python", "opensystem python": "python",
    "fast api": "fastapi", "springboot": "spring boot",
    "rest api": "rest apis", "restful apis": "rest apis",
    "amazon web services": "aws", "microsoft azure": "azure",
    "postgres": "postgresql", "react js": "react", "react.js": "react",
}
NOISE = {"technology", "opensystem"}
SUFFIXES = {"limited", "ltd", "pvt", "private", "inc", "llc"}

def norm(skill):
    s = re.sub(r"[^a-z0-9+#.]+", " ", skill.lower()).strip()
    return ALIASES.get(s, s)

def company_key(name):
    words = re.sub(r"[^a-z0-9 ]+", " ", name.lower()).split()
    return " ".join(w for w in words if w not in SUFFIXES)

def skill_table(jobs):
    jobs_with = Counter()
    companies_with = defaultdict(set)
    for job in jobs:
        skills = {norm(s) for s in job.get("skills", [])}.difference(NOISE)
        jobs_with.update(skills)
        for s in skills:
            companies_with[s].add(company_key(job["company"]))
    n_companies = len({company_key(j["company"]) for j in jobs})
    rows = [{"skill": s, "jobs": n, "companies": len(companies_with[s]),
             "pct_of_companies": round(100 * len(companies_with[s]) / n_companies)}
            for s, n in jobs_with.items()]
    rows.sort(key=lambda r: (-r["companies"], -r["jobs"]))
    return rows, len(jobs), n_companies

run = client.actor("themineworks/foundit-jobs-scraper").call(run_input={
    "searchKeywords": ["python developer"],
    "location": "Bangalore",
    "employmentType": "Full Time",
    "postedWithinDays": "7",
    "maxJobs": 100,
})
jobs = [i for i in client.dataset(run["defaultDatasetId"]).iterate_items()
        if "_type" not in i]

rows, n_jobs, n_companies = skill_table(jobs)
print(f"{n_jobs} jobs from {n_companies} employers")
for r in rows[:15]:
    print(f"{r['skill']:<14} {r['companies']:>3} employers ({r['pct_of_companies']}%)  {r['jobs']:>3} jobs")

with open("skills_demand.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.DictWriter(f, fieldnames=["skill", "jobs", "companies", "pct_of_companies"])
    writer.writeheader()
    writer.writerows(rows)

On our September 30 data, the top of the table looks like this:

Skill	Employers (of 32)	Jobs (of 49)
python	32 (100%)	48
sql	12 (38%)	16
fastapi	12 (38%)	13
flask	12 (38%)	13
django	11 (34%)	16
git	11 (34%)	11
react	8 (25%)	11
rest apis	8 (25%)	10
docker	8 (25%)	9
aws	8 (25%)	8
azure	8 (25%)	8

Notice Django. By job count it ties SQL for the top spot after Python, with 16 jobs. By employer count it drops below FastAPI and Flask, because those 16 jobs come from only 11 employers. Ranking by employers tells you what the market wants; ranking by jobs tells you what the biggest poster wants. For one named company rather than a market, the same tags read as a signal of what that company is building next.

The ALIASES map holds the variants we saw in our runs. Print the full table for your own role, look for near-duplicates in the long tail, and add them to the map.

Compare cities or track the trend

To compare cities, run the same keyword once per city and put the tables side by side. We did this for "Java Spring Boot Microservices" on October 2, 2026, capped at 15 jobs per city. Bangalore returned 15 jobs from 9 employers, 3 of those jobs with an empty skills list; Hyderabad returned 7 jobs from 5 employers. Spring Boot and Java led in both. Kubernetes was tagged by 4 of the 5 Hyderabad employers but only 2 of the 9 in Bangalore, which is the kind of difference worth checking with a larger run before you act on it: at 5 employers, one company moves a skill by 20 points.

To follow a trend, schedule the run. Save the input as a task in Apify Console, open Schedules, and add a weekly schedule such as 0 8 * * 1 (Mondays at 08:00). With postedWithinDays at "7", each run covers one week of new listings without overlap. Push each run to a Google Sheet with Apify’s Google Sheets integration, or have a webhook start the script and append the week’s table to a CSV with a date column. After a couple of months you can see whether a skill such as LangChain, tagged by 4 Bangalore Python jobs in our run, is growing or holding still.

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.

Our September 30 run delivered 49 jobs, about $0.10 on Bronze. A weekly run at the full cap of 100 jobs costs at most $0.20, or about $0.87 a month over 52 weeks a year. Comparing five roles across three cities at 300 jobs each is 4,500 jobs at most, $9.00 on Bronze or $6.75 on Gold, and you pay only for the jobs Foundit actually has.

Limits worth knowing

• Tags are what employers choose to tag. Some list 25 skills, some list 4, and a few list none: our Bangalore Java run had 3 of 15 jobs with an empty skills array, and the actor’s own 1,000-row test had 77 empty lists. Jobs without tags still count in the employer total, which slightly lowers every percentage.
• The alias map is never finished. New spellings appear with new employers. Review the long tail every few runs.
• Large employers repeat themselves. Infosys posted 11 of our 49 Bangalore Python jobs. Counting employers handles this, but read both columns.
• Small samples swing. Below about 20 employers, treat differences of one or two companies as noise.
• Up to 1,000 jobs per run. Each keyword also stops after 40 pages of 100. For a large all-India role, split by city.
• This measures demand, not pay. The skills array says nothing about what a skill is worth. For that, see the salary guide below.

Related

• Compare Salary Bands in Lakhs by City and Experience on Foundit
• India Tech Hiring Trends 2025: What the Job Data Actually Shows
• Foundit Jobs Scraper