DEV Community: DataDaemon

IIMJobs data for recruiters: salary disclosure, applicant counts and who is hiring, in one spreadsheet

DataDaemon — Sun, 18 Oct 2026 02:56:35 +0000

If you recruit for management, finance, consulting or HR roles in India, IIMJobs is one of the boards you already watch. Watching it by hand works for one requisition. It does not work when someone asks you a market question:

"How many product manager roles opened in Mumbai and Bangalore this week?"
"Are competitors disclosing salary for talent acquisition leads, and at what band?"
"How crowded is an investment banking posting? Will we get 50 applicants or 500?"

Every IIMJobs listing already carries the answer: posting date, experience range, salary (when the recruiter shows it), locations, skills, applicant count and view count. You just need the listings in a spreadsheet instead of a browser tab.

This post shows how to get that spreadsheet in about five minutes without writing code, how to refresh it every week, and five questions you can answer once you have it. There is an optional Python section at the end for people who want charts.

What a quick pull already tells you

I pulled the first ~50 results for three keywords, limited to jobs posted in the last 7 days, on 18 October 2026:

Keyword	Postings in last 7 days	Salary disclosed	Median applicants per posting	Median views
product manager	348	13%	162	291
talent acquisition	47	8%	201	415
investment banking	77	17%	72	241

Three things stand out even from a small sample:

Salary disclosure is rare. Fewer than one posting in five shows a band. If you publish yours, you stand out; if you benchmark from postings, you are benchmarking from a small, self-selected minority. Treat disclosed bands as a signal, not a market median.
Talent acquisition roles get swamped. A median of 201 applicants per TA posting means screening capacity matters more than reach.
Investment banking is a Mumbai market. 27 of the 57 IB postings in the sample listed Mumbai; Bangalore was a distant second with 10.

Your own numbers will differ by week and keyword. The point is that these are one-click questions once the data is in a sheet.

Step 1: get the listings into a spreadsheet (no code)

I use the IIMJobs Scraper on Apify. Disclosure: I built it. It reads the same JSON the IIMJobs website loads, so it needs no login, no browser and no proxy, and it returns one clean row per job.

Open one of the ready-made examples and click Run example (an Apify account is free and the free plan includes $5 of usage every month):
Change the inputs to your own market:
- Search keywords: one line per role family, for example talent acquisition, hr business partner, compensation and benefits.
- Locations: Mumbai, Bangalore, Gurgaon, Remote, or leave empty for all of India.
- Minimum / maximum experience: for example 5 to 10 years for mid-level roles.
- Posted within (days): 7 for a weekly snapshot.
- Include full job description: switch it off for benchmarking. You only need it if you want to read or text-mine the JDs.
Click Start. A few hundred jobs take well under a minute.
Open the Output tab and click Export: Excel, CSV or JSON. You can also send results straight to Google Sheets with Apify's Google Sheets integration.

Cost: $0.002 per job, plus $0.002 per job if you include the full description. A 500-job weekly snapshot without descriptions costs $1.00, which fits inside the free monthly credit with room to spare. From 2 November 2026 the full description is included in the $0.002 job price (plus $0.001 per run).

Step 2: make it weekly

Run example already copied the example into your account as a saved task, with your edited input. Add a schedule for it: Apify Console → Schedules → create a schedule such as every Monday 08:00 IST → add your task. Each run creates a new dataset. If you export each one into a new tab of the same Google Sheet, you get a week-over-week history without any manual work.

Tip: keep the keywords identical from week to week. Changing them changes the population and breaks your trend lines.

Step 3: five questions to answer from the sheet

The columns you will use most:

Column	What it is
`query`	the keyword that found the job
`title`, `designation`	job title as posted
`company.name`, `company.ambitionBoxRating`	employer and its AmbitionBox rating, when available
`experienceMinYears`, `experienceMaxYears`	experience range
`salaryMinLpa`, `salaryMaxLpa`, `salaryHidden`	band in lakhs per annum, and whether the recruiter hid it
`locations`, `remote`	cities and remote flag
`skills`, `mandatorySkills`	tagged skills
`applicants`, `views`	competition signals
`postedAt`	posting timestamp

