# Internshala Scraper - Internships & Fresher Jobs, 48 Fields (`parseforge/internshala-scraper`) Actor

Scrape Internshala internships and fresher jobs with exact posting dates, numeric stipend ranges, skills and perks. Export to CSV, Excel, JSON or XML.

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

## Pricing

from $2.00 / 1,000 internship or job 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?

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🎓 Internshala Scraper

> 🚀 **Export India's internship and fresher job market in seconds.** 48 fields per posting, exact calendar posting dates instead of "3 days ago", and stipends parsed into numbers on every row.

Internshala is where most of India's student hiring happens, and both of its feeds are served as plain public pages that nobody has to log into. This Actor reads them directly. Point it at a search URL such as `https://internshala.com/internships/`, build a search from the filters, or hand it a single posting URL, and it returns a flat row per opportunity with the title, company, location, stipend or CTC, duration, skills, perks, requirements, application deadline and the hiring company's own track record on the platform.

Coverage measured on the live site while building this Actor: **7,303 internships and 14,685 fresher jobs** reachable through the public paginator, across **206 profile categories** and **639 cities and states** taken from Internshala's own sitemap rather than guessed. A 60-posting run finished in 12 seconds, with a stipend or salary range parsed into numbers on 60 of 60 rows and an exact posting date on 51 of them. No login, no API key, no proxy required.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Campus recruiters and university placement cells | Track which employers are hiring students in your city and what they pay |
| Compensation and market analysts | Build entry-level stipend benchmarks from thousands of live disclosed ranges |
| Job board and aggregator operators | Feed a student-jobs board with fresh Indian internship and fresher listings |
| EdTech and skilling companies | See which skills are actually demanded per profile, straight from the skills tags |
| Lead generation teams selling to employers | Find companies actively hiring, with their website and hiring history attached |
| Students and career coaches | Export every matching opportunity to a spreadsheet and sort by stipend or deadline |

### 📋 What the Internshala Scraper does

- 🎓 **Both feeds, one Actor.** Internships and fresher jobs share a schema, so a single run can cover the whole 22,000-posting surface instead of forcing you to pick.
- 📅 **Exact posting dates.** Internshala only ever shows visitors a relative label like "3 days ago". This Actor reads the structured date behind the page and returns `datePosted` as a real calendar date you can sort and filter on, while keeping the relative `postedAgo` label too.
- 💰 **Stipends as numbers.** `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod` are numeric and comparable, whether the posting pays per month, per week, per year or as a lump sum. `fixedPay` and `variablePay` split the package when the employer breaks it out.
- 🛠️ **Skills and perks as arrays.** Every skill tag and every perk comes through as a clean array, ready to count, group or feed to a model.
- 🏢 **The employer's track record.** `companyHiringSince`, `companyOpportunitiesPosted` and `companyCandidatesHired` tell you whether a poster actually hires or just posts.
- 🎛️ **Filters that map to real Internshala searches.** 206 profile categories and 639 locations, both pulled from the site's own sitemap, plus work-from-home, part-time, minimum stipend and free-text keywords. Nothing is invented, so a run returns what the site itself would show.
- 🔗 **Single posting URLs.** Drop in one internship or job link and get the full row, no search required.
- 🧹 **Deduplicated by posting.** Internshala repeats the last ten cards of page 1 at the top of page 2. The Actor dedupes on the posting ID so you never pay for the same row twice.

> 💡 **Why it matters:** the two things anyone analysing this market needs, when a posting went live and what it actually pays, are the two Internshala never hands you in a usable form. This Actor returns both on every row.

### 🎬 Full Demo (🚧 Coming soon)

### 📊 Output

Every run writes one flat row per opportunity. 48 fields, always the same keys, so the dataset is safe to load straight into a pipeline.

