Indeed Job Scraper - Salaries, Skills & Company Data avatar

Indeed Job Scraper - Salaries, Skills & Company Data

Pricing

from $1.80 / 1,000 job scrapeds

Go to Apify Store
Indeed Job Scraper - Salaries, Skills & Company Data

Indeed Job Scraper - Salaries, Skills & Company Data

Indeed job data for recruiters and compensation teams: job listings, posted salaries and skills, priced per returned job with optional reports and exports.

Pricing

from $1.80 / 1,000 job scrapeds

Rating

0.0

(0)

Developer

harvestlab

harvestlab

Maintained by Community

Actor stats

0

Bookmarked

31

Total users

5

Monthly active users

a day ago

Last modified

Categories

Features

Limited permissions

Share

Collect Indeed job listings with posted salary ranges, skills, company names and source links for recruiting and compensation research. Pay per returned job; optional analysis and exports have separate events. Country domains are supported by the Actor, but access and field coverage vary.

Who it's for

  • Recruiters comparing open roles, employers and hiring locations.
  • Compensation teams analyzing employer-posted salary ranges.
  • Workforce researchers building a repeatable role-and-location dataset.

What you get

  • Job-level JSON/CSV with source IDs, posting links, available salary fields and detected skills.
  • A role-by-location comparison mode, with optional CSV salary matrices and Markdown briefings.
  • Optional AI analysis using a configured provider; it is off in the starter.

Cost example: 100 returned jobs cost 100 × $0.0024 = $0.24 on Starter/Bronze, or $0.30 at the no-discount base, with AI, comparison reports and exports off. This pricing schedule has no separate Actor startup or dataset-item event. Optional reports, exports and separately billed services can add cost. Discounts follow your Apify plan. Check current pricing.

Hiring intelligence

Use Indeed for a role-and-location view of the job market. Use ATS Hiring Signal Monitor for a selected set of company career boards, saved comparisons and new-job exports. The datasets answer different questions: repeated Indeed samples alone do not prove a company opened or closed a role.

Best first run

Open the Amsterdam data analyst example to copy the saved task into your account. It searches for data analist in the Netherlands and returns up to two jobs, which can include other Dutch cities. The saved Actor charge cap is $0.10. Two jobs cost $0.0048 in Actor events on Starter/Bronze or $0.006 at base rates with optional analysis and reports off.

The API accepts the same input.

{
"searchQuery": "data analist",
"location": "Amsterdam",
"country": "nl",
"maxJobs": 2,
"proxyConfiguration": {
"useApifyProxy": true,
"apifyProxyGroups": [
"RESIDENTIAL"
],
"apifyProxyCountry": "NL"
}
}

On November 14, 2026, build 1.8.28 returned two jobs in 23.224 seconds with this Netherlands starter. Runtime and availability can change. Check that your target query returns usable jobs before increasing maxJobs or adding comparison mode.

The existing Track remote AI jobs on Indeed task is a separate US search. Its target and defaults differ from this starter; the Netherlands check does not establish current US access.

No cookies, no OAuth, no API keys (for the scraping) - runs on public data only. Hosted AI providers need your own API key when enabled; self-hosted Ollama needs no key. Provider token charges are separate from Actor AI events.

Build live Indeed salary matrices and skill-demand reports for $0.003/listing at the base rate, or $0.0024 on Starter, $0.0021 on Scale and $0.0018 on Business. These discounts follow your Apify plan, not the number of jobs in a run. Unless a plan is named, prices and examples below use the Free/no-discount base rates; see Cost and Pricing. Total event charges depend on the jobs returned, reports and exports requested. The actor parses salary ranges, detects 70+ skills, and provides a multi-query x multi-location compare mode across 8 countries.

Indeed Job Scraper

Scrape Indeed jobs by title, keyword, location, country, job type, experience level, salary floor, posting date, and remote/hybrid/on-site filter. Each job row includes title, company, rating, location, salary fields, benefits, skills, job URL, posting date, and search context.

Indeed Salary Scraper

Extract employer-posted salary ranges and normalize them into structured salary_min, salary_max, salary_period, and currency fields. Use compare mode to benchmark compensation across roles, cities, countries, or remote-work markets.

Indeed Company Reviews And Ratings

Indeed job cards can include employer ratings from Indeed's company review system. Use those ratings alongside salary, benefits, skills, and remote-work fields to prioritize employers, screen roles, or enrich talent-market dashboards.

Use cases

  • Benchmark posted salary ranges for the same role across selected locations, keeping currencies separate.
  • Build a research feed of job titles, employers, skill mentions and source URLs.
  • Generate a comparison CSV or Markdown briefing after checking source coverage and sample size.
  • Retain dated exports for longitudinal research; distinguish source observations from verified hiring growth.

Input

