# Internshala Scraper (`solidcode/internshala-scraper`) Actor

\[💰 $3.5 / 1K] Extract internship and fresher-job listings from Internshala — titles, companies, stipends, salaries, locations, skills, durations, and detail-page descriptions. Filter by category, location, work-from-home, part-time, stipend, duration, and special tags.

- **URL**: https://apify.com/solidcode/internshala-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 7 total users, 4 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.50 / 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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Internshala Scraper

Extract internship and fresher-job listings from **Internshala** — India's #1 platform for internships and entry-level jobs. Pull title, company, location, stipend or salary, duration, skills, posting date, badges, and apply URL for any search query, with optional one-click enrichment for full descriptions, perks, openings count, and application deadlines.

### Why This Scraper?

- **Two modes in one actor** — collect paid internships (monthly stipend) or fresher jobs (annual salary) from a single, simple input
- **Filter the way Internshala does** — by category, city, work-from-home, part-time, minimum stipend, salary, duration, experience cap, and special badges
- **Multi-duration fan-out** — pick several internship durations (1, 2, 3, 4, 6, 12+ months) and the actor sweeps each one for you and merges the results
- **Optional full-detail enrichment** — flip one switch and every result includes the full description, complete skills list, perks, openings count, and application deadline
- **Honest stipend & salary parsing** — Indian-rupee formatting (₹ 4,00,000 / 4 LPA / Performance based / Unpaid) is normalised into clean min/max numbers in INR
- **Defence-in-depth filtering** — Internshala's URL filters are advisory; the actor re-validates every listing against your hard constraints (minimum stipend, max experience, duration) so the dataset matches what you asked for
- **Direct URL support** — paste any Internshala search URL into `startUrls` to bypass the filter form entirely
- **Pay only for what you keep** — flat $3.50 per 1,000 results, no compute charges, no proxy bills, no surprises

### Use Cases

**Recruiting & Talent Sourcing**
- Build live feeds of open internships and fresher jobs by city, role, or skill
- Track a competitor's hiring across all their open postings
- Identify which companies are hiring most aggressively for a given role

**Career Platforms & Job Boards**
- Aggregate Indian internship inventory into your own platform or newsletter
- Power campus placement tools, college career portals, and student communities
- Build daily-digest emails of new openings matching student profiles

**Lead Generation & Outreach**
- Reach hiring teams at SMBs and startups posting their first internship
- Find companies hiring for niche skills (Data Science, UI/UX, Content Writing)
- Surface "Internship with job offer" listings — these are pre-placement pipelines worth reaching out to

**Market Research & Salary Benchmarking**
- Track stipend and salary trends across categories, cities, and durations
- Measure remote vs onsite share for each role family over time
- Compare hiring activity across Bangalore, Mumbai, Delhi, Hyderabad, Pune, Chennai

**EdTech & Skill Analytics**
- Map demand for specific skills (Python, React, SEO, Tally, Figma) by posting volume
- Inform curriculum design with up-to-date listings of "must-have" skills
- Build skill-gap dashboards for training providers

### Getting Started

#### All internships in Mumbai

The simplest possible run — every open internship in one city:

```json
{
    "mode": "internships",
    "location": "Mumbai",
    "maxResults": 200
}
````

#### Computer-Science work-from-home internships, with full details

Filter by category and remote, then fetch the full description, perks, and deadline for every result:

```json
{
    "mode": "internships",
    "category": "Computer Science",
    "workFromHome": true,
    "minStipend": 6000,
    "durationMonths": ["3", "6"],
    "includeDetails": true,
    "maxResults": 500
}
```

#### Fresher jobs in Bangalore with a salary floor

Switch the mode to jobs and ask for entry-level roles paying at least ₹5 lakh per year:

```json
{
    "mode": "jobs",
    "category": "Web Development",
    "location": "Bangalore",
    "minSalary": 500000,
    "experienceMax": 1,
    "maxResults": 300
}
```

#### Direct search URLs (advanced)

Paste one or more Internshala search URLs to bypass the filter form. Useful for niche pages and saved searches:

```json
{
    "startUrls": [
        "https://internshala.com/internships/marketing-internship-in-delhi/",
        "https://internshala.com/internships-for-women/work-from-home-internship/"
    ],
    "maxResults": 1000
}
```

#### Internships with a job offer (pre-placement)

Find listings where the internship is followed by a guaranteed job offer:

```json
{
    "mode": "internships",
    "category": "Finance",
    "specialFilters": ["with_job_offer"],
    "includeDetails": true,
    "maxResults": 250
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `"internships"` | Pick `Internships` (paid, monthly stipend) or `Jobs` (annual salary, fresher-friendly) |
| `startUrls` | string\[] | `[]` | Optional list of Internshala search URLs. When provided, these override every filter below |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | string | `""` | Free-text role / profile (e.g. Computer Science, Marketing, Finance, Web Development, Content Writing, Data Science). Leave empty for all categories |
| `location` | string | `""` | City name (Mumbai, Bangalore, Delhi, Hyderabad, Pune, Chennai). Ignored when work-from-home is enabled |
| `workFromHome` | boolean | `false` | Only include fully remote listings. Disables the city filter |
| `partTime` | boolean | `false` | Only include part-time roles |
| `minStipend` | integer | empty | Internships only. Minimum monthly stipend in ₹. Tiers: 2000, 4000, 6000, 8000, 10000 |
| `minSalary` | integer | empty | Jobs only. Minimum annual salary in ₹. Tiers: 100000 to 1000000+ |
| `durationMonths` | string\[] | `[]` | Internships only. One or more of `1 month`, `2 months`, `3 months`, `4 months`, `6 months`, `12+ months`. Multi-pick fans out one search per value and merges results |
| `experienceMax` | integer | empty | Jobs only. Cap on years of experience (0 = fresher-only, max 10) |
| `specialFilters` | string\[] | `[]` | Require one or more badges: `Internship with job offer`, `Early applicant`, `Fast response from employer`, `For women` |

#### Output

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `false` | Fetch the full description, complete skills list, perks, openings count, and application deadline for each listing. Slower but much richer |
| `maxResults` | integer | `100` | Maximum number of listings to collect. Set to `0` for all available results across pagination |

### Output

Each result is one listing. The exact fields depend on `mode` (internship vs job) and whether `includeDetails` is on. Here is a typical internship row with details enabled:

```json
{
    "recordType": "internship",
    "id": "3119378",
    "url": "https://internshala.com/internship/detail/marketing-internship-in-mumbai-acme-3119378",
    "title": "Marketing Internship",
    "company": "Acme Pvt Ltd",
    "companyLogoUrl": "https://internshala-uploads.s3.amazonaws.com/logo/acme.jpg",
    "locations": ["Mumbai"],
    "workMode": "onsite",
    "workFromHome": false,
    "partTime": false,
    "stipend": {
        "min": 8000,
        "max": 10000,
        "currency": "INR",
        "period": "month",
        "raw": "₹ 8,000-10,000 /month"
    },
    "salary": null,
    "durationMonths": 3,
    "experienceYears": null,
    "skills": ["Digital Marketing", "Content Writing", "SEO"],
    "badges": {
        "activelyHiring": true,
        "earlyApplicant": false,
        "jobOffer": true,
        "womenOnly": false,
        "fastResponse": false
    },
    "postedAt": "2 days ago",
    "postedAtIso": "2026-04-24T10:14:23+00:00",
    "applyUrl": "https://internshala.com/internship/detail/marketing-internship-in-mumbai-acme-3119378",
    "scrapedAt": "2026-04-26T08:42:11+00:00",
    "sourceUrl": "https://internshala.com/internships/marketing-internship-in-mumbai/",
    "description": "We're looking for a hands-on marketing intern to support campaigns across...",
    "perks": ["Certificate", "Letter of recommendation", "Flexible hours"],
    "whoCanApply": "Available for full-time (in-office) internship; can start between 1st May and 30th May",
    "openings": 3,
    "applicationDeadline": "2026-05-17T18:29:59+00:00",
    "aboutCompany": "Acme is a Mumbai-based marketing agency working with..."
}
```

#### Common Fields (Both Internships and Jobs)

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | `"internship"` or `"job"` |
| `id` | string | Internshala's stable internal ID for the listing |
| `url` | string | Canonical detail-page URL |
| `title` | string | Listing title (e.g. "Marketing Internship") |
| `company` | string | Hiring company name |
| `companyLogoUrl` | string | URL of the company logo |
| `locations` | string\[] | List of cities or "Work from home" |
| `workMode` | string | `wfh`, `onsite`, `hybrid`, or `partial_wfh` |
| `workFromHome` | boolean | True if the listing is remote |
| `partTime` | boolean | True if the listing is part-time |
| `skills` | string\[] | Skills required (from listing card or detail page) |
| `badges` | object | `{activelyHiring, earlyApplicant, jobOffer, womenOnly, fastResponse}` |
| `activelyHiring` | boolean | Convenience copy of `badges.activelyHiring` |
| `earlyApplicant` | boolean | Convenience copy of `badges.earlyApplicant` |
| `withJobOffer` | boolean | Convenience copy of `badges.jobOffer` |
| `forWomen` | boolean | Convenience copy of `badges.womenOnly` |
| `fastResponse` | boolean | Convenience copy of `badges.fastResponse` |
| `postedAt` | string | Relative posted-at as shown on Internshala (e.g. "2 days ago") |
| `postedAtIso` | string | ISO 8601 UTC timestamp of when the listing was posted |
| `applyUrl` | string | Canonical detail URL — apply requires Internshala login |
| `sourceUrl` | string | The search URL this row was discovered through |
| `scrapedAt` | string | ISO 8601 UTC timestamp of the run |

#### Internship-only fields

| Field | Type | Description |
|-------|------|-------------|
| `stipend` | object | `{min, max, currency, period, raw}` — `period` is usually `"month"` |
| `durationMonths` | integer | Internship length in months (1, 2, 3, 4, 6, 12+) |

#### Job-only fields

| Field | Type | Description |
|-------|------|-------------|
| `salary` | object | `{min, max, currency, period, raw}` — `period` is usually `"year"` |
| `experienceYears` | object | `{min, max}` years of experience required |

#### Detail-only fields (only when `includeDetails: true`)

| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Full job/internship description, plain text |
| `perks` | string\[] | Perks list (Certificate, Letter of recommendation, Flexible hours, etc.) |
| `whoCanApply` | string | Eligibility text (start date, full-time/part-time, year of study) |
| `openings` | integer | Total number of positions for this listing |
| `applicationDeadline` | string | ISO 8601 UTC deadline (Internshala stores deadlines in IST; we convert) |
| `aboutCompany` | string | "About the company" section |

When `includeDetails` is **off**, all six detail-only fields are still present but set to `null` (or `[]` for `perks`) — your downstream schema stays stable.

### Tips for Best Results

- **Start broad, then narrow.** Run with `mode` and `location` only first to see how much data is available, then add filters one at a time.
- **Use `includeDetails: true` selectively.** It adds one extra request per listing. For large sweeps, run without it first, then re-run a smaller filtered set with details on.
- **Multi-pick `durationMonths` is fine.** Internshala's URL grammar only carries one duration per page, so the actor sweeps each value separately and merges. You'll get clean dedup'd results.
- **`startUrls` overrides everything.** When `startUrls` is set, every filter field below is ignored — paste the URL you want exactly.
- **Stipend and salary are post-filtered.** Internshala's filters are advisory — the platform sometimes mixes in lower-paid listings. The actor re-checks every row against your `minStipend` / `minSalary` so the dataset is precise.
- **All amounts are in ₹ (INR).** Internshala is India-focused; even when a listing says "Performance based", the actor returns it with `currency: "INR"` and the raw text preserved.
- **Apply links require login.** Internshala's "Apply Now" button on the public site requires a student account. The actor returns the canonical detail-page URL as `applyUrl` — anyone can open it logged-out, and applying still works once the user signs in.

### Pricing

**$3.50 per 1,000 results** — flat, predictable, with no compute or proxy charges layered on top.

| Results | Cost |
|---------|------|
| 100 | $0.35 |
| 1,000 | $3.50 |
| 10,000 | $35.00 |

**No compute charges — you only pay per result returned.** If a run yields zero results (e.g. an over-filtered query), you pay nothing.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Apify API** — Full programmatic access to runs, datasets, and live results
- **Webhooks** — Get notified when a run completes or new data lands
- **Google Sheets** — One-click export of every result to a spreadsheet
- **Zapier** / **Make** / **n8n** — Automate workflows: post new listings to Slack, push leads to your CRM, trigger emails
- **Datasets** — Download as JSON, CSV, XML, or Excel for offline analysis

### Good to Know

- **Apply links require Internshala login.** Listings are publicly viewable, but actually applying needs a student account — the actor captures the canonical detail URL, which anyone can open.
- **Stipend, salary, and duration filters are advisory.** Internshala's path-segment filters are suggestions, not hard guarantees. The actor applies your numeric thresholds as a post-fetch check so the dataset is precise.
- **All amounts are in INR.** Internshala is an India-focused platform; some listings include qualitative pay ("Performance based", "Unpaid") which are returned with `min`/`max` set to `null` and the original text preserved.
- **Multi-value `durationMonths` fans out.** One Internshala URL carries one duration. Picking multiple durations creates one search per value and merges the deduplicated results.
- **For-women internships use a separate page.** Selecting `For women` switches the actor to Internshala's dedicated women-only listings root automatically.
- **`Internship with job offer` is internship-only.** It's silently ignored in `mode: "jobs"`.

### Legal & Ethical Use

This actor is designed for legitimate recruiting research, market analysis, career platforms, and lead generation. Only public listing data is collected — no private profiles, no candidate PII, no data behind login. Users are responsible for complying with applicable laws and Internshala's Terms of Service. Do not use the extracted data for spam, harassment, or any unlawful purpose.

# Actor input Schema

## `mode` (type: `string`):

Choose whether to collect paid internships (with monthly stipend) or fresher jobs (with annual salary). Each mode applies different filters.

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

Optional. Paste one or more Internshala search URLs (e.g. https://internshala.com/internships/computer-science-internship/work-from-home). When provided, these override the filter fields below.

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

Free-text role category. Examples: Computer Science, Marketing, Finance, Web Development, Content Writing, Data Science. Leave empty to include all categories.

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

City name like Mumbai, Bangalore, Delhi, Hyderabad, Pune, Chennai. Ignored when 'Work from home' is enabled.

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

Only include fully remote listings. When enabled, the City filter is ignored.

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

Only include part-time roles.

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

Internships only. Minimum monthly stipend in Indian Rupees. Internshala supports tiers 2000, 4000, 6000, 8000, 10000. Leave empty for no minimum.

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

Jobs only. Minimum annual salary in Indian Rupees. Internshala supports tiers from 1 lakh (100000) to 10+ lakhs (1000000). Leave empty for no minimum.

## `durationMonths` (type: `array`):

Internships only. Pick one or more allowed durations. Leave empty for any.

## `experienceMax` (type: `integer`):

Jobs only. Cap on years of experience required. Use 0 for fresher-only roles. Leave empty for any.

## `specialFilters` (type: `array`):

Optional badges to require on every listing.

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

Fetch the full description, complete skills list, perks, openings count, and application deadline for each listing. Slower (one extra request per result) but much richer output.

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

Maximum number of listings to collect. Set to 0 to fetch all available results across pagination.

## Actor input object example

```json
{
  "mode": "internships",
  "startUrls": [],
  "workFromHome": false,
  "partTime": false,
  "durationMonths": [],
  "specialFilters": [],
  "includeDetails": false,
  "maxResults": 100
}
```

# Actor output Schema

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

Compact table of every listing — title, company, location, stipend or salary, and link.

## `details` (type: `string`):

Per-listing detail rows including skills, perks, badges, and description.

# 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 = {
    "mode": "internships",
    "startUrls": [],
    "category": "",
    "location": "",
    "workFromHome": false,
    "partTime": false,
    "durationMonths": [],
    "specialFilters": [],
    "includeDetails": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "mode": "internships",
    "startUrls": [],
    "category": "",
    "location": "",
    "workFromHome": False,
    "partTime": False,
    "durationMonths": [],
    "specialFilters": [],
    "includeDetails": False,
    "maxResults": 100,
}

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

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

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

```

## CLI example

```bash
echo '{
  "mode": "internships",
  "startUrls": [],
  "category": "",
  "location": "",
  "workFromHome": false,
  "partTime": false,
  "durationMonths": [],
  "specialFilters": [],
  "includeDetails": false,
  "maxResults": 100
}' |
apify call solidcode/internshala-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=solidcode/internshala-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Internshala Scraper",
        "description": "[💰 $3.5 / 1K] Extract internship and fresher-job listings from Internshala — titles, companies, stipends, salaries, locations, skills, durations, and detail-page descriptions. Filter by category, location, work-from-home, part-time, stipend, duration, and special tags.",
        "version": "1.0",
        "x-build-id": "Dje4ZgRgN6eXf6A5O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~internshala-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-internshala-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~internshala-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-internshala-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~internshala-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-internshala-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "mode": {
                        "title": "What to Scrape",
                        "enum": [
                            "internships",
                            "jobs"
                        ],
                        "type": "string",
                        "description": "Choose whether to collect paid internships (with monthly stipend) or fresher jobs (with annual salary). Each mode applies different filters.",
                        "default": "internships"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Optional. Paste one or more Internshala search URLs (e.g. https://internshala.com/internships/computer-science-internship/work-from-home). When provided, these override the filter fields below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category / Profile",
                        "type": "string",
                        "description": "Free-text role category. Examples: Computer Science, Marketing, Finance, Web Development, Content Writing, Data Science. Leave empty to include all categories."
                    },
                    "location": {
                        "title": "Location (City)",
                        "type": "string",
                        "description": "City name like Mumbai, Bangalore, Delhi, Hyderabad, Pune, Chennai. Ignored when 'Work from home' is enabled."
                    },
                    "workFromHome": {
                        "title": "Work from home only",
                        "type": "boolean",
                        "description": "Only include fully remote listings. When enabled, the City filter is ignored.",
                        "default": false
                    },
                    "partTime": {
                        "title": "Part-time only",
                        "type": "boolean",
                        "description": "Only include part-time roles.",
                        "default": false
                    },
                    "minStipend": {
                        "title": "Minimum stipend (₹/month)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Internships only. Minimum monthly stipend in Indian Rupees. Internshala supports tiers 2000, 4000, 6000, 8000, 10000. Leave empty for no minimum."
                    },
                    "minSalary": {
                        "title": "Minimum salary (₹/year)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Jobs only. Minimum annual salary in Indian Rupees. Internshala supports tiers from 1 lakh (100000) to 10+ lakhs (1000000). Leave empty for no minimum."
                    },
                    "durationMonths": {
                        "title": "Duration (months)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Internships only. Pick one or more allowed durations. Leave empty for any.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "6",
                                "12"
                            ],
                            "enumTitles": [
                                "1 month",
                                "2 months",
                                "3 months",
                                "4 months",
                                "6 months",
                                "12+ months"
                            ]
                        },
                        "default": []
                    },
                    "experienceMax": {
                        "title": "Maximum experience (years)",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Jobs only. Cap on years of experience required. Use 0 for fresher-only roles. Leave empty for any."
                    },
                    "specialFilters": {
                        "title": "Special filters",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Optional badges to require on every listing.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "with_job_offer",
                                "early_applicant",
                                "fast_response",
                                "for_women"
                            ],
                            "enumTitles": [
                                "Internship with job offer",
                                "Early applicant",
                                "Fast response from employer",
                                "For women"
                            ]
                        },
                        "default": []
                    },
                    "includeDetails": {
                        "title": "Include full details",
                        "type": "boolean",
                        "description": "Fetch the full description, complete skills list, perks, openings count, and application deadline for each listing. Slower (one extra request per result) but much richer output.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of listings to collect. Set to 0 to fetch all available results across pagination.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
