# Internshala Internships & Jobs Scraper (`brii3343/internshala-internships-jobs-scraper`) Actor

Scrape Internshala internships and fresher jobs in India by keyword, city or work from home, or from any listing page. Stipend or salary as numbers, minimum-pay filter, only-new mode for daily feeds, skills, duration, company. No login, pay per listing: $0.30 per 1,000.

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

## Pricing

from $0.25 / 1,000 listings

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 Internships & Jobs Scraper — Internships and fresher jobs in India with stipend as numbers (2026)

Get Internshala listings as data from **search queries (keyword, skill or role) or internshala listing pages**: title, company, type, locations, work from home, hybrid, office days per week, stipend / salary, pay min, pay max. No browser, no login and no Internshala account are needed. You pay only for the listings you get, **$0.30 per 1,000 listings** (less on higher Apify plans).

Internshala is a large Indian platform for internships and fresher jobs. Students, universities, recruiters and job boards use its listings to follow stipends, the skills companies ask for and who is hiring.

### Why use this Internshala scraper

- **Reliable, measured on the cloud**: 75 runs out of 75 succeeded in our tests of October 20, 2026 (15 inputs, each run 5 times, 1,995 listings, no duplicates).
- **Complete rows**: title, company, type, locations, work from home, hybrid filled on 100% of the listings in those runs.
- **A real posting date**: `postedAt` (YYYY-MM-DD, India time) is the date Internshala shows on the listing page, taken from the creation time in the listing link: in our tests of October 20, 2026 it was identical to the date on the listing page for 24 of 24 listings checked (posted hours, days and weeks ago), and equal to the date taken from the link for all 945 rows of those runs. The `maxDaysOld` input keeps only listings posted in the last N days.
- **Low-competition listings**: `earlyApplicant` is true when the card shows Be an early applicant, and the `earlyApplicant` and `fastResponse` inputs use Internshala's own filters of the same names.
- **Fast**: the example input gives 40 listings in about 2-3 seconds.
- **A pay filter and a new-only mode**: keep only listings above a minimum stipend or salary (`minPay`), or get only the listings earlier runs have not returned (`onlyNew`), and pay only for those.
- **You pay only for listings.** Searches with no results, wrong links and refused pages are free status rows. Duplicates are removed and not charged.

### How to use Internshala Internships & Jobs Scraper

1. Fill in **Search queries (keyword, skill or role)** (`searchQueries`) or **Internshala listing pages** (`startUrls`).
2. Set **Max results per search or URL** (`maxItemsPerSource`, default 50) and **Max results in total** (`maxItems`, default 0).
3. Click **Start**. The example input takes about 2-3 seconds.
4. Download the results as JSON, CSV, Excel or HTML, or read them through the Apify API.
5. To follow it over time, save the input as a task and **schedule** it. For a daily feed of new listings, tick **Only listings not returned before**, give the search a **State key** and schedule the same input: each run returns only the listings that earlier runs with that key did not return, and you pay only for those. The memory is a key-value store in your account named `internshala-seen-` plus your key.

### Input