ParameterTypeDefaultDescription
searchQuerystring-- (required in single-query mode)Job title or keywords (e.g., "software engineer", "marketing manager"). Hidden aliases: query, q, search, keyword, searchTerm, jobTitle.
queriesstring[]--Compare mode: list of job titles to run in parallel. Requires locations also set.
locationsstring[]--Compare mode: list of locations to run in parallel. Requires queries also set.
locationstringRemoteCity, state, zip code, or "remote" (single-query mode only). The Console starter uses Amsterdam, Netherlands; API defaults remain separate.
countryselectusIndeed country domain: us, uk, ca, au, de, fr, nl, in
maxJobsinteger3Maximum job rows for one search, or per query-location cell in compare mode (1-100). Start small, then scale after your target query is returning data. Hidden aliases: maxItems, maxResults.
datePostedselect1Posting recency filter: 1 (24h), 3 (3 days), 7 (7 days), 14 (14 days), any
jobTypeselectanyJob type: any, fulltime, parttime, contract, internship, temporary
experienceLevelselectanyExperience: any, entry, mid, senior
salaryMininteger--Minimum salary filter in local currency
remoteFilterselectanyWork arrangement: any, remote, hybrid, in_person
sortByselectrelevanceSort by: relevance or date
fetchDetailsbooleanfalseBackfill salary from job detail pages when the list card is missing it (common on sponsored/pagead cards like nursing roles). Adds ~1 extra request per missing-salary job. Off by default to keep runs fast. Hidden alias: includeDetails.
exportFormatselectnoneCompare mode only: render a briefing artifact. Options: none, csv, markdown, both. Charged $0.01 per artifact.
artifactWebhookUrlstring--Compare mode only: optional HTTPS webhook to POST artifact URLs after generation. Wire to Slack / Zapier / Make for autonomous weekly compensation briefings. Non-fatal on failure. Hidden aliases: webhookUrl, slackWebhookUrl.
enableAiAnalysisbooleanfalseGenerate AI market intelligence report (single-query) or comparison report (compare mode)
llmProviderselectopenrouterAI provider: openrouter, anthropic, google, openai, or ollama
llmModelstring--Override default AI model (leave empty for recommended default)
openrouterApiKeystring--OpenRouter API key - set OPENROUTER_API_KEY env var OR openrouterApiKey input. Get one at https://openrouter.ai/keys.
anthropicApiKeystring--Anthropic API key - set ANTHROPIC_API_KEY env var OR anthropicApiKey input. Get one at https://console.anthropic.com/settings/keys.
googleApiKeystring--Google AI API key - set GOOGLE_API_KEY env var OR googleApiKey input. Get one at https://aistudio.google.com/app/apikey.
openaiApiKeystring--OpenAI API key - set OPENAI_API_KEY env var OR openaiApiKey input. Get one at https://platform.openai.com/api-keys.
ollamaBaseUrlstringhttp://localhost:11434Ollama base URL for self-hosted AI. Set ollamaBaseUrl input or run Ollama locally. Install at https://ollama.com/download.
proxyConfigurationproxyRESIDENTIALProxy settings. Indeed aggressively blocks datacenter IPs - RESIDENTIAL is strongly recommended. When Apify Proxy is enabled and no country is set, the actor auto-selects the exit country for the chosen Indeed domain.

Full Example Input

{
"searchQuery": "data analyst",
"location": "Remote",
"country": "us",
"maxJobs": 3,
"datePosted": "1",
"jobType": "any",
"experienceLevel": "any",
"remoteFilter": "any",
"sortBy": "relevance",
"enableAiAnalysis": true,
"llmProvider": "openrouter",
"openrouterApiKey": "sk-or-..."
}

Real sample output

These two records are selected fields from the accepted Netherlands starter on November 13, 2026. The first posting did not expose a salary; missing values remain null. These historical observations are not a guarantee that the vacancies remain open.

[
{
"job_id": "e95c4bb0072e4f1c",
"title": "Privacy, Data and AI Analyst - EMEA",
"company_name": "Tesla",
"location": "Amsterdam",
"salary_min": null,
"salary_max": null,
"salary_period": null,
"currency": "EUR",
"url": "https://nl.indeed.com/viewjob?jk=e95c4bb0072e4f1c",
"scraped_at": "2026-11-13T13:42:48.372815+00:00"
},
{
"job_id": "89a236122de298b2",
"title": "Data analist Lenen, Sparen & Retailbeleggen",
"company_name": "Autoriteit Financiele Markten",
"location": "Amsterdam",
"salary_min": 52500,
"salary_max": 103500,
"salary_period": "yearly",
"currency": "EUR",
"url": "https://nl.indeed.com/viewjob?jk=89a236122de298b2",
"scraped_at": "2026-11-13T13:42:48.777896+00:00"
}
]

Output field reference