| Field | What it holds |
|---|---|
| 🖼 `imageUrl` | Company logo, when the employer uploaded one |
| 📌 `title` | Posting title, for example "Graphic Design" |
| 🎓 `opportunityType` | `Internship` or `Job` |
| 🟢 `status` | `Active` or `Closed` |
| 🔗 `url` | Canonical posting URL |
| 🆔 `id` / `postingId` | Internshala's numeric IDs for the posting |
| 🏢 `companyName` | Hiring company |
| 🏬 `companyProfileUrl` | The company's Internshala page |
| 🌐 `companyWebsite` | The company's own site, when published |
| 📍 `locationText` | Location line as shown, including "Work from home" |
| 🏙 `city` / 🗺 `region` / 🌏 `country` | Parsed location, with the Indian state |
| 🏠 `isWorkFromHome` | `Yes` / `No` |
| 🗓 `datePosted` | Exact calendar date the posting went live |
| ⏳ `postedAgo` | The relative label Internshala shows, for example "3 days ago" |
| 📅 `applyByDate` / ⌛ `applyByDeadline` | Application deadline, as a date and a full timestamp |
| 🚀 `startDate` | When the role starts |
| 📆 `duration` | Internship length, for example "6 Months" |
| 🧾 `employmentType` | For example `INTERN, FULL_TIME` or `VOLUNTEER, INTERN, PART_TIME` |
| 🕐 `isPartTime` | `Yes` / `No` |
| 🏭 `industry` | Employer industry |
| 💰 `compensationText` | Stipend or CTC exactly as displayed |
| 📉 `salaryMin` / 📈 `salaryMax` | The range as numbers |
| 💱 `salaryCurrency` / 🔁 `salaryPeriod` | For example `INR` and `MONTH` |
| 🧮 `fixedPay` / 🎯 `variablePay` | Package split, when the employer breaks it out |
| 🧠 `experienceRequired` / 📊 `experienceMonths` | Experience asked for, as text and as months |
| 🎁 `jobOfferAfterInternship` | Pre-placement offer, for example "Job offer upto ₹ 5LPA post internship" |
| 🔢 `openings` | Number of positions |
| 👥 `applicants` | Applicant volume as Internshala buckets it |
| 📝 `description` | Full posting body as plain text |
| ✅ `whoCanApply` | The eligibility list |
| 📋 `otherRequirements` / ➕ `additionalInformation` | Extra employer requirements and stipend structure notes |
| 🏛 `companyDescription` | The employer's own blurb |
| 📌 `companyHiringSince` | When the employer started hiring on Internshala |
| 📤 `companyOpportunitiesPosted` / 🤝 `companyCandidatesHired` | The employer's platform track record |
| 🛠 `skills` | Array of required skills |
| ✨ `perks` | Array of perks |
| 🕒 `scrapedAt` | Run timestamp |
| ❌ `error` | `null` on every successful row |

#### Three real records from a live run

```json
{
  "imageUrl": "https://internshala-uploads.internshala.com/logo%2F60b87b5fa52e01622702943.png.webp",
  "title": "Graphic Design",
  "opportunityType": "Internship",
  "status": "Active",
  "url": "https://internshala.com/internship/detail/graphic-design-internship-in-indore-at-heterize-infotech-private-limited1787812559",
  "id": "3254559",
  "companyName": "Heterize Infotech Private Limited",
  "locationText": "Indore",
  "city": "Indore",
  "region": "Madhya Pradesh",
  "isWorkFromHome": "No",
  "datePosted": "2026-08-27",
  "postedAgo": "1 day ago",
  "applyByDate": "2026-09-26",
  "startDate": "Immediately",
  "duration": "3 Months",
  "employmentType": "INTERN, FULL_TIME",
  "industry": "Computer Services",
  "compensationText": "₹ 8,000 - 14,000 /month",
  "salaryMin": 8000,
  "salaryMax": 14000,
  "salaryCurrency": "INR",
  "salaryPeriod": "MONTH",
  "openings": 8,
  "applicants": "Be an early applicant",
  "companyHiringSince": "June 2021",
  "companyOpportunitiesPosted": "1148",
  "companyCandidatesHired": "49",
  "skills": ["Canva", "Creative Thinking", "Video Editing"],
  "perks": ["Certificate", "Letter of recommendation", "Free snacks & beverages", "Job offer"]
}
```

```json
{
  "imageUrl": "https://internshala-uploads.internshala.com/logo%2F9ulaps19rbu-1787200325.jpeg",
  "title": "Video Editor",
  "opportunityType": "Internship",
  "url": "https://internshala.com/internship/detail/video-editor-internship-in-chennai-at-biotastic-health-systems-ice-code-recovery1787224348",
  "id": "3247109",
  "companyName": "Biotastic Health Systems (Ice Code Recovery)",
  "companyWebsite": "http://biotastic.in",
  "city": "Chennai",
  "region": "Tamil Nadu",
  "datePosted": "2026-08-20",
  "postedAgo": "1 week ago",
  "applyByDate": "2026-09-24",
  "duration": "3 Months",
  "industry": "Professional Services",
  "compensationText": "₹ 15,000 /month",
  "salaryMin": 15000,
  "salaryMax": 15000,
  "salaryPeriod": "MONTH",
  "openings": 2,
  "companyHiringSince": "August 2026",
  "companyOpportunitiesPosted": "4",
  "companyCandidatesHired": "N/A",
  "skills": ["Adobe After Effects", "Adobe Photoshop", "Adobe Premiere Pro", "Content Editing", "Content Management", "Content Marketing", "Creative Writing", "Instagram Marketing", "Photography", "Social Media Marketing", "Video Editing", "Videography", "Video Making"],
  "perks": ["Certificate", "Letter of recommendation"]
}
```