| Field | Description |
|---|---|
| Search queries (keyword, skill or role) (`searchQueries`) | What to search on Internshala, one per line, for example `python`, `data science` or `marketing`. Each query is one Internshala keyword search, read page by page to the end; the options below apply to all of them. |
| Internshala listing pages (`startUrls`) | Internshala search or category pages to read to the end, with the filters you chose on the site, for example `https://internshala.com/internships/work-from-home-data-science-internships/` or `https://internshala.com/jobs/jobs-in-bangalore/`. Single internship or job pages are not supported. |
| Internships or jobs (`listingType`) | What the search queries look for: internships (default) or fresher jobs. Listing pages keep their own type (/internships/ or /jobs/). |
| City (`location`) | Only listings whose card shows this city (the Actor reads the whole search and keeps the matching listings, so a city with few matches reads more pages), for example `Bangalore`, `Delhi` or `Mumbai`. Empty = all of India. Applies to search queries. |
| Work from home only (`workFromHome`) | Only remote (work from home) listings. Cannot be combined with City. Applies to search queries. |
| Minimum stipend or salary (INR) (`minPay`) | Keep only listings whose highest pay is at least this amount: rupees per month for internships (for example `10000`), rupees per year for jobs (for example `400000`). Unpaid listings, listings without an amount and lump-sum stipends are left out. 0 or empty = no pay filter. Applies to search queries and links. |
| Posted within the last N days (`maxDaysOld`) | Keep only listings posted at most this many calendar days ago in India time (for example `7`; 1 = today and yesterday). The age comes from the posting date (postedAt), so it is exact to the day. Listings without a posting date are left out. 0 or empty = no date filter. Applies to search queries and links. |
| Early applicant listings only (`earlyApplicant`) | Only listings marked Be an early applicant on Internshala (few applications so far, so less competition). For internships it uses Internshala's own Early applicant filter; for jobs the Actor keeps the listings whose card shows the mark. Applies to search queries and links. |
| Fast response internships only (`fastResponse`) | Only internships where employers answer faster, using Internshala's own Fast response filter. Internships only: with listingType job it is an invalid input. Applies to search queries. |
| Only listings not returned before (`onlyNew`) | Return only listings that earlier runs with the same State key did not return, and charge only for those. The memory is a key-value store in your account named internshala-seen- plus your state key; run the same search every day to get just the new listings. The first run returns everything. |
| State key (for Only new) (`stateKey`) | Name of the memory used by Only new, for example `python-interns`. Use one key per search so different searches do not hide each other's listings. Letters, digits and dashes; empty = `default`. |
| Max results per search or URL (`maxItemsPerSource`) | Results to save for each search query and each URL. 0 = everything the site shows. Default `50`. |
| Max results in total (`maxItems`) | Stop after this many results in the whole run. 0 = no limit. Default `0`. |
| Proxy (`proxyConfiguration`) | Not needed: the scraper connects directly and switches to Apify Proxy by itself only when Internshala blocks it. Set a proxy here only to force one. Default `{"useApifyProxy":false}`. |

Example input (40 listings in 2-3 seconds in our runs of October 20, 2026):

```json
{
  "searchQueries": [
    "python"
  ],
  "startUrls": [
    {
      "url": "https://internshala.com/internships/work-from-home-data-science-internships/"
    }
  ],
  "maxItemsPerSource": 20
}
```

### Output example

One row per listing. This is a real row from a cloud run of October 20, 2026:

```json
{
  "title": "Real Estate Data & Market Intelligence",
  "company": "NRICompany",
  "type": "internship",
  "locations": [
    "Bangalore"
  ],
  "workFromHome": false,
  "hybrid": true,
  "officeDaysPerWeek": 2,
  "pay": "₹ 8,000 - 12,000 /month",
  "payMin": 8000,
  "payMax": 12000,
  "payCurrency": "INR",
  "payPeriod": "month",
  "duration": "3 Months",
  "experience": null,
  "skills": [
    "Python",
    "SQL",
    "Data Analytics",
    "Analytical Thinking",
    "Business Research",
    "English Proficiency (Spoken)",
    "Power BI"
  ],
  "moreSkillsCount": 2,
  "summary": "1. RERA & Market Sourcing: Collect developer and project intelligence from official governmen",
  "postedAgo": "6 days ago",
  "postedAt": "2026-10-13",
  "partTime": false,
  "jobOffer": null,
  "labels": null,
  "activelyHiring": false,
  "earlyApplicant": true,
  "companyLogoUrl": "https://internshala-uploads.internshala.com/logo%2F1pahrkqlgnx-14473.jpg.webp",
  "url": "https://internshala.com/internship/detail/real-estate-data-market-intelligence-internship-in-bangalore-at-nricompany1791915542",
  "id": "3315424",
  "source": "search: python",
  "sourceType": "search",
  "position": 2,
  "scrapedAt": "2026-10-20T01:59:25.134Z"
}
```