FieldTypeDescription
job_idstring16-char Indeed job key (e.g. d55eb1a8c9e4bbe8)
titlestringJob title as posted
company_namestringEmployer name
company_ratingfloatIndeed employer rating (1.0-5.0) when available
locationstringCity, state / region as posted
is_remotebooleanTrue if the listing is tagged remote
salary_textstringRaw salary string from the listing
salary_min / salary_maxnumberParsed numeric salary range
salary_periodstringhourly, daily, weekly, monthly, or yearly
salary_currencystringISO-ish currency code (USD, GBP, EUR, etc.) - legacy field
currencystringPortfolio-standard ISO 4217 currency code - prefer this
job_typestringfull-time, part-time, contract, internship, temporary
description_snippetstringFirst ~500 chars of the job description
posted_datestringISO 8601 posting date or original relative label when a date cannot be established
job_urlstringDirect viewjob?jk=... link - legacy field
urlstringPortfolio-standard URL field - prefer this
benefitsstring[]Extracted perk labels (health, 401k, RSU, etc.)
skills_mentionedstring[]70+ tech + business skills detected in title + description
search_query / search_location / search_countrystringEcho of the original request
scraped_atstringISO 8601 UTC timestamp

For Netherlands search results with structured data, a valid ISO posting date or timezone-qualified publication timestamp takes priority. A positive numeric pubDate in Unix seconds or milliseconds supplies the publication day in Europe/Amsterdam, with a UTC day fallback when the time zone is unavailable. Recognized labels such as “Zojuist geplaatst” and “1 dag geleden” yield an estimated calendar date based on the response observation day in Europe/Amsterdam. Keep unresolved raw labels, including “30+ dagen geleden” and employer activity, out of posting-date comparisons. Use scraped_at separately to track when a listing was observed.

Field migration note: salary_currency and job_url are retained for backward compatibility, but both dual-emit the portfolio-standard currency and url alongside. New integrations should read currency and url; legacy names will be dropped in a future release.

AI Market Intelligence Output

When enableAiAnalysis is enabled, an additional dataset item contains a comprehensive market report including:

  • Salary benchmarking -- 25th, 50th, 75th, and 90th percentile salary ranges for the searched role
  • Top skills by frequency -- ranked list of the most mentioned technical and professional skills
  • Company hiring volume -- which companies are posting the most jobs and at what salary levels
  • Remote vs on-site ratios -- breakdown of work arrangement preferences in the market
  • Top-paying listings -- highest compensation packages with company and requirements details
  • Market temperature -- hiring velocity, competition level, and demand indicators
  • Actionable recommendations -- tailored advice for job seekers, recruiters, and hiring managers

Cost and Pricing

This actor uses pay-per-event pricing with no separate Actor rental fee. Starter (Bronze), Scale (Silver) and Business (Gold) receive 20%, 30% and 40% off all events below. Platinum and Diamond use the Business/Gold amounts. Discounts depend on your Apify subscription plan, not a per-run quantity threshold. The live Pricing tab shows your applicable prices.

All amounts are USD per event. Optional AI-provider charges are separate from these Actor events.

EventFree / baseStarter / BronzeScale / SilverBusiness / GoldWhen it applies
job-scraped$0.003$0.0024$0.0021$0.0018Each stored job row, deduplicated within its search. The same job can be billed once per compare cell where it is saved.
ai-analysis-completed$0.05$0.04$0.035$0.03A single-query AI market intelligence report is generated
market-comparison-report$0.10$0.08$0.07$0.06A multi-query compare-mode report is generated
export-csv-generated$0.01$0.008$0.007$0.006Each compare-mode CSV salary-matrix artifact
export-markdown-generated$0.01$0.008$0.007$0.006Each compare-mode Markdown briefing artifact

vs. commercial alternatives: Indeed's Employer API requires partner approval and starts at enterprise pricing ($5k+/mo); Adzuna API charges $0.01-$0.05/job; Reed.co.uk charges £500+/mo for bulk job data; Brilliant.jobs data feeds start at $499/mo. This actor uses pay-per-event - $0.003/job listing with no subscription and no partner approval needed.

Base-rate event subtotal examples: Multiply these Actor-event subtotals by 0.8 on Starter, 0.7 on Scale or 0.6 on Business. For example, 100 jobs without AI or exports cost $0.30 at base rates, $0.24 on Starter, $0.21 on Scale or $0.18 on Business. These are event subtotals, not all-in quotes; optional external-provider charges are separate.

In compare mode, multiply maxJobs by the number of query-location cells, up to 16. At 100 rows per cell and 16 cells, 1,600 job events would cost $4.80 at base rates, $3.84 on Starter, $3.36 on Scale or $2.88 on Business before optional report and export events. Actual charges depend on saved rows and your maximum Actor charge. Set that cap before starting.

ScenarioJobsAI EventExportBase event subtotal
Quick salary check10nonenone$0.03
Role market analysis (single query)25$0.05 ai-analysisnone$0.125
Full market intelligence (single query)50$0.05 ai-analysisnone$0.20
Large-scale data collection100$0.05 ai-analysisnone$0.35
Compare 3 roles x 4 cities at 25/cell300$0.10 comparisonnone$1.00
Weekly Slack briefing: 3 roles x 4 cities300$0.10 comparisonCSV+MD ($0.02)$1.02
Daily Slack tracker: 2 roles x 3 cities150$0.10 comparisonCSV+MD ($0.02)$0.57

How we compare to other Indeed scrapers on Apify

