# India Entry-Level IT Jobs Scraper (`scrapers-hub/india-it-jobs-multi-source-scraper`) Actor

India Entry-Level IT Jobs Scraper aggregates fresher tech roles across multiple job boards - title, company, city, experience, skills, salary, job type, apply link and posted date. 💼 For job aggregators, recruiters and hiring analysis.

- **URL**: https://apify.com/scrapers-hub/india-it-jobs-multi-source-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## India Entry-Level IT Jobs Scraper

### 💼 India Entry-Level IT Jobs Scraper – Fresher Job Listings From 13 ATS Sources

The **India entry-level IT jobs scraper** collects fresher and junior software job listings from thirteen recruitment sources in a single run, including LinkedIn and twelve applicant tracking systems used by Indian and global employers. Rather than checking Greenhouse, Lever, Workday, Darwinbox, Keka, Zoho and the rest one at a time, this India entry-level IT jobs scraper queries them concurrently and returns one normalised dataset of job listings with company, location, apply link and posted date.

The problem it solves is fragmentation. Indian tech hiring is spread across a long tail of ATS platforms — a startup on Lever, a mid-market firm on Keka, an enterprise on Workday, a services company on Darwinbox — and each has its own job board format. Aggregators lag behind, and many stale postings never get removed. Pulling directly from the source boards, with a `posted_within` filter defaulting to jobs posted today, gives you a fresher and more complete view of entry-level IT job data than any single portal provides.

***

### 📊 What Data Can You Extract with This India IT Jobs Scraper?

Each dataset item is one job listing, normalised across every source:

| Category | Fields | What you get |
|---|---|---|
| 📋 Role identity | `title`, `company`, `description` | The advertised job title, the hiring company, and the long-form description text where the source provides it |
| 📍 Location | `city`, `state`, `country` | Split location components, so you can filter to Bengaluru, Hyderabad, Pune or remote roles without string parsing |
| 🎓 Requirements | `experience`, `skills` | Required experience level and listed skills, which is what separates a genuine fresher role from a mislabelled one |
| 💰 Compensation | `salary` | Advertised salary where the employer discloses it |
| 🕒 Recency | `posted_date_raw`, `posted_date_parsed` | The source's original date string plus a normalised UTC timestamp for reliable sorting |
| 🔗 Application | `apply_link`, `job_type` | Direct link to the application page and the employment type |
| 🏷️ Provenance | `source` | Which of the thirteen sources produced the listing |

The `posted_date_parsed` field deserves particular attention. Every ATS formats dates differently — ISO 8601 with an offset from Greenhouse, relative strings like "2 days ago" from LinkedIn, local formats elsewhere. Having a single normalised UTC value alongside the raw string means you can sort a merged multi-source result set chronologically without writing a parser per platform, which is exactly the work that usually makes multi-source job aggregation painful.

***

### 🌟 Key Features of the India IT Jobs Scraper

| Feature | Description |
|---|---|
| 🌐 13 job sources | LinkedIn plus Greenhouse, Lever, SmartRecruiters, Workday, iCIMS, Jobvite, BambooHR, Zoho, Freshteam, Keka, Darwinbox and Recruitee |
| 🔤 Automatic keyword expansion | LinkedIn searches are expanded into synonym variants, up to `max_keyword_variants`, so "software engineer fresher" also catches equivalent phrasings |
| ⏱️ Recency filtering | `posted_within` restricts results to jobs posted today, in the last 24 hours, this week, or any time |
| ⚡ Concurrent source scraping | `source_concurrency` controls how many sources are queried in parallel, with LinkedIn variants concurrent separately |
| 🎚️ Fast and thorough modes | `execution_mode` trades shorter timeouts and fewer retries against completeness |
| 🛑 Wall-clock budgets | `run_timeout_seconds` and `source_timeout_seconds` cap total and per-source runtime so a slow board cannot stall the job |
| 📊 Per-source result caps | `max_results_per_source` prevents one prolific board from dominating the dataset |
| 🗓️ Normalised dates | Every listing carries both the raw source date and a parsed UTC timestamp |
| 🔗 Direct apply links | `apply_link` points at the employer's own application page, not an intermediary |

***