```json
{
  "imageUrl": "https://internshala-uploads.internshala.com/logo%2F62ea852c204121659536684.png.webp",
  "title": "Inside Sales - Full Time",
  "opportunityType": "Internship",
  "url": "https://internshala.com/internship/detail/inside-sales-full-time-internship-in-mumbai-at-hiwi-forex-services-limited1787656710",
  "id": "3252730",
  "companyName": "HiWi Forex Services Limited",
  "companyWebsite": "http://hiwipay.com",
  "city": "Mumbai",
  "region": "Maharashtra",
  "datePosted": "2026-08-25",
  "postedAgo": "3 days ago",
  "applyByDate": "2026-09-24",
  "duration": "6 Months",
  "compensationText": "₹ 15,000 - 15,001 /month",
  "salaryMin": 15000,
  "salaryMax": 15001,
  "salaryPeriod": "MONTH",
  "openings": 5,
  "applicants": "33 applicants",
  "companyHiringSince": "August 2022",
  "companyOpportunitiesPosted": "61",
  "companyCandidatesHired": "3",
  "skills": ["Effective Communication", "Interpersonal skills"],
  "perks": ["Certificate", "Letter of recommendation", "Informal dress code"]
}
```

### ✨ Why choose this Actor

| | What you get |
|---|---|
| **Dates you can sort on** | `datePosted` is a real calendar date. Sorting a spreadsheet by "3 weeks ago" is not a thing you can do. |
| **Pay as numbers** | `salaryMin` and `salaryMax` are numeric on every row of a 60-posting sample, across monthly, weekly, annual and lump-sum postings. |
| **The widest published schema in this niche** | 48 fields. The next most detailed Internshala Actor on the Store publishes 25, and two of the four most popular publish 10. |
| **Filters taken from the source, not guessed** | 206 profile slugs and 639 location slugs read from Internshala's sitemap. A filter that would not work on the site is not offered here. |
| **Honest empties** | `Not Disclosed` marks what the employer withheld, `N/A` marks what does not apply to that posting type. There are no silently blank columns. |
| **No duplicate rows** | The page-1 and page-2 overlap in Internshala's own paginator is deduplicated before anything is delivered. |
| **No credentials, no proxy** | The pages are public and answered 11 out of 11 burst requests and 20 out of 20 at concurrency 8 from a plain connection. Proxy support is included and off by default. |
| **Stable schema** | The same 48 keys on every row, so scheduled runs never break a downstream pipeline. |
| **Runs on Apify** | Schedule it, trigger it by webhook, or call it from the API. Export to CSV, JSON, Excel, or XML. |

### 📈 How it compares to alternatives

Run counts, prices and published field counts below were read from the Apify Store API while pricing this Actor. Where a competitor publishes no dataset schema, its field coverage is listed as not published rather than guessed.

| Feature | ParseForge Internshala Scraper | Internshala Scraper (2,694 runs) | Internshala Scrapper (2,144 runs) | Internshala Scraper (1,506 runs) | Internshala Scraper (931 runs) |
|---|---|---|---|---|---|
| Published output fields | 48 | 25 | Not published | 10 | 10 |
| Exact calendar posting date | Yes | Not published | Not published | No | No |
| Stipend parsed to numbers | Yes, with period and currency | Not published | Not published | No | No |
| Internships and fresher jobs | Both | Both | Internships only | Both | Both |
| Profile filter | 206 verified slugs | Yes | Yes | Free text | Yes |
| Location filter | 639 verified slugs | Yes | Yes | Free text | Yes |
| Part-time filter | Yes | Yes | Yes | No | Yes |
| Employer hiring history | Yes | Not published | Not published | No | No |
| Skills and perks as arrays | Yes | Not published | Not published | No | No |
| Single posting URL supported | Yes | Yes | No | No | Yes |
| Price per 1,000 results | $2.50 | $0.40 | $5.00 | $5.00 | $3.00 |

**Two ceilings worth knowing before you buy.**

First, Internshala's page heading is a search-engine figure, not a promise. A filtered search can advertise "350 Computer Science Internships in Mumbai" while its own paginator ends after 56 records. This Actor follows the paginator, reports what it actually reached, and prints a note when the two disagree, so your coverage is never guessed. The unfiltered feeds are honest: 7,303 internships and 14,685 jobs are fully reachable.