ScraperPriceModelAI Analysis
This actorBase: $3/1K jobs + $0.05/AI report; plan discounts abovePay-per-event, no Actor rental feeYes (5 providers)
misceres/indeed-scraper$3/1KPay-per-resultNo
borderline/indeed-scraper$5/1KPay-per-resultNo
memo23/apify-indeed-cheerio$29/month + usageRental + usageNo
curious_coder/indeed-scraper$20/month + usageRental + usageNo

Quick Start

Use the Netherlands input in Best first run, inspect the returned jobs and missing fields, then save your own task with the role, location and country you need. Confirm that target's output before increasing the cap or adding paid analysis.

Weekly compensation briefing example

This example compares three roles across three locations and requests CSV and Markdown exports. Save your own task and configure a schedule separately if you want weekly runs. Delivery requires your own authorized webhook; the JSON alone does not create a schedule.

{
"queries": ["data engineer", "ML engineer", "AI engineer"],
"locations": ["New York, NY", "San Francisco, CA", "Remote"],
"country": "us",
"datePosted": "7",
"exportFormat": "both",
"enableAiAnalysis": true,
"llmProvider": "openrouter",
"openrouterApiKey": "sk-or-...",
"artifactWebhookUrl": "https://hooks.slack.com/services/YOUR/WEBHOOK/HERE",
"maxJobs": 50
}
  1. Replace the example roles, locations, provider key and webhook with your own configuration; omit the webhook if no delivery is needed.
  2. Run a small sample and inspect the jobs and generated files.
  3. Save that input as a task, then configure an Apify Schedule with the timezone and cadence you intend.

Base-rate event subtotal: The 3-role x 3-location weekly template above can return up to 450 jobs: 450 x $0.003 + one $0.10 compare report + $0.02 for CSV/Markdown exports = $1.47. The same events cost $1.176 on Starter, $1.029 on Scale or $0.882 on Business. These figures exclude external AI-provider charges and are not all-in run quotes.

Multi-Query Compare Mode (v1.6+)

Supply queries and locations as arrays to run the full N x M grid in one job and get a single cross-role / cross-location AI comparison report:

{
"queries": ["data scientist", "ML engineer", "AI researcher"],
"locations": ["New York, NY", "San Francisco, CA", "Austin, TX", "Remote"],
"country": "us",
"maxJobs": 25,
"enableAiAnalysis": true,
"llmProvider": "openrouter",
"openrouterApiKey": "sk-or-..."
}

The actor runs 3 x 4 = 12 parallel searches (max 8 concurrent), writes every job to the dataset tagged with its search_query and search_location, and pushes a market_comparison_report item containing the median-salary matrix, highest-paying combinations, geo premium analysis, hottest skills overall, and emerging-skill gaps between roles. Grid is capped at 16 cells to protect proxy budget.

Compare mode charges a single $0.10 market-comparison-report event in place of the $0.05 ai-analysis-completed event.

Compare-Mode Export Artifacts (v1.7+)

Autonomous weekly compensation briefings. Set exportFormat to "csv", "markdown", or "both" and the actor renders a ready-to-share artifact on top of the raw dataset:

  • "csv" -- RFC-4180 salary-matrix spreadsheet. Loads cleanly into Google Sheets, Tableau, Power BI, Excel.
  • "markdown" -- README-style executive brief designed for direct paste into Slack / Notion / email.
  • "both" -- emit both. Charged $0.01 per artifact.

Each artifact is available from the run storage as compare-{run_id}.csv / .md, and the public URL is included as an export_artifact dataset item. CSV schema 1.1 keeps one row per query/location cell and adds salary_currency_status plus JSON salary_currency_groups. Each observed currency retains separate annualized counts, quantiles and original salary observations. Mixed or unknown units have no pooled cell median; no exchange-rate conversion or cross-currency pay ranking is performed. Unknown-unit amounts remain in the groups, while their aggregate quantiles stay null.

Pair with the optional artifactWebhookUrl input and Apify Scheduler for an autonomous weekly comp-briefing pipeline:

{
"queries": ["data scientist", "ML engineer"],
"locations": ["New York, NY", "San Francisco, CA", "Remote"],
"country": "us",
"maxJobs": 25,
"enableAiAnalysis": true,
"llmProvider": "openrouter",
"openrouterApiKey": "sk-or-...",
"exportFormat": "both",
"artifactWebhookUrl": "https://hooks.slack.com/services/T00/B00/XXXX"
}

Every Monday at 8 AM, the actor scrapes 2 roles x 3 cities, writes a Markdown brief + CSV matrix to key-value storage, and POSTs the URLs to your Slack / Zapier / Make webhook. At base rates, the event subtotal is $0.57 for 25 jobs per cell or $1.02 for 50 jobs per cell, including one comparison report and both export artifacts. Apply your plan discount from the pricing table; external AI-provider charges are separate.

More Examples

Basic job search - scrape software engineer jobs in San Francisco:

{
"searchQuery": "software engineer",
"location": "San Francisco, CA",
"maxJobs": 25,
"country": "us"
}