### 🚀 Why Choose This India Entry-Level IT Jobs Scraper?

**Direct-from-ATS data, not aggregator leftovers.** Listings come from the applicant tracking systems employers actually post into — Greenhouse's board API, Lever's API, SmartRecruiters' API and the rest. That means fewer stale postings, fewer duplicates from reposting agencies, and an `apply_link` that goes straight to the employer.

**Recency you can trust and control.** The default `posted_within` value is `today`, which is deliberately aggressive. Job boards are full of roles that were filled weeks ago. Being able to constrain the window to today or 24 hours, and to sort reliably on `posted_date_parsed`, is what makes the output usable for daily job alerts rather than an archive.

**Synonym expansion for LinkedIn coverage.** Indian entry-level tech roles are advertised under a wide range of titles — fresher, graduate engineer trainee, associate software engineer, junior developer, GET. The scraper expands your base `keywords` phrase into up to `max_keyword_variants` synonyms for LinkedIn, catching listings a single literal query would miss.

**Runtime you can budget.** Multi-source scraping normally means unpredictable run lengths. Here, `run_timeout_seconds`, `source_timeout_seconds` and `execution_mode` give you explicit control: a slow or unresponsive board is dropped for that run rather than blocking everything else.

***

### 📥 Input

```json
{
  "sources": [
    "linkedin", "greenhouse", "lever", "smartrecruiters", "workday",
    "icims", "jobvite", "bamboohr", "zoho", "freshteam",
    "keka", "darwinbox", "recruitee"
  ],
  "keywords": "software engineer fresher",
  "location": "India",
  "posted_within": "today",
  "job_type": "both",
  "max_results_per_source": 100,
  "max_keyword_variants": 20,
  "execution_mode": "fast",
  "run_timeout_seconds": 180,
  "source_timeout_seconds": 120,
  "source_concurrency": 6,
  "linkedin_variant_concurrency": 2
}
```

#### 🔧 India IT Jobs Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `sources` | array | No | all 13 sources | Which job sources to query. The ATS sources (greenhouse, lever, smartrecruiters, workday, recruitee, icims, jobvite, bamboohr, zoho, freshteam, keka, darwinbox) all require company identifiers in `companies_seed.json` |
| `keywords` | string | No | `software engineer fresher` | Base job title or keyword phrase to search for. LinkedIn expands this into multiple synonym variants automatically |
| `location` | string | No | `India` | Location filter applied when searching and filtering jobs |
| `posted_within` | string | No | `today` | Only keep jobs posted within this window. One of `today`, `24h`, `week`, `any` |
| `job_type` | string | No | `both` | Employment type filter. One of `both`, `full-time`, `internship`, `part-time`, `contract`. `both` applies no filter |
| `max_results_per_source` | integer | No | `100` | Upper bound on how many jobs to collect from each individual source |
| `max_keyword_variants` | integer | No | `20` | Maximum number of keyword synonym variants generated for LinkedIn |
| `execution_mode` | string | No | `fast` | `fast` favours shorter timeouts and fewer retries; `thorough` favours completeness over speed |
| `run_timeout_seconds` | integer | No | `180` | Overall wall-clock budget for the whole run, across all sources |
| `source_timeout_seconds` | integer | No | `120` | Wall-clock budget for any single source before it is dropped for this run |
| `source_concurrency` | integer | No | `6` | How many sources to scrape concurrently |
| `variant_concurrency` | integer | No | `4` | Reserved for future sources that support keyword-parameterised search; currently unused |
| `linkedin_variant_concurrency` | integer | No | `2` | How many LinkedIn keyword variants to search concurrently |

#### 💡 Input Examples

Daily fresher alert across ATS boards only, skipping LinkedIn:

```json
{
  "sources": ["greenhouse", "lever", "smartrecruiters", "workday", "recruitee"],
  "keywords": "graduate engineer trainee",
  "location": "India",
  "posted_within": "today",
  "job_type": "full-time"
}
```

Weekly internship sweep, thorough mode with a longer budget:

```json
{
  "keywords": "software engineering intern",
  "location": "Bengaluru",
  "posted_within": "week",
  "job_type": "internship",
  "execution_mode": "thorough",
  "run_timeout_seconds": 600,
  "source_timeout_seconds": 240,
  "max_results_per_source": 200
}
```

