# 🎓 Internshala Scrapper (`scraper-engine/internshala-scrapper`) Actor

Internshala Scraper extracts public internship and job listings, including titles, companies, locations, salaries, skills, durations, work types, descriptions, and application details. Build structured datasets for recruitment, job market research, and opportunity discovery.

- **URL**: https://apify.com/scraper-engine/internshala-scrapper.md
- **Developed by:** [Scraper Engine](https://apify.com/scraper-engine) (community)
- **Categories:**
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### Internshala Scrapper — Internships, Stipends and Company Data

Internshala Scrapper is an Internshala scraper that turns internship and job search results into structured JSON — title, company, stipend, location, duration, and required skills, straight off the listing page. It supports two ways to search: paste Internshala search-result URLs directly, or build a search from job category, location, work-from-home, part-time, and minimum-stipend filters. Every match streams into the dataset the moment it's parsed. Run it now on the Apify Store to pull your first batch of listings.

### 🎓 What is Internshala Scrapper?

Internshala Scrapper is an Apify Actor that searches Internshala.com for internship and job listings and returns every field visible on the results page — title, company, stipend, location, skills, and more — as one JSON record per listing. It reads only Internshala's public search-result and autocomplete pages over plain HTTPS, so no Internshala account, login, or cookie is required to run it. It's built for recruiters, career platforms, ed-tech teams, and developers who need structured internship data without maintaining their own HTML parser.

### 🌐 What Internshala internship data is publicly available to scrape?

Everything Internshala Scrapper returns is visible on a search-results page to any visitor without logging in — Internshala does not gate internship or job listing details behind an account.

| Data Category | Publicly Available | Restricted (candidate login) |
| --- | --- | --- |
| Title, company and job URL | Yes | — |
| Location and work-from-home status | Yes | — |
| Stipend and duration | Yes | — |
| Required skills | Yes | — |
| Full job description | Yes | — |
| "Actively hiring" / "Early applicant" badges and posting age | Yes | — |
| Company logo | Yes | — |
| Submitting an application | No | Requires an Internshala candidate account |
| Applicant count or who else applied | No | Not shown on the listing at all |

Internshala Scrapper only returns publicly visible data — what any visitor sees. Nothing behind a login wall.

### 📊 What data can I extract with Internshala Scrapper?

Internshala Scrapper returns 16 fields per record: listing identity and content, status/badge flags, and run metadata for every internship or job it collects.

| Field Name | Description |
| --- | --- |
| `title` | The internship/job title |
| `company` | Hiring company name |
| `job_url` | Canonical Internshala listing URL |
| `apply_url` | Direct, referral-tagged application link |
| `location` | City, or "Work from home" |
| `duration` | Internship/job duration as shown on the listing |
| `logo_url` | Company logo image URL |
| `job_description` | Full job/internship description text |
| `skills` | Array of skills listed on the posting |
| `type` | `"Part time"` when badged as such, otherwise empty |
| `stipend` | Stipend/salary text as shown on the listing |
| `actively_hiring` | Whether the "Actively hiring" badge is present |
| `posted` | Relative posting-age badge, e.g. "3 days ago"; empty if not shown |
| `early_applicant` | Whether the "Be an early applicant" badge is present |
| `search_query` | Which search (URL or filter combination) produced this record |
| `scraped_at` | UTC timestamp the record was scraped, ISO 8601 |

#### Listing identity and content fields

`title`, `company`, `job_url`, `apply_url`, `location`, `duration`, `logo_url`, `job_description`, `skills`, and `type` describe what the internship or job is, who's offering it, and where it lives.

#### Status, badges and timing fields

`stipend`, `actively_hiring`, `posted`, and `early_applicant` carry the numeric and flag-style signals Internshala surfaces on the card — pay, hiring urgency, and freshness.

#### Run metadata fields

`search_query` and `scraped_at` record which search produced each row and when it was collected, which matters once you're merging output from several runs or bulk `urls`.

#### 🤖 Add-on: Need additional job or candidate data?

Need to go beyond Internshala? Scraper Engine's Naukri Job Scraper (India, Gulf, Emails & 41 Fields) pulls job listings with contact emails, Greenhouse Job Scraper collects postings from companies running on Greenhouse's ATS, and Ats Jobs API aggregates listings across multiple applicant-tracking systems. Pair any of them with Internshala Scrapper for a fuller view of India's internship-to-job pipeline.

### 🛠️ Why not build this yourself?

Internshala does not publish a public developer API for its internship or job listings, so the only way to get this data programmatically is to parse the site's HTML yourself. That means writing and maintaining your own card-anchor and regex-based parser, handling pagination and duplicate listings across pages, and building a proxy-escalation strategy for when Internshala blocks a plain request. Internshala Scrapper already does all three, and keeps them working as the site's markup changes.

### ▶️ How to use Internshala Scrapper

Internshala Scrapper runs on the Apify platform — no separate signup, install, or API key beyond an Apify account is needed to start pulling data.

1. Open the Internshala Scrapper page on the Apify Store and start a run.
2. Leave the input empty to use the defaults, or fill in the filter fields — `jobCategory`, `location`, `workFromHome`, `partTime`, `minStipend` — to describe your search. None of these are required.
3. Set `maxResults` and `pagesToScrape` to bound the run, and leave `proxyConfiguration` on its default so the Actor manages proxy escalation for you.

   ⚠️ **Hard caps:** regardless of what you set `maxResults` (schema max 100000) or `pagesToScrape` (schema max 1000) to, the Actor enforces an absolute backstop of 1000 results and 100 pages per search — a fixed limit in the code, not a bug in your input.
4. Start the run.
5. Download results as JSON or CSV, or open one of the six sectioned dataset views (Overview, Description, Skills, Badges & Status, Apply Links, Run Metadata).

#### Scaling to bulk internship extraction

Internshala Scrapper accepts a `urls` array — paste multiple Internshala search-result URLs (different categories, cities, or filter combinations), one per line, and each runs as its own independent search inside the same run, capped independently by the same `maxResults` and `pagesToScrape`. When `urls` is populated, the filter fields (`jobCategory`, `location`, etc.) are ignored entirely, so there's no need to launch a separate run per search.

### 💡 What can you do with Internshala internship data?

- A campus placement coordinator comparing offers uses `stipend` and `location` across categories to see which cities and roles pay best for students right now.
- A recruitment agency prioritizing outreach uses `actively_hiring` and `posted` to contact companies that are hiring urgently instead of chasing stale postings.
- An ed-tech curriculum team uses `skills` pulled from thousands of `job_description` records to identify which technical skills employers ask for most often.
- A job-aggregator site uses `apply_url` and `job_url` to route candidates straight to the original Internshala listing without re-hosting its content.
- An AI engineer builds a RAG-based internship-matching assistant by indexing `job_description` and `skills` as retrieval context, then uses `title`, `company`, and `apply_url` to generate direct, cite-able recommendations for student queries.

### 🛡️ How does Internshala Scrapper handle rate limits and blocking?

Internshala Scrapper starts every run with no proxy at all, and only escalates when Internshala actually blocks a request: a 403, 429, or 5xx response bumps it from no-proxy to a datacenter proxy, and a further block from there bumps it to a residential proxy. The escalation is sticky — once a run is bumped up, it stays there instead of flip-flopping between tiers. Each request gets up to `maxRetries` attempts (default 3) with backoff between them, and escalating tiers is free — it doesn't consume a retry. If 12 consecutive requests fail to even reach Internshala, the run treats the connection as dead, stops issuing new requests, and keeps everything already pushed to the dataset instead of failing the whole run. It does not solve CAPTCHAs — the ladder addresses proxy-level blocking, not challenge pages.

⚠️ **Part-time filtering happens client-side:** with filter-mode search and `partTime` on, listings are fetched first and then kept only if badged "Part time" — if 200 scanned listings produce zero matches, that search stops early instead of scanning forever, so a narrow part-time search can return fewer results than `maxResults`.

### ⬇️ Input

| Parameter | Required | Type | Description | Example Value |
| --- | --- | --- | --- | --- |
| `urls` | No | Array | Internshala search-result URLs, one per line. Bulk mode — when populated, the filter fields below are ignored. | `["https://internshala.com/internships/work-from-home-software-development-internships"]` |
| `jobCategory` | No | String | Internship/job category to search for. Default `"Software Development"`. An unrecognized value runs without a category filter. | `"Data Science"` |
| `workFromHome` | No | Boolean | Only show remote/work-from-home internships. Default `true`. Ignores `location` when on. | `false` |
| `location` | No | String | City to search in. Default `"Delhi"`. Only applies when `workFromHome` is off. | `"Bangalore"` |
| `partTime` | No | Boolean | Only keep listings explicitly badged "Part time". Default `false`. | `false` |
| `minStipend` | No | String | Minimum monthly stipend (₹), snapped to Internshala's nearest supported value. Default `""` (no minimum). | `"10000"` |
| `maxResults` | No | Integer | Stop each search after collecting this many internships. Default `30`, minimum `1`, maximum `100000`. | `50` |
| `pagesToScrape` | No | Integer | Stop each search after this many result pages. Default `20`, minimum `1`, maximum `1000`. | `20` |
| `proxyConfiguration` | No | Object | Proxy configuration. Default starts with no proxy, auto-escalating to datacenter then residential as needed. | `{"useApifyProxy": false}` |
| `maxRetries` | No | Integer | Retry attempts per page fetch, across proxy-tier escalation. Default `3`, minimum `1`, maximum `10`. | `3` |

#### Example input

```json
{
  "urls": [],
  "jobCategory": "Data Science",
  "workFromHome": false,
  "location": "Bangalore",
  "partTime": false,
  "minStipend": "10000",
  "maxResults": 50,
  "pagesToScrape": 20,
  "proxyConfiguration": { "useApifyProxy": false },
  "maxRetries": 3
}
```

### ⬆️ Output

Internshala Scrapper writes one typed JSON record per internship or job to the Apify dataset, live as each page is parsed — the schema is identical across every run, whether the search came from a filter combination or a pasted URL. Results are available as the full JSON dataset, a CSV export, or six sectioned views (Overview, Description, Skills, Badges & Status, Apply Links, Run Metadata) that group the same fields by purpose. Every pushed record bills one `row_result` event — there are no separate uncharged accounting or error rows mixed into the dataset.

#### Example output

```json
{
  "title": "Data Science Internship",
  "company": "Basti Ki Pathshala Foundation",
  "job_url": "https://internshala.com/internship/detail/data-science-internship-in-bangalore-at-basti-ki-pathshala-foundation1234567",
  "apply_url": "https://internshala.com/internship/detail/data-science-internship-in-bangalore-at-basti-ki-pathshala-foundation1234567?amp;referral=web_share",
  "location": "Bangalore",
  "duration": "3 Months",
  "stipend": "₹ 10,000 /month",
  "actively_hiring": true,
  "logo_url": "https://internshala.com/static/company_logo/basti-ki-pathshala.png",
  "job_description": "Selected intern's day-to-day responsibilities include:\n1. Clean and preprocess datasets\n2. Build and evaluate machine learning models\n3. Present findings to the team",
  "skills": ["Python", "Machine Learning", "SQL", "Data Visualization"],
  "posted": "2 days ago",
  "early_applicant": true,
  "type": "",
  "search_query": "Data Science • Bangalore",
  "scraped_at": "2026-09-03T10:15:42.123456+00:00"
}
```

### ⚙️ How does it work?

Internshala Scrapper sends requests straight to Internshala's public search-result pages over plain HTTPS, using TLS fingerprint impersonation (`curl_cffi`, impersonating Chrome) instead of a headless browser — there's no JavaScript rendering step because every field it needs already lives in the server-rendered listing card. Every request starts with no proxy; only if Internshala responds with a block (403, 429, or 5xx) does the Actor escalate to a datacenter, then residential, Apify proxy. A page-fingerprint check on the first request of a run confirms Internshala's markup still matches what the parser expects, and logs a warning if it doesn't. Because parsing is anchored to structural markers — the listing card's own ID — rather than a fixed layout position, the same output schema keeps working across ordinary Internshala redesigns. Only what's visible on the public results page is ever returned.

### 🔌 Integrations

Internshala Scrapper works with the tools you already use to move data — call it directly over HTTP, or wire it into a no-code automation.

#### Calling Internshala Scrapper programmatically

```python
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("<your-apify-username>/internshala-scrapper").call(run_input={
    "jobCategory": "Data Science",
    "location": "Bangalore",
    "workFromHome": False,
    "maxResults": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["stipend"])
```

Works in Go, Ruby, Node.js, cURL — any language that can make an HTTP request.

#### No-code tools (n8n, Make, LangChain)

In n8n, use the HTTP Request node (or the community Apify node) pointed at Internshala Scrapper's run endpoint, passing your input as the request body. In Make, add the Apify app's "Run an Actor and get dataset items" module and select `internshala-scrapper` as the Actor. In LangChain, use `langchain_community.utilities.ApifyWrapper` to call the Actor and load the results as Documents for a retrieval pipeline.

### ⚖️ Is it legal to scrape Internshala internship listings?

Scraping publicly available internship and job listing pages is generally legal — Internshala Scrapper only collects business/product data (title, company, stipend, location, skills) that Internshala publishes openly to any visitor, without a login. This is listing/business data, not personal data, so GDPR and similar personal-data regimes do not apply to it; the relevant framework is Internshala's own Terms of Service and database-rights law in the jurisdiction where the data is stored or reused. Consult legal counsel if your use case involves bulk storage of personal data.

### ❓ Frequently asked questions

#### What Internshala internship fields does Internshala Scrapper return?

Internshala Scrapper returns 16 fields per listing, including `title`, `company`, `stipend`, `location`, and `skills` — see the [data fields section](#-what-data-can-i-extract-with-internshala-scrapper) above for the complete list, including description, badges, and run metadata.

#### Does Internshala Scrapper require an Internshala account or login?

No. Internshala Scrapper only reads Internshala's public search-result and autocomplete pages over plain HTTPS — it never logs in, and no Internshala credentials are part of its input.

#### How many internships can I extract in one run?

Up to `maxResults` per search (default 30), though the Actor hard-caps every search at 1000 results and 100 pages regardless of a higher `maxResults`/`pagesToScrape` value. Bulk `urls` mode applies that same per-search budget independently to each URL, so a run with several search URLs can return well beyond that per-search cap in total.

#### What happens if a search returns zero results?

Internshala Scrapper stops that search early rather than looping forever: two consecutive empty pages end a normal search, and if a `partTime` filter keeps rejecting every listing across 200 scanned results, it gives up on that search specifically and logs why. Either way, the run continues to the next search (in bulk `urls` mode) and keeps everything already collected.

#### Can I scrape multiple Internshala searches at once?

Yes. Paste multiple Internshala search-result URLs into the `urls` array (one per line) and each is scraped as its own independent search in the same run; leaving `urls` empty runs exactly one search built from the filter fields instead.

#### Does Internshala Scrapper work with Claude, ChatGPT, and other AI agent tools?

Yes — Internshala Scrapper is callable as a standard HTTP API through the Apify platform, so any agent framework that can make an HTTP call, including custom Claude, ChatGPT, or LangChain agents, can trigger a run and read back the dataset.

#### Can I search Internshala by URL instead of filters?

Yes — paste one or more Internshala search-result URLs into `urls` and Internshala Scrapper scrapes exactly those searches, ignoring the `jobCategory`, `location`, `workFromHome`, `partTime`, and `minStipend` filter fields entirely. Leave `urls` empty to build a search from those filters instead.

#### Does Internshala Scrapper return data in a format LLMs can use directly?

Yes. Every record is typed, normalized JSON with the same field names across every run — no HTML, no selectors to write. Pass it directly to an LLM prompt, index it into a vector store, or feed it to an agent tool.

#### What happens when Internshala changes its layout or anti-bot system?

Internshala Scrapper is maintained, and its output schema is designed to stay stable across ordinary Internshala redesigns — its parser anchors on structural markers, like the listing card's own ID, rather than a fixed page layout, and a built-in fingerprint check flags a run in its logs if Internshala's markup changes enough to affect results.

#### Can I use Internshala Scrapper without managing proxies or browser infrastructure?

Yes. Internshala Scrapper manages its own proxy strategy — starting with no proxy and escalating to a datacenter, then residential, Apify proxy only if Internshala blocks a request — and it never launches a browser, so there's no browser infrastructure to provision either.

#### Which Internshala fields work best for AI training data and RAG indexing?

For RAG, index `job_description` and `skills` — they carry the most free-text, high-information content per listing. For structured training data, `title`, `company`, `stipend`, `duration`, and `posted` return as consistent typed strings and booleans across every record.

### 🔗 Related scrapers

| Scraper Name | What it extracts |
| --- | --- |
| Naukri Job Scraper (India, Gulf, Emails & 41 Fields) | India and Gulf job listings with contact emails across 41 fields |
| Greenhouse Job Scraper | Job postings from companies running on the Greenhouse applicant-tracking system |
| Ats Jobs API | Job listings aggregated across multiple applicant-tracking systems |
| Y Combinator Scraper | YC-backed startup and company data |
| LinkedIn People Profile Scraper | Public LinkedIn profile data |
| LinkedIn Profile Scraper with Email & Company Data | LinkedIn profile data enriched with email and company details |

### 💬 Your feedback

Found a bug, or need a field this README doesn't cover? Contact Scraper Engine at dev.scraperengine@gmail.com — the same address listed in the Actor's own input form for custom requests. Reports like this keep Internshala Scrapper's parser current as Internshala's site evolves.

# Actor input Schema

## `urls` (type: `array`):

➕ Paste one or more Internshala <b>internship/job search result</b> URLs, one per line — e.g. <code>https://internshala.com/internships/work-from-home-software-development-internships</code>. Each URL is scraped as its own independent search (great for running several categories/cities in one go). 💡 <b>Leave this empty</b> to build a single search from the filter fields below instead — when URLs are provided here, the filter fields are ignored.

## `jobCategory` (type: `string`):

The internship/job category to search for, e.g. <code>Software Development</code>, <code>Marketing</code>, <code>Data Science</code>. Matched against Internshala's own category list — an unrecognized value runs without a category filter instead of guessing. Used only when the URL list above is empty.

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

✅ Only show remote / work-from-home internships. When ON, the Location field below is ignored (matches Internshala's own site behavior). Used only when the URL list above is empty.

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

City to search in, e.g. <code>Delhi</code>, <code>Mumbai</code>, <code>Bangalore</code>. Only applies when 🏠 Work From Home Only is OFF. Used only when the URL list above is empty.

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

✅ Only keep listings explicitly badged "Part time" by Internshala. Used only when the URL list above is empty.

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

Minimum monthly stipend to filter for, e.g. <code>5000</code>. Snapped to the nearest value Internshala's own filter actually supports. Leave empty for no minimum. Used only when the URL list above is empty.

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

Stop each search after collecting this many internships. Applies independently to every URL in bulk mode, or to the one search built from the filters above.

## `pagesToScrape` (type: `integer`):

Stop each search after this many result pages, even if 🎯 Maximum Results hasn't been reached yet.

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

⚡ <b>Smart auto-escalation, on by default</b>: 1️⃣ <b>No proxy</b> is tried first for every request. 2️⃣ Only if Internshala rejects/blocks that (HTTP 403/429/5xx) does the Actor escalate to a <b>Datacenter</b> proxy. 3️⃣ If the datacenter tier is <i>also</i> blocked, it escalates to a <b>Residential</b> proxy and retries there. Once escalated, the run <b>sticks</b> with that tier for every remaining request — no flip-flopping. Every escalation is logged clearly. Leave the default as-is to let the Actor manage this for you.

## `maxRetries` (type: `integer`):

Attempts per page fetch, across proxy-tier escalation (also doubles as the retry budget once escalated to the residential tier).

## Actor input object example

```json
{
  "urls": [],
  "jobCategory": "Software Development",
  "workFromHome": true,
  "location": "Delhi",
  "partTime": false,
  "minStipend": "",
  "maxResults": 30,
  "pagesToScrape": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRetries": 3
}
```

# Actor output Schema

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

Title, company, location, stipend, duration and hiring status for every result.

## `description` (type: `string`):

Full posting description text.

## `skills` (type: `string`):

Required skills per posting.

## `badges` (type: `string`):

Actively-hiring, early-applicant, part-time and posting-age badges.

## `apply` (type: `string`):

Direct application links per posting.

## `meta` (type: `string`):

Which search produced each record and when it was scraped.

## `allItems` (type: `string`):

Every field for every scraped internship/job.

## `csv` (type: `string`):

The full dataset as CSV.

# 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 = {
    "urls": [],
    "jobCategory": "Software Development",
    "location": "Delhi",
    "minStipend": "",
    "maxResults": 30,
    "pagesToScrape": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    },
    "maxRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraper-engine/internshala-scrapper").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 = {
    "urls": [],
    "jobCategory": "Software Development",
    "location": "Delhi",
    "minStipend": "",
    "maxResults": 30,
    "pagesToScrape": 20,
    "proxyConfiguration": { "useApifyProxy": False },
    "maxRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("scraper-engine/internshala-scrapper").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 '{
  "urls": [],
  "jobCategory": "Software Development",
  "location": "Delhi",
  "minStipend": "",
  "maxResults": 30,
  "pagesToScrape": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRetries": 3
}' |
apify call scraper-engine/internshala-scrapper --silent --output-dataset

```

## MCP server setup

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

```

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/Ir5TksHMZf5Zr2cE4/builds/4dMZUCFhxx0oySVBw/openapi.json