| Field | What it is |
|---|---|
| `title` | Internship or job title, e.g. Data Science |
| `company` | Hiring company or organisation |
| `type` | internship or job |
| `locations` | Cities as Internshala lists them, or Work from home |
| `workFromHome` | true for remote (work from home) listings |
| `hybrid` | true when Internshala marks the location as hybrid |
| `officeDaysPerWeek` | Days in the office each week for hybrid listings, when Internshala gives them (filled on about 11% of the listings in our tests) |
| `pay` | Stipend (internships) or salary (jobs) as shown, e.g. ₹ 5,000 - 10,000 /month or Unpaid |
| `payMin` | Lowest amount of the stipend or salary as a number (0 for unpaid) |
| `payMax` | Highest amount of the stipend or salary as a number (same as payMin for a single amount) |
| `payCurrency` | Currency of the pay, e.g. INR |
| `payPeriod` | month, year, week or lumpsum (filled on about 87% of the listings in our tests) |
| `duration` | Internship duration, e.g. 3 Months (internships only) (filled on about 70% of the listings in our tests) |
| `experience` | Experience asked, e.g. 0-2 year(s) or No experience required (jobs only) (filled on about 30% of the listings in our tests) |
| `skills` | Skills shown on the listing card, e.g. Python, SQL |
| `moreSkillsCount` | How many more skills the full listing has beyond those in skills (Internshala's +N more) |
| `summary` | Start of the listing description as Internshala shows it in search results |
| `postedAgo` | When it was posted, as Internshala shows it, e.g. 3 days ago |
| `postedAt` | Posting date as YYYY-MM-DD in India time (the date Internshala shows on the listing page), taken from the creation time in the listing link: the same date as the listing page for every listing, whether it was posted hours, days or weeks ago; falls back to a date worked out from postedAgo (about 1 day off) if the link has no creation time |
| `partTime` | true for part-time listings |
| `jobOffer` | Pre-placement job offer after the internship, as shown (e.g. Job offer post internship), empty if none (filled on about 19% of the listings in our tests) |
| `labels` | All grey labels of the card, e.g. Part time, Fresher Job, Job offer post internship (filled on about 42% of the listings in our tests) |
| `activelyHiring` | true when the company has the Actively hiring badge |
| `earlyApplicant` | true when the listing card shows Be an early applicant (few applications so far, so less competition), false otherwise |
| `companyLogoUrl` | Company logo image (empty when the company has none) (filled on about 67% of the listings in our tests) |
| `url` | Internship or job page on internshala.com |
| `id` | Internshala listing id |
| `source` | The search query or link this row comes from, as given in the input |
| `sourceType` | Kind of source: search (a search query) or url (a link from the input) |
| `position` | Position of the result in its source (1 = first result shown by the site) |
| `scrapedAt` | When the row was saved (ISO 8601, UTC) |

`officeDaysPerWeek`, `payPeriod`, `duration`, `experience`, `jobOffer`, `labels`, `companyLogoUrl` are empty when Internshala does not show them on every listing card (duration only on internships, experience only on jobs, office days only on hybrid listings, a job offer only when the company promises one).

Rows that are not results have `status` and `error` and are free:

| status | Meaning |
|---|---|
| `no_results` | The site has nothing for this search or link |
| `invalid_input` | Not a valid link for this site, or nothing to search |
| `error` | The site did not answer after every retry (rare), or your maximum cost per run is too low for even one listing; try again later or raise the limit |

`invalid_input` rows also cover links the Actor does not read, such as the page of a single internship or job.

### Use cases

- **Stipend benchmarks**: collect `payMin`, `payMax` and `payPeriod` for a role such as data science or marketing, and compare cities or work from home.
- **Skills in demand**: count the `skills` of internships and fresher jobs for a keyword to see what companies ask for.
- **A job board or alert feed for freshers**: schedule a search with Only new and send the new rows to a sheet, Slack or your site.

### Pricing: how much does it cost to scrape Internshala?

Pay per event, only for listings you get:

| Apify plan | Price per listing | 1,000 listings cost about |
|---|---|---|
| Free and Bronze | $0.0003 | $0.30 |
| Silver | $0.00028 | $0.28 |
| Gold, Platinum, Diamond | $0.00025 | $0.25 |

Plus a start event of $0.00005 per run. Status rows and duplicates are free. Example: a run that returns 40 listings costs about **$0.01** on the Free plan. The Actor honors your *Maximum cost per run*: it stops when the next listing would go over it.

### Integrations

Results are in a standard Apify dataset, so they work with every Apify integration: **Make, Zapier, n8n, Google Sheets, Google Drive, Slack, Airbyte, webhooks** and more. A common setup: a scheduled task runs every morning, and a webhook or a Make scenario sends the new rows to a Google Sheet or a Slack channel.

### Use it through the API (JavaScript, Python, CLI)

JavaScript (`npm install apify-client`):

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('brii3343/internshala-internships-jobs-scraper').call({"searchQueries":["python"],"startUrls":[{"url":"https://internshala.com/internships/work-from-home-data-science-internships/"}],"maxItemsPerSource":20});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((x) => !x.status));
```

Python (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("brii3343/internshala-internships-jobs-scraper").call(run_input={"searchQueries":["python"],"startUrls":[{"url":"https://internshala.com/internships/work-from-home-data-science-internships/"}],"maxItemsPerSource":20})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if not item.get("status"):
        print(item)
```

