# Internshala Internship & Jobs Scraper (`scrapers-hub/internshala-jobs-scraper`) Actor

Internshala Internship & Jobs Scraper extracts listings with stipend range, duration, location, remote flag, skills, perks, openings, apply-by date and full description. 🎓 For job boards, campus recruiting and internship research.

- **URL**: https://apify.com/scrapers-hub/internshala-jobs-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

### 🎓 Internshala Internship & Jobs Scraper – Stipend, Skills & Hiring Data Extraction

The **Internshala Internship & Jobs Scraper** extracts structured internship and job listings from Internshala, India's largest student hiring platform, including stipend ranges, required skills, perks, duration, application deadlines, and the number of openings per role. Point it at internships or jobs, apply filters for category, city, remote work, part-time status, or minimum stipend, and it returns clean records ready for recruitment analytics, salary benchmarking, or a job aggregator feed.

Internshala sits at the entry-level end of the Indian hiring market, which makes it an unusually good source of early-career labour market data. Where general job boards skew towards experienced roles, this platform concentrates internship listings, fresher jobs, and work-from-home opportunities aimed at students and recent graduates — a segment that is hard to measure anywhere else.

The Internshala scraper covers both the search listing pages and, optionally, each listing's detail page, where the long-form description, skill requirements, and perk list live. It runs without a headless browser, which keeps runs efficient even across thousands of listings, and proxy rotation is handled automatically inside the Actor.

***

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

Each dataset record represents one internship or job listing, with 26 fields grouped as follows.

| Category | Fields | What it gives you |
| --- | --- | --- |
| 🆔 Listing identity | `listingId`, `listingType`, `url`, `title`, `category`, `scrapedAt` | Stable identifiers, the canonical listing URL, role title, profile category, and the capture timestamp |
| 🏢 Employer detail | `company`, `companyUrl` | Hiring company name and its Internshala company page link |
| 📍 Location & work mode | `location`, `isRemote`, `isPartTime` | City or work-from-home designation plus explicit remote and part-time flags |
| 💰 Compensation | `stipend`, `stipendMin`, `stipendMax`, `isUnpaid` | Raw stipend text alongside parsed numeric minimum and maximum, and an unpaid flag |
| 📅 Timing & scale | `duration`, `startDate`, `applyBy`, `openings`, `postedAt` | Internship length, start date, application deadline, headcount, and posting recency |
| 🧠 Requirements & benefits | `skills`, `perks`, `description`, `hasJobOffer` | Skill array, perk array, full description text, and whether a pre-placement offer is on the table |
| 🔥 Hiring signals | `isActivelyHiring`, `isEarlyApplicant` | Platform badges indicating responsive employers and low-competition listings |

The standout fields are `stipendMin` and `stipendMax`. Internshala displays stipends as free text — "₹10,000 - 15,000 /month", "Unpaid", "Performance based" — which is useless for analysis until parsed. The Internshala scraper returns both the original `stipend` string and the parsed numeric bounds, so you can compute medians, plot distributions by city, and rank categories by pay without writing your own parser.

***

### 🌟 Key Features of the Internshala Jobs Scraper

| Feature | Description |
| --- | --- |
| 🔀 Internships or jobs | The `listingType` selector switches the scraper between Internshala's internship and job sections |
| 💰 Parsed stipend ranges | `stipendMin` and `stipendMax` convert free-text stipend strings into numeric INR values for analysis |
| 🧠 Skills and perks arrays | Detail-page scraping returns the full required-skills list and the perks offered with each listing |
| 🏠 Remote and part-time filters | `workFromHome` and `partTime` restrict the crawl to remote-only or part-time listings at source |
| 🎯 Category and city targeting | `categories` and `cities` narrow the crawl to specific profiles and locations instead of the whole board |
| 📄 Optional detail-page crawl | `scrapeDetails` toggles between fast listing-level extraction and full description, skill, and perk enrichment |
| ⚙️ Throughput controls | `maxListings`, `maxPages`, `requestDelay`, and `maxConcurrency` let you trade speed against politeness |
| 🔥 Hiring intent signals | `isActivelyHiring` and `isEarlyApplicant` surface which employers respond and which listings are uncontested |
| 🛡️ Automatic proxy rotation | Proxy handling is built into the Actor — there is nothing to configure |