Wide LinkedIn-focused search with aggressive synonym expansion:

```json
{
  "sources": ["linkedin"],
  "keywords": "junior data engineer",
  "location": "Hyderabad",
  "posted_within": "24h",
  "max_keyword_variants": 30,
  "linkedin_variant_concurrency": 4
}
```

***

### 📤 Output

```json
{
  "title": "Customer Success Engineer, India",
  "company": "gitlab",
  "source": "greenhouse",
  "city": "Remote",
  "state": "India",
  "country": "India",
  "experience": "",
  "skills": "",
  "salary": "Not mentioned",
  "job_type": "",
  "apply_link": "https://job-boards.greenhouse.io/gitlab/jobs/8607271002",
  "posted_date_raw": "2026-08-10T16:52:46-04:00",
  "posted_date_parsed": "2026-08-10 20:52 UTC",
  "description": ""
}
```

#### 🧾 India IT Jobs Output Fields

| Field | Type | Description |
|---|---|---|
| `title` | string | null | Job title as advertised |
| `company` | string | null | Company name |
| `source` | string | null | Which source the listing came from |
| `city` | string | null | City, or `Remote` for location-independent roles |
| `state` | string | null | State or region |
| `country` | string | null | Country |
| `experience` | string | null | Required experience, where the source publishes it |
| `skills` | string | null | Skills required or listed |
| `salary` | string | null | Advertised salary |
| `job_type` | string | null | Employment type of the job |
| `apply_link` | string | null | Link to the job application page |
| `posted_date_raw` | string | null | Posted date exactly as the source provided it |
| `posted_date_parsed` | string | null | Normalised UTC timestamp for the posted date |
| `description` | string | null | Long-form description text |

Not every source populates every field. As the real sample above shows, `experience`, `skills`, `job_type` and `description` are frequently empty on ATS listings that only expose a summary record, while `title`, `company`, `apply_link` and the date fields are consistently present.

***

### 💻 How to Use the India IT Jobs Scraper (Step by Step)

#### Step 1: Choose which sources to query

`sources` defaults to all thirteen. Note the important caveat in the schema: every ATS source other than LinkedIn requires company identifiers to be present in `companies_seed.json`. The scraper queries specific companies' job boards on those platforms rather than searching the platform globally. If you only want the broadest coverage with no seed dependency, restrict `sources` to `["linkedin"]`; if you want direct-from-employer data, keep the ATS sources enabled.

#### Step 2: Write a keyword phrase, not a keyword list

`keywords` is a single string, not an array. Give it a natural phrase such as "software engineer fresher", "graduate engineer trainee" or "junior full stack developer". For LinkedIn, the scraper expands this into synonym variants automatically, so you do not need to enumerate every possible title yourself — that is what `max_keyword_variants` controls.

#### Step 3: Set your location filter

`location` defaults to `India` and is applied when searching and filtering. Narrow it to a city — Bengaluru, Hyderabad, Pune, Chennai, Noida — when you are targeting a specific tech hub. Note that remote roles frequently come through with `city` set to `Remote` and `state` set to the country, as in the sample output, so a city filter will exclude them.

#### Step 4: Choose a recency window

`posted_within` defaults to `today`, which is the right setting for a daily alert. Use `24h` for a rolling window, `week` for a broader sweep, or `any` when you are building a historical picture rather than chasing new postings. Recency is the single biggest determinant of how many results you get, so if a run returns very few listings, widen this first.

#### Step 5: Tune the runtime budget

Multi-source scraping is inherently variable in duration. `run_timeout_seconds` caps the whole job at 180 seconds by default and `source_timeout_seconds` gives each individual source 120 seconds before it is abandoned. If you enable many sources or set a high `max_results_per_source`, raise both. Switching `execution_mode` to `thorough` lengthens internal timeouts and adds retries, which improves completeness at the cost of speed.

#### Step 6: Set concurrency to match your budget

`source_concurrency` (default 6) determines how many boards are queried at once, and `linkedin_variant_concurrency` (default 2) how many LinkedIn synonym searches run in parallel. Higher concurrency finishes faster but is more likely to trigger rate limiting on the source side. If LinkedIn results are inconsistent, lower `linkedin_variant_concurrency` before anything else.