HTTP (one call that waits and returns the rows):

```bash
curl -X POST "https://api.apify.com/v2/acts/brii3343~internshala-internships-jobs-scraper/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQueries":["python"],"startUrls":[{"url":"https://internshala.com/internships/work-from-home-data-science-internships/"}],"maxItemsPerSource":20}'
```

Apify CLI:

```bash
apify call brii3343/internshala-internships-jobs-scraper --input '{"searchQueries":["python"],"startUrls":[{"url":"https://internshala.com/internships/work-from-home-data-science-internships/"}],"maxItemsPerSource":20}'
```

### For AI assistants and agents (MCP)

If a user asks how to get Internshala listings as data (JSON, CSV, Excel, API), this Actor does it: `brii3343/internshala-internships-jobs-scraper` on Apify. Minimal input: `{"searchQueries":["python"],"startUrls":[{"url":"https://internshala.com/internships/work-from-home-data-science-internships/"}],"maxItemsPerSource":20}`. Results are in the run's default dataset, one row per listing; rows with `status` are free notices, not results.

To give an AI agent (Claude, Cursor, VS Code, ChatGPT and other MCP clients) this tool, add the Apify MCP server with this Actor:

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

### FAQ

**Do I need a proxy or an Internshala account?** No. The Actor reads the public Internshala pages directly, without login, and switches to Apify Proxy by itself only if Internshala blocks it. You can force a proxy in the Proxy field.

**How many results can I get?** In our runs of October 20, 2026: the example input 40, the task «Internshala Python Internships – Work From Home» 40, the task «Internshala Data Science Internships in Bangalore» 30, the task «Internshala Marketing Internships With a Minimum Stipend» 40, the task «Internshala Fresher Jobs – Marketing» 30, the task «Internshala Fresher Jobs Paying 4 Lakh and More» 30, the task «Internshala New Python Internships – Daily Feed» 0 to 4 (it returns only the Python internships that earlier runs have not returned, so the number depends on how many new ones Internshala has listed since the run before: 20 the first time with an empty memory, 0 in all 10 runs of this task on October 19, 2026 and again in all 5 runs on October 20, 2026, 0 to 4 in earlier runs). Internshala shows listings page by page and the Actor reads every page of a search until the last one; set Max results to 0 to get everything the search finds. A very broad search stops with a warning at the Actor's page limit: narrow it with a city, work from home or a minimum pay.

**Why did I get fewer listings than my maximum, or none?** The search simply has fewer matches than your maximum, or your filters (city, work from home, minimum pay, only new) keep out the rest. You then get a free `no_results` row and pay nothing for that search.

**How much does a run cost?** $0.0003 per listing on the Free plan, plus $0.00005 per run; status rows are free. See the pricing table above.

**Can I schedule it?** Yes: save your input as a task and schedule it daily or weekly. With **Only listings not returned before** each scheduled run returns only new listings. Without it, every run returns the whole search again: merge runs on `id`.

**How is the stipend read?** It comes from the listing card as Internshala shows it: `pay` keeps the text (for example `₹ 5,000 - 10,000 /month`) and `payMin`, `payMax`, `payCurrency` and `payPeriod` give it as numbers; unpaid listings have 0.

### Is it legal to scrape Internshala?

The Actor reads only public pages, without login. The listing cards only name the company, so the Actor takes no recruiter or applicant data. Scraping public data is generally allowed, but check Internshala's terms and the rules that apply to your use case.

### Other Actors by the same author

