# Internshala Scraper API - Internships & Jobs in India (`dami_studio/internshala-scraper`) Actor

Scrape Internshala, India's biggest internship and fresher-job board: role, company, city, stipend with an honesty flag (range, fixed or unpaid), duration, apply-by date, openings, exact posted date, work-from-home flag and skills. No login. At $0.34 per 1,000 postings, the lowest price on Apify.

- **URL**: https://apify.com/dami\_studio/internshala-scraper.md
- **Developed by:** [Dami's Studio](https://apify.com/dami_studio) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.34 / 1,000 posting returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 Scraper — internships and fresher jobs in India

Pulls live postings from [Internshala](https://internshala.com), India's biggest internship and
entry-level job board. No login, no cookies, no browser.

Every row comes back with the role, the company, the city, the stipend or salary **with a flag
saying what kind of figure it is**, the duration, the apply-by date, the number of openings, the
exact posted date, a work-from-home flag, the required skills, the perks and the eligibility rules.

On 2026-08-08 the site had **7,007 live internships** and **8,663 live jobs**. Both boards are
reachable, in full, page by page.

***

### What you get per posting

| Field | Example | Where it comes from |
|---|---|---|
| `title` | `Front End Development` | listing card |
| `companyName`, `companyUrl`, `companyLogo` | `SciAstra Education Private Limited` | card + posting page |
| `locations`, `locationLabel`, `region` | `["Pune","Mumbai","Virar"]`, `Maharashtra` | card + posting page |
| `isWorkFromHome`, `isHybrid`, `isPartTime` | `true` / `false` | card + `employmentType` |
| `stipendText` | `₹ 12,000 - 17,000 /month` | card |
| `stipendMin`, `stipendMax`, `stipendCurrency`, `stipendPeriod` | `12000`, `17000`, `INR`, `MONTH` | parsed |
| `stipendType` | `range`, `fixed`, `unpaid`, `lump-sum`, `performance-based` | parsed |
| `stipendIsEstimate` | always `false` — see below | — |
| `durationText`, `durationMonths` | `6 Months`, `6` | card |
| `experienceText`, `experienceYears` | `1 year(s)`, `1` | jobs board |
| `skills` | `["HTML","React","Node.js"]` | card + posting page |
| `postedRelative`, `postedAt`, `postedAtIsExact` | `2 days ago`, `2026-08-06`, `true` | posting page JSON-LD |
| `applyByText`, `applyBy` | `5 Sep' 26`, `2026-09-05` | posting page |
| `openings` | `3` | posting page |
| `startDateText`, `startsImmediately` | `Immediately`, `true` | posting page |
| `perks` | `["Certificate","Letter of recommendation","Job offer"]` | posting page |
| `eligibility` | `["are available for duration of 6 months", …]` | posting page |
| `hasJobOfferAfterInternship`, `jobOfferText` | `true`, `Job offer upto ₹ 2.4LPA post internship` | card |
| `industry`, `employmentType` | `Engineering`, `INTERN, FULL_TIME` | posting page JSON-LD |
| `aboutCompany`, `descriptionText` | full text | posting page |
| `url`, `id`, `type`, `countryCode` | `internship` / `job`, `IN` | — |

Three real rows, copied out of live runs:

```
Mobile App Testing | Shreyans Industries | Bangalore | ₹ 5,000 /month (fixed)
   | 1 Month | posted 2026-08-06 | apply by 2026-09-05 | 5 openings

Meta Ads Executive | EMIAC Technologies | Jaipur | ₹ 2,00,000 - 2,40,000 /year (range)
   | job, 1 year(s) experience | posted 2026-08-01 | apply by 2026-08-31 | 2 openings

Backend Development | Pledge India Foundation | Work from home | Unpaid (unpaid)
   | 2 Weeks | posted 2026-08-07 | apply by 2026-09-06 | 20 openings
```

***

### About the stipend — read this before you trust the number

Internshala mixes several kinds of pay, and a scraper that flattens them into one "stipend" column
is lying to you. Every row therefore carries `stipendType`.

Measured on two real runs of this actor on 2026-08-08 — **1,000 internships** and **300 jobs**:

| `stipendType` | Internships (n=1,000) | Jobs (n=300) |
|---|---|---|
| `range` (e.g. ₹ 12,000 - 17,000 /month) | 867 (86.7%) | 283 (94.3%) |
| `fixed` (e.g. ₹ 5,000 /month) | 114 (11.4%) | 17 (5.7%) |
| `unpaid` | 16 (1.6%) | 0 |
| `lump-sum` | 2 (0.2%) | 0 |
| `performance-based` | 1 (0.1%) | 0 |
| missing / not stated | **0** | **0** |

An independent 1,050-internship / 530-job sample taken the same day landed within 0.5 points of
every one of those figures, so this is the shape of the board, not a lucky page.

Two things follow from that:

1. **Every posting states its own pay.** There were no blanks in either sample. That is unusual for
   a job board and it is the main reason this data is worth having.
2. **`stipendIsEstimate` is `false` on every row, and it always will be.** Internshala publishes
   what the employer typed. It never invents a "salary estimate" the way some Western boards do, so
   there is no guessed figure hiding in this dataset. Filter on `stipendType` when you need only
   hard numbers: `range` and `fixed` together are 98.2% of internships and 100% of jobs.

Note that a `range` is a range. `stipendMin` and `stipendMax` differ on 87% of internship rows, so
averaging `stipendMin` alone will understate the market.

***

### Searching

You can drive it three ways, and mix them.

**Keywords** — `searchQueries: ["python", "data science"]`. Each one is walked separately.

**Filters** — category, city, work-from-home, part-time, minimum stipend, maximum duration,
pre-placement offer, start date, women-only, international, early-applicant, fast-response. On the
jobs board: minimum annual salary, experience band, fresher-only, and Internshala's "also show
internships" toggle. They compose:

```
categories: ["computer science"], cities: ["bangalore","mumbai"],
workFromHome: true, maxDurationMonths: 3, minStipend: 5000
```

**Pasted URLs** — `startUrls` accepts any Internshala listing page
(`https://internshala.com/internships/work-from-home-computer-science-internships/`) and any single
posting (`https://internshala.com/internship/detail/...`). Listing URLs are walked page by page from
wherever you pasted them.

Measured filter sizes on 2026-08-08, so you know what to expect:

| Filter | Result count |
|---|---|
| everything, internships | 7,007 |
| everything, jobs | 8,663 |
| work from home (internships) | 2,154 |
| work from home (jobs) | 1,456 |
| part time | 1,449 |
| with a job offer afterwards (PPO) | 1,223 |
| internships for women | 3,379 |
| international internships | 85 |
| fresher jobs | 4,179 |
| jobs paying ≥ ₹600,000/year | 2,281 |
| `keywords: python` | 262 |
| `keywords: python` + Bangalore | 163 |

***

### Speed and limits

Real runs of this actor, all at the default 1,024 MB:

| Run | Rows | Wall time |
|---|---|---|
| `searchQueries: ["python"]` | 5 | 5 s |
| `categories: ["computer science"]` | 250 | 34 s |
| `listing: "jobs"` | 300 | 47 s |
| `listing: "both"` | 1,000 | 107 s |
| `cities: ["bangalore"]`, details off | 200 | 19 s |

- A listing page is one request and returns 40–50 postings. Measured **430 ms per page** from the
  plain Apify container address; 60 pages in a row took 29.6 s and produced 2,400 rows with zero
  failures and no rate limiting.
- With **Open each posting** on (the default), each posting costs one extra request, measured at
  **84 ms per posting at concurrency 10**. That is where `applyBy`, `openings`, the exact
  `postedAt`, `startDateText`, `perks`, `eligibility`, `region` and the full description come from.
- A single search runs out at Internshala's own last page. The unfiltered internships board ends at
  **page 176 (7,007 rows)** and returns an empty page after that — there is no hidden ceiling and no
  silent row clamp. To go wider, use several keywords, cities or categories.

### Field coverage, measured

From the 1,000-internship run and the 300-job run, percentage of rows where the field is filled:

| Field | Internships | Jobs |
|---|---|---|
| `title`, `companyName`, `companyUrl`, `locationLabel`, `stipendText`, `stipendMin/Max`, `skills`, `descriptionText`, `url`, `openings`, `startDateText`, `postedAt` | 100% | 100% |
| `durationText` | 100% | 12% (jobs rarely have one) |
| `experienceText` | 0% (internships have none) | 100% |
| `applyBy` | 100% | 83% |
| `applyByText` (Internshala's `5 Sep' 26` wording) | 100% | 0% — the jobs board does not print it |
| `postedAtIsExact` | 83% | 83% |
| `region`, `industry`, `employmentType`, `aboutCompany` | 83% | 83% |
| `eligibility` | 83% | 78% |
| `perks` | 78% | 51% |
| `companyWebsite` | 52% | 50% |
| `jobOfferText` (post-internship offer) | 16% | 0% — jobs have no PPO |

### What this does not do

- **No applicant counts, no employer contact details, no candidate data.** Internshala hides those
  behind a student login and this actor never logs in.
- **Multi-city postings carry no JSON-LD.** Internshala only emits structured data for
  single-location postings, so **17% of rows** (169 of 1,000 internships, 52 of 300 jobs — always
  the "in multiple locations" ones) come back with `postedAtIsExact: false`, and with `region`,
  `industry`, `employmentType` and `isPartTime` `null`. Everything else on those rows, including
  `applyBy` and `openings`, is read out of the HTML and is still there.
- **`companyWebsite` is missing about half the time.** It only exists when the employer filled it
  in. It is emitted when it is there and left `null` when it is not — never guessed.
- **No expired postings.** Internshala takes a posting down once its apply-by date passes; a pasted
  URL for a dead posting returns an uncharged diagnostic row, not a charge.
- **India only** (plus the 85 international internships Internshala itself lists).
- **Posted dates without the detail pass are approximate.** With **Open each posting** off, the
  board only says "2 days ago", so `postedAt` is derived from that and `postedAtIsExact` is `false`
  on every row.

### Price

**$0.0005 to start a run, then $0.34 per 1,000 postings.** That is the cheapest of the 13
Internshala scrapers on the Apify Store as of 2026-08-08; the next cheapest is $0.40 per 1,000 and
the rest run from $1.00 to $5.00. The start fee matches the cheapest rival's exactly, so this actor
is cheaper at every run size, not just at large ones.

Sample rows, diagnostic rows, failed requests and empty searches are all uncharged. One charge per
genuine posting, and nothing else. A run that returns nothing costs you the start fee alone.

***

### FAQ

**Is there an Internshala API?**
Not a public one. Internshala paginates its own listings over XHR — `internships_ajax` and
`jobs_ajax` — and that is what this actor reads. It is the same data the website shows you, in JSON,
without rendering a browser.

**Do I need an Internshala account or a login?**
No. Every request in this actor is anonymous.

**Can I scrape Internshala internships by city?**
Yes. `cities: ["bangalore","delhi"]` combines cities with OR, and it composes with category,
work-from-home and every other filter.

**Can I get remote / work-from-home internships only?**
Yes — `workFromHome: true`. 2,154 of the 7,007 live internships were work-from-home on 2026-08-08.

**Does it return the stipend?**
Yes, on every row, and it says what kind of figure it is. 87% of internships quote a range, 11% a
fixed monthly amount, 1.5% are unpaid. Nothing is estimated.

**How do I get the application deadline?**
`applyBy` (ISO date) and `applyByText` (Internshala's own `5 Sep' 26` wording). Both need
**Open each posting** to be on, which it is by default.

**How many results can I get from one run?**
As many as the search has. A 1,000-row run finished in 107 seconds. The whole internships board —
7,007 rows — is reachable in one run; `maxItems` is the only cap, and it goes to 20,000.

**What does it cost?**
$0.0005 per run plus $0.34 per 1,000 postings — the cheapest Internshala scraper on the Apify Store
on 2026-08-08, against a field of 13 where the next cheapest is $0.40 and most are $1 to $5.

**Does it work outside India?**
Yes. The actor runs from Apify's own network and Internshala serves the same board regardless. An
Indian residential exit and a US datacenter address were compared side by side and returned the same
40 postings, in the same order, with the same 7,007 total.

**What is the difference between the internships board and the jobs board?**
Internships are short placements with a monthly stipend and a duration. Jobs are full-time
fresher/early-career roles with an annual salary and an experience requirement. Set
`listing: "both"` to walk both; every row carries a `type` field.

# Actor input Schema

## `searchQueries` (type: `array`):

One or more searches, exactly as you would type them into Internshala's search box: a skill ("python"), a role ("graphic design"), or a company name ("Infosys"). Each keyword is walked separately, so \["python", "data science"] runs two searches. Leave empty to take everything that matches the filters below.

## `listing` (type: `string`):

Internshala runs two boards. Internships (7,007 live on 2026-08-08) are short placements with a monthly stipend. Jobs (8,663 live) are full-time fresher and early-career roles with an annual salary. "Both" walks the two in turn and tags every row with a "type" field.

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

Internshala's own categories, written the way the site writes them: "marketing", "computer science", "human resources", "content writing", "data science", "finance", "graphic design", "web development". Several categories are combined with OR.

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

Indian cities, for example "bangalore", "delhi", "mumbai", "pune", "hyderabad", "chennai", "kolkata", "gurgaon". Several cities are combined with OR. Leave empty for the whole country.

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

Only remote postings. Measured on 2026-08-08: 2,154 of 7,007 internships and 1,456 of 8,663 jobs are work-from-home.

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

Only part-time internships — 1,449 of 7,007 on 2026-08-08. Ignored on the jobs board.

## `withJobOffer` (type: `boolean`):

Internshala's PPO filter: internships with a pre-placement offer. 1,223 of 7,007 on 2026-08-08. Those rows also carry the offer text, for example "Job offer upto ₹ 2.4LPA post internship".

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

Only internships paying at least this much per month. Internshala's own slider stops at 12,000, and anything above that is ignored by the site, so the value is clamped there. Every row also carries stipendMin, so you can filter harder afterwards.

## `maxDurationMonths` (type: `integer`):

Only internships that last at most this many months. It is cumulative: 1 gave 610 results, 2 gave 1,319, 6 gave 6,975 on 2026-08-08.

## `minSalary` (type: `integer`):

Only jobs paying at least this much per year. 600,000 cut the board from 8,663 to 2,281 on 2026-08-08. Ignored on the internships board.

## `experience` (type: `string`):

Internshala's own experience filter for the jobs board. The numbered options are cumulative caps ("1 year" returned 6,092 jobs, "2 years" 6,648); "more than 5 years" is a separate senior bucket and returned 146.

## `fresherOnly` (type: `boolean`):

Only jobs open to candidates with no work experience — 4,179 of 8,663 on 2026-08-08. Ignored on the internships board.

## `includeInternshipsInJobs` (type: `boolean`):

Internshala's "also show internships" toggle on the jobs board. It merges the two corpora into one walk — 14,447 rows on 2026-08-08 instead of 8,663. Ignored on the internships board.

## `internationalOnly` (type: `boolean`):

Internshala's international board: internships based outside India. It is small — 85 live on 2026-08-08.

## `forWomen` (type: `boolean`):

Internshala's women-only board: 3,379 internships on 2026-08-08. Combines with the category and city filters.

## `earlyApplicant` (type: `boolean`):

Only internships with few applications so far — 1,924 of 7,007 on 2026-08-08.

## `fastResponse` (type: `boolean`):

Internshala's fast-response badge: employers who review applications quickly. 4,061 of 7,007 on 2026-08-08.

## `startingAfter` (type: `string`):

Only internships whose start date is on or after this day, written as YYYY-MM-DD.

## `startUrls` (type: `array`):

Paste Internshala URLs instead of building a search. Works with a listing page (https://internshala.com/internships/computer-science-internship-in-bangalore/) and with a single posting (https://internshala.com/internship/detail/...). Listing URLs are walked page by page.

## `includeDetails` (type: `boolean`):

Reads each posting's own page. That is where the apply-by date, the number of openings, the exact posted date (instead of "2 days ago"), the start date, the perks, the eligibility rules, the company's Internshala profile and website, the state, and the full description come from. Measured at 84 ms per posting at concurrency 10. Turn it off for a listing-only run: you keep title, company, city, stipend, duration, skills, the description snippet and an approximate posted date.

## `detailConcurrency` (type: `integer`):

How many posting pages to read at once when "Open each posting" is on. 10 is measured as comfortable; Internshala did not rate-limit at that level.

## `maxItems` (type: `integer`):

Stop after this many postings. One search runs out at Internshala's own last page — the unfiltered internships board ends at page 176 (7,007 rows) and returns nothing beyond it, so use several keywords, cities or categories to go wider.

## `egressMode` (type: `string`):

Leave on automatic. Internshala answers the plain Apify container address on every request we measured, and that route is also the fastest (430 ms per page against 1,200 ms through a proxy). The other options exist only for debugging.

## `proxyConfiguration` (type: `object`):

Leave as is. Internshala needs no proxy — supply your own servers here only if you have a reason to.

## Actor input object example

```json
{
  "searchQueries": [
    "python",
    "data science"
  ],
  "listing": "internships",
  "categories": [
    "computer science",
    "data science"
  ],
  "cities": [
    "bangalore",
    "mumbai"
  ],
  "workFromHome": false,
  "partTime": false,
  "withJobOffer": false,
  "minStipend": 10000,
  "maxDurationMonths": 3,
  "minSalary": 600000,
  "experience": "",
  "fresherOnly": false,
  "includeInternshipsInJobs": false,
  "internationalOnly": false,
  "forWomen": false,
  "earlyApplicant": false,
  "fastResponse": false,
  "startingAfter": "2026-09-01",
  "startUrls": [
    {
      "url": "https://internshala.com/internships/work-from-home-computer-science-internships/"
    }
  ],
  "includeDetails": true,
  "detailConcurrency": 10,
  "maxItems": 50,
  "egressMode": "auto",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchQueries": [
        "python"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dami_studio/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 = { "searchQueries": ["python"] }

# Run the Actor and wait for it to finish
run = client.actor("dami_studio/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 '{
  "searchQueries": [
    "python"
  ]
}' |
apify call dami_studio/internshala-scraper --silent --output-dataset

```

## MCP server setup

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