Second, a small share of postings, mainly the ones listed across multiple cities, ship without the structured data block behind the page. On those rows `datePosted`, `region` and `industry` come back as sentinels while the stipend, location and everything else still parse from the visible page. On a 60-posting sample that was 9 rows. No scraper can recover what the source does not publish, and this one tells you which rows they are rather than leaving a blank.

### 🚀 How to use

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Actor. Either paste an Internshala URL into **Start URLs**, or leave it empty and build the search from the filters.
3. Pick **Opportunity type**, then narrow with **Profiles / categories**, **Cities / states**, **Work from home only**, **Part-time only**, **Minimum monthly stipend** or free-text **Keywords**.
4. Set **Max Items**. Free-plan runs preview 10 results.
5. Click **Start**. A 60-posting run takes about 12 seconds.
6. Open the **Dataset** tab and download CSV, JSON, Excel, or XML, or pull the results from the API.

A first run:

```json
{
  "opportunityType": "internships",
  "categories": ["computer-science"],
  "cities": ["mumbai"],
  "maxItems": 100
}
```

### 💼 Business use cases

**📊 Entry-level compensation benchmarking.** Pull every posting in a profile and city, then average `salaryMin` and `salaryMax` by `salaryPeriod`. Because the numbers are parsed rather than left as "₹ 8,000 - 14,000 /month" strings, a pivot table answers "what does a graphic design intern in Indore actually earn" in one step. Add `fixedPay` and `variablePay` to see how much of a package is really guaranteed.

**🎯 Employer lead generation.** Every row carries `companyName`, `companyProfileUrl`, `companyWebsite` and the platform track record in `companyHiringSince`, `companyOpportunitiesPosted` and `companyCandidatesHired`. Filter for companies that have posted often and actually hired, and you have a list of employers with a live, funded hiring need rather than a scraped directory.

**🧭 Skills demand tracking.** The `skills` array is the employer's own tagging, not inferred text. Count tags across a few thousand postings in a profile and you get a ranked list of what the market is asking for this month, which is exactly the input a curriculum or course roadmap needs.

**📰 Job board and newsletter feeds.** Schedule a daily run filtered to your niche, dedupe on `id` against yesterday's dataset, and publish only the new rows. `applyByDate` lets you expire listings automatically instead of showing readers a closed posting.

### 🔌 Automating Internshala Scraper

Apify integrations work out of the box, so the dataset can land wherever your team already works.

- **Make** and **Zapier** can trigger on a finished run and push each new posting into a sheet, a CRM or an email.
- **Slack** can receive a digest of the day's new internships in a channel.
- **Airbyte** can sync the dataset into a warehouse for joins against your own hiring data.
- **GitHub** Actions can call the Actor on a schedule and commit the results as versioned JSON.
- **Google Drive** can hold a daily CSV export that non-technical colleagues open directly.

### 🌟 Beyond business use cases

**🔬 Research.** Labour economists studying the Indian student job market get a dated, priced, geolocated panel that is very hard to assemble by hand.

**👤 Personal.** A student can export every work-from-home internship paying at least ₹ 10,000 a month, sort by deadline, and apply in order instead of scrolling.

**🤝 Non-profit.** Placement cells at colleges with small teams can hand students a filtered spreadsheet each week rather than forwarding links one at a time.

**🧪 Experimentation.** The `description`, `whoCanApply` and `skills` fields together make a clean, well-labelled corpus for testing extraction or matching models.

### 🤖 Ask an AI assistant about this scraper

Paste this into ChatGPT, Claude or any assistant that can browse:

> I want to collect internship and fresher job postings from Internshala. Look at https://apify.com/parseforge/internshala-scraper and tell me how to configure a run that pulls every work-from-home computer science internship paying at least ₹ 6,000 a month, and how to turn the salaryMin and salaryMax fields into a stipend benchmark by city.

### ❓ Frequently Asked Questions

**🔑 Do I need an Internshala account or API key?**
No. Everything this Actor reads is on public pages that a logged-out visitor sees.

**🌐 Do I need a proxy?**
No. Internshala answered 11 out of 11 burst requests and 20 out of 20 at concurrency 8 from an ordinary connection, and the cloud verification run needed no proxy either. Apify Proxy is exposed and defaults to off, so you can switch it on for very large jobs without paying for it on small ones.

**🎓 Does it cover jobs as well as internships?**
Yes. Both feeds share the same 48-field schema, and `opportunityType` tells you which one a row came from. Internships-only fields such as `duration` come back as `N/A` on job rows, and job-only fields such as `experienceRequired` come back as `N/A` on internship rows.

