# Internshala Internship Scraper (`axiomworks/internshala-internships-scraper`) Actor

Collect Internshala internship listings by keyword, category, city, work-from-home filter or listing URL. Results include role, company, location, stipend, duration, skills and posting date; optional detail pages add applicants, openings, salary range, company details and the full text.

- **URL**: https://apify.com/axiomworks/internshala-internships-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 results

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

**Returns:** one row per Internshala internship or job with `title`, `company`, `compensationText`, `locations`, `duration`, `applicants`, `validThrough` and `skills`.
**Input:** `{"keyword": "python", "listingType": "internships", "maxItems": 50}`
**Best for:** internship and fresher job lead lists, stipend and salary research, tracking who is hiring in a city or category.

```json
{
    "id": "3315801",
    "employmentType": "job",
    "title": "Artificial Intelligence (AI) Specialist",
    "company": "Smarth Technology",
    "locations": ["Mumbai"],
    "compensationText": "₹ 2,10,000 - 3,80,000 /year",
    "experience": "1 year(s)",
    "applicants": 60
}
```

### What does Internshala Internship Scraper do?

Internshala Internship Scraper collects internship and job postings from Internshala, India's large internship and fresher job board. Give it a keyword (for example `python` or `graphic design`), a category and city (for example `data-science` in `mumbai`), the work-from-home filter, or any Internshala listing URL, and it returns one clean row per posting: role title, company, stipend or salary, locations, duration or required experience, when it was posted, the skills asked for, and the posting link.

By default it also opens each posting's own page and adds the details that the search results don't show: the number of applicants, the start date, the date posted and the application deadline, the number of openings, the salary as numbers with currency and period, the full skills list, the company's industry and website, Internshala's category for the role, and the full description text. All of it comes from public pages that load without logging in.

Use it as an Internshala scraper or an unofficial Internshala API for internship lead lists, stipend benchmarks by city and skill, monitoring new postings in a category, or feeding job data to an AI agent. Results export to JSON, CSV, Excel or XML, or come straight from the Apify API.

### What data can you get from Internshala?

| Field | Description | Example |
|---|---|---|
| `id` | Internshala posting ID, unique within a run | `3315801` |
| `employmentType` | `internship` or `job` | `job` |
| `title` | Role title | `Artificial Intelligence (AI) Specialist` |
| `company` | Hiring company or organisation | `Smarth Technology` |
| `companyLogo` | Logo image URL, null for the placeholder logo | `https://internshala-uploads.internshala.com/logo%2F73hzfyzocib-56042.jpg.webp` |
| `activelyHiring` | True when the card shows the "Actively hiring" badge | `true` |
| `locations` | Location names, or "Work from home" | `["Thane", "Navi Mumbai", "Mumbai"]` |
| `isWorkFromHome` | True when one location is "Work from home" | `false` |
| `compensationText` | Stipend or salary as shown | `₹ 2,10,000 - 3,80,000 /year` |
| `duration` | Internship duration (null for jobs) | `1 Month` |
| `experience` | Required experience for jobs (null for internships) | `1 year(s)` |
| `postedAgo` | Relative posting time | `2 days ago` |
| `tags` | Extra labels such as "Part time" | `["Part time"]` |
| `listSkills` | Skills shown on the search card | `["HTML", "Python", "SQL"]` |
| `sourceUrl` | Posting page URL | `https://internshala.com/job/detail/...` |
| `applicantsText` | Applicant count as shown | `1000+ applicants` |
| `applicants` | Applicant count as a number | `1000` |
| `startDate` | Start date as shown | `Immediately` |
| `datePosted` | Date posted | `2026-10-14` |
| `validThrough` | Application deadline | `2026-11-13 23:59:59` |
| `openings` | Number of openings | `6` |
| `salaryMin` | Lower salary or stipend bound | `210000` |
| `salaryMax` | Upper salary or stipend bound | `380000` |
| `salaryCurrency` | Currency code | `INR` |
| `salaryUnit` | Salary period | `YEAR` |
| `skills` | Full skills list from the posting page | `["Artificial intelligence"]` |
| `industry` | Company industry | `Entertainment` |
| `category` | Internshala category of the role | `Artificial Intelligence (AI)` |
| `companyWebsite` | Company website, when listed | `http://salesforce.com` |
| `description` | Full posting text as plain text | `About the job: As an AI Specialist ...` |
| `searchUrl` | Listing page the posting was found on | `https://internshala.com/jobs/data-science-jobs-in-mumbai/` |
| `scrapedAt` | When the record was scraped (UTC) | `2026-10-17T00:16:09.449Z` |

The fields from `applicantsText` to `description` come from the posting page and are null when `includeDetails` is false. Internshala doesn't publish structured posting data on every page (multi-location jobs often lack it); on those pages the date, salary-number, industry, category and website fields stay null, while the listing fields, applicants, start date, openings and skills are still filled.