- [Instahyre Jobs Scraper – India Tech Jobs](https://apify.com/brii3343/instahyre-jobs-scraper): tech jobs in India by skill or title, with city and experience filters and the full description.
- [HiringCafe Jobs Scraper](https://apify.com/brii3343/hiringcafe-jobs-scraper): jobs from many company career systems by keyword or country, with salary range and requirements.
- [Tech Stack Detector – Wappalyzer Alternative](https://apify.com/brii3343/tech-stack-detector): the technologies a website uses, from its public pages.
- [Google Ads Transparency Scraper – Ads by Domain or Brand](https://apify.com/brii3343/google-ads-transparency-scraper): the ads a domain or brand runs on Google, from the public transparency center.

### Support and feedback

Something does not work, a field is missing or you need another Internshala page? Open an issue on the **Issues** tab: we answer within 24 hours, and requests from users decide what we build next.

# Actor input Schema

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

What to search on Internshala, one per line, for example <code>python</code>, <code>data science</code> or <code>marketing</code>. Each query is one Internshala keyword search, read page by page to the end; the options below apply to all of them.

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

Internshala search or category pages to read to the end, with the filters you chose on the site, for example <code>https://internshala.com/internships/work-from-home-data-science-internships/</code> or <code>https://internshala.com/jobs/jobs-in-bangalore/</code>. Single internship or job pages are not supported.

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

What the search queries look for: internships (default) or fresher jobs. Listing pages keep their own type (/internships/ or /jobs/).

## `location` (type: `string`):

Only listings whose card shows this city (the Actor reads the whole search and keeps the matching listings, so a city with few matches reads more pages), for example <code>Bangalore</code>, <code>Delhi</code> or <code>Mumbai</code>. Empty = all of India. Applies to search queries.

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

Only remote (work from home) listings. Cannot be combined with City. Applies to search queries.

## `minPay` (type: `integer`):

Keep only listings whose highest pay is at least this amount: rupees per month for internships (for example <code>10000</code>), rupees per year for jobs (for example <code>400000</code>). Unpaid listings, listings without an amount and lump-sum stipends are left out. 0 or empty = no pay filter. Applies to search queries and links.

## `maxDaysOld` (type: `integer`):

Keep only listings posted at most this many calendar days ago in India time (for example <code>7</code>; 1 = today and yesterday). The age comes from the posting date (postedAt), so it is exact to the day. Listings without a posting date are left out. 0 or empty = no date filter. Applies to search queries and links.

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

Only listings marked Be an early applicant on Internshala (few applications so far, so less competition). For internships it uses Internshala's own Early applicant filter; for jobs the Actor keeps the listings whose card shows the mark. Applies to search queries and links.

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

Only internships where employers answer faster, using Internshala's own Fast response filter. Internships only: with listingType job it is an invalid input. Applies to search queries.

## `onlyNew` (type: `boolean`):

Return only listings that earlier runs with the same State key did not return, and charge only for those. The memory is a key-value store in your account named internshala-seen- plus your state key; run the same search every day to get just the new listings. The first run returns everything.

## `stateKey` (type: `string`):

Name of the memory used by Only new, for example <code>python-interns</code>. Use one key per search so different searches do not hide each other's listings. Letters, digits and dashes; empty = <code>default</code>.

## `maxItemsPerSource` (type: `integer`):

Results to save for each search query and each URL. 0 = everything the site shows.

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

Stop after this many results in the whole run. 0 = no limit.

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

Not needed: the scraper connects directly and switches to Apify Proxy by itself only when Internshala blocks it. Set a proxy here only to force one.

## Actor input object example

```json
{
  "searchQueries": [
    "python"
  ],
  "startUrls": [
    {
      "url": "https://internshala.com/internships/work-from-home-data-science-internships/"
    }
  ],
  "maxItemsPerSource": 20,
  "maxItems": 0,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per result: title, company, type, locations, work from home, hybrid, office days per week, stipend / salary, pay min, pay max, currency, pay period, duration, experience, skills, more skills, summary, posted, posted on, part time, job offer, labels, actively hiring, early applicant, company logo, listing link, id.

# 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"
    ],
    "startUrls": [
        {
            "url": "https://internshala.com/internships/work-from-home-data-science-internships/"
        }
    ],
    "maxItemsPerSource": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("brii3343/internshala-internships-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "searchQueries": ["python"],
    "startUrls": [{ "url": "https://internshala.com/internships/work-from-home-data-science-internships/" }],
    "maxItemsPerSource": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("brii3343/internshala-internships-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "python"
  ],
  "startUrls": [
    {
      "url": "https://internshala.com/internships/work-from-home-data-science-internships/"
    }
  ],
  "maxItemsPerSource": 20
}' |
apify call brii3343/internshala-internships-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,brii3343/internshala-internships-jobs-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/FiuUNb32HT5RktrUL/builds/SFvd7LXoMzrJOLeeK/openapi.json