1. How much hiring is there, and where? Pivot table: rows = query, columns = first location, values = count of id. Compare with last week's tab.

2. Who is hiring the most? Pivot table: rows = company.name, values = count of id, sorted descending. Add the AmbitionBox rating column next to it. A company posting ten roles with a 3.1 rating is a different competitor from one posting ten roles with a 4.2.

3. What do disclosed bands look like? Filter salaryHidden = FALSE, then pivot query × experience bucket with the median of salaryMinLpa and salaryMaxLpa. Always show the count next to the median; with 8 to 17% disclosure, a median of three postings is an anecdote.

4. How crowded is each role? Median applicants per query and city. A high applicant count with a short posting age means you need screening help, not more sourcing.

5. Which skills are mandatory? Split mandatorySkills into rows and count. When "Workday" or "SuccessFactors" starts showing up as mandatory in HRBP postings, you want to know before your next intake meeting.

Optional: the same analysis in Python

If you prefer pandas over pivot tables:

import os
import pandas as pd
from apify_client import ApifyClient  # pip install apify-client pandas

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("data_daemon/iimjobs-jobs-scraper").call(run_input={
    "queries": ["product manager", "talent acquisition", "investment banking"],
    "postedWithinDays": 7,
    "includeDescription": False,   # cheaper; not needed for benchmarking
    "maxJobsPerQuery": 300,
})
jobs = pd.json_normalize(list(client.dataset(run["defaultDatasetId"]).iterate_items()))

summary = jobs.groupby("query").agg(
    postings=("id", "size"),
    salary_disclosed=("salaryHidden", lambda s: round(100 * (~s.astype(bool)).mean())),
    median_applicants=("applicants", "median"),
    median_views=("views", "median"),
)
print(summary)

# Disclosed bands by experience bucket, with counts so nobody over-reads a median of 3
disclosed = jobs[~jobs["salaryHidden"].astype(bool)].copy()
disclosed["exp_bucket"] = pd.cut(disclosed["experienceMinYears"], [-1, 3, 7, 12, 40],
                                 labels=["0-3", "4-7", "8-12", "13+"])
print(disclosed.groupby(["query", "exp_bucket"], observed=True)[["salaryMinLpa", "salaryMaxLpa"]]
      .agg(["count", "median"]))

# Top hiring companies with their AmbitionBox rating
print(jobs.groupby("company.name")
      .agg(postings=("id", "size"), rating=("company.ambitionBoxRating", "first"))
      .sort_values("postings", ascending=False).head(15))

# City split (a job can list several cities)
print(jobs.explode("locations")["locations"].value_counts().head(10))

Caveats worth knowing

Disclosed salary is a biased sample. Companies that show bands are often the ones paying at or above market.
Applicant counts are IIMJobs-only. The same role is usually also on LinkedIn and Naukri, so treat the number as relative competition, not total pipeline.
Postings are not hires. Some listings are evergreen pipelines. Week-over-week deltas are more reliable than absolute counts.
Use the data for market intelligence, not mass outreach. Respect IIMJobs' terms and India's data-protection rules if anything you store relates to a person.

IT and tech roles instead of management? The sister Hirist Jobs Scraper returns the same columns for Hirist.tech.
Tracking a specific large employer? Many of them run their career site on Oracle Cloud HCM, which this Oracle HCM jobs scraper reads directly.

If there is a column you need for your reports that is not in the output, leave a comment or open an issue on the Actor page. I read both.

Indian stock fundamentals as JSON: the Tickertape endpoints that work without a login

DataDaemon — Fri, 04 Sep 2026 14:51:49 +0000

If you have ever tried to pull fundamentals for Indian stocks programmatically, you know the pain: NSE sits behind Akamai and blocks anything that isn't a browser, BSE is worse, Screener.in needs a login for anything useful, and the paid vendors want an enterprise contract for what is essentially public data.

There is a quieter option. Tickertape renders its stock pages from a set of JSON endpoints that answer plain HTTP requests, no cookies, no token. I spent a day mapping them. This post documents what I found, with working Python, and then shows the hosted version I built for people who would rather not maintain scrapers.