***

### 🚀 Why Choose This Internshala Jobs Scraper?

**Stipend data arrives analysis-ready.** Most job scrapers hand you a compensation string and leave the parsing to you. Returning `stipendMin`, `stipendMax`, and `isUnpaid` alongside the raw `stipend` text means salary benchmarking works the moment the run finishes.

**Filtering happens before the crawl, not after.** Setting `categories`, `cities`, `workFromHome`, `partTime`, and `minStipend` narrows what gets fetched in the first place. That is faster and cheaper than pulling the entire board and discarding 95% of it downstream.

**Detail-page enrichment is optional and controllable.** With `scrapeDetails` enabled you get `description`, `skills`, and `perks` for every listing; with it disabled you get a fast listing-level sweep. The choice is yours per run rather than baked into the Actor.

**Built for repeatable monitoring.** `listingId`, `postedAt`, and `scrapedAt` together let you deduplicate across runs, detect newly posted roles, and build a genuine time series of the Indian entry-level hiring market rather than a series of disconnected snapshots.

***

### 📥 Input

```json
{
  "listingType": "internships",
  "categories": [],
  "cities": [],
  "workFromHome": false,
  "partTime": false,
  "minStipend": 0,
  "maxListings": 200,
  "maxPages": 20,
  "scrapeDetails": true,
  "requestDelay": 500,
  "maxConcurrency": 3
}
```

#### 🔧 Internshala Scraper Input Fields

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `listingType` | string | ✅ Yes | `internships` | Choose whether to scrape internships or jobs. Options: `internships`, `jobs` |
| `categories` | array | No | `[]` | Filter by specific categories/profiles |
| `cities` | array | No | `[]` | Filter by specific cities |
| `workFromHome` | boolean | No | `false` | Only scrape work-from-home/remote listings |
| `partTime` | boolean | No | `false` | Only scrape part-time listings |
| `minStipend` | integer | No | `0` | Filter by minimum stipend/salary value (in INR) |
| `maxListings` | integer | No | `200` | Maximum number of listings to scrape (0 = unlimited) |
| `maxPages` | integer | No | `20` | Maximum number of search pages to crawl per filter (0 = unlimited) |
| `scrapeDetails` | boolean | No | `true` | Navigate to detail page of each listing to scrape description, perks, skills, etc. |
| `requestDelay` | integer | No | `500` | Delay between requests in milliseconds |
| `maxConcurrency` | integer | No | `3` | Maximum number of concurrent requests |

#### 💡 Input Examples

**Remote software internships paying at least ₹10,000 per month**

```json
{
  "listingType": "internships",
  "categories": ["Software Development"],
  "workFromHome": true,
  "minStipend": 10000,
  "maxListings": 500,
  "scrapeDetails": true
}
```

**Fast city-level jobs sweep without detail pages**

```json
{
  "listingType": "jobs",
  "cities": ["Bangalore", "Hyderabad", "Pune"],
  "scrapeDetails": false,
  "maxListings": 1000,
  "maxPages": 40
}
```

**Part-time internship monitoring with gentle crawl settings**

```json
{
  "listingType": "internships",
  "partTime": true,
  "maxListings": 200,
  "requestDelay": 1200,
  "maxConcurrency": 2
}
```

***

### 📤 Output

```json
{
  "listingId": "3236762",
  "listingType": "internships",
  "url": "https://internshala.com/internship/detail/work-from-home-software-development-internship-at-queens-of-change-foundation",
  "title": "Software Development",
  "company": "Queens Of Change Foundation",
  "companyUrl": null,
  "location": "Work from home",
  "isRemote": true,
  "stipend": "Unpaid",
  "stipendMin": 0,
  "stipendMax": 0,
  "duration": "1 Month",
  "startDate": "immediately",
  "applyBy": "9 Sep' 26",
  "openings": 20,
  "skills": [".NET", "C++ Programming", "CSS", "English Proficiency (Spoken)", "HTML", "Java", "JavaScript"],
  "perks": ["Certificate", "Letter of recommendation", "Flexible work hours", "Job offer"],
  "isPartTime": true,
  "hasJobOffer": true,
  "isUnpaid": true,
  "isActivelyHiring": true
}
```