Multi-query market research - compare salaries across roles in one city:

{
"queries": ["data scientist", "machine learning engineer", "AI researcher"],
"locations": ["New York, NY"],
"maxJobs": 10,
"country": "us"
}

Remote jobs with AI analysis - find remote Python developer jobs and get market intelligence:

{
"searchQuery": "Python developer remote",
"maxJobs": 50,
"enableAiAnalysis": true,
"llmProvider": "openrouter",
"openrouterApiKey": "YOUR_KEY"
}

MCP Quickstart - call this actor from Claude / Cursor / ChatGPT

Open Apify's hosted MCP server with this actor selected:

https://mcp.apify.com?tools=harvestlab/indeed-scraper

Then prompt the agent:

"Use the harvestlab/indeed-scraper actor on Apify to compare salaries for 'machine learning engineer' between New York, San Francisco, and Remote with AI matrix analysis and CSV export. Push the results back as JSON."

Through Apify MCP, the agent will discover the actor schema, generate the right input, run it, and pipe the typed output back into your conversation.

Use with AI agents

Use the structured job rows and optional comparison reports in a recruiting or compensation workflow. Keep the source job IDs and observation timestamps, preserve missing salaries, and check target access before relying on recurring exports.

The Python examples below use apify-client 3.x, langchain-core and langgraph (tested with 3.4.0 / 1.7.6 / 1.2.20). Set APIFY_TOKEN privately in your environment. Calling the tool or graph starts a billable Actor run; constructing them does not. Start with one role and one location.

The default is AI off: native CSV supplies the observed, annualized salary matrix, and missing salaries remain None. The parser accepts legacy CSV 1.0 (with group provenance marked legacy_unverified) and currency-aware CSV 1.1. For 1.1, inspect salary_currency_groups for each currency's observations; mixed/unknown cells legitimately have null top-level quantiles. CSV and Markdown each add their existing $0.01 artifact event, alongside job events and applicable platform usage. Optional AI requires enableAiAnalysis=True and your local OPENROUTER_API_KEY; hosted-provider token charges are separate. Its completed report is optional interpretation, not a replacement for the observed matrix.

LangChain - structured salary-comparison tool:

import csv
import io
import json
import os
from datetime import timedelta
from decimal import Decimal, InvalidOperation
from apify_client import ApifyClient
from langchain_core.tools import tool
client = ApifyClient(os.environ["APIFY_TOKEN"])
def parse_salary_matrix(record: dict, expected: set[tuple[str, str]], country: str,
max_jobs: int) -> list[dict]:
if (not isinstance(record, dict) or not isinstance(record.get("value"), str)
or record.get("content_type", "").split(";")[0].lower() != "text/csv"
or len(record["value"]) > 100000):
raise RuntimeError("Expected the completed run's native salary CSV")
reader = csv.DictReader(io.StringIO(record["value"]))
required = {"query", "location", "country", "jobs_count", "salaried_jobs_count",
"median_yearly", "p25", "p75", "currency", "schema_version"}
if not required.issubset(reader.fieldnames or []):
raise ValueError("Incomplete salary CSV columns")
rows, seen, matrix = list(reader), set(), []
if len(rows) != len(expected):
raise ValueError("Incomplete comparison grid")
def amount(value):
try:
number = Decimal(str(value).replace(",", "")) if value is not None and str(value).strip() else None
except InvalidOperation:
raise ValueError("Invalid salary CSV amount") from None
if number is not None and (not number.is_finite() or number < 0):
raise ValueError("Invalid salary CSV amount")
return float(number) if number is not None else None
for row in rows:
key = (row["query"], row["location"])
version = row["schema_version"]
if (key not in expected or key in seen or row["country"] != country.upper()
or version not in {"1.0", "1.1"}):
raise ValueError("Unexpected salary CSV cell")
seen.add(key)
jobs, salaried = int(row["jobs_count"]), int(row["salaried_jobs_count"])
if not 0 <= salaried <= jobs <= max_jobs:
raise ValueError("Invalid salary observation counts")
values = {field: amount(row[field]) for field in ("median_yearly", "p25", "p75")}
status, groups = "legacy_unverified", None
if version == "1.0":
# Legacy CSV has no currency groups: preserve its fields, infer none.
if (salaried == 0 and any(v is not None for v in values.values())) or (
salaried > 0 and any(v is None for v in values.values())):
raise ValueError("Salary counts and amounts disagree")
else:
if not {"salary_currency_status", "salary_currency_groups"}.issubset(row):
raise ValueError("Missing salary currency groups")
groups = json.loads(row["salary_currency_groups"])
if not isinstance(groups, list):
raise ValueError("Invalid salary currency groups")
codes, counted = set(), 0
for group in groups:
if not isinstance(group, dict):
raise ValueError("Invalid salary currency group")
code, count = group.get("currency"), group.get("salaried_jobs_count")
if (not isinstance(code, str) or not code or code in codes
or type(count) is not int or not 0 < count <= salaried):
raise ValueError("Invalid salary currency group counts")
codes.add(code)
counted += count
quantiles = [amount(group.get(field)) for field in ("median_yearly", "p25", "p75")]
if (code == "UNKNOWN" and any(v is not None for v in quantiles)) or (
code != "UNKNOWN" and any(v is None for v in quantiles)):
raise ValueError("Unknown units must not be pooled")
yearly = group.get("yearly_values")
observations = group.get("salary_observations")
if (not isinstance(yearly, list) or len(yearly) != count
or any(amount(v) is None for v in yearly)
or not isinstance(observations, list) or len(observations) != count):
raise ValueError("Missing original salary observations")
for observation in observations:
if (not isinstance(observation, dict)
or amount(observation.get("yearly_estimate")) is None
or all(amount(observation.get(k)) is None for k in ("salary_min", "salary_max"))):
raise ValueError("Invalid original salary observation")
status = ("not_available" if not groups else "mixed" if len(groups) > 1
else "unknown" if "UNKNOWN" in codes else "single")
currency = (groups[0]["currency"] if status == "single" else "MULTIPLE" if status == "mixed"
else "UNKNOWN" if status == "unknown" else "")
if (counted != salaried or row["salary_currency_status"] != status
or row["currency"] != currency
or (status == "single" and any(v is None for v in values.values()))
or (status != "single" and any(v is not None for v in values.values()))):
raise ValueError("Salary currency counts and aggregates disagree")
matrix.append({"query": key[0], "location": key[1], "country": row["country"],
"jobs_count": jobs, "salaried_jobs_count": salaried,
"currency": row["currency"], "salary_currency_status": status,
"salary_currency_groups": groups, **values})
return matrix
@tool("compare_indeed_salaries")
def compare_indeed_salaries_tool(queries: list[str], locations: list[str], country: str = "us",
maxJobs: int = 2, enableAiAnalysis: bool = False) -> dict:
"""Compare observed Indeed salary cells; optionally add a BYOK AI report."""
queries = list(dict.fromkeys(q.strip() for q in queries if q.strip()))
locations = list(dict.fromkeys(loc.strip() for loc in locations if loc.strip()))
country = country.lower()
if (country not in {"us", "uk", "ca", "au", "de", "fr", "nl", "in"}
or not queries or not locations or len(queries) * len(locations) > 4
or not 1 <= maxJobs <= 3):
raise ValueError("Use 1-4 query/location cells, 1-3 jobs per cell and a supported country")
inputs = {"queries": queries, "locations": locations, "country": country, "maxJobs": maxJobs,
"fetchDetails": False, "exportFormat": "both", "enableAiAnalysis": enableAiAnalysis,
"artifactWebhookUrl": "", "webhookUrl": "", "slackWebhookUrl": "",
"proxyConfiguration": {"useApifyProxy": True, "apifyProxyGroups": ["RESIDENTIAL"]}}
if enableAiAnalysis:
key = os.environ.get("OPENROUTER_API_KEY", "").strip()
if not key:
raise ValueError("Set OPENROUTER_API_KEY privately before requesting optional AI")
inputs.update(llmProvider="openrouter", openrouterApiKey=key)
run = client.actor("harvestlab/indeed-scraper").call(
run_input=inputs, memory_mbytes=256, run_timeout=timedelta(seconds=180),
max_total_charge_usd=Decimal("0.25" if enableAiAnalysis else "0.10"), restart_on_error=False)
if (run is None or run.status != "SUCCEEDED" or not run.default_dataset_id
or not run.default_key_value_store_id):
raise RuntimeError("Run did not complete; inspect its status before consuming output")
items = list(client.dataset(run.default_dataset_id).iterate_items(limit=100))
jobs = [item for item in items if item.get("job_id") and not item.get("diagnostic_item")]
artifacts = [item for item in items if item.get("type") == "export_artifact"]
if len(artifacts) != 1 or artifacts[0].get("run_id") != run.id:
raise RuntimeError("No complete comparison export; inspect this run's dataset diagnostics")
artifact = artifacts[0]
base = f"https://api.apify.com/v2/key-value-stores/{run.default_key_value_store_id}/records/compare-{run.id}"
if artifact.get("csv_url") != base + ".csv" or artifact.get("markdown_url") != base + ".md":
raise RuntimeError("Unexpected comparison artifact identity")
try:
record = client.key_value_store(run.default_key_value_store_id).get_record(f"compare-{run.id}.csv")
except Exception:
raise RuntimeError("Salary CSV unavailable; retain the completed run for inspection") from None
expected = {(q, loc) for q in queries for loc in locations}
matrix = parse_salary_matrix(record, expected, country, maxJobs)
if (artifact.get("grid_cells") != len(matrix) or artifact.get("total_jobs") != len(jobs)
or sum(cell["jobs_count"] for cell in matrix) != len(jobs)):
raise RuntimeError("Comparison dataset and CSV counts disagree")
analysis = next((item["analysis"] for item in items
if item.get("type") == "market_comparison_report" and not item.get("error")
and isinstance(item.get("analysis"), dict) and item["analysis"]
and not any(k in item["analysis"] for k in ("error", "parse_error", "raw_analysis", "raw_response"))), None)
return {"run_id": run.id, "jobs": jobs, "salary_matrix": matrix,
"csv_url": artifact["csv_url"], "markdown_url": artifact["markdown_url"],
"ai_analysis": analysis,
"ai_status": "completed" if analysis else ("not_returned" if enableAiAnalysis else "not_requested")}
# result = compare_indeed_salaries_tool.invoke({"queries": ["Python developer"], "locations": ["Remote"]})