The endpoints

All of these live on https://api.tickertape.in and only need a normal browser user agent and a Referer header.

Search a ticker or name to get Tickertape's internal id (sid):

import requests

H = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/128.0 Safari/537.36",
    "Referer": "https://www.tickertape.in/",
}

r = requests.get("https://api.tickertape.in/search", params={"text": "reliance", "types": "stock"}, headers=H)
stocks = r.json()["data"]["stocks"]
print(stocks[0]["sid"], stocks[0]["ticker"], stocks[0]["slug"])
# RELI RELIANCE /stocks/reliance-industries-RELI

Key ratios and company info:

info = requests.get("https://api.tickertape.in/stocks/info/RELI", headers=H).json()["data"]
print(info["info"]["name"], info["ratios"]["pe"], info["ratios"]["mrktCapf"])

ratios includes P/E, P/B, EPS, book value, dividend yield, ROE, beta, 52-week range, market-cap rank and the industry averages for P/E, P/B and yield.

Quarterly shareholding history (promoter, pledged, FII, DII, mutual funds, retail):

holdings = requests.get("https://api.tickertape.in/stocks/holdings/RELI", headers=H).json()["data"]
for h in holdings:
    d = h["data"]
    print(h["date"][:10], "promoter", round(d["pmPctT"], 2), "FII", round(d["fiPctT"], 2), "MF", round(d["mfPctT"], 2))

Index constituents:

nifty = requests.get("https://api.tickertape.in/indices/constituents/.NSEI", headers=H).json()["data"]
print(len(nifty["constituents"]), nifty["constituents"][0]["ticker"])

.NSEI is NIFTY 50; .NSEBANK, .NIFTY500 and friends work the same way.

The screener is a POST with a filter object. g means greater than, l means less than:

body = {
    "match": {"mrktCapf": {"g": 5000}, "apef": {"l": 20}, "divYield": {"g": 2}},
    "sortBy": "divYield", "sortOrder": -1,
    "project": ["subindustry", "mrktCapf", "lastPrice", "apef", "divYield", "pr1y"],
    "offset": 0, "count": 50, "sids": [],
}
res = requests.post("https://api.tickertape.in/screener/query", json=body, headers=H).json()["data"]["results"]
for row in res[:5]:
    print(row["stock"]["info"]["ticker"], row["stock"]["advancedRatios"]["divYield"])

The financial statements

The statements aren't on the API host. They're embedded in the stock page's Next.js payload. Fetch the page, pull the __NEXT_DATA__ script tag, and you get ten years of income statement, balance sheet and cash flow, plus quarterly results, dividends, corporate actions, analyst forecasts and the mutual funds holding the stock:

import json, re

html = requests.get("https://www.tickertape.in/stocks/reliance-industries-RELI", headers=H).text
data = json.loads(re.search(r'<script id="__NEXT_DATA__"[^>]*>(.*?)</script>', html, re.S).group(1))
props = data["props"]["pageProps"]

income = props["income-normal-annual"]          # list of yearly rows
print(income[-1]["displayPeriod"], income[-1]["incTrev"], income[-1]["incNinc"])

Field names are codes (incTrev is total revenue, incNinc net income). The page also ships a labels object mapping every code to its display name under the frontL key, so you can translate them in one pass.

Things that bit me

The screener returns at most 100 rows per call; paginate with offset.
Statement values are in ₹ crore.
The page payload is about 1.2 MB per stock. Cache it.
Nothing here is documented or guaranteed. Tickertape can rename a field any day, and their terms of use apply.

If you'd rather not maintain this

I packaged all of the above as a pay-per-result actor on Apify, so the endpoint mapping is my problem, not yours: Tickertape India Stocks Scraper. It has three modes: a list of tickers, a whole index, or a screener query, and it returns the statements with readable field names. A full profile costs two cents; all of NIFTY 50 with ten years of financials is about a dollar. There are runnable examples in Python, Node and n8n in this repo.

If you're after IPO data instead, Chittorgarh and InvestorGain have similar hidden report endpoints; that mapping is here.

Questions or a field you need that isn't there? Comments are open.