### How to use Internshala Internship Scraper

1. Open Internshala Internship Scraper in Apify Console and go to the Input tab.
2. Choose what to search. Type a keyword such as `python`, or leave the keyword empty and set a category (`data-science`), a city (`mumbai`) or switch on "Work from home only". To scrape a page you already have open on Internshala, paste its URL into "Listing URLs" instead.
3. Pick "Internships" or "Jobs" in "Internships or jobs".
4. Set "Maximum results". The run stops as soon as that many postings are saved.
5. Keep "Include detail page fields" on for applicants, dates, openings, salary numbers and descriptions, or switch it off for a faster run with listing fields only.
6. Click Start. When the run finishes, open the Output tab and export the dataset as JSON, CSV, Excel or XML.

Tips:

1. Keyword search takes free text. Multi-word keywords work: `graphic design` becomes Internshala's `keywords-graphic-design` search.
2. Category and city use Internshala's URL slugs. If a slug doesn't exist, Internshala quietly redirects to a broader list; the run log warns when that happens so you can fix the slug.
3. Search pages hold about 40 to 60 postings each, and the scraper follows `page-2/`, `page-3/` and so on until it has `maxItems` results or the listing ends.
4. Internshala usually works without a proxy. If a run reports blocked or rate-limited requests, switch on Apify Proxy in the Proxy section.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `keyword` | string | No | Free-text search, e.g. `python`. When set, category, city and work from home are ignored. |
| `listingType` | string | No | `internships` (default) or `jobs`. |
| `category` | string | No | Category slug, e.g. `data-science`, `marketing`, `content-writing`. |
| `city` | string | No | City slug, e.g. `bangalore`, `mumbai`, `pune`. Ignored with work from home. |
| `workFromHome` | boolean | No | Only remote postings, optionally within the category. Default false. |
| `startUrls` | array | No | Internshala listing URLs (any `/internships/...` or `/jobs/...` page) or single posting URLs. When given, the fields above are ignored. |
| `locationKeywords` | string array | No | Match any location substring, case-insensitive, up to 20; default empty. |
| `workFromHomeOnly` | boolean | No | Require `isWorkFromHome: true`, including keyword searches and URLs; default false. |
| `partTimeOnly` | boolean | No | Require a Part time tag; default false. |
| `includeDetails` | boolean | No | Open each posting page for the detail fields. Default true. |
| `maxItems` | integer | No | Maximum number of postings across all targets, 1-10000, default 50. |
| `proxyConfiguration` | object | No | Proxy settings. Default: no proxy. |

With no keyword, category, city or URL at all, the scraper returns the newest postings of the chosen listing type.

Example: Python internships, 50 results with details.

```json
{
    "keyword": "python",
    "listingType": "internships",
    "maxItems": 50,
    "includeDetails": true
}
```

Example: data science jobs in Mumbai.

```json
{
    "listingType": "jobs",
    "category": "data-science",
    "city": "mumbai",
    "maxItems": 100
}
```

Example: a listing URL copied from the browser.

```json
{
    "startUrls": [
        { "url": "https://internshala.com/internships/work-from-home-content-writing-internships/" }
    ],
    "maxItems": 60
}
```

The optional result filters work with every target form. For example, `{"keyword":"python","workFromHomeOnly":true,"partTimeOnly":true,"maxItems":7}` returns up to seven remote, part-time Python postings. `locationKeywords` matches any supplied substring against `locations`; the remote and part-time switches must also match when enabled. Filtering happens before detail requests, saving those requests for matching postings. Pagination continues past pages with no matching rows, until the source ends or the shared result limit is reached. Narrow filters can return fewer results. All three options are off by default.

### Output

Each posting is one dataset item. Two real records from a local run (descriptions shortened):