The limits above bound this example, not the Actor's full schema. The charge limit covers Actor events; inspect actual platform/provider usage separately. Runs without a completed native export raise an explicit error. Returned zero-job cells retain zero counts and None salaries; they are not observations of market salary. Retrying an export does not require starting another scrape. salary_matrix contains the native CSV's per-cell counts, currency, median and quartiles, with blank salaries represented as None. Keep currencies explicit and do not treat undisclosed salaries as zero or this small sample as a population benchmark.

LangGraph - observed salary-matrix node:

from typing import TypedDict
from langgraph.graph import StateGraph, START, END
# Run the LangChain block above first; this node reuses its bounded tool.
class SalaryState(TypedDict, total=False):
role: str
locations: list[str]
country: str
enableAiAnalysis: bool
run_id: str
jobs: list[dict]
salary_matrix: list[dict]
ai_analysis: dict | None
ai_status: str
geo_premium_analysis: dict | None
csv_url: str
markdown_url: str
def salary_benchmark_node(state: SalaryState) -> SalaryState:
result = compare_indeed_salaries_tool.invoke({
"queries": [state["role"]], "locations": state["locations"],
"country": state.get("country", "us"), "maxJobs": 2,
"enableAiAnalysis": state.get("enableAiAnalysis", False)})
analysis = result["ai_analysis"] or {}
return {**state, **result, "geo_premium_analysis": analysis.get("geo_premium_analysis")}
graph = StateGraph(SalaryState)
graph.add_node("salary_benchmark", salary_benchmark_node)
graph.add_edge(START, "salary_benchmark")
graph.add_edge("salary_benchmark", END)
salary_benchmark = graph.compile()
# result = salary_benchmark.invoke({"role": "Python developer", "locations": ["Remote"], "country": "us"})

The graph returns the observed salary_matrix even when AI is off or no AI report completes. With explicit BYOK AI, additional fields live in the completed record's analysis, including geo_premium_analysis; they are not top-level job fields. Constructing a graph does not schedule runs, retain prior observations or send notifications. Save or deliver its results only through your authorized workflow. Source blocking, sample size and employer salary disclosure still limit the comparison.

See Apify's actor-templates/js-langchain and js-langgraph-agent for full reference setups.

Troubleshooting

Getting blocked or 0 results returned Check the affected run for a source block, rate limit, or empty result. Verify that the configured proxy location matches the intended country domain. Use the two-job Netherlands starter above to see a bounded example of the expected output.

Salary data missing for most jobs Salary is employer-provided and often not disclosed. The actor captures salary when present; missing salary results in null fields, not an error. Enable fetchDetails to backfill salary from job detail pages for sponsored listings that omit salary on the list card.

Jobs appear duplicated across result pages Indeed sometimes serves the same promoted job listing on multiple search pages. The actor deduplicates by job_id within a single search or compare-mode cell. A job can appear and be billed in multiple cells because each row records a query-location match. Use job_id to deduplicate across cells or runs when you need a list of unique jobs.

AI comparison fails for multi-query runs Compare mode starts when both queries and locations are nonempty; one role and one location is a valid 1×1 comparison. Native CSV/Markdown salary matrices work with AI off. A completed AI comparison additionally requires enableAiAnalysis: true and a configured hosted-provider key (or your reachable self-hosted Ollama); its fields are nested under analysis in a type: "market_comparison_report" record.

CSV/Markdown export not appearing in dataset Compare-mode files are stored in the run's key-value store. A successful export adds a dataset reference with type: "export_artifact", csv_url and markdown_url; inspect the raw default dataset JSON if a selected view hides that record. File keys are compare-{run_id}.csv / .md. The salary matrix works with AI off; missing exports should be investigated in that exact run's diagnostics rather than inferred from an AI report.

Persistent 403 responses or CAPTCHA Inspect the affected run’s logs and any diagnostics in the default dataset. Stop the batch if the block persists. Repeated blocked runs can consume platform or proxy resources without returning jobs. Treat the intended market as unavailable for that run. The two-job Netherlands starter verified the Amsterdam query only. Access to the US or another market remains unverified by that run.

Frequently Asked Questions

How accurate is the salary data? The actor extracts salary information directly from Indeed job postings. Salary data is only available for jobs that include salary in their listings; coverage depends on the role and market. The automatic parser normalizes all formats (hourly, yearly, K notation, ranges) into consistent structured fields.

