# Internshala Scraper (`automation-lab/internshala-scraper`) Actor

Scrape internship and job listings from Internshala — India's largest internship platform. Extract title, company, stipend, skills, location, duration, and more.

- **URL**: https://apify.com/automation-lab/internshala-scraper.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 465 total users, 31 monthly users, 99.2% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $2.10 / 1,000 result extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Internshala Scraper

### What does it do?

Internshala Scraper extracts internship and job listings from [Internshala](https://internshala.com) — India's largest internship and fresher jobs platform with over 7,000 active listings at any time. The scraper fetches structured data from search results pages and optionally enriches each listing with full detail page information including the complete job description, start date, apply-by deadline, and company background.

The actor uses pure HTTP requests and Cheerio for fast, lightweight scraping — no browser required. Optional `locationKeywords` and `workFromHomeOnly` inputs filter already-parsed listings before the `maxResults` limit is counted. It runs in 256 MB of memory and typically completes 100 listings in under 30 seconds.

### Who is it for?

- 🎓 **Career coaches and placement officers** who maintain internship databases for students and need bulk exports on a schedule
- 📊 **HR analytics teams** tracking stipend benchmarks, skill demand trends, and hiring velocity across industries in India
- 🤖 **Job board developers** building aggregator platforms focused on Indian fresher hiring
- 📈 **Recruiters and talent acquisition teams** monitoring competitor hiring activity and supply of candidates by skill
- 🔬 **Researchers and policy analysts** studying the Indian internship market, WFH trends, and industry skill requirements

### Why use it?

✅ **No browser required** — pure HTTP+Cheerio means fast, cheap runs (< $0.01 for 100 listings)

✅ **Filters by keyword** — narrow results by role type, technology, or domain (e.g. `python`, `marketing`, `data-science`)

✅ **Filters by location** — provide up to 20 `locationKeywords`; a listing matches when its location contains any keyword using case-insensitive matching

✅ **Work-from-home mode** — set `workFromHomeOnly: true` to emit only listings identified as remote or work from home

✅ **Covers both internships and jobs** — switch between internship listings and fresher job listings with one input field

✅ **Rich skill data** — every listing includes the full array of required skills extracted from the card

✅ **Detail page enrichment** — optionally fetch the full job description, company about section, start date, and apply-by deadline

✅ **Automatic pagination** — scrapes as many pages as needed to hit your `maxResults` target

### What data does it extract?

| Field | Description | Example |
|-------|-------------|---------|
| `id` | Internshala listing ID | `3145597` |
| `title` | Job/internship title | `Business Development (Sales)` |
| `company` | Company name | `Basti Ki Pathshala Foundation` |
| `companyLogoUrl` | Portable absolute company logo image URL (including Internshala placeholders) | `https://internshala-uploads.internshala.com/...` |
| `location` | City or "Work from home" | `Mumbai`, `Work from home` |
| `isWorkFromHome` | Boolean WFH flag | `true` |
| `stipend` | Monthly or lump-sum stipend | `₹ 5,000 /month`, `₹ 15,000 lump sum` |
| `duration` | Internship duration or job experience | `3 Months`, `1-3 year(s)` |
| `skills` | Array of required skills | `["Python", "SQL", "Excel"]` |
| `description` | Brief job description from listing card | `"1. Build dashboards..."` |
| `postedAt` | When posted | `Few hours ago`, `2 days ago` |
| `isPartTime` | Part-time flag | `false` |
| `isActivelyHiring` | Currently actively hiring | `true` |
| `applyBy` | Application deadline (detail page) | `10 Jun' 26` |
| `startDate` | Start date (detail page) | `Immediately`, `1 Jul' 26` |
| `aboutCompany` | Company description (detail page) | `"DineMatters is a fast-growing SaaS..."` |
| `fullDescription` | Full job description (detail page) | `"Selected intern's day-to-day..."` |
| `url` | Portable absolute detail page URL | `https://internshala.com/internship/detail/...` |

> **Note:** `applyBy`, `startDate`, `aboutCompany`, and `fullDescription` are only populated when `fetchDetails: true` is set.

### How much does it cost?

Internshala Scraper uses **Pay Per Event** pricing:

| Tier | Price per listing |
|------|-------------------|
| FREE | $0.005/result |
| BRONZE | $0.0035/result |
| SILVER | $0.0027/result |
| GOLD | $0.0021/result |
| PLATINUM | $0.0014/result |
| DIAMOND | $0.001/result |

A one-time run start fee of $0.005 covers initialization. Volume-tier discounts apply automatically based on your Apify subscription plan.

**Typical costs at BRONZE:**

- 20 listings (test run): ~$0.075
- 100 listings (standard research): ~$0.355
- 500 listings (bulk export): ~$1.755
- With `fetchDetails: true`, each run makes one additional HTTP request per listing, adding a small amount of compute cost

The per-result pricing is competitive with similar scrapers on the Apify Store (market range: $0.001–$0.005 per result). Start with 20 results to verify output before scaling up.

### How to use it

1. Go to the **Input** tab in the Apify Console
2. Set your **search keyword** (e.g. `python`, `marketing`) or leave blank for all listings
3. Choose **search mode**: `internships` or `jobs`
4. Optionally add **location keywords** or enable **work from home only**
5. Set **max results** (start with 20 for testing); this counts matching emitted listings after those filters
6. Toggle **fetch details** if you need the full description and apply-by date
7. Click **Start** — results appear in the **Output** tab within seconds

#### Step-by-step example

**Goal:** Find work-from-home Python internships in Mumbai or Bengaluru and export them to a spreadsheet

1. Set `searchQuery: "python"`
2. Set `searchMode: "internships"`
3. Set `locationKeywords: ["Mumbai", "Bengaluru"]`
4. Set `workFromHomeOnly: true`
5. Set `maxResults: 100`
6. Click **Start**
7. In the **Output** tab, click **Export** → **CSV**
8. Open in Excel/Google Sheets — each row is one matching internship with title, company, stipend, skills, and more

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | `""` | Keyword to filter listings. Passed directly to Internshala's URL slug. Use hyphens for multi-word terms: `data-science`, `business-development`. |
| `searchMode` | select | `internships` | Whether to scrape `internships` or `jobs`. |
| `locationKeywords` | string\[] | `[]` | Up to 20 non-empty location keywords. A listing matches if its parsed `location` contains any trimmed keyword using case-insensitive matching. An empty list matches every location. |
| `workFromHomeOnly` | boolean | `false` | When `true`, return only listings whose parsed `isWorkFromHome` value is `true`. |
| `fetchDetails` | boolean | `false` | Fetch the detail page for each listing to get `applyBy`, `startDate`, `aboutCompany`, and `fullDescription`. Adds one HTTP request per listing. |
| `maxResults` | integer | `50` | Maximum number of matching emitted results. Pagination continues until this limit or source exhaustion. |
| `maxRequestRetries` | integer | `3` | Retry attempts for failed requests. |

### Output example

```json
{
  "id": "3145597",
  "title": "Business Development (Sales)",
  "company": "Basti Ki Pathshala Foundation",
  "companyLogoUrl": "https://internshala-uploads.internshala.com/logo/...",
  "location": "Work from home",
  "isWorkFromHome": true,
  "stipend": "₹ 1,500 - 15,000 lump sum",
  "duration": "1 Month",
  "skills": ["Social Media Marketing", "MS-Office", "Digital Marketing"],
  "description": "1. Develop and implement strategic sales plans...",
  "postedAt": "Few hours ago",
  "isPartTime": true,
  "isActivelyHiring": true,
  "applyBy": "10 Jun' 26",
  "startDate": "Immediately",
  "aboutCompany": "Basti Ki Pathshala Foundation is a Government-registered organization...",
  "fullDescription": "Selected intern's day-to-day responsibilities include: ...",
  "url": "https://internshala.com/internship/detail/work-from-home-business-development-sales-..."
}
```

### Tips for best results

💡 **Use hyphens in multi-word keywords** — Internshala's URL system uses hyphens: `data-science` not `data science`

💡 **Leave `searchQuery` blank** for the broadest results — scrapes all active listings, not filtered by category

💡 **Use `fetchDetails: false` first** — get 100 listings in seconds, then refine your keyword before enabling detail fetching

💡 **Combine with scheduling** — run daily to detect new postings; compare with yesterday's export using the `id` field as a stable key

💡 **Target locations and WFH** — combine `locationKeywords` with `workFromHomeOnly: true`; both filters are applied before `maxResults`, so the limit counts emitted matching rows

💡 **Internship categories** — popular Internshala keyword slugs: `computer-science`, `marketing`, `finance`, `design`, `engineering`, `data-science`, `content-writing`, `accounting`

### Integrations

#### Google Sheets pipeline

Run the scraper daily with a schedule → connect the Apify dataset to Google Sheets via the **Google Sheets integration** in Apify → share a live sheet with your team that auto-updates with new Internshala listings every morning.

#### Airtable internship database

Use Apify's Airtable integration to push each new result to an Airtable base. Add a formula field to flag listings where `isActivelyHiring = true` and `stipend` contains "month" for paid internships, and share the filtered view with candidates.

#### Slack job alerts

Connect the actor output to a Zapier or Make webhook trigger → filter for listings where `postedAt` is "Few hours ago" → post to a Slack channel for real-time alerts on new hot internships.

#### CRM lead enrichment

For recruiters: extract the `company` field and company URL from `url`, then cross-reference with your CRM. Use the `isActivelyHiring` flag and `skills` array to identify target companies and auto-tag them by tech stack in your CRM.

### API usage

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/internshala-scraper').call({
  searchQuery: 'python',
  searchMode: 'internships',
  locationKeywords: ['Mumbai', 'Bengaluru'],
  workFromHomeOnly: true,
  maxResults: 100,
  fetchDetails: false,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Scraped ${items.length} listings`);
items.forEach(item => console.log(item.title, item.company, item.stipend));
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("automation-lab/internshala-scraper").call(run_input={
    "searchQuery": "marketing",
    "searchMode": "internships",
    "maxResults": 50,
    "fetchDetails": True,
})

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["company"], item["stipend"])
```

#### cURL

```bash
curl -s -X POST \
  "https://api.apify.com/v2/acts/automation-lab~internshala-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "data-science",
    "searchMode": "internships",
    "maxResults": 50
  }'
```

### Use with Claude (MCP)

You can use this scraper directly from Claude Code, Claude Desktop, Cursor, or VS Code via the Apify MCP server.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/internshala-scraper"
```

Then in Claude Code:

> "Scrape 50 Python internships from Internshala and list the top ones by stipend"

> "Get all marketing internships with fetchDetails enabled and summarize the most common required skills"

#### Claude Desktop / Cursor / VS Code

Add to your MCP config (e.g. `~/.claude/claude_desktop_config.json`):

```json
{
  "mcpServers": {
    "apify": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/internshala-scraper",
      "headers": { "Authorization": "Bearer YOUR_APIFY_TOKEN" }
    }
  }
}
```

**Example prompts:**

- "Find the 20 best-paying Python internships on Internshala right now"
- "Scrape 100 marketing jobs from Internshala and show the ones that are work-from-home"
- "Get Internshala internships for data science and list all unique required skills"

### Legality — Is scraping Internshala legal?

Web scraping publicly available job listings is generally permissible for personal research, academic, and business intelligence purposes under most jurisdictions. Internshala's listings are publicly accessible without login. Always review Internshala's [Terms of Service](https://internshala.com/terms) for the latest guidance, and use this tool responsibly and respectfully.

This actor only reads publicly available data and does not submit applications, create accounts, or interact with authenticated endpoints. Respect rate limits and avoid running extremely large scrapes that could impact Internshala's service for real users.

### FAQ — Frequently asked questions

**Q: Can I filter by location?**
A: Yes. Add up to 20 values to `locationKeywords`. Matching is case-insensitive against the existing parsed `location` field, and a listing is kept when any keyword occurs in that location. Leave the list empty to include every location. Set `workFromHomeOnly: true` as well when you only want listings identified as remote or work from home.

**Q: Why does my run return fewer results than `maxResults`?**
A: `maxResults` counts emitted rows after optional location and work-from-home filters. A run can return fewer rows when the source is exhausted before enough matching listings are found. For example, searching `"fortran"` may only find a handful of results.

**Q: The run succeeded but some fields like `stipend` or `postedAt` are empty — is that a bug?**
A: No. Some listings (especially fresher jobs) don't display stipend or posted-date in their listing card. Jobs listings use a salary range format instead of `₹/month`. These fields are optional on Internshala's side.

**Q: I see "Ignored attempt to charge for an event" in local test logs — is that normal?**
A: Yes, this message appears during local `apify run` testing and can be safely ignored. Pay-per-event charges only apply during cloud runs on the Apify platform.

**Q: Can I scrape a specific company's listings?**
A: Not directly — Internshala's public search doesn't expose company-specific URLs in a predictable pattern. Use the actor to scrape broadly and filter by `company` in the output.

### Related scrapers

- [LinkedIn Scraper](https://apify.com/automation-lab) — for global job listings
- [Naukri Scraper](https://apify.com/automation-lab) — India's largest job portal for experienced professionals
- [Indeed Scraper](https://apify.com/automation-lab) — multi-country job listings

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/internshala-scraper/changelog.md

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword to filter listings (e.g. 'python', 'marketing', 'data-science'). Leave blank to scrape all listings.

## `searchMode` (type: `string`):

Scrape internships or jobs.

## `locationKeywords` (type: `array`):

Return listings whose parsed location contains at least one keyword (case-insensitive). Leave empty to include every location.

## `workFromHomeOnly` (type: `boolean`):

Return only listings identified as work from home or remote.

## `fetchDetails` (type: `boolean`):

Fetch the full detail page for each listing to extract additional fields: start date, apply-by deadline, about company, and full job description. Slower but richer data.

## `maxResults` (type: `integer`):

Maximum number of matching listings to return after optional location and work-from-home filters are applied.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed HTTP requests.

## Actor input object example

```json
{
  "searchQuery": "marketing",
  "searchMode": "internships",
  "locationKeywords": [],
  "workFromHomeOnly": false,
  "fetchDetails": false,
  "maxResults": 20,
  "maxRequestRetries": 3
}
```

# Actor output Schema

## `overview` (type: `string`):

Table of extracted Internshala listings with portable detail and company logo URLs.

# 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 = {
    "searchQuery": "marketing",
    "searchMode": "internships",
    "locationKeywords": [],
    "workFromHomeOnly": false,
    "fetchDetails": false,
    "maxResults": 20,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/internshala-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 = {
    "searchQuery": "marketing",
    "searchMode": "internships",
    "locationKeywords": [],
    "workFromHomeOnly": False,
    "fetchDetails": False,
    "maxResults": 20,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/internshala-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 '{
  "searchQuery": "marketing",
  "searchMode": "internships",
  "locationKeywords": [],
  "workFromHomeOnly": false,
  "fetchDetails": false,
  "maxResults": 20,
  "maxRequestRetries": 3
}' |
apify call automation-lab/internshala-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/internshala-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/E5AdE5X0rQzfRdQNo/builds/a7znYf52McSJyLDVX/openapi.json