# CutShort Jobs Scraper — India Tech Jobs, Salary & Skills (`haketa/cutshort-scraper`) Actor

Scrape CutShort.io tech job listings in India: job title, company, salary range, required skills, years of experience, location, remote type, company size & stage, and full description. Search by role or skill, filter by city, or paste search URLs. Export JSON/CSV/Excel.

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

## Pricing

from $1.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## CutShort Jobs Scraper — India Tech Jobs, Salary, Skills & Company Data

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue?logo=apify)](https://apify.com/haketa/cutshort-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/cutshort-scraper)
[![Data Format](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)](https://apify.com/haketa/cutshort-scraper)
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Deep%20Fan--Out-success)](https://apify.com/haketa/cutshort-scraper)
[![Deduplication](https://img.shields.io/badge/Deduplication-JobId%20Verified-blueviolet)](https://apify.com/haketa/cutshort-scraper)

Extract technology job opportunities across India from [CutShort.io](https://cutshort.io) into clean, structured data without coding or manual browser intervention. This **CutShort scraper** harvests active software, cloud, data, AI, product, and design roles: capturing **job title, hiring organization, structured INR salary ranges, required technology skills array, experience prerequisites, location, remote work model, publication timestamp, and verified company intelligence (headcount, funding stage, business model)**.

Export structured datasets to **JSON, CSV, Excel, or consume live data feeds directly via the Apify REST API**.

> Built for **tech recruiters, staffing agencies, compensation analysts, startup researchers, talent intelligence teams, and engineering leaders** who need comprehensive visibility into the Indian technology talent market.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Platform** | CutShort.io (India Tech Hiring Ecosystem) |
| **Data Types** | Tech Job Postings, Employer Profiles, INR Salary Bands, Skill Tags |
| **Geographic Coverage** | Bangalore, Mumbai, Pune, Delhi NCR, Hyderabad, Chennai, and Remote India |
| **Pagination Mode** | Multi-role parallel fan-out (unlocked 1,000+ items across Indian tech hubs) |
| **Throughput Speed** | Pure HTTP execution (~500 jobs in ~25–35 seconds) |
| **Data Enrichment** | Structured INR min/max pay, experience bounds, clean description, funding stage |
| **Output Formats** | JSON, CSV, XML, Excel (XLSX), HTML Table |
| **Default Concurrency** | 6 parallel workers (configurable up to 12) |
| **Proxy Compatibility** | Pure HTTP datacenter or Apify Proxy with automatic session rotation |

***

### 🔎 Why scrape CutShort?

[CutShort](https://cutshort.io) serves as one of India's most prominent recruitment networks dedicated strictly to software engineering, cloud infrastructure, AI/ML, and tech startup talent. Postings on CutShort offer exceptional analytical value: almost every vacancy discloses an **explicit salary range in Indian Rupees (INR)**, mandated **minimum and maximum experience requirements**, granular **developer skill tags**, and verified **startup funding classifications** (`Raised funding`, `Bootstrapped`).

Extracting CutShort data manually is constrained by client-side single-page rendering and infinite scroll limitations. This **CutShort.io scraper** automates extraction directly from server-hydrated payloads: retrieving all matching positions for target roles and locations, normalizing numerical compensation bands, deduplicating records across queries, and delivering high-yield talent datasets ready for immediate analysis.

#### Primary enterprise use cases

- **India Tech Compensation Benchmarking**: Aggregate verified `salaryMin` and `salaryMax` distributions in INR segmented by tech stack, experience level, and metropolitan hub.
- **Developer Sourcing & Headhunting**: Stream fresh senior engineering and product management opportunities into recruitment CRM pipelines.
- **Funded Startup Tracking**: Identify emerging early-stage and growth-stage startups actively expanding their core engineering teams.
- **Skill Demand & Framework Analytics**: Measure quantitative hiring demand shifts (e.g., Python vs. Golang, React vs. Flutter, GenAI adoption) across the Indian subcontinent.
- **Regional Workforce Intelligence**: Evaluate compensation differentials and remote work adoption rates between Bengaluru, Hyderabad, Pune, and NCR.

***

### ✨ Core capabilities

- ✅ **Multi-Role & Skill Search**: Crawl multiple tech disciplines simultaneously (`"python"`, `"reactjs"`, `"devops"`, `"golang"`, `"datascience"`).
- ✅ **City-Specific Filtering**: Scope searches to leading Indian tech ecosystems (`bangalore`, `mumbai`, `pune`, `delhi`, `hyderabad`) or nationwide remote.
- ✅ **Direct URL Ingestion**: Paste exact CutShort role, location, or curated collection URLs to scrape targeted feeds.
- ✅ **Unlocked 1,000+ Result Scalability**: Automatically fans out across popular software engineering and product disciplines to collect thousands of verified jobs without artificial limits.
- ✅ **Dual Salary Representation**: Extracts both the human-readable display string (`"₹25L - ₹45L / yr"`) and normalized numerical integers (`salaryMin: 2500000`, `salaryMax: 4500000`).
- ✅ **Experience Range Parsing**: Captures lower and upper bounds of experience requirements in years (`experienceMin`, `experienceMax`).
- ✅ **Standardized Skill Arrays**: Delivers clean, tokenized arrays of programming languages, frameworks, and architectural proficiencies.
- ✅ **Company Intelligence**: Pulls company sizes, venture funding stages, operating models (`Product` vs. `Services`), and corporate profile links.
- ✅ **Zero Duplicate Guarantee**: Enforces natural key deduplication on CutShort `jobId` across all queried roles.

***

### 📥 Input parameters

The scraper accepts role names, Indian city filters, or direct search URLs. All fields are optional; running without input initiates a default Python tech exploration.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | Array of Strings | `["python"]` | Roles or skills to search on CutShort (e.g. `python`, `devops`, `reactjs`). |
| `location` | String | `""` | Target Indian city (e.g. `bangalore`, `mumbai`, `remote`). Leave empty for all India. |
| `searchUrls` | Array of Strings | `[]` | Explicit CutShort listing URLs to crawl directly. |
| `includeJobDetails` | Boolean | `false` | When enabled, visits individual job postings to capture full descriptions and deadlines. |
| `maxPages` | Integer | `0` | Maximum search roles to process. Set to `0` for unlimited / automatic extraction. |
| `maxItems` | Integer | `200` | Maximum job postings to retain. Set to `0` for unlimited. |
| `maxConcurrency` | Integer | `6` | Parallel worker concurrency (1–12). |
| `proxyConfiguration` | Object | `{ "useApifyProxy": true }` | Proxy settings. |

***

### 📋 Ready-to-use input examples

#### Example 1: Full-stack & backend hiring in Bangalore

```json
{
  "searchQueries": ["python", "golang", "nodejs"],
  "location": "bangalore",
  "includeJobDetails": false,
  "maxItems": 150,
  "maxPages": 0
}
```

#### Example 2: Remote AI & data science positions

```json
{
  "searchQueries": ["datascience", "machine-learning"],
  "location": "remote",
  "includeJobDetails": true,
  "maxItems": 100
}
```

#### Example 3: Large-scale nationwide startup scan

```json
{
  "searchQueries": ["devops", "product-manager", "reactjs", "backend-developer"],
  "location": "",
  "includeJobDetails": false,
  "maxItems": 500,
  "maxPages": 0
}
```

***

### 📤 Output dataset structure

Every harvested position produces a clean JSON record. Below is a representative output record:

```json
{
  "jobId": "6adb68d35a1e8fe07b3b9c0e",
  "title": "Principal Backend Architect",
  "url": "https://cutshort.io/job/Principal-Engineer-Bengaluru-Bangalore-AbleCredit-33DMzJTt",
  "company": "AbleCredit",
  "companySize": "20-100",
  "companyStage": "Raised funding",
  "companyType": "Product",
  "companyFounded": 2023,
  "companyLogo": "https://cdnv2.cutshort.io/company-static/logos/ablecredit.jpg",
  "companyProfileUrl": "https://cutshort.io/company/ablecredit-30-5hynosCr",
  "location": "Bengaluru (Bangalore)",
  "remoteType": "remote_okay",
  "roleTypes": [
    "full_time"
  ],
  "salary": "₹45L - ₹85L / yr",
  "salaryMin": 4500000,
  "salaryMax": 8500000,
  "salaryCurrency": "INR",
  "experienceMin": 8,
  "experienceMax": 14,
  "skills": [
    "Python",
    "Java",
    "FastAPI",
    "Microservices",
    "Kubernetes",
    "AWS",
    "PostgreSQL"
  ],
  "hiringForClient": false,
  "applyUrl": "https://cutshort.io/profile/view/j/6adb68d35a1e8fe07b3b9c0e",
  "datePosted": "2026-11-04T12:30:00.000Z",
  "sourceRole": "python",
  "detailEnriched": false,
  "scrapedAt": "2026-11-10T14:50:00.000Z"
}
```

When `includeJobDetails: true` is activated, each item additionally carries:

```json
{
  "description": "Full job description text cleaned to readable plain text without broken HTML tags...",
  "validThrough": "2026-12-31T23:59:59.000Z",
  "employmentType": "FULL_TIME",
  "detailEnriched": true
}
```

***

### 📊 Field definitions & coverage

#### 💼 Job specifications

| Field | Type | Description | Coverage |
|---|---|---|---|
| `jobId` | String | Unique CutShort listing key (deduplication identifier) | 🟢 High (100%) |
| `title` | String | Job title or position headline | 🟢 High (100%) |
| `url` | String | Canonical URL to the CutShort job profile | 🟢 High (100%) |
| `roleTypes` | Array | Employment nature (`full_time`, `contract`, `internship`) | 🟢 High (100%) |
| `applyUrl` | String | Application routing URL | 🟢 High (100%) |
| `sourceRole` | String | Role keyword used during discovery | 🟢 High (100%) |
| `datePosted` | String | ISO 8601 listing publication timestamp | 🟢 High (100%) |
| `description` | String | Sanitized plaintext description *(details on)* | 🟢 High (99%) |
| `validThrough` | String | Application closing deadline *(details on)* | 🟡 Conditional (85%) |

#### 💰 Compensation & experience prerequisites

| Field | Type | Description | Coverage |
|---|---|---|---|
| `salary` | String | Verbatim compensation string (e.g. `"₹25L - ₹45L / yr"`) | 🟢 High (100%) |
| `salaryMin` | Number | Minimum base salary in INR integers | 🟢 High (100%) |
| `salaryMax` | Number | Maximum base salary in INR integers | 🟢 High (100%) |
| `salaryCurrency` | String | Currency standard (`INR` or `USD`) | 🟢 High (100%) |
| `experienceMin` | Number | Minimum required years of professional experience | 🟢 High (100%) |
| `experienceMax` | Number | Maximum required years of professional experience | 🟢 High (100%) |
| `skills` | Array | Structured developer technology skill tags | 🟢 High (100%) |

#### 🏢 Employer intelligence & location

| Field | Type | Description | Coverage |
|---|---|---|---|
| `company` | String | Legal or operating employer name | 🟢 High (100%) |
| `companyProfileUrl` | String | Link to corporate CutShort profile | 🟢 High (100%) |
| `companyLogo` | String | CDN URL to the corporate logo graphic | 🟢 High (95%) |
| `companySize` | String | Headcount bracket (e.g. `20-100`, `100-500`) | 🟡 Conditional (70%) |
| `companyStage` | String | Funding stage (`Raised funding`, `Bootstrapped`) | 🟡 Conditional (70%) |
| `companyType` | String | Operating model (`Product`, `Services`) | 🟡 Conditional (75%) |
| `companyFounded` | Number | Founding calendar year | 🟡 Conditional (72%) |
| `location` | String | Metro location string | 🟢 High (100%) |
| `remoteType` | String | Model: `remote_only`, `remote_okay`, `remote_not_okay` | 🟢 High (100%) |

***

### 💡 Search strategies & best practices

1. **Leverage Standard Role Slugs**: CutShort standardizes role pages around specific slugs (e.g. `datascience`, `reactjs`, `devops`, `product-manager`). The actor automatically tries de-hyphenated variants, but adhering to standard naming ensures direct matching.
2. **High-Speed Pure-HTTP Mode**: Keep `includeJobDetails: false` for maximum extraction velocity. The listing feed natively supplies salary min/max, skills, experience, and company stage, enabling 500+ jobs to be scraped in ~30 seconds.
3. **Regional Compensation Comparison**: Query the same role (e.g., `golang`) with different `location` inputs (`bangalore`, `hyderabad`, `pune`, `remote`) to generate accurate geographic wage curve analyses.
4. **Automated Weekly Monitoring**: Configure an Apify Schedule running weekly to ingest newly published positions, filtering for `companyStage: "Raised funding"` to uncover newly capitalized startups.

#### Popular CutShort tech role slugs directory

To get the highest relevance and fastest extraction, use CutShort's standard role slugs in `searchQueries`:

- **Core Engineering**: `python`, `reactjs`, `nodejs`, `java`, `golang`, `c-sharp`, `php`, `ruby-on-rails`
- **Frontend & Mobile**: `frontend-developer`, `angular`, `flutter`, `android-developer`, `ios-developer`, `react-native`
- **Data & AI/ML**: `datascience`, `machine-learning`, `data-engineer`, `data-analyst`, `deep-learning`, `nlp`
- **Cloud & DevOps**: `devops`, `cloud-engineer`, `kubernetes`, `aws`, `cybersecurity`, `system-admin`
- **Product & Design**: `product-manager`, `ui-ux-designer`, `scrum-master`, `technical-architect`, `qa-engineer`

#### Indian technology hubs covered

Filter any role above by setting the `location` parameter:

- **`bangalore` (Bengaluru)** — India's Silicon Valley; highest density of venture-backed tech startups and global capability centers.
- **`hyderabad`** — Dominant enterprise cloud, cybersecurity, and large-scale platform engineering center.
- **`pune`** — Major automotive tech, BFSI software development, and product engineering hub.
- **`delhi` / `ncr` (Gurugram, Noida)** — Fast-growing consumer internet, fintech, and e-commerce tech headquarters.
- **`mumbai`** — Premier fintech, wealthtech, and digital banking technology center.
- **`chennai`** — Global SaaS corridor with deep enterprise B2B software engineering talent.
- **`remote`** — Pan-India distributed and remote-first engineering vacancies.

***

### ⚙️ How to use

1. Select roles or skills in `searchQueries` (e.g. `["python", "reactjs"]`) and optionally specify a `location`.
2. Choose whether to enable `includeJobDetails` for full description text.
3. Define `maxItems` based on your project volume requirements. Leave `maxPages: 0` for automatic pagination across all roles.
4. Click **Start** in the Apify Console and watch results stream directly into your Apify Dataset.
5. Download your clean dataset in JSON, CSV, or Excel formats.

***

### 💻 API & Integration examples

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~cutshort-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["python", "devops"],
    "location": "bangalore",
    "includeJobDetails": false,
    "maxItems": 100,
    "maxPages": 0
  }'
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")

run_input = {
    "searchQueries": ["datascience", "machine-learning"],
    "location": "remote",
    "includeJobDetails": False,
    "maxItems": 100
}

run = client.actor("haketa/cutshort-scraper").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item.get('title')} at {item.get('company')} — Salary: {item.get('salary')}")
```

#### Node.js / JavaScript

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

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const runInput = {
    searchQueries: ['reactjs'],
    location: 'pune',
    maxItems: 50,
    includeJobDetails: false,
};

const run = await client.actor('haketa/cutshort-scraper').call(runInput);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Retrieved ${items.length} tech jobs from CutShort.`);
```

#### Webhook & Zapier Automation

Connect this scraper directly to your workflow tools:

- **Make (Integromat)**: Create a scenario triggered by an Apify "Run Succeeded" webhook. Parse the resulting dataset and automatically append records to Google Sheets or Airtable.
- **Zapier**: Connect the Apify app, listen for dataset item creation, and send Slack notifications whenever a high-salary role is posted.
- **AWS S3 / Google Cloud Storage**: Use Apify Integrations to automatically sync every completed dataset to cloud storage buckets for enterprise data lakes.

***

### ❓ Frequently Asked Questions

**How does deep pagination work on CutShort?**
CutShort serves approximately 50 live positions per role. When `maxPages` is set to `0`, the scraper automatically traverses the configured role queries and fans out across complementary disciplines to fulfill requested `maxItems` counts seamlessly.

**Are salaries guaranteed to be present?**
CutShort strongly encourages compensation transparency; virtually all postings carry structured `salaryMin` and `salaryMax` bands in INR alongside the display string.

**What is the difference between listing summary and full detail mode?**
Listing summary mode (`includeJobDetails: false`) extracts all metadata present in the role feed (title, company, INR salary, experience range, skills, company stage) at very high throughput (~500 jobs in ~30s). Full detail mode (`includeJobDetails: true`) concurrently visits each job page to extract the complete HTML-sanitized description and deadline.

**Can I run scheduled sweeps for fresh postings?**
Yes. You can configure an Apify Schedule (e.g., daily at 08:00 UTC) to build an automated pipeline capturing new vacancies every morning without duplicates.

**Can I export data directly to Excel or CSV?**
Yes. From the Apify Dataset tab, you can download all extracted fields in CSV, Excel (XLSX), JSON, XML, or HTML table formats with a single click.

***

### 🔗 Related tech job scrapers

- [Dice Job Scraper](https://apify.com/haketa/dice-scraper) — United States tech and IT recruitment intelligence.
- [SimplyHired Jobs Scraper](https://apify.com/haketa/simplyhired-scraper) — Multi-industry nationwide US employment listings.
- [ZipRecruiter Jobs Scraper](https://apify.com/haketa/ziprecruiter-scraper) — Global employment listings and salary benchmarks.
- [IndiaMART Scraper](https://apify.com/haketa/indiamart-scraper) — B2B suppliers and business intelligence across India.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Multi-Role Deep Fan-Out Unlock**: Unlocked 1,000+ result extraction through automated discipline fan-out and configurable `maxPages` (0 = auto/unlimited).
- **Fast Prefill Optimization**: Streamlined default execution parameters ensuring sample test runs complete in under 15 seconds.
- **Resilient Empty Run Fallback**: Configured automated software engineering role selection when executing without explicit search parameters.
- **Strict Schema Hardening**: Standardized integer limits to minimum 0 and sanitized dataset schemas to views-only structure.

#### v1.1 (2026-10)

- Enhanced slug resolution supporting automatic hyphenated and de-hyphenated variant retries.
- Added structured experience range extraction (`experienceMin`, `experienceMax`).

#### v1.0 (2026-09)

- Initial production release supporting multi-role search, city filtering, and structured JSON/CSV exports.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/cutshort-scraper/changelog.md

# Actor input Schema

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

Roles or skills to search on CutShort (use the names CutShort uses, e.g. python, devops, backend-developer, product-manager, datascience). Browse cutshort.io/jobs for the full list.

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

Optional Indian city to filter by (e.g. bangalore, mumbai, remote). Applied to every role.

## `searchUrls` (type: `array`):

Optional CutShort role/search result URLs to scrape directly. Example: https://cutshort.io/jobs/python-jobs

## `includeJobDetails` (type: `boolean`):

Open each job to add the full description, posted date, application deadline and employment type. Slower; the listing already includes salary, skills, experience and company data.

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

Maximum search roles to process. Set to 0 for unlimited / automatic extraction governed by Maximum jobs.

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

Maximum number of job records to save across all roles. Set to 0 for unlimited.

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

How many pages to fetch in parallel. Recommended 4–8.

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

Apify Proxy is recommended for reliable access.

## Actor input object example

```json
{
  "searchQueries": [
    "python",
    "devops",
    "product manager"
  ],
  "location": "bangalore",
  "searchUrls": [
    "https://cutshort.io/jobs/python-jobs"
  ],
  "includeJobDetails": false,
  "maxPages": 0,
  "maxItems": 15,
  "maxConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "searchQueries": [
        "python"
    ],
    "includeJobDetails": false,
    "maxPages": 0,
    "maxItems": 15,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "searchQueries": ["python"],
    "includeJobDetails": False,
    "maxPages": 0,
    "maxItems": 15,
    "proxyConfiguration": { "useApifyProxy": True },
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchQueries": [
    "python"
  ],
  "includeJobDetails": false,
  "maxPages": 0,
  "maxItems": 15,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/cutshort-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/cutshort-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/YpBfUJDYHevAA07mS/builds/aF52aH4KshP8ntUvx/openapi.json