```json
[
    {
        "id": "3318726",
        "employmentType": "internship",
        "title": "Data Analytics",
        "company": "Basti Ki Pathshala Foundation",
        "companyLogo": "https://internshala-uploads.internshala.com/logo%2F73hzfyzocib-56042.jpg.webp",
        "activelyHiring": true,
        "locations": ["Work from home"],
        "isWorkFromHome": true,
        "compensationText": "Unpaid",
        "duration": "1 Month",
        "experience": null,
        "postedAgo": "Today",
        "tags": ["Part time"],
        "listSkills": ["HTML", "Python", "SQL", "Data Analytics", "MS-Excel", "Data Science", "Power BI"],
        "sourceUrl": "https://internshala.com/internship/detail/work-from-home-data-analytics-internship-at-basti-ki-pathshala-foundation1792146175",
        "applicantsText": "101 applicants",
        "applicants": 101,
        "startDate": "Immediately",
        "datePosted": "2026-10-16",
        "validThrough": "2026-11-15 23:59:59",
        "openings": 20,
        "salaryMin": null,
        "salaryMax": null,
        "salaryCurrency": null,
        "salaryUnit": null,
        "skills": ["HTML", "Python", "SQL", "Data Analytics", "MS-Excel", "Data Science", "Power BI", "Tableau"],
        "industry": "Education",
        "category": "Data Analytics",
        "companyWebsite": null,
        "description": "About the internship: Are you a data-savvy individual looking to make a real impact? Join us at Basti Ki Pathshala Foundation as a Data Analytics intern! ...",
        "searchUrl": "https://internshala.com/internships/keywords-python/",
        "scrapedAt": "2026-10-17T00:15:46.487Z"
    },
    {
        "id": "3315801",
        "employmentType": "job",
        "title": "Artificial Intelligence (AI) Specialist",
        "company": "Smarth Technology",
        "companyLogo": null,
        "activelyHiring": false,
        "locations": ["Mumbai"],
        "isWorkFromHome": false,
        "compensationText": "₹ 2,10,000 - 3,80,000 /year",
        "duration": null,
        "experience": "1 year(s)",
        "postedAgo": "2 days ago",
        "tags": [],
        "listSkills": ["Artificial intelligence"],
        "sourceUrl": "https://internshala.com/job/detail/artificial-intelligence-ai-specialist-job-in-mumbai-at-smarth-technology1791962807",
        "applicantsText": "60 applicants",
        "applicants": 60,
        "startDate": "Immediately",
        "datePosted": "2026-10-14",
        "validThrough": "2026-11-13 23:59:59",
        "openings": 6,
        "salaryMin": 210000,
        "salaryMax": 380000,
        "salaryCurrency": "INR",
        "salaryUnit": "YEAR",
        "skills": ["Artificial intelligence"],
        "industry": "Entertainment",
        "category": "Artificial Intelligence (AI)",
        "companyWebsite": null,
        "description": "About the job: As an AI Specialist at our cutting-edge Smart Technology company, you'll be at the forefront of revolutionizing the way we interact with technology. ...",
        "searchUrl": "https://internshala.com/jobs/data-science-jobs-in-mumbai/",
        "scrapedAt": "2026-10-17T00:16:09.449Z"
    }
]
```

The Output tab's Overview shows the most useful columns (title, company, type, locations, stipend or salary, duration, experience, posted, applicants, dates and link); the full dataset has every field above. Download it as JSON, CSV, Excel, XML or RSS, or read it with the API.

### How much does it cost to scrape Internshala?

Internshala Internship Scraper is charged per result. You pay only for the postings returned, and `maxItems` caps how many that can be. Detail pages are included in the per-result charge: switching `includeDetails` off makes runs faster but doesn't change what a result costs. See the Pricing tab for the current price.

If you set a maximum cost per run in the run options, the scraper stops cleanly when that budget is used up and keeps everything it saved so far.

### Use with AI agents (MCP)

Connect Internshala Internship Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/internshala-internships-scraper"
        }
    }
}
```

Example prompts:

1. "Find 30 Python internships on Internshala and list the ones with a stipend above 10,000 a month."
2. "Get data science jobs in Mumbai from Internshala and summarise the salary ranges and required experience."
3. "Which companies are hiring work-from-home content writing interns on Internshala this week? Give me titles, stipends and deadlines."

The agent sees the input fields and their descriptions, so it can pick a keyword, a category and city, or a listing URL by itself.

### Integrations and API

Run Internshala Internship Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("axiomworks/internshala-internships-scraper").call(
    run_input={"keyword": "python", "listingType": "internships", "maxItems": 50}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["company"], item["compensationText"])
```

