# Cutshort Jobs Scraper - India Tech Jobs, Salary & Companies (`topapi/cutshort-jobs-scraper`) Actor

Scrape Cutshort (cutshort.io) India tech and startup jobs: title, salary in INR and lakhs, skills, experience, remote type, full description, recruiter activity (ghost jobs), company profile and employer email. Any skill, city or company, monitor mode. $0.039 per 1,000 jobs.

- **URL**: https://apify.com/topapi/cutshort-jobs-scraper.md
- **Developed by:** [Top Api](https://apify.com/topapi) (community)
- **Categories:** Jobs, Lead generation, Business
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.04 / 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

### What does Cutshort Jobs Scraper do?

**Cutshort Jobs Scraper** reads India tech and startup jobs from [Cutshort](https://cutshort.io) (cutshort.io) and returns one row per job: title, company, cities, remote type, salary (the band candidates see, Cutshort's internal band, a year in INR and in lakhs), experience, skills, the full description, the recruiter (and, with the job page, when they were last active on the job), and the hiring company's profile (stage, size, founded, website, LinkedIn, tech stack). Built for recruiters, staffing agencies, sales teams selling to hiring startups, HR-tech products and salary analysts who need Cutshort jobs as data.

Cutshort scraper · cutshort.io scraper · Cutshort jobs API · India tech jobs data · startup jobs India · Bangalore tech jobs

- **Any skill or role:** type `python`, `react`, `product manager` or `remote golang`; the actor finds Cutshort's job category (React -> React.js) and says which in the log. 3,769 categories, 14 city pages each, remote pages.
- **More than one page of jobs:** a Cutshort category shows only its newest 400-650 jobs (python: 400 of 4,341 live). When that runs out, the actor reads the same category's 14 city pages and its remote page: python goes from 400 to 2,589 different jobs in one run (2-4 minutes); 1,000 jobs take 6 seconds to 5 minutes, depending on how many of the pages were already read in the current hour.
- **Current rows, with their age on every row:** Cloudflare keeps copies of Cutshort's pages for hours to days (on 22 list pages on 2026-11-07 the median cached copy was 10.4 hours old, one 6 days; on 30 pages a copy 5.9 days old missed 16 of its 50 jobs). The actor checks each copy's age: rows come from pages at most 1 hour old (Cloudflare's copy when it is that recent, otherwise one built for the current hour), or built fresh for the run with **Live pages** on. Every row carries `cacheAgeSeconds` and `pageFetchedAt`.
- **Real or ghost job:** `ghostJob` after 90 days without activity (you choose) and `redFlags` with the reason (a fee asked, WhatsApp, a phone number, a 4x salary range, a client not named) on every row. With **Job page details** on, the recruiter's last hiring activity too (`hiringIntentShownAt`, `daysSinceRecruiterActive`); without it, the posting date decides. In a 1,000-job python run, 559 jobs had no recruiter activity for over 90 days.
- **Company or agency:** `postedByType`, the agency's name for jobs posted for a client, and whether the client is only described ("MNC").
- **Every job of a company, or of all Cutshort:** paste company links or names, or switch on **Every job on Cutshort** (its job sitemap, ~45,000 live jobs).
- **Employer email (option):** a contact email from the hiring company's own website.
- **Only new jobs:** monitor mode returns only jobs not delivered before (new and changed), and reports closed ones.
- **No login, cookies or API key.** Pay only for delivered rows: no start fee; filtered-out jobs, copies and jobs delivered by earlier monitor runs are never charged.
- **Export anywhere:** JSON, CSV, Excel, XML; schedules, webhooks, Make, Zapier, n8n, Google Sheets, Slack, Telegram, Discord.
- **Works with AI agents:** call it through the Apify API or the Apify MCP server; `outputMode: "summary"` gives short rows for LLM pipelines.

### What data can you get from Cutshort?

<table>
<tr>
<td>💼 Job title, Cutshort id, link</td>
<td>🏢 Company, logo, Cutshort page</td>
<td>🏷️ Category, Cutshort match tags</td>
</tr>
<tr>
<td>📍 Cities, postal code</td>
<td>🏠 Remote only / remote friendly / on-site</td>
<td>🎓 Experience from - to (years), fresher</td>
</tr>
<tr>
<td>💰 Salary as shown, min / max, currency, period</td>
<td>📊 Internal band, a year in INR, lakhs</td>
<td>🙈 Hidden salary ("Best in industry")</td>
</tr>
<tr>
<td>🛠️ Skills and Cutshort skill codes</td>
<td>📝 Full description (text or HTML)</td>
<td>📅 Posted date, valid through</td>
</tr>
<tr>
<td>👤 Recruiter and their last activity</td>
<td>👻 Ghost job, red flags with reasons</td>
<td>🧑‍💼 Company or agency, client named or not</td>
</tr>
<tr>
<td>🚀 Stage, funding, size, founded, followers</td>
<td>🌐 Website, LinkedIn, X, Facebook, AmbitionBox</td>
<td>📧 Employer email (option)</td>
</tr>
</table>

Measured on a 1,000-job python run (2026-11-06, default settings): title, company, skills, experience, description, posted date, recruiter, remote type and salary text on 100% of rows; cities 81% (the rest are remote-only), shown salary 88% (12% hidden as "Best in industry"), company website 78%, founded 75%, stage 72%, size 69%, company description 68%, LinkedIn 66%; 245 jobs posted by agencies, 745 with at least one red flag. With **Job page details** on, recruiter activity, job valid and match tags on 100% and postal code on 78%. With **Employer email** on, 56-82% of rows got an email (python, react and devops, 50 jobs each); with **Company profile page** on, 60-86% got the company's open-job count.

### How to scrape Cutshort with Cutshort Jobs Scraper

1. [Create a free Apify account](https://console.apify.com/sign-up) - $5 of monthly credit, no card needed.
2. Open [Cutshort Jobs Scraper](https://apify.com/topapi/cutshort-jobs-scraper) and click **Try for free**.
3. Type one or more **Skills or roles** (e.g. `python`, `react`, `data analyst`), add **Locations** (`Bangalore`, `Pune`, `Remote`) if you want, and set **Max jobs**.
4. Click **Start**.
5. Open the **Storage** tab and **Export** as JSON, CSV or Excel - or let a schedule run it for you.

### ⬇️ Input

| Parameter | Type | Description |
|---|---|---|
| **🔍 What to scrape** | | |
| `skills` | List | Skills or roles, each its own search, e.g. `["python", "react", "product manager"]`. `"remote golang"` reads the remote page, `"java in pune"` the Pune page. Empty (with no link or company) = Python jobs. |
| `startUrls` | List | Cutshort links: category pages (`/jobs/python-jobs`, `/jobs/reactjs-jobs-in-pune`, `/jobs/remote-golang-jobs`), job pages (`/job/...`), company pages (`/company/...`). |
| `companies` | List | Every open job of these companies: links, aliases or names, e.g. `["Techjays"]`. |
| `allCutshortJobs` | Boolean | Every job on Cutshort (its job sitemap), most recently updated first. Combine with locations and filters. |
| **🎯 Filters** | | |
| `locations` | List | Cities or `Remote`. Cutshort's 14 city pages (Bangalore, Mumbai, Delhi NCR, Hyderabad, Pune, Chennai, Ahmedabad, Kolkata, Jaipur, Indore, Coimbatore, Kochi, Chandigarh, Bhubaneswar) are read directly; other places filter the jobs' locations. |
| `remoteOnly`, `workplace` | Boolean / Select | Remote only; or `remoteAllowed`, `onSite`, `notRemote`. |
| `roleTypes` | List | `full_time`, `internship`. |
| `postedWithin`, `postedWithinHours` | Select / Integer | Last 24 hours ... 3 months, or any number of hours. |
| **✂️ Refine results** | | |
| `experienceMinYears`, `experienceMaxYears` | Integer | Experience range; `experienceMaxYears: 0` = freshers. |
| `minYearlySalary`, `withSalaryOnly` | Integer / Boolean | Minimum salary a year in INR (e.g. `1000000` = ₹10 L); skip hidden salaries. |
| `companyStages`, `companyType`, `postedBy` | List / Select | `bootstrapped`, `raisedFunding`, `profitable`; `product` / `services`; `company` / `agency`. |
| `titleMustMatchKeyword`, `titleInclude`, `titleExclude` | Boolean / List | Title must contain the skill; title words to keep / skip. |
| `companyNames`, `companyExclude` | List | Company (or agency) names to keep / skip. |
| `hideGhostJobs`, `ghostAfterDays` | Boolean / Integer | Skip jobs with no recruiter activity (with job page details; otherwise since posting) for N days (default 90). |
| `skipJobsWithRedFlags`, `skipDuplicates` | Boolean | Skip red-flagged jobs; one row per title + company + city (default on). |
| **➕ Extra data** | | |
| `includeDetails` | Boolean | Each job's own page: recruiter's last activity, job valid, match tags, valid-through date, postal code, agency flag. Default `false`; $0.0009 per job with its page. Job links and **Every job on Cutshort** always read it. |
| `includeCompanyDetails` | Boolean | Company description, tech stack, FAQs, team, photos. Default `true`, free. |
| `includeCompanyProfile` | Boolean | Each company's Cutshort profile once: open jobs, agency or not, tech team size, planned developer hires, typical developer pay, hiring team. Default `false`, free. |
| `includeRecruiter` | Boolean | The recruiter's name, id and picture. Default `true`. |
| `enrichEmails` | Boolean | Employer email from the company's own website (paid add-on). Default `false`. |
| `readCityPages` | Boolean | Read the city and remote pages when a category's own page runs out. Default `true`. |
| `liveData` | Boolean | Every page built fresh for this run. Default `false` = pages at most 1 hour old (a page read in the last hour answers in ~0.5 s; otherwise Cutshort takes 8-25 s to build it). |
| **🔁 Monitoring** | | |
| `monitoringMode`, `stateName` | Boolean / String | Only jobs not delivered by earlier runs with the same input and state name. |
| `includeUnchanged`, `emitExpired`, `resetMonitoringState` | Boolean | Also return unchanged jobs; report closed jobs (`EXPIRED`); forget the memory once. |
| Alerts | String | `webhookUrl`, `slackWebhookUrl`, `discordWebhookUrl`, `telegramToken` + `telegramChatId`. |
| **📦 Output** | | |
| `maxItems` | Integer | Default `50`; `0` = everything that matches. |
| `maxItemsPerSearch` | Integer | Cap per skill x location, link or company. |
| `outputMode` | Select | `full` (default), `summary`, `urls_only`. |
| `descriptionFormat` | Select | `text` (default), `html`, `both`, `none`. |
| **⚙️ Advanced** | | `maxConcurrency` (default 8), `proxyConfiguration` (not needed). |

The input names of the other Cutshort actors are accepted too (`searchQueries`, `keywords`, `city`, `jobType`, `fullDetails`, `onlyNewJobs`, `monitorName`, `maxResults` ...), so an API call written for one of them runs here unchanged.

#### Input JSON

```json
{
  "skills": ["python", "data engineer"],
  "locations": ["Bangalore", "Remote"],
  "postedWithin": "pastWeek",
  "experienceMaxYears": 5,
  "hideGhostJobs": true,
  "maxItems": 200
}
```

#### One skill per line

Each skill is its own search and the run cap is shared between searches. **Do:** `["react", "node"]` · **Don't:** `["react node developer bangalore"]` - put the city in **Locations**. Cutshort has no free-text search: a skill is matched to Cutshort's own job category, and the log says which (`Skill "react" -> Cutshort category "React.js"`).

#### A category also holds jobs that only list the skill

Cutshort's `python-jobs` page holds every job with Python among its skills, so a Java job that also asks for Python is there too. Turn on **Title must contain the skill** for titles with the word in them.

### ⬆️ Output

One row per job. A real row from a run on 2026-11-06 with **Job page details** on (description and company text shortened here; without the job page, `hiringIntentShownAt`, `jobValid`, `matchCategory`, `matchTags`, `postalCode` and `recruiterId` are empty):

```json
{
  "type": "job",
  "jobId": "6aeda64ecb15c5cf29bcffe8",
  "url": "https://cutshort.io/job/SRE-Production-Support-Hyderabad-VY-SYSTEMS-PRIVATE-LIMITED-jZlEiu1f",
  "title": "SRE Production Support",
  "companyName": "MNC",
  "companyStage": "Bootstrapped",
  "companyFounded": 2025,
  "companyWebsite": "https://isquaresoft.com",
  "companyLinkedin": "https://linkedin.com/company/i-square-soft",
  "postedByType": "agency",
  "hiringForClient": true,
  "staffingAgencyName": "VY SYSTEMS PRIVATE LIMITED",
  "clientCompanyName": "MNC",
  "locations": ["Hyderabad"],
  "postalCode": "500081",
  "remoteType": "remote_not_okay",
  "workplaceType": "onsite",
  "roleTypes": ["full_time"],
  "salaryMin": 150000,
  "salaryMax": 1300000,
  "salaryCurrency": "INR",
  "salaryPeriod": "year",
  "salaryRawText": "₹1.5L - ₹13L / yr",
  "salaryInternalMin": 0,
  "salaryInternalMax": 1300000,
  "salaryLakhsMin": 1.5,
  "salaryLakhsMax": 13,
  "experienceMin": 7,
  "experienceMax": 11,
  "experienceText": "7 - 11 years",
  "skills": ["Production support", "site reliability Engineer", "SRE", "openshift", "OCP", "Python", "Tomcat", "Splunk", "open telemetry", "Networking"],
  "descriptionText": "We are looking for an experienced SRE Production Support Engineer with strong expertise in production support, OpenShift cloud environments ...",
  "postedAt": "2026-11-06T10:05:02.084Z",
  "hiringIntentShownAt": "2026-11-06T11:14:45.178Z",
  "daysSinceRecruiterActive": 0,
  "ghostJob": false,
  "jobValid": true,
  "redFlags": ["salary range 4x wide or more"],
  "matchCategory": "support",
  "matchTags": ["tech-support"],
  "category": "Python",
  "recruiterName": "ASHMI GR",
  "searchKeyword": "python",
  "contentHash": "16405d67525ffbd6",
  "detailsFetched": true,
  "source": "cutshort.io",
  "scrapedAt": "2026-11-06T20:29:03.019Z"
}
```

#### Fields

| Group | Fields |
|---|---|
| Job | `jobId`, `shortId`, `jobSlug`, `url`, `applyUrl`, `title`, `skills`, `skillCodes`, `matchedSkills`, `descriptionText`, `descriptionHtml`, `roleTypes`, `employmentTypes`, `isInternship`, `category`, `categories`, `matchCategory`, `matchTags` |
| Place | `locations`, `locationsText`, `city`, `postalCode`, `country`, `remoteType`, `remote`, `workplaceType`, `remotePolicy` |
| Salary | `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryRawText`, `salaryHidden`, `salaryShowsOnlyMax`, `salaryInternalMin`, `salaryInternalMax`, `salaryYearlyMin`, `salaryYearlyMax`, `salaryYearlyInrMin`, `salaryYearlyInrMax`, `salaryLakhsMin`, `salaryLakhsMax` |
| Experience | `experienceMin`, `experienceMax`, `experienceText`, `experienceLevel` |
| Real or ghost | `postedAt`, `postedDate`, `postedText`, `daysSincePosted`, `hiringIntentShownAt`, `daysSinceRecruiterActive`, `ghostJob`, `jobValid`, `validThrough`, `directApply`, `redFlags`, `redFlagCount` |
| Who posted it | `postedByType`, `hiringForClient`, `staffingAgencyName`, `staffingAgencyUrl`, `clientNameHidden`, `clientCompanyName`, `clientDescription`, `recruiterId`, `recruiterName`, `recruiterPhoto` |
| Company | `companyName`, `companyId`, `companyAlias`, `companyUrl`, `companyLogo`, `companyType`, `companySize`, `companyStage`, `companyFunding`, `companyFounded`, `companyFollowersCount`, `companyWebsite`, `companyDomain`, `companyLinkedin`, `companyTwitter`, `companyFacebook`, `companyInstagram`, `companyYoutube`, `companyBlog`, `companyAmbitionbox`, `companyDescription`, `companyTechStack`, `companyFaqs`, `companyTeam`, `companyPhotos`, `companyIsRecruitmentAgency` |
| Company profile (option) | `companyTotalJobs`, `companyTechTeamSize`, `companyExpectedDevHirings`, `companyTypical3yrDevSalaryMin`, `companyTypical3yrDevSalaryMax`, `companyDomains`, `companyLocationPreferences`, `companyHiringTeam` |
| Employer email (option) | `employerEmail`, `employerEmails`, `employerEmailKind`, `employerEmailDomain`, `employerEmailSourceUrl`, `employerWebsite`, `emailEnrichmentStatus` |
| Monitor | `changeType` (`NEW`, `UPDATED`, `UNCHANGED`, `EXPIRED`, `DETAILS` = delivered before without an add-on this run asks for, now with it), `firstSeenAt`, `lastSeenAt`, `expiredAt`, `closedReason`, `monitoringStateKey`, `contentHash`, `dedupeKey` |
| Search | `searchKeyword`, `matchedSearchTerms`, `searchLocation`, `searchUrl`, `page`, `positionOnPage`, `sourceUrl`, `detailsFetched`, `scrapedAt` |
| Freshness | `cacheAgeSeconds` (how old the Cutshort page the row came from was, 0 = built for this read), `pageFetchedAt` (when that page was built) |

Not on the rows: an applicant count (Cutshort does not show one to a visitor), an ESOP flag (no Cutshort job record carries one; 500 checked), and per-row lists of every page that also listed the job (rows are delivered as they are found; later pages that list the same job are counted in the run summary as `duplicates`).

**Salary bands.** Cutshort stores two salary bands: the one candidates see (`salaryMin` / `salaryMax`, as in `salaryRawText`) and a separate internal band (`salaryInternalMin` / `salaryInternalMax`, often a lower floor or 0). Stipends are shown a month (`salaryPeriod: "month"`); `salaryYearly*` is always a year, `salaryYearlyInr*` a year in INR (Cutshort's own conversion for USD, SGD and other currencies), `salaryLakhs*` the same in lakhs. A hidden salary ("Best in industry") has `salaryHidden: true` and empty shown fields.

Five table views in the Console: **Jobs**, **Real or ghost**, **Salary**, **Company** and **Details**.

### How can I use Cutshort data?

- **Recruiting and staffing:** which startups hire for which stack, in which city, at what pay - with the recruiter's last activity so you skip dead postings.
- **Sales to hiring companies:** company stage, size, website, LinkedIn and an employer email for every company hiring for a skill.
- **Salary research:** INR bands by skill, city, experience and company stage, both the shown and the internal band.
- **Job alerts and job boards:** a schedule with monitor mode feeds only new jobs to Slack, Telegram, a sheet or your own board.
- **Market tracking:** live job counts per category (`liveJobs` in the run summary) over time.

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

Pay per result, no subscription:

| Event | Price |
|---|---|
| Job (every field of the category page: title, company block, cities, remote type, salary, experience, skills, description, recruiter, red flags) | $0.000039 ($0.039 per 1,000 jobs) |
| Job page details (only with **Job page details** on, a job link or **Every job on Cutshort**) | $0.0009 per job whose page was read |
| Employer email (once per employer per run, only when an email is found) | $0.0072 |

No start fee. Jobs removed by your filters, copies, ghost jobs you hide and jobs delivered by earlier monitor runs are not charged; a job page that could not be read is not charged. Set a maximum cost per run in the run options and the actor stops there.

### Run it on a schedule (only new jobs)

1. Set your skills, locations and filters, turn on **Only new jobs (monitor)** and give it a **State name** (e.g. `python-bangalore`).
2. Save it as a task and add a **Schedule** (every morning, or hourly).
3. Each run returns only jobs posted since the previous run (`changeType: "NEW"`), plus jobs whose content changed (`UPDATED`). Turn on **Report closed jobs** to get jobs Cutshort deactivated (`EXPIRED`).
4. Send them on with Apify integrations, or straight from the actor: **Webhook**, **Slack**, **Discord** or **Telegram**.

A poll with nothing new reads the newest page and stops; nothing is charged. By default a poll sees pages at most 1 hour old; turn on **Live pages** to read them as Cutshort builds them.

### Integrations, API, scheduling & MCP

Run it from the Apify API, the JavaScript or Python client, n8n, Make or Zapier, or from AI agents through the [Apify MCP server](https://mcp.apify.com). One call returns the jobs as JSON:

`POST https://api.apify.com/v2/acts/topapi~cutshort-jobs-scraper/run-sync-get-dataset-items` with the input JSON above.

### More job scrapers

| Actor | What it does |
|---|---|
| [Indeed Jobs Scraper](https://apify.com/topapi/indeed-jobs-scraper) | Jobs from Indeed's country sites, India included |
| [Naukrigulf Jobs Scraper](https://apify.com/topapi/naukrigulf-jobs-scraper) | Gulf jobs, salaries and recruiters |
| [Welcome to the Jungle Jobs Scraper](https://apify.com/topapi/welcome-to-the-jungle-jobs-scraper) | Startup and tech jobs with company profiles |

### Limits & empty runs

- **A category page shows its newest 400-650 jobs.** With city and remote pages, python reached 2,589 different jobs; **Every job on Cutshort** reads the whole board (44,931 live jobs on 2026-11-06).
- **Fresh pages take Cutshort time:** a page nobody read in the current hour takes Cutshort 8-25 seconds to build (every page, with **Live pages**); the actor reads eight at once, and a page that does not come in time is read from Cloudflare's older copy (`servedFromCdnCopy` in the run summary; the rows say how old in `cacheAgeSeconds`). The first run in an hour is the slow one.
- **Filters the actor applies stop when they keep too little:** Cutshort's category pages take no filter of their own (experience, salary, job type, posting date, stage: all ignored when probed); a city and remote are read as Cutshort's city and remote pages. For the other filters, the actor reads the next page only while the jobs kept so far pay for it; when that stops a search, the status message says how many jobs your filters kept of how many read. Loosen the filters, or use a city / Remote only, to go further.
- **Cutshort keeps old jobs open:** many city-page jobs have had no recruiter activity for years; `ghostJob` and `hideGhostJobs` handle them.
- **The job sitemap is rebuilt about once a day,** so **Every job on Cutshort** misses jobs posted since then (category pages have them).
- **Not available to a visitor:** applicant counts and candidate profiles. The actor reads only public job and company pages.
- **No rows?** The status message says why: a skill Cutshort has no category for, filters that removed every job (with the count per filter), or nothing new since the last monitor run. A run Cutshort refuses entirely fails with a clear message and charges nothing.

### FAQ

#### How many jobs can Cutshort Jobs Scraper collect in one run?

As many as Cutshort shows: 400-650 per category page, each city and remote page its own window, or the whole board with **Every job on Cutshort**. 1,000 jobs took 6 seconds (pages already read in the hour) to 5 minutes; all 2,589 python jobs 2-4 minutes.

#### How fresh is the data?

Every row comes from a page at most 1 hour old: the actor reads Cloudflare's copy only when its age is under an hour, and otherwise a copy built for the current hour (Cloudflare's own copies are usually many hours old: median 10.4 hours on 22 list pages). `cacheAgeSeconds` on each row says how old its page was. Turn on **Live pages** (`liveData`) to build every page fresh for the run.

#### What is a ghost job?

A job Cutshort still lists but whose recruiter has shown no hiring activity for **Ghost after** days (90 by default). Every row has `daysSinceRecruiterActive` and `ghostJob`; **Hide ghost jobs** skips them for free.

#### How fresh is the data on a schedule?

A monitor on the default settings sees a new job within an hour of its posting; with **Live pages** on, on the next run.

#### Can I get every job of one company?

Yes: paste its Cutshort company link (or name) into **Companies**. Turn on **Company profile page** for its open-job count, tech team size, planned developer hires and hiring team.

#### Can I use it with the Apify API or MCP?

Yes, see **Integrations** above; `outputMode: "summary"` keeps rows short for agents.

#### Do I need a Cutshort account, cookies or an API key?

No. The actor reads the public job pages a visitor sees, without signing in.

#### Why did my run return no results?

The status message says why (see **Limits & empty runs**). The most common cause is a skill Cutshort has no category for: use a skill or role name (`python`, `react`, `product manager`) or paste the category link from cutshort.io.

#### Your feedback

Found a bug or need a field? Open an issue on the actor's **Issues** tab.

# Actor input Schema

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

One search per skill or role, matched to Cutshort's job category, e.g. "python", "react", "product manager", "remote golang", "java in pune". Empty (with no link or company) = Python jobs.

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

Category pages (cutshort.io/jobs/python-jobs, /jobs/reactjs-jobs-in-pune, /jobs/remote-golang-jobs), job pages (cutshort.io/job/...) and company pages (cutshort.io/company/...).

## `companies` (type: `array`):

Every open job of these companies: Cutshort company links, aliases or names, e.g. "https://cutshort.io/company/techjays-92-tGmHamzp", "Techjays".

## `allCutshortJobs` (type: `boolean`):

Read the whole job board (Cutshort's job sitemap, ~45,000 live jobs, most recently updated first) instead of categories. Combine with Locations and the filters below.

## `locations` (type: `array`):

Cities or "Remote", e.g. "Bangalore", "Pune", "Delhi NCR", "Remote". Cutshort's 14 city pages are read directly (deeper than the India-wide page); other places filter the jobs' locations.

## `remoteOnly` (type: `boolean`):

Only fully remote jobs (Cutshort's remote_only). Reads the category's remote page when Cutshort has one.

## `workplace` (type: `string`):

Cutshort's remote type of each job: remote_only, remote_okay (remote friendly), remote_not_okay (on-site).

## `roleTypes` (type: `array`):

Cutshort's role types. Empty = both.

## `postedWithin` (type: `string`):

By the posting date. Pages are read newest first, so a short window is fast and cheap. Pairs with a daily schedule.

## `postedWithinHours` (type: `integer`):

Any number of hours, e.g. 6 or 48. Overrides "Posted within".

## `experienceMinYears` (type: `integer`):

Keeps jobs whose experience range reaches this many years.

## `experienceMaxYears` (type: `integer`):

Keeps jobs open to candidates with at most this many years. 0 = jobs for freshers.

## `minYearlySalary` (type: `integer`):

Keeps jobs whose shown salary reaches this much a year, in INR (other currencies converted by Cutshort), e.g. 1000000 = ₹10 L. Hidden salaries are removed.

## `withSalaryOnly` (type: `boolean`):

Skip jobs whose salary is hidden ("Best in industry").

## `companyStages` (type: `array`):

As the company states on Cutshort. Empty = any.

## `companyType` (type: `string`):

"Products & Services" companies count as both.

## `postedBy` (type: `string`):

Agencies post for clients, often under a described name ("MNC"). Every row says postedByType and hiringForClient.

## `titleMustMatchKeyword` (type: `boolean`):

A category also holds jobs that only list the skill (a Java job with Python in its skills). On = only titles with every word of the skill.

## `titleInclude` (type: `array`):

Keep a job when its title contains any of these, e.g. "senior", "lead", "intern".

## `titleExclude` (type: `array`):

Skip a job when its title contains any of these, e.g. "manager", "sales".

## `companyNames` (type: `array`):

Keep only jobs whose company (or posting agency) name contains any of these.

## `companyExclude` (type: `array`):

Company or agency names (or parts) to skip.

## `hideGhostJobs` (type: `boolean`):

Skip jobs whose recruiter has shown no hiring activity (with Job page details; otherwise the posting date) for "Ghost after" days. Off = every job, with ghostJob true / false.

## `ghostAfterDays` (type: `integer`):

A job is a ghost when its recruiter's last hiring activity (or its posting date) is older than this.

## `skipJobsWithRedFlags` (type: `boolean`):

Skip jobs that ask for a fee, send you to WhatsApp, a phone number or a Gmail address, promise easy money, show a 4x salary range or hide the client. Every row lists its redFlags either way.

## `skipDuplicates` (type: `boolean`):

Same title, company and city = one job (companies post one job many times). Copies are free.

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

Also read each job's own page: the recruiter's last hiring activity (ghost-job check), job still valid, match tags, valid-through date, agency or company. $0.0009 per job with its page. Job links always include it.

## `includeCompanyDetails` (type: `boolean`):

Company description, tech stack, FAQs, team members and photos on every row (stage, size, founded, website, LinkedIn are always there). Free.

## `includeCompanyProfile` (type: `boolean`):

Read each company's Cutshort profile once: open jobs, recruitment agency or not, tech team size, planned developer hires, typical developer salary, domains, hiring team. Free.

## `includeRecruiter` (type: `boolean`):

The name, id and picture of the person who posted the job, as shown on the job.

## `enrichEmails` (type: `boolean`):

A contact email from the hiring company's own website (the one on its Cutshort profile; for an agency job without a client name, the agency's). $0.0072 per employer with an email found, once per run.

## `readCityPages` (type: `boolean`):

A Cutshort category page shows only its newest 400-650 jobs (python: 400 of 4,341). When it runs out, also read the same category's 14 city pages and its remote page.

## `liveData` (type: `boolean`):

Build every page fresh for this run. Off (default) = pages at most 1 hour old: a page read in the last hour answers in ~0.5 s; a fresh build can wait up to 25 s. Each row says how old its page was.

## `monitoringMode` (type: `boolean`):

Remember the jobs of earlier runs with the same input and state name; return only new (and changed) ones. Jobs seen before are free. Pairs with a schedule.

## `stateName` (type: `string`):

Separate memory per monitor, e.g. "python-pune".

## `includeUnchanged` (type: `boolean`):

In monitor mode, also return (and charge) jobs seen before whose content did not change, marked UNCHANGED.

## `emitExpired` (type: `boolean`):

In monitor mode, re-check remembered jobs not seen for a day; a job Cutshort deactivated or removed comes back as a row with changeType EXPIRED (charged as a job).

## `resetMonitoringState` (type: `boolean`):

One run: forget the jobs remembered so far (after changing a search, or to rebuild the baseline).

## `webhookUrl` (type: `string`):

POST the new jobs of each run (JSON) to your own endpoint.

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL for a message per run with new jobs.

## `discordWebhookUrl` (type: `string`):

Discord webhook URL.

## `telegramToken` (type: `string`):

Your Telegram bot's token (with the chat id below).

## `telegramChatId` (type: `string`):

Chat or channel id the bot posts to.

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

Most jobs to return in this run (0 = no limit). A category shows 400-650 jobs; with its city and remote pages python reaches ~2,500.

## `maxItemsPerSearch` (type: `integer`):

Cap for each skill x location, link and company. Empty = shared from Max jobs.

## `outputMode` (type: `string`):

Full returns every field; Summary the core job fields; Links only the job identity and links.

## `descriptionFormat` (type: `string`):

Plain text keeps paragraphs and bullet points.

## `maxConcurrency` (type: `integer`):

Job pages read at once.

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

Not needed: cutshort.io answers directly. The actor moves to Apify's proxies by itself if a request is refused.

## Actor input object example

```json
{
  "skills": [
    "python"
  ],
  "allCutshortJobs": false,
  "remoteOnly": false,
  "workplace": "any",
  "postedWithin": "anyTime",
  "withSalaryOnly": false,
  "companyType": "any",
  "postedBy": "any",
  "titleMustMatchKeyword": false,
  "hideGhostJobs": false,
  "ghostAfterDays": 90,
  "skipJobsWithRedFlags": false,
  "skipDuplicates": true,
  "includeDetails": false,
  "includeCompanyDetails": true,
  "includeCompanyProfile": false,
  "includeRecruiter": true,
  "enrichEmails": false,
  "readCityPages": true,
  "liveData": false,
  "monitoringMode": false,
  "stateName": "default",
  "includeUnchanged": false,
  "emitExpired": false,
  "resetMonitoringState": false,
  "maxItems": 50,
  "outputMode": "full",
  "descriptionFormat": "text",
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per Cutshort job: title, company block, locations, remote type, salary (shown band, internal band, INR a year, lakhs), experience, skills, full description, recruiter activity, ghost-job and red-flag checks.

## `summary` (type: `string`):

Per-search counts (live jobs, pages read, delivered), filters, job-page results, egress and requests. Written when a search failed; every run logs it.

# 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"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "skills": ["python"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "skills": [
    "python"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call topapi/cutshort-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

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

## OpenAPI specification

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