# Cutshort Jobs Scraper: India Tech Jobs, Salary & Skills (`cprussin/cutshort-jobs`) Actor

Scrape Cutshort tech jobs by skill and city: title, company, salary range, experience range, skills, locations, remote, posted date and job URL; full description optional. Monitor new, updated and removed jobs. No login. $1.50 per 1,000 jobs.

- **URL**: https://apify.com/cprussin/cutshort-jobs.md
- **Developed by:** [Connor Prussin](https://apify.com/cprussin) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 jobs

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/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

## Cutshort Jobs Scraper: India Tech Jobs, Salary & Skills

**Cutshort Jobs Scraper** exports tech and startup job listings from Cutshort (cutshort.io) as clean JSON, CSV or Excel. It reads the same public job pages the website shows to logged-out visitors, no login needed:

- ✅ **Jobs by skill or role and city**: `python`, `reactjs`, `java`, `devops`, `product-manager`, ... in Bangalore, Mumbai, Pune, Hyderabad, Delhi NCR, Chennai and more, remote, or all of India.
- ✅ **Salary and experience ranges**: yearly salary range (Cutshort shows salary on almost every job) and years of experience.
- ✅ **Job details**: title, company (size, stage, type, founded, website), skills, locations, work mode (onsite / remote / both), role type, posted date, job URL and description snippet. Full description optional.
- ✅ **Monitor mode**: get only **new**, **updated** and **removed** jobs since the last run.
- ✅ **All jobs**: leave skills empty to export every job in Cutshort's jobs sitemap.
- ✅ Fast, light and polite: plain HTTP, one request at a time, no browser. Pay only for jobs written to your dataset.

### Start in one minute

Click **Start** with the prefilled input:

```json
{
  "skills": ["python"],
  "cities": ["bangalore"],
  "maxItems": 20
}
```

You get: the 20 newest Python jobs in Bangalore, with `headline`, `companyName`, `salaryMin`/`salaryMax`, `experienceMin`/`experienceMax`, `skills`, `locations` and `url`.

**Cost:** $0.03: 20 jobs × $0.0015, plus the $0.00005 actor-start fee.

### Use with an AI assistant

Connect the [Apify MCP server](https://mcp.apify.com) to Claude, ChatGPT, Cursor or any MCP client (`https://mcp.apify.com?tools=cprussin/cutshort-jobs` loads only this actor), then paste:

```text
Use the Apify actor cprussin/cutshort-jobs to get the 30 newest React.js jobs in Pune on Cutshort, and summarize the salary range by experience level and the most requested skills.
```

### Recipes

#### Backend jobs in two cities

Newest Golang and Node.js jobs in Bangalore and Hyderabad.

```json
{
  "skills": ["golang", "nodejs"],
  "cities": ["bangalore", "hyderabad"],
  "maxItems": 100
}
```

#### Remote jobs with full descriptions

Remote DevOps jobs with the full description, valid-through date and tags.

```json
{
  "skills": ["devops"],
  "cities": ["remote"],
  "maxItems": 20,
  "includeDetails": true
}
```

#### Daily new, updated and removed jobs

Schedule it daily: after the first (baseline) run you get, and pay for, only changes.

```json
{
  "skills": ["python", "datascience"],
  "cities": ["pune"],
  "maxItems": 1000,
  "monitorMode": true
}
```

#### Older jobs: pages 3 to 4

Skip the newest 100 jobs and read the next two pages (50 jobs each).

```json
{
  "skills": ["java"],
  "startPage": 3,
  "maxPages": 2,
  "maxItems": 100
}
```

#### Every job on Cutshort

Empty skills: all jobs in Cutshort's jobs sitemap, each with full details.

```json
{
  "skills": [],
  "maxItems": 500
}
```

### Who uses Cutshort job data?

- **Recruiters and staffing agencies**: see which startups hire for a skill in a city right now, with pay and experience.
- **Sales and lead generation**: companies hiring engineers are growing and buying. Company size, stage and website are included.
- **Job seekers and job boards**: build your own feed or alerts for Indian tech jobs with salary.
- **HR and market analysts**: benchmark salaries and in-demand skills by role, city and experience.
- **AI agents**: give an LLM live Indian tech job listings through the Apify API or MCP server.

### How does the Cutshort jobs scraper work?

1. Add skills or roles and (optionally) cities.
2. For each skill × city, the actor reads Cutshort's listing (e.g. [cutshort.io/jobs/python-jobs-in-pune](https://cutshort.io/jobs/python-jobs-in-pune)), 50 jobs per page, newest first, about one request per second.
3. It pages through results until `maxItems` jobs in total, `maxPages` pages, or the end of the listing.
4. With `includeDetails`, it also opens each job page (`cutshort.io/job/...`).
5. Without skills, it reads Cutshort's jobs sitemap and opens each job page.

### How do I choose which Cutshort jobs to scrape?

| Field                | Description                                                                | Example                     |
| -------------------- | -------------------------------------------------------------------------- | --------------------------- |
| `skills`             | Skills or roles, names or Cutshort slugs or listing URLs; empty = all jobs | `["python", "React.js"]`    |
| `cities`             | Cities (optional), or `remote`                                             | `["bangalore", "pune"]`     |
| `maxItems`           | Max jobs in total, across all searches                                     | `500`                       |
| `startPage`          | First listing page per search (50 jobs each)                               | `1`                         |
| `maxPages`           | Listing pages per search; 0 = all                                          | `2`                         |
| `includeDetails`     | Open each job page for the full description and more                       | `true`                      |
| `monitorMode`        | Only new, updated and removed jobs since the last run with the same search | `true`                      |
| `proxyConfiguration` | Optional Apify Proxy (not needed normally)                                 | `{ "useApifyProxy": true }` |

- **Skill names**: Cutshort has a listing per skill or role. Names are converted to its slugs (`React.js` → `reactjs`, `Data Science` → `datascience`). If a name is not found, the run log says so: open [cutshort.io/jobs](https://cutshort.io/jobs), find the listing and paste its URL or slug (e.g. `machine-learning-ml-jobs`).
- **Cities**: Bangalore, Mumbai, Pune, Hyderabad, Chennai, Delhi (Delhi, NCR, Gurgaon and Noida), Kolkata, Ahmedabad, Jaipur, Kochi, Indore, Chandigarh, Coimbatore and Bhubaneswar have listings, plus `remote`.

### What data do you get for each Cutshort job?

```json
{
  "jobId": "uhRqRgf1",
  "internalId": "6ad2060ef7ba8e021579552f",
  "headline": "GCP Data engineer",
  "companyName": "VY SYSTEMS PRIVATE LIMITED",
  "hiringForClient": false,
  "recruiterName": null,
  "companyLogoUrl": "https://cdnv2.cutshort.io/company-static/676cda781975060026864b32/user_uploaded_data/logos/company_logo.png",
  "companyUrl": "https://cutshort.io/company/vy-systems-private-limited-16-e43Khktp",
  "companyWebsite": "https://vysystems.com",
  "companyType": "Services",
  "companySize": "100-1000",
  "companyStage": "Profitable",
  "companyFounded": 2000,
  "locations": ["Bengaluru (Bangalore)", "Pune", "Hyderabad", "Chennai"],
  "workMode": "onsite",
  "remote": false,
  "experienceMin": 8,
  "experienceMax": 12,
  "salaryMin": 2000000,
  "salaryMax": 3000000,
  "salaryCurrency": "INR",
  "salaryText": "₹20L - ₹30L / yr",
  "skills": ["Python", "PySpark", "SQL", "Lead Generation"],
  "roleTypes": ["full_time"],
  "postedAt": "2026-10-16T11:10:06.864Z",
  "url": "https://cutshort.io/job/GCP-Data-engineer-Bengaluru-Bangalore-Pune-Hyderabad-Chennai-VY-SYSTEMS-PRIVATE-LIMITED-uhRqRgf1",
  "descriptionSnippet": "GCP Data engineer (L1 virtual, L2 or DM F2F ) GCP + Python + Pyspark + sql + Lead 8+yrs Bangalore/hyderabad location ( relocation profiles also from Chennai pune location) immediate to 15days",
  "searchSlug": "python-jobs-in-bangalore-bengaluru",
  "scrapedAt": "2026-10-16T13:00:00.000Z"
}
```

- `salaryMin`/`salaryMax` are **yearly** amounts (2000000 = ₹20 lakh a year), also for internships that Cutshort shows per month (`salaryText` keeps the shown form, e.g. `₹15000 - ₹18000 / mo`). `null` when not given.
- `workMode` is `onsite`, `remote` or `remoteOrOnsite`; `locations` is empty for remote-only jobs.
- Agency jobs have `hiringForClient: true`, the client in `companyName` and the agency in `recruiterName`.
- With `includeDetails` (and in all-jobs mode) each job also has `description` (plain text), `validThrough`, `employmentTypes`, `category`, `tags`, `postalCode` and `jobValid`.
- In monitor mode each job has `changeType`: `new`, `updated` or `removed`. Removed jobs carry only `jobId`, `headline`, `companyName` and `url`.

### How much does it cost to scrape Cutshort jobs?

Pay-per-event, only for jobs written to your dataset:

| Event       | Price       | When                                                                   |
| ----------- | ----------- | ---------------------------------------------------------------------- |
| Job         | **$0.0015** | Every job (or monitor-mode change) in the dataset                      |
| Job details | **$0.001**  | Only when the job page is fetched (`includeDetails`, or all-jobs mode) |

That's **$1.50 per 1,000 jobs**, or $2.50 per 1,000 with details. The default input (20 Python jobs in Bangalore) costs $0.03. In monitor mode unchanged jobs are free. If you set a **maximum cost per run**, the actor stops cleanly when it reaches it.

### How do I monitor Cutshort for new, updated and removed jobs?

Turn on `monitorMode` and run the actor on an [Apify schedule](https://docs.apify.com/platform/schedules) (e.g. daily; save the input as a task and schedule the task).

- The first run is a baseline and returns every job as `new`. Set `maxItems` high enough to cover all jobs of your searches.
- Later runs return only changes: `new` jobs, `updated` jobs (title, company, salary, experience, skills, locations, work mode or description changed) and `removed` jobs (no longer listed). Unchanged jobs are skipped and not billed. `maxItems` counts new and updated jobs; removed jobs don't count.
- Removed jobs are checked only when every search was read to the end (no `maxPages`, `startPage` 1, `maxItems` not reached). Otherwise the next complete run reports them.
- In all-jobs mode (no skills) you get new and removed jobs from the sitemap.
- State lives in your account in the key-value store `cutshort-jobs-state`, one record per set of searches. Changing the skills or cities starts a new baseline. It remembers the latest 50,000 jobs.

### Cutshort jobs scraper FAQ

**Is this an official Cutshort API?** No. It reads public job listings and job pages that cutshort.io shows to logged-out visitors, and respects its robots.txt (no `/view/j/`, `/vj/`, `?job_listing`, `?free_text` or `/apply/` pages).

**Why are some jobs outside my city?** Multi-city jobs are listed in each of their cities. Filter on `locations` if you need exact matches.

**Why do all-jobs runs include older jobs?** The sitemap lists every open job, including some posted long ago that are still marked open. Sort or filter on `postedAt`.

**Do I need a proxy?** No. cutshort.io answers Apify's servers directly. You can still enable Apify Proxy; the actor then switches IP automatically if a request is blocked.

**Can I use it through the API or with AI agents?** Yes. Call it through the Apify API, the Apify MCP server or any Apify integration.

**Disclaimer:** This actor is not affiliated with, endorsed by or sponsored by Cutshort. Cutshort is a trademark of its owner. You are responsible for complying with Cutshort's terms and applicable laws when using the data.

### Related actors

- [foundit-jobs](https://apify.com/cprussin/foundit-jobs?fpr=to54nm): Indian job listings from Foundit (Monster India) with salary, experience and skills.
- [hirist-iimjobs-jobs](https://apify.com/cprussin/hirist-iimjobs-jobs?fpr=to54nm): India tech jobs from Hirist and management jobs from iimjobs, with experience, salary and skills.
- [wellfound-jobs](https://apify.com/cprussin/wellfound-jobs?fpr=to54nm): Startup jobs from Wellfound (AngelList Talent) with salary, equity and company data.
- [ycombinator-companies](https://apify.com/cprussin/ycombinator-companies?fpr=to54nm): Y Combinator startups with batch, industry, team size and hiring status.

# Actor input Schema

## `skills` (type: `array`):

Skills or roles, e.g. <code>python</code>, <code>reactjs</code>, <code>java</code>, <code>devops</code>, <code>product-manager</code>. Names like <code>React.js</code> or <code>Data Science</code> are converted automatically, or paste a listing URL or slug from cutshort.io/jobs (e.g. <code>machine-learning-ml-jobs</code>). Each skill is searched in every city below. Leave empty to export all jobs (jobs sitemap, with details).

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

Optional city filter, one per entry: <code>Bangalore</code>, <code>Mumbai</code>, <code>Pune</code>, <code>Hyderabad</code>, <code>Chennai</code>, <code>Delhi</code> (Delhi, NCR, Gurgaon and Noida), <code>Kolkata</code>, <code>Ahmedabad</code>, <code>Jaipur</code>, <code>Kochi</code>, <code>Indore</code>, <code>Chandigarh</code>, <code>Coimbatore</code>, <code>Bhubaneswar</code>, or <code>Remote</code>. Leave empty for all of India.

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

Stop after this many jobs in total, across all searches. In monitor mode it counts only new and updated jobs. Each job is billed as one event.

## `startPage` (type: `integer`):

First listing page to read per search (50 jobs per page, newest first). 1 = the newest jobs.

## `maxPages` (type: `integer`):

Listing pages to read per search (50 jobs each). 0 = all pages, up to Max jobs.

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

Open each job page for the full description, valid-through date, employment type, category tags and postal code. Billed as an extra <code>job-detail</code> event per job. Every job always has a short <code>descriptionSnippet</code>.

## `monitorMode` (type: `boolean`):

Output only changes since the last run with the same skills and cities: <code>new</code> jobs, <code>updated</code> jobs (title, salary, experience, skills, locations or description changed) and <code>removed</code> jobs (no longer listed), in the <code>changeType</code> field. Unchanged jobs are skipped and not billed. The first run is a baseline that returns every job as <code>new</code>. State is kept in the key-value store "cutshort-jobs-state" in your account.

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

Optional Apify Proxy. Not needed normally: cutshort.io answers datacenter IPs directly. If set, the actor switches to a new IP whenever a request is blocked or rate-limited.

## Actor input object example

```json
{
  "skills": [
    "python"
  ],
  "cities": [
    "bangalore"
  ],
  "maxItems": 20,
  "startPage": 1,
  "maxPages": 0,
  "includeDetails": false,
  "monitorMode": false
}
```

# Actor output Schema

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

No 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 = {
    "skills": [
        "python"
    ],
    "cities": [
        "bangalore"
    ],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("cprussin/cutshort-jobs").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 = {
    "skills": ["python"],
    "cities": ["bangalore"],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("cprussin/cutshort-jobs").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 '{
  "skills": [
    "python"
  ],
  "cities": [
    "bangalore"
  ],
  "maxItems": 20
}' |
apify call cprussin/cutshort-jobs --silent --output-dataset

```

## MCP server setup

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

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/MoAldhcFDnNmaiVre/builds/SUgPGH9gblIGYPPBX/openapi.json