#### 🧾 Internshala Listing Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `listingId` | string | null | Identifier of the listing |
| `listingType` | string | null | Whether the record is an internship or a job |
| `url` | string | null | Canonical URL of the scraped listing |
| `title` | string | null | Role or profile title |
| `company` | string | null | Hiring company name |
| `companyUrl` | string | null | URL of the listing's company page |
| `location` | string | null | Location of the listing |
| `isRemote` | boolean | null | Whether the listing is work-from-home |
| `stipend` | string | null | Stipend as displayed on the listing |
| `stipendMin` | integer | null | Parsed lower bound of the stipend |
| `stipendMax` | integer | null | Parsed upper bound of the stipend |
| `duration` | string | null | Duration of the internship or role |
| `startDate` | string | null | Start date of the position |
| `applyBy` | string | null | Application deadline |
| `openings` | integer | null | Number of openings advertised |
| `skills` | array | null | Skills required or listed |
| `perks` | array | null | Perks offered with the listing |
| `description` | string | null | Long-form description text |
| `isPartTime` | boolean | null | Whether the listing is part-time |
| `hasJobOffer` | boolean | null | Whether a job offer is attached to the internship |
| `isUnpaid` | boolean | null | Whether the listing is unpaid |
| `isActivelyHiring` | boolean | null | Whether the employer is flagged as actively hiring |
| `isEarlyApplicant` | boolean | null | Whether applying now counts as an early application |
| `postedAt` | string | null | When the listing was posted |
| `category` | string | null | Category or profile of the listing |
| `scrapedAt` | string | null | When this record was scraped |

`description`, `skills`, and `perks` are populated by the detail-page crawl. If you set `scrapeDetails` to `false`, expect those fields to be sparse or empty.

***

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

#### Step 1: Choose between internships and jobs

Open the Actor and set `listingType`. Internshala separates internships from full-time jobs, and the two sections have different audiences and different compensation semantics — internships report a monthly stipend, jobs report an annual salary band. Decide which market you are studying before anything else, and run two separate jobs if you need both.

#### Step 2: Narrow the crawl with categories and cities

Use `categories` to restrict the Internshala scraper to specific profiles such as software development, marketing, or design, and `cities` to focus on particular metros. Leaving both empty crawls across the board, which is fine for a broad market survey but wasteful when you only care about one segment. Each filter combination is crawled up to `maxPages` deep.

#### Step 3: Apply work-mode and stipend filters

Set `workFromHome` to `true` for remote-only listings and `partTime` to `true` for part-time roles. `minStipend` filters by the minimum stipend in INR, which is the fastest way to strip unpaid and token-stipend listings out of a compensation study. All three filters apply at the search level, so they reduce crawl volume rather than just trimming output.

#### Step 4: Decide whether to scrape detail pages

`scrapeDetails` is the single biggest lever on run cost and data richness. Leave it `true` when you need `description`, `skills`, and `perks` — essential for skills-demand analysis or for populating a job board. Set it `false` when you only need titles, companies, locations, and stipends, and you want a fast sweep of a large number of listings.

#### Step 5: Tune limits, delay, and concurrency

`maxListings` caps the total number of records and `maxPages` caps how deep each filter combination is crawled; both accept `0` for unlimited. `requestDelay` and `maxConcurrency` control crawl pressure. The defaults — 500 ms between requests, three concurrent requests — are a reasonable balance. Raise the delay and lower concurrency if you see failures on very large runs.

#### Step 6: Run the Internshala scraper and review results

Press **Start** and watch the log as pages are crawled and listings extracted. When the run completes, open the Dataset tab. Check that `stipendMin` and `stipendMax` are populated for paid roles, and that `skills` and `perks` arrays are present if you enabled detail scraping. Spot-check a couple of `url` values against the live site.