**JavaScript**

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('axiomworks/internshala-internships-scraper').call({
    listingType: 'jobs',
    category: 'data-science',
    city: 'mumbai',
    maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~internshala-internships-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword": "python", "listingType": "internships", "maxItems": 20}'
```

You can also schedule runs (for example every morning for new postings in your category) and send results to Google Sheets, Make, Zapier, n8n, Slack or a webhook from the Integrations tab.

### FAQ

**How many postings can I get?**
Up to 10,000 per run with `maxItems`. In practice you get as many as Internshala lists for your search: a popular keyword such as `python` has a few hundred internships, while a niche category in a small city may have a handful.

**Why did my run return 0 results?**
The keyword, category or city has no postings right now, or the URL isn't an Internshala listing page. The run still ends successfully and the status message says so. Try a broader keyword, drop the city, or open the URL in a browser to check it shows postings.

**Why do some records have null dates, salary numbers or industry?**
Those fields come from structured data that Internshala adds to most posting pages but not all (multi-location jobs often lack it). Unpaid postings can also omit the entire salary object, leaving salaryCurrency and salaryUnit null. Missing dates, currency, units, industry and category are not inferred from nearby text. Listing fields, applicants, start date, openings and skills are still filled where the page shows them. With `includeDetails` set to false all detail fields are null.

**What is the difference between `listSkills` and `skills`?**
`listSkills` is what the search card shows, which is cut to about seven skills with "+N more". `skills` is the full list from the posting page.

**Can I scrape a single posting?**
Yes. Put the posting URL (`https://internshala.com/internship/detail/...` or `https://internshala.com/job/detail/...`) in "Listing URLs" and the run returns that one posting.

**Do I need an Internshala account or a proxy?**
No account: the scraper reads public pages only. Internshala normally answers without a proxy; if you see blocked or rate-limited requests in the log, switch on Apify Proxy.

**How fresh is the data?**
Every run reads Internshala live, so results are as current as the site at run time. `postedAgo`, `datePosted` and `scrapedAt` tell you how old each posting is.

### Is it legal to scrape Internshala?

Internshala Internship Scraper reads only publicly available pages that anyone can open without logging in, and it requests them at a modest rate. Postings can include company names and other business details; if you store or process personal data, you are responsible for following the laws that apply to you, such as GDPR or India's DPDP Act, and Internshala's terms. This is not legal advice; ask a lawyer if you are unsure about your use case.

Internshala Internship Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by Internshala.

### Related Actors

| Actor | What it does |
|---|---|
| [LinkedIn Jobs Scraper](https://apify.com/axiomworks/linkedin-jobs-scraper) | Job postings from LinkedIn search |
| [Google Jobs Scraper](https://apify.com/axiomworks/google-jobs-scraper) | Job listings aggregated by Google |
| [Remote Job Listings Scraper](https://apify.com/axiomworks/remote-jobs-scraper) | Remote job postings |

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

## `keyword` (type: `string`):

Free-text search, e.g. 'python' or 'graphic design'. Turned into Internshala's keyword URL (/internships/keywords-graphic-design/). When set, category, city and workFromHome are ignored. Leave empty to filter by category and city instead.

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

Which listings to search: 'internships' (default) or 'jobs' (fresher and experienced jobs). Applies to keyword, category, city and workFromHome; ignored for startUrls.

## `category` (type: `string`):

Internshala category slug, e.g. 'python', 'data-science', 'marketing', 'content-writing'. Spaces become dashes. Combine with city or workFromHome. An unknown slug makes Internshala redirect to a broader list; the log warns when that happens.

## `city` (type: `string`):

City slug, e.g. 'bangalore', 'mumbai', 'pune', 'delhi'. Used with or without category; ignored when workFromHome is on.

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

Only remote postings, optionally within category (city is ignored). Default false.

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

Internshala URLs to scrape instead of the fields above, e.g. https://internshala.com/internships/work-from-home-content-writing-internships/. Any /internships/ or /jobs/ listing or filter page (page-N optional, paging starts at page 1), or a single posting URL (/internship/detail/... or /job/detail/...).

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

Default true: open each posting's page for applicants, startDate, datePosted, validThrough, openings, salary numbers, full skills, industry, category, companyWebsite and description (one extra request per result). False is faster and leaves those fields null.

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

Maximum number of postings to return across all targets, 1-10000, default 50. The run stops as soon as this many results are saved, and you are charged only for results returned.

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

Proxy to use for requests, default none. Switch on Apify Proxy if runs get blocked or rate-limited.

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

Return postings whose locations contain any of up to 20 city or location keywords, case-insensitive. Default \[] keeps all locations. Applies with keyword and startUrls, before detail requests and the shared maxItems limit. Combine with remote and part-time filters using AND.

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

Return only postings with isWorkFromHome true. Default false. Unlike workFromHome URL selection, applies even with keyword or startUrls. Nonmatching postings are skipped before maxItems and charging.

## `partTimeOnly` (type: `boolean`):

Return only postings whose tags contain Part time. Default false. Applies to every target before detail requests and maxItems; listings without that tag are excluded. No matches or blocked targets return zero results successfully.

## Actor input object example

```json
{
  "keyword": "python",
  "listingType": "internships",
  "workFromHome": false,
  "includeDetails": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "locationKeywords": [],
  "workFromHomeOnly": false,
  "partTimeOnly": false
}
```

# Actor output Schema

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

Dataset with one item per result, in the order found.

# 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 = {
    "keyword": "python",
    "listingType": "internships",
    "includeDetails": true,
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/internshala-internships-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 = {
    "keyword": "python",
    "listingType": "internships",
    "includeDetails": True,
    "maxItems": 10,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/internshala-internships-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 '{
  "keyword": "python",
  "listingType": "internships",
  "includeDetails": true,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/internshala-internships-scraper --silent --output-dataset

```

## MCP server setup

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