**📅 Why do some rows have no `datePosted`?**
Postings listed across multiple cities ship without the structured data block behind the page. Those rows keep every field that is visible on the page, including the stipend and the relative `postedAgo` label, but the exact calendar date is not published for them and the Actor will not invent one.

**📊 The page says 3,246 results but I got 1,023. Why?**
That heading is a search-engine figure. Internshala's own paginator for that filter ends at page 26. The Actor follows the paginator and logs a note when it stops early, so what you get is what the site actually serves.

**🔢 How many postings are there in total?**
7,303 internships and 14,685 fresher jobs at the time of writing, both fully reachable through the unfiltered feeds.

**💸 Are stipends always numbers?**
Whenever the employer states one. Unpaid postings and the handful that publish no figure come back as `Not Disclosed` rather than a fake zero.

**🏠 Can I combine work-from-home with a city?**
Yes, and it genuinely filters: on a spot check, 10 of the first 12 cards of a work-from-home Mumbai search were remote, against 0 of 12 on the plain Mumbai search. Part-time and work-from-home cannot be combined, because Internshala itself does not support that pair.

**⏱️ How fast is it?**
A 60-posting run took 12 seconds, and the 5-posting cloud verification run took under 3 seconds. Listing pages are read one at a time and detail pages 8 at a time.

**🔁 Will duplicate rows appear?**
No. Internshala repeats the last ten cards of page 1 at the top of page 2. The Actor deduplicates on the posting ID before delivering anything.

**🧾 What happens if a page fails to load?**
It is retried three times. If it still fails, a row with only an `error` message is written so you can see exactly which posting is missing, and that row is never charged for.

### 🔌 Integrate with any app

Results land in an Apify dataset, which means webhooks, the REST API, scheduled runs, and the official Python and JavaScript clients all work out of the box. Wire a run-finished webhook into your own service and the postings arrive as JSON the moment a run completes.

### 🔗 Recommended Actors

- [Workday Jobs Scraper](https://apify.com/parseforge/workday-jobs-scraper) for postings on any Workday career site.
- [LinkedIn Comments Scraper](https://apify.com/parseforge/linkedin-comments-scraper) for engagement research around hiring posts.
- [Meetup Scraper](https://apify.com/parseforge/meetup-scraper) for the events side of community and campus recruiting.
- [Instagram Profile Scraper](https://apify.com/parseforge/instagram-profile-scraper) for employer-brand research.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** this is an independent tool and is not affiliated with, endorsed by, or connected to Internshala or any employer whose posting you scrape. It collects only publicly available data.

# Actor input Schema

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

Internshala search or detail pages to scrape. Accepts any listing URL (https://internshala.com/internships/marketing-internship-in-mumbai/) and any single opportunity URL (https://internshala.com/internship/detail/... or https://internshala.com/job/detail/...). Leave empty to build the search from the filters below.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `opportunityType` (type: `string`):

Which Internshala feed to search when no Start URLs are given. Internships covers the ~7,300 live internship postings; Jobs covers the ~14,700 fresher and entry-level job postings.

## `searchKeywords` (type: `string`):

Free-text search, exactly as the site's own keyword box takes it. Example: python, video editing, Infosys.

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

Internshala profile categories. Selecting several widens the search (the site ORs them together). All 206 values are the live category slugs published in Internshala's own sitemap.

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

Locations to search. Selecting several widens the search. All 639 values are the live location slugs published in Internshala's own sitemap, and include states as well as cities.

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

Restrict to remote postings. Internshala only supports this filter on the internships feed, so it is ignored for jobs.

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

Restrict to part-time postings. Works on both feeds and combines with profiles, cities and the stipend filter.

## `minStipend` (type: `string`):

Internships only. These are the exact steps Internshala's own stipend slider offers; other values are not accepted by the site.

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

Internshala serves this data without a proxy, so this is off by default and the Actor runs at zero proxy cost. Switch on Apify Proxy if you are running very large jobs and want the requests spread across more IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://internshala.com/internships/"
    }
  ],
  "maxItems": 10,
  "opportunityType": "internships",
  "searchKeywords": "python",
  "workFromHome": false,
  "partTime": false,
  "minStipend": "0",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Key fields

## `fullData` (type: `string`):

Complete dataset with all 48 fields

# 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 = {
    "startUrls": [
        {
            "url": "https://internshala.com/internships/"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "startUrls": [{ "url": "https://internshala.com/internships/" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "startUrls": [
    {
      "url": "https://internshala.com/internships/"
    }
  ],
  "maxItems": 10
}' |
apify call parseforge/internshala-scraper --silent --output-dataset

```

## MCP server setup

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