#### Step 7: Export, deduplicate, and schedule

Export as JSON, CSV, Excel, XML, or HTML, or read the dataset through the API. Deduplicate on `listingId` when combining runs, and use `postedAt` to isolate newly published roles. Scheduling the Internshala jobs scraper daily or weekly turns one-off extraction into a hiring-trend dataset that shows which categories, cities, and skills are gaining or losing demand.

***

### 🔌 API Access & Integrations

Run the Internshala scraper synchronously and receive dataset items directly:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~internshala-jobs-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "listingType": "internships",
    "workFromHome": true,
    "minStipend": 10000,
    "maxListings": 300,
    "scrapeDetails": true
  }'
```

Compute median stipends by category with the Python client:

```python
import statistics
from collections import defaultdict
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/internshala-jobs-scraper").call(run_input={
    "listingType": "internships",
    "cities": ["Bangalore"],
    "maxListings": 500,
    "scrapeDetails": True,
})

by_category = defaultdict(list)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item.get("isUnpaid"):
        continue
    low, high = item.get("stipendMin"), item.get("stipendMax")
    if low and high:
        by_category[item.get("category") or "uncategorised"].append((low + high) / 2)

for category, values in sorted(by_category.items()):
    print(f"{category}: median ₹{statistics.median(values):,.0f}/month across {len(values)} listings")