#### Step 7: Run, export and deduplicate

Start the run, then export the dataset as JSON, CSV or Excel, or read it via the API. Because the same role can legitimately appear from more than one source, deduplicate on the combination of `company` and `title`, or on `apply_link` where it is populated. Then sort on `posted_date_parsed` to get a clean, chronological view of what is genuinely new.

***

### 🔌 API Access & Integrations

Run the India entry-level IT jobs scraper and get listings back in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~india-it-jobs-multi-source-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "keywords": "software engineer fresher",
    "location": "India",
    "posted_within": "today",
    "job_type": "full-time",
    "max_results_per_source": 100
  }'
```

Python, using the official client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/india-it-jobs-multi-source-scraper").call(
    run_input={
        "sources": ["linkedin", "greenhouse", "lever"],
        "keywords": "junior software developer",
        "location": "Bengaluru",
        "posted_within": "24h",
        "execution_mode": "thorough",
        "run_timeout_seconds": 400,
    }
)

for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["posted_date_parsed"], job["company"], "-", job["title"])
    print("  apply:", job["apply_link"])
```

The dataset can be forwarded to Zapier, Make, Google Sheets or Slack, or pushed to your own endpoint with an Apify webhook when a run finishes — which is how most people wire up a daily fresher-jobs digest.

***

### 💡 Best Use Cases for India IT Jobs Data

#### 🎓 Daily fresher job alerts

Schedule the scraper with `posted_within` set to `today` and route new listings to Slack or email. Because `apply_link` points at the employer's own application page and `posted_date_parsed` gives a reliable timestamp, candidates can apply within hours of a role going live — which measurably matters for high-volume entry-level roles.

#### 🏫 Campus placement and training cell support

Placement cells need to know which companies are hiring freshers right now and at what level. Grouping listings by `company` and filtering on `job_type` of `internship` or `full-time` produces a live picture of graduate demand that is far more current than annual placement brochures.

#### 📈 Tech hiring market analysis

Aggregate `title`, `skills` and `city` over repeated runs and you have a longitudinal dataset of what Indian employers are asking entry-level engineers to know. Counting distinct `company` values per `source` also reveals which ATS platforms dominate different segments of the market.

#### 💵 Entry-level salary benchmarking

The `salary` field is populated only when an employer discloses it, which in Indian tech is a minority of listings. That minority is still valuable: filtering to rows where `salary` is present and not "Not mentioned", then segmenting by `city` and `experience`, gives a defensible baseline for fresher compensation conversations.

#### 🗺️ Location and remote-work trend tracking

The split `city` / `state` / `country` fields make it straightforward to measure how many entry-level roles are tied to a specific hub versus advertised as remote. Rows where `city` is `Remote` are directly countable, which is difficult when location is a single unparsed string.

#### 🏢 Competitive recruitment intelligence

Recruiters and employer-brand teams can track which competitors are posting fresher roles, how frequently, and with what titles. Filtering by `company` and sorting on `posted_date_parsed` shows hiring cadence; the `skills` field, where populated, shows what capability they are building.

#### 🤖 Job board and aggregator content

If you operate a niche job board for Indian tech freshers, this actor is a content pipeline. The normalised schema — one shape across thirteen sources — means ingestion logic is written once, and `source` lets you attribute or filter by origin platform.

***

### ⚙️ Tips for Better India IT Jobs Scraping Results

- **Widen `posted_within` before changing anything else.** The default of `today` is strict. If a run returns few listings, try `24h` or `week` before concluding your keywords are wrong.
- **Remember the seed dependency.** All ATS sources depend on company identifiers in `companies_seed.json`. A run with only ATS sources enabled and no matching seed entries will return little regardless of your other settings.
- **Raise timeouts when enabling many sources.** With all thirteen sources and `execution_mode` set to `thorough`, the default 180-second `run_timeout_seconds` is likely to cut the run short. Budget generously.
- **Lower `linkedin_variant_concurrency` if LinkedIn results fluctuate.** Two parallel variant searches is already conservative; dropping to one trades speed for stability.
- **Use `job_type` deliberately.** `both` applies no employment-type filter at all, which is usually what you want for broad coverage. Set it explicitly only when you specifically need internships or contracts.
- **Deduplicate on `company` + `title`.** The same role can appear via more than one source. Deduplicating before analysis prevents double-counting in any hiring-trend metric.