Which countries are supported? The actor supports 8 Indeed country domains: United States (us), United Kingdom (uk), Canada (ca), Australia (au), Germany (de), France (fr), Netherlands (nl), and India (in). Each country uses the localized Indeed domain for accurate local results.

How does skill detection work? The actor scans job titles + description snippets against a library of 70+ technical and professional skills including programming languages, cloud platforms, data/ML tooling, frameworks, infrastructure tools, AI tools, and business systems.

How does compare mode work? Set queries (e.g. ["data scientist", "ML engineer", "AI researcher"]) and locations (e.g. ["New York, NY", "San Francisco, CA", "Remote"]) instead of the single searchQuery / location fields. Arrays take precedence. The actor runs the full N x M grid of searches in parallel (8 concurrent, capped at 16 cells), tags every job with its search_query and search_location, and - if enableAiAnalysis is true - produces a single market_comparison_report with a median-salary matrix, highest-paying combinations, geo premium analysis, hottest skills, and emerging skill gap callouts.

Can I track hiring trends over time? Yes. Schedule regular runs on Apify (weekly or monthly) for the same search queries and locations. Over time, you build a longitudinal dataset showing changes in job volume, salary ranges, skill demand, and remote work adoption.


Scheduling and webhooks

Set up weekly Indeed runs in Apify Console to keep a live pipeline of fresh job postings for a target role and location. Use Apify webhooks for run-completion delivery, or use artifactWebhookUrl in compare mode to POST CSV/Markdown artifact URLs into Slack, n8n, Zapier, Make, Notion, or Airtable. Typical pipeline: AI Engineer San Francisco weekly -> Apify webhook -> Slack alert for postings with salary above USD 180k.


This actor scrapes publicly available data. By using this actor, you agree to the following:

  • Your responsibility: You are solely responsible for ensuring your use complies with all applicable laws, regulations, and the target website's terms of service. This includes but is not limited to GDPR (EU), CCPA (California), and other data protection laws in your jurisdiction.
  • No legal advice: This actor does not constitute legal advice. Consult a qualified attorney if you have questions about the legality of your specific use case.
  • Intended use: This actor is designed for legitimate business purposes such as market research, competitive analysis, and academic research using publicly accessible data.
  • Data handling: You are responsible for how you store, process, and share any data collected. Ensure you have a lawful basis for processing any personal data under applicable privacy laws.
  • Rate limiting: This actor implements polite crawling practices including request delays and retry backoff to minimize impact on target servers.
  • No warranty: This actor is provided "as is" without warranty. Data accuracy depends on the target website's content and structure.
  • Job data: Indeed's terms of service restrict automated data collection. Job listings are provided for informational and research purposes. Do not use scraped data to create competing job board services.
  • Personal data notice: Job listings may contain names of hiring managers or company representatives. Under GDPR and similar regulations, even publicly available personal data may be subject to data protection requirements. Ensure you have a lawful basis (such as legitimate interest) for collecting and processing this data. Implement appropriate data retention policies.

Limitations

  • Source access varies by market and query. Follow Troubleshooting when a run hits a persistent HTTP 403 or CAPTCHA. Treat access to each market as its own check.
  • Salary data is only available for jobs that include salary information in their listings (not all do).
  • Skills detection is based on pattern matching from job description snippets, not full job descriptions -- some skills may be missed.
  • AI analysis quality depends on the number of jobs scraped (25+ recommended) and the AI model chosen.
  • Indeed's HTML structure may change; the actor uses multiple parsing strategies for resilience but temporary disruptions are possible.
  • Maximum 100 job rows for one search, or 100 per query-location cell in compare mode. Compare mode processes at most 16 cells.
  • Job posting recency depends on Indeed's internal date tracking, which may not always be precise.

Tips for Reliable Runs

  • Use specific job titles. "Senior Data Engineer" returns more targeted results than generic terms like "data" or "engineer."
  • Filter by date posted. Set datePosted to 1 or 3 to focus on active, current openings rather than stale listings and reduce blocked broad-result pages.
  • Enable AI analysis for salary benchmarking. The AI report synthesizes salary data across all scraped jobs into actionable percentile ranges.
  • Scale after a small pass. Use a small limit on the intended query. Increase volume for skill-demand or AI benchmarking only after you receive usable jobs.
  • Compare across locations. Run the same search query in multiple cities to understand geographic salary differences.
  • Use residential proxies for large runs. For scraping 50+ jobs, residential proxies improve reliability.
  • Monitor New Jobs Only — To follow selected employers over time, supply their supported ATS board URLs, save a baseline, and export newly observed roles on later runs. The first baseline and unchanged repeats return no job rows; source scan fees still apply. Company names from Indeed are not automatically converted to ATS boards.
  • Website Contact Extractor — Extract public contact details from company websites you supply, with optional email checks and tech-stack signals. Available contacts depend on what each website publishes.

Share feedback from your run

If you have used the output, an honest Store review can help other users decide whether this Actor fits their workflow. Describe what worked and what did not. For a problem that needs investigation, open an issue with the relevant run ID and expected output, omitting credentials and private data.