```

The Actor also connects to Zapier, Make, Google Sheets, and Slack, and supports webhooks that fire on run completion so new listings can flow into your ATS or alerting channel automatically.

***

### 💡 Best Use Cases for Internshala Internship and Jobs Data

#### 💰 Entry-level stipend benchmarking

Aggregate `stipendMin` and `stipendMax` across `category` and `location` to establish what internships in each profile and city actually pay. Because `isUnpaid` isolates the zero-stipend listings, you can report both the share of unpaid roles and the median stipend among paid ones — two numbers that tell very different stories about a segment.

#### 🧠 Skills demand tracking for curriculum design

The `skills` array is a direct read on what employers are asking entry-level candidates to know. Counting skill frequency over time, segmented by `category`, shows which tools and languages are rising and which are fading — exactly the evidence training providers and university departments need to justify curriculum changes.

#### 🎯 Recruitment competitive intelligence

Monitor `company`, `openings`, `stipend`, and `perks` across your category to see how rival employers are positioning their internship programmes. If competitors are offering higher stipends, more openings, or richer perk lists, `isActivelyHiring` tells you which of them are converting that offer into actual hiring momentum.

#### 📰 Job board and aggregator feeds

Populate a niche job site with listings filtered by `categories`, `cities`, and `workFromHome`. The combination of `url`, `title`, `company`, `applyBy`, and `description` gives you everything a listing page needs, while `listingId` provides the deduplication key and `applyBy` lets you expire stale entries automatically.

#### 🏠 Remote work share analysis

The `isRemote` flag, combined with `location` and `postedAt`, quantifies how much of India's entry-level hiring is genuinely work-from-home and how that share moves over time. Segmenting by `category` reveals which functions have normalised remote internships and which still require presence.

#### 🎓 Student career guidance and placement support

Placement cells can filter for `hasJobOffer` to find internships with pre-placement offers attached, `isEarlyApplicant` to point students at listings with less competition, and `applyBy` to prioritise deadlines. The `perks` array highlights which listings include certificates and letters of recommendation that matter for academic credit.

#### 📊 Labour market research on early careers

`postedAt`, `openings`, and `duration` together form the basis of a hiring-volume time series. Tracking total openings per category month over month gives researchers, policy analysts, and journalists a measurable indicator of graduate hiring demand that is otherwise very difficult to source in India.

***

### ⚙️ Tips for Better Internshala Scraping Results

- **Run internships and jobs as separate jobs.** The two `listingType` values have different compensation semantics — monthly stipends versus salaries — and mixing them in one dataset makes any aggregate figure misleading.
- **Disable `scrapeDetails` for large exploratory sweeps.** Listing-level data is enough to map the shape of the market. Turn detail scraping back on once you have narrowed to the categories and cities that matter.
- **Use `minStipend` rather than filtering afterwards.** Filtering at search level cuts crawl volume, whereas post-filtering means you paid to fetch listings you then discarded.
- **Keep `maxPages` in mind on multi-filter runs.** The page cap applies per filter combination, so a run with five categories and four cities crawls far more pages than a single unfiltered run at the same setting.
- **Raise `requestDelay` before lowering `maxConcurrency`.** A slightly longer gap between requests is usually a gentler and more effective stabiliser on large crawls than cutting parallelism outright.
- **Deduplicate on `listingId` across scheduled runs.** Listings persist for weeks, so consecutive runs overlap heavily. `listingId` plus `scrapedAt` gives you both a clean unique set and a full observation history.

***

### 🛠️ Troubleshooting

**`skills`, `perks`, and `description` are empty in my dataset.**
Those three fields come from the listing detail pages. Confirm `scrapeDetails` is set to `true` — with it disabled the Internshala scraper only reads search result pages, which do not contain the full description, skill list, or perk list.

**I got far fewer listings than `maxListings` allows.**
Your filters are probably narrower than you intended. Combining a specific category, a specific city, `workFromHome`, `partTime`, and a high `minStipend` can reduce the matching pool to a handful of listings. Relax one filter at a time to see which is the binding constraint. `maxPages` may also be capping the crawl before `maxListings` is reached.

**Stipend fields are zero for listings that look paid.**
`stipendMin` and `stipendMax` are parsed from the displayed stipend text. Listings using non-numeric wording such as performance-based or negotiable compensation cannot produce numeric bounds, so they return zeros while the original text remains in `stipend`. Filter on `isUnpaid` and on a non-zero `stipendMax` when building compensation statistics.

**A large run slowed down or produced failures partway through.**
Reduce crawl pressure: increase `requestDelay` towards 1000–1500 ms and lower `maxConcurrency` to two. Also consider splitting one very large run into several smaller runs partitioned by city or category.

**Results include listings outside the cities I specified.**
Remote listings are commonly surfaced across city searches because work-from-home roles are not tied to a location. Cross-check `isRemote` and `location` when you need strictly location-based results, and set `workFromHome` to `false` if you want to exclude remote roles from a city study.

***

### ❓ Frequently Asked Questions About Internshala Scraping

**What does the Internshala Internship & Jobs Scraper extract?**
It extracts internship and job listings from Internshala with 26 fields per listing, covering title, company, location, stipend, duration, deadlines, openings, skills, perks, description, and platform hiring signals.

**Can it scrape both internships and jobs?**
Yes, through the `listingType` field, which accepts `internships` or `jobs`. Run it twice if you need both, since the two sections report compensation differently.

**How do I scrape only remote internships?**
Set `workFromHome` to `true`. Each returned record also carries an `isRemote` boolean you can verify against.

**Is stipend data numeric or text?**
Both. `stipend` holds the original displayed text, while `stipendMin` and `stipendMax` hold parsed numeric INR values, and `isUnpaid` flags zero-stipend listings.

**How many listings can the Internshala scraper collect in one run?**
`maxListings` controls the cap and accepts `0` for unlimited. In practice the total is also bounded by `maxPages` and by how many listings match your filters.

**What is the difference between `maxListings` and `maxPages`?**
`maxListings` caps the total number of records saved across the run. `maxPages` caps how many search result pages are crawled per filter combination. Whichever limit is reached first stops that part of the crawl.

**Do I need to configure a proxy?**
No. Proxy rotation is handled automatically inside the Actor and there is no proxy field in the input schema.

**Does the scraper use a headless browser?**
No. It fetches and parses pages directly over HTTP, which keeps runs fast and memory-light even on large crawls.

**What is `isEarlyApplicant` useful for?**
It flags listings where applying now still counts as an early application, which generally means fewer competing candidates. Career services teams use it to prioritise which listings to promote to students.

**What does `hasJobOffer` mean?**
It indicates that the internship advertises a job offer — a pre-placement offer — as one of its perks, which is a strong signal of employer intent to convert interns into full-time hires.

**How do I avoid duplicate listings across scheduled runs?**
Deduplicate on `listingId`. Keep `scrapedAt` alongside it if you want an observation history rather than a single current-state row per listing.

**Can I export Internshala data to Google Sheets?**
Yes. Apify datasets export to JSON, CSV, Excel, XML, and HTML, and the Actor integrates with Google Sheets, Zapier, Make, and Slack, plus webhooks on run completion.

**How current is the data?**
Each record reflects the listing as it appeared when the run executed, recorded in `scrapedAt`. Use `postedAt` to judge how recently the employer published the role, and schedule regular runs to keep a dataset current.

**Can I filter by minimum stipend?**
Yes, using `minStipend`, expressed in INR per month. Filtering at search level is more efficient than collecting everything and discarding low-paying listings afterwards.

**Can I request a custom version of the Internshala jobs scraper?**
Yes. Email `scraperhubapi@gmail.com` to discuss additional fields, different filter logic, or integration with your own ATS or data warehouse.

***

### 🆘 Support & Feedback

If the Internshala scraper misses listings, returns unexpected values, or a run fails, report it on the **Issues** tab of the Actor page. Include your input configuration and the run ID so the behaviour can be reproduced.

For custom scraping work — larger recruitment data pipelines, additional fields, or a tailored version of this Internshala jobs scraper for your own hiring analytics — email `scraperhubapi@gmail.com`.

If this Actor helps your recruitment research, please leave a review on the Apify Store. Ratings and written feedback shape which improvements are prioritised.

***

### ⚖️ Disclaimer

The Internshala Internship & Jobs Scraper collects publicly visible internship and job listings. It does not log in, bypass authentication, or access candidate applications, private employer dashboards, or any content behind a login.

You are responsible for how you use the recruitment data this Internshala scraper produces. Comply with Internshala's terms of service, crawl at reasonable rates using `requestDelay` and `maxConcurrency`, and respect the platform's technical limits. Job listings occasionally contain personal information such as an individual recruiter's name; where that is the case, data protection law — including the GDPR where it applies, and India's own data protection framework — governs your handling of it, and you must establish a lawful basis, honour data subject rights, and apply appropriate retention limits.

Listing data is provided as-is and reflects the state of the platform at the moment recorded in `scrapedAt`. Verify stipends, deadlines, and openings against the live listing before making hiring, application, or publication decisions.

If you believe data returned by this Actor should be removed or corrected, email `scraperhubapi@gmail.com` with the details and the request will be reviewed.

# Actor input Schema

## `listingType` (type: `string`):

Choose whether to scrape internships or jobs.

## `categories` (type: `array`):

Filter by specific categories/profiles.

## `cities` (type: `array`):

Filter by specific cities.

## `workFromHome` (type: `boolean`):

Only scrape work-from-home/remote listings.

## `partTime` (type: `boolean`):

Only scrape part-time listings.

## `minStipend` (type: `integer`):

Filter by minimum stipend/salary value (in INR).

## `maxListings` (type: `integer`):

Maximum number of listings to scrape (0 = unlimited).

## `maxPages` (type: `integer`):

Maximum number of search pages to crawl per filter (0 = unlimited).

## `scrapeDetails` (type: `boolean`):

Navigate to detail page of each listing to scrape description, perks, skills, etc.

## `requestDelay` (type: `integer`):

Delay between requests in milliseconds.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent requests.

## Actor input object example

```json
{
  "listingType": "internships",
  "categories": [],
  "cities": [],
  "workFromHome": false,
  "partTime": false,
  "minStipend": 0,
  "maxListings": 200,
  "maxPages": 20,
  "scrapeDetails": true,
  "requestDelay": 500,
  "maxConcurrency": 3
}
```

# Actor output Schema

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

Records scraped by Internshala Internship & Jobs Scraper, stored in the run's default dataset.

## `outputRecord` (type: `string`):

Full result set written as a single OUTPUT record.

# 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/internshala-jobs-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/internshala-jobs-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/internshala-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/internshala-jobs-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/alzoovaoe2yK4Xkk9/builds/s9Tt4wEQyfWwbNsrG/openapi.json