***

### 🛠️ Troubleshooting

**Why did the run return very few jobs?**
Three likely causes, in order: `posted_within` is set to `today` and few roles were posted today; the ATS sources you enabled have no matching entries in `companies_seed.json`; or `run_timeout_seconds` expired before slower sources finished. Widen the date window, verify your source selection, and raise the timeout.

**A source is missing entirely from my results.**
Each source has its own `source_timeout_seconds` budget and is dropped for that run if it exceeds it. Check the log for which sources were abandoned, then raise `source_timeout_seconds`, switch `execution_mode` to `thorough`, or reduce `source_concurrency` so each source gets more effective bandwidth.

**Why are `experience`, `skills` and `description` empty on many listings?**
Because many ATS job board endpoints expose only a summary record. The fields exist in the schema and are populated when the source provides them; when it does not, they come back empty rather than being fabricated. Follow `apply_link` for the full posting.

**The salary field says "Not mentioned".**
Salary disclosure is optional and uncommon in Indian tech postings. The scraper reports what the source publishes. Filter to rows with a real value if you are doing compensation analysis.

**Results include roles that are not entry-level.**
`keywords` biases the search but does not guarantee seniority filtering, and LinkedIn's synonym expansion can broaden the net. Post-filter on `title` and `experience` for terms like fresher, graduate, junior, associate or trainee to tighten the set.

***

### ❓ Frequently Asked Questions About India IT Jobs Scraping

**What does the India entry-level IT jobs scraper collect?**
Fresher and junior IT job listings from thirteen sources — LinkedIn plus twelve applicant tracking systems — normalised into a single schema with title, company, location, skills, salary, apply link and posted date.

**Which job sources are supported?**
LinkedIn, Greenhouse, Lever, SmartRecruiters, Workday, iCIMS, Jobvite, BambooHR, Zoho, Freshteam, Keka, Darwinbox and Recruitee.

**Do all sources work out of the box?**
LinkedIn does. Every ATS source requires company identifiers in `companies_seed.json`, because those platforms are queried per employer board rather than searched globally.

**How recent are the job listings?**
As recent as you ask for. `posted_within` accepts `today`, `24h`, `week` or `any`, and defaults to `today`.

**Can I search for internships specifically?**
Yes. Set `job_type` to `internship`. The other options are `full-time`, `part-time`, `contract` and `both`, where `both` applies no employment-type filter.

**How does keyword expansion work?**
For LinkedIn, the base phrase in `keywords` is expanded into synonym variants — up to `max_keyword_variants`, default 20 — and each variant is searched. This catches roles advertised under different but equivalent titles.

**Can I scrape jobs outside India?**
The `location` field is a free-text filter and defaults to `India`, but the actor is tuned for the Indian entry-level IT market. Other locations may work with reduced coverage.

**Why do some listings have `city` set to Remote?**
Because the employer advertised the role as location-independent. In those cases `state` and `country` typically still carry the region the role is scoped to, as in the sample output.

**How long does a run take?**
It is bounded by `run_timeout_seconds`, default 180. Actual duration depends on how many sources you enable, `max_results_per_source`, and whether `execution_mode` is `fast` or `thorough`.

**What is the difference between fast and thorough mode?**
`fast` uses shorter timeouts and fewer retries, finishing sooner but potentially missing slower sources. `thorough` favours completeness at the cost of runtime.

**What does `variant_concurrency` do?**
Nothing at present. It is reserved for future sources that support keyword-parameterised search and is currently unused. Use `linkedin_variant_concurrency` to control LinkedIn parallelism.

**How do I remove duplicate listings?**
Deduplicate on `apply_link` where present, or on the combination of `company` and `title`. The same role can appear legitimately from more than one source.

**Can I schedule daily job alerts?**
Yes. Use Apify Schedules with `posted_within` set to `today`, and attach a webhook that pushes new items into Slack, email or your own application.

**Are the apply links direct to the employer?**
Yes for ATS sources — `apply_link` points at the employer's own job board page, such as a Greenhouse or Lever hosted application form, rather than an intermediary.

**Is scraping job listings legal?**
The scraper reads publicly accessible job postings. You remain responsible for complying with the terms of service of each source platform and with applicable data protection law when storing or republishing listings.

***

### 🆘 Support & Feedback

If a source is failing, results look wrong, or a run behaves unexpectedly, please open a report on the **Issues** tab with your input configuration and the run ID. Including which sources were involved makes diagnosis much quicker.

For custom work — additional ATS integrations, an expanded company seed list, different geographies, or a private build tuned to your hiring pipeline — email **scraperhubapi@gmail.com**.

If this India entry-level IT jobs scraper is useful, please leave a review on the actor page. Feedback directly shapes which sources and features get added next.

***

### ⚖️ Disclaimer

This India entry-level IT jobs scraper collects only publicly available job listings from public job boards and applicant tracking system pages. It does not log into any platform, bypass authentication, or access recruiter-only or candidate-private data.

Job listings may contain personal data such as recruiter names or contact details. Where they do, GDPR, India's Digital Personal Data Protection Act and comparable regimes may apply to your processing, and you are responsible for establishing a lawful basis and honouring erasure requests. You are also responsible for complying with the terms of service of LinkedIn and of each applicant tracking system whose listings you collect, including any restrictions on republication or commercial reuse of job data.

To request removal of specific data collected by this actor, email **scraperhubapi@gmail.com** with the details.

# Actor input Schema

## `sources` (type: `array`):

Which job sources to query. greenhouse/lever/smartrecruiters/workday/recruitee/icims/jobvite/bamboohr/zoho/freshteam/keka/darwinbox all require company identifiers in companies\_seed.json.

## `keywords` (type: `string`):

Base job title/keyword phrase to search for (e.g. 'software engineer fresher'). LinkedIn expands this into multiple synonym variants automatically.

## `location` (type: `string`):

Location filter to apply when searching/filtering jobs.

## `posted_within` (type: `string`):

Only keep jobs posted within this time window.

## `job_type` (type: `string`):

Employment type filter. 'both' applies no employment-type filter.

## `max_results_per_source` (type: `integer`):

Upper bound on how many jobs to collect from each individual source.

## `max_keyword_variants` (type: `integer`):

Maximum number of keyword synonym variants to generate and search for LinkedIn.

## `execution_mode` (type: `string`):

'fast' favors shorter timeouts/fewer retries; 'thorough' favors completeness over speed.

## `run_timeout_seconds` (type: `integer`):

Overall wall-clock budget for the whole run, across all sources.

## `source_timeout_seconds` (type: `integer`):

Wall-clock budget for any single source before it's dropped for this run.

## `source_concurrency` (type: `integer`):

How many sources to scrape concurrently.

## `variant_concurrency` (type: `integer`):

Reserved for future sources that support keyword-parameterized search; currently unused.

## `linkedin_variant_concurrency` (type: `integer`):

How many LinkedIn keyword variants to search concurrently.

## Actor input object example

```json
{
  "sources": [
    "linkedin",
    "greenhouse",
    "lever",
    "smartrecruiters",
    "workday",
    "icims",
    "jobvite",
    "bamboohr",
    "zoho",
    "freshteam",
    "keka",
    "darwinbox",
    "recruitee"
  ],
  "keywords": "software engineer fresher",
  "location": "India",
  "posted_within": "today",
  "job_type": "both",
  "max_results_per_source": 100,
  "max_keyword_variants": 20,
  "execution_mode": "fast",
  "run_timeout_seconds": 180,
  "source_timeout_seconds": 120,
  "source_concurrency": 6,
  "variant_concurrency": 4,
  "linkedin_variant_concurrency": 2
}
```

# Actor output Schema

## `results` (type: `string`):

Records scraped by India Entry-Level IT Jobs Scraper, stored in the run's default dataset.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/india-it-jobs-multi-source-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/india-it-jobs-multi-source-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 '{}' |
apify call scrapers-hub/india-it-jobs-multi-source-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/india-it-jobs-multi-source-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/gnmnGDtDTjiHaktDt/builds/2mLsGioju9JbNAAvf/openapi.json