# Shine.com Jobs Scraper — 22 Fields, Monitor Mode, No Login (`themineworks/shine-jobs-scraper`) Actor

Scrape live Shine.com (Times Group) job listings: title, company, salary, experience band, location, employment type, skills and full description. Filter by keyword, location, experience, salary and employment type. No login, no browser. Use it as an MCP server in Claude, ChatGPT & AI agents.

- **URL**: https://apify.com/themineworks/shine-jobs-scraper.md
- **Developed by:** [The Mine Works](https://apify.com/themineworks) (community)
- **Categories:** Jobs, Business, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

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

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

# README

## Shine.com Jobs Scraper: Salary, Experience & Skills

Scrape live Shine.com (Times Group) job listings — title, company, salary, experience band, location, employment type and full description. Filter by keyword, location, experience, salary and employment type, exactly the way Shine's own site does. No login, no browser, pay per job. Use it as an MCP server in Claude, ChatGPT & AI agents.

> ⚡ Part of a 90+ scraper suite with thousands of runs · no login, no cookies, no ban risk.
>
> 💸 You are only charged for delivered results — empty searches, failed pages and duplicates are never billed.

### What it does

Shine.com is one of India's larger broad-market job boards (Times Group), covering IT, BPO,
banking, retail and manufacturing roles. Its search page is a Next.js app, but the client itself
calls a fully public, unauthenticated JSON endpoint to load and filter results — the same endpoint
this actor reads directly. No browser, no session cookies, no login wall, and (verified during
build) no anti-bot challenge of any kind.

That means every filter you see on shine.com — location, experience, salary band, employment type,
shift type, sort order — is a plain input field here, each mapped to Shine's own internal filter
IDs rather than a guess. You get one record per job: title, company, every listed location, a
normalised experience range, a normalised salary range (in ₹ lakhs/year, when published), employment
type, shift type, Shine's own skill/keyword tags, the description with HTML stripped, and a direct
apply URL.

### Input

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchKeywords` | array | yes | — | One or more keywords, e.g. `"python developer"`, `"data scientist"`. Each is searched separately and results are merged. |
| `location` | string | no | (all India) | City name, e.g. `"Bangalore"`. Common Indian cities resolve to Shine's own location filter; any other name falls back to Shine's own location search so nothing is silently dropped. |
| `experienceLevel` | select | no | Any | `< 1 Year`, `1 to 2 Years`, `3 to 5 Years`, `6 to 8 Years`, `9 to 10 Years`, `11 to 15 Years`, `> 15 Years` — Shine's own experience bands. |
| `salaryRange` | select | no | Any | `Up to 2 Lakh` through `> 25 Lakh` — Shine's own annual CTC bands. |
| `employmentType` | select | no | Any | `Regular`, `Contractual`, `Internship`, `Work from home`. |
| `shiftType` | select | no | Any | `Full time` or `Part time`. |
| `sortBy` | select | no | `relevance` | `relevance` (Shine's default ranking) or `freshness` (newest postings first — pairs well with Monitor mode). |
| `maxJobs` | integer | no | `5` | Maximum jobs to return across all keywords. Hard cap 1000. |
| `includeJobDescription` | boolean | no | `false` | Return the full job description; otherwise truncated to 500 characters. |
| `monitorMode` | boolean | no | `false` | Deliver only jobs not seen in a previous run with the same input — for scheduled daily/weekly monitoring. |
| `proxyConfiguration` | object | no | none | Optional. Shine's search endpoint is publicly reachable with no proxy at all; only enable this for very high-volume runs. |

#### Example input

```json
{
  "searchKeywords": ["python developer"],
  "location": "Bangalore",
  "experienceLevel": "3to5",
  "salaryRange": "6to8",
  "maxJobs": 25,
  "includeJobDescription": false
}
```

### Output

One record per job. Field list and example below are taken from a real run against the live
actor, not a mock-up.

| Field | Type | Example |
|---|---|---|
| `job_id` | string | `"19181937"` |
| `title` | string | `"Python Developer with ReactJS REST API AI 2Plus Yrs Chennai, Pune & Blore"` |
| `company` | string | `"WHITE HORSE MANPOWER CONSULTANCY (P) LTD"` |
| `locations` | array | `["Bangalore", "Chennai", "Pune"]` |
| `location` | string | `"Bangalore, Chennai, Pune"` |
| `experience_min_years` | number | `2` |
| `experience_max_years` | number | `7` |
| `experience_text` | string | `"2 to 7 Yrs"` |
| `salary_text` | string | `"Rs 4.0  - 6 Lakh/Yr"` |
| `salary_min_lakhs` | number | `4` |
| `salary_max_lakhs` | number | `6` |
| `employment_type` | string | `"regular"` |
| `shift_type` | string | `"full-time"` |
| `skills` | array | `["javascript", "python", "react developer", "reactjs developer", …]` |
| `description` | string | `"Job Description (JD) Hiring Python Developer with ReactJS & AI…"` |
| `apply_url` | string | `"https://www.shine.com/jobs/python-developer-with-reactjs-rest-api-ai-2plus-yrs-chennai-pune-blore/white-horse-manpower-consultancy-p-ltd/19181937"` |
| `recruiter_name` | string | `"Coders Brain Technology"` |
| `posted_date` | string | `"2026-06-30T18:30:05.000Z"` |
| `posted_days_ago` | number | `30` |
| `expiry_date` | string | `"2026-08-29T00:00:00.000Z"` |
| `early_applicant` | boolean | `false` |
| `scraped_at` | string | `"2026-07-31T18:18:20.597Z"` |

#### Example output

```json
{
  "job_id": "19307153",
  "title": "Python Developer with Rest api (banglore)",
  "company": "G-Jobs Hiring For Coders Brain Technology",
  "locations": ["Bangalore"],
  "location": "Bangalore",
  "experience_min_years": 6,
  "experience_max_years": 10,
  "experience_text": "6 to 10 Yrs",
  "salary_text": "[Salary Hidden]",
  "employment_type": "regular",
  "shift_type": "full-time",
  "skills": ["Python", "REST API", "Automation Testing", "DevOps", "Azure", "Pytest"],
  "description": "Experience: 6 +Years Location: Bangalore The minimum necessary qualification is a bachelors degree in a relevant Engineering field…",
  "apply_url": "https://www.shine.com/jobs/python-developer-with-rest-api-banglore/coders-brain-technology/19307153",
  "recruiter_name": "Coders Brain Technology",
  "posted_date": "2026-07-26T08:26:14.000Z",
  "posted_days_ago": 5,
  "expiry_date": "2026-09-24T08:26:12.000Z",
  "early_applicant": false,
  "scraped_at": "2026-07-31T18:18:20.704Z"
}
```

### Use cases

- **India hiring-demand tracking** — pull a keyword daily with Monitor mode on to see only newly posted roles, without re-paying for the whole feed each run.
- **Salary benchmarking** — `salary_min_lakhs`/`salary_max_lakhs` are numeric, so compensation-by-experience analysis is a groupby, not a text-parsing project.
- **Recruiter sourcing lists** — combine `experienceLevel` + `location` + `employmentType` to build a targeted candidate-outreach or client-lead list.
- **Remote/WFH tracking** — filter `employmentType` to `work-from-home` to isolate remote listings specifically, rather than guessing from free text.
- **Skills-demand research** — the `skills` array reflects Shine's own keyword tags per listing, so you can count technology demand without NLP over the description.
- **Feeding an AI agent or job-alert bot** — call this actor as an MCP tool so an agent can answer "what Python jobs pay 6-8 LPA in Bangalore right now" directly from live data.

### FAQ

#### Is this scraping HTML?

No. It calls the same public JSON endpoint (`/api/v2/search/simple/`) Shine's own web app calls to
load and filter results client-side — no browser, and it runs in a few seconds per keyword rather
than the tens of seconds a Playwright-based scraper needs.

#### Do I need a proxy?

No. The endpoint was verified reachable with no User-Agent, no cookies and no proxy at all.
`proxyConfiguration` is exposed for very high-volume users who want IP rotation, but leaving it
unset is the normal, supported way to run this actor.

#### Why is `salary_text` sometimes `"[Salary Hidden]"`?

Many Indian recruiters and consultancies choose not to publish a number on the listing itself.
When Shine hides it, this actor reports that faithfully rather than inventing a figure — the
numeric `salary_min_lakhs`/`salary_max_lakhs` fields are simply absent on those records.

#### How does location filtering work for cities you don't list?

Common Indian metros map to Shine's own internal location IDs for exact filtering. Any other city
name (a smaller town, for instance) falls back to Shine's own `<keyword>-jobs-in-<city>` search
convention, so no location input is ever silently ignored — it is simply matched the way Shine's
own site would match a manual search for that city.

#### Can I get only the newest postings?

Yes — set `sortBy` to `freshness`, and turn on `monitorMode` if you want the actor to remember
what it already delivered and charge you only for genuinely new listings on repeat/scheduled runs.

### Billing

Pay per event: one `job-scraped` event per delivered record, charged only **after** the record is
validated and stored. Empty results, failed pages and duplicates are never charged. Store-plan
discounts apply automatically for Apify Bronze/Silver/Gold+ users.

### Run on a schedule

In Apify Console: open this Actor → **Schedules** → **Add schedule** → pick a cadence (e.g. daily)
→ **Save**. Combined with `monitorMode: true`, each scheduled run delivers only jobs not seen in
the previous run, so you pay for new postings, not the whole feed every time.

### Use in Claude, ChatGPT & any MCP agent

This actor runs as an MCP server, so an AI agent can call it directly:

```
https://mcp.apify.com/?tools=themineworks/shine-jobs-scraper
```

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("themineworks/shine-jobs-scraper").call(run_input={
    "searchKeywords": ["python developer"],
    "location": "Bangalore",
    "maxJobs": 25,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

### Legal and compliance

This actor collects only publicly available information — the same data any visitor can see on
shine.com without logging in. It does not access private or authenticated areas, does not attempt
to bypass any paywall or login wall, and collects no personal data beyond what the source already
publishes openly. You are responsible for using the output in line with Shine.com's terms and with
the data protection law that applies to you.

MIT © [The Mine Works](https://apify.com/themineworks)

# Actor input Schema

## `searchKeywords` (type: `array`):

One or more job-search keywords, e.g. 'python developer', 'data scientist'. Each keyword is searched separately on Shine.com and results are merged.

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

City name, e.g. 'Bangalore', 'Mumbai', 'Pune'. Leave blank for all India. Common Indian cities are matched to Shine's internal location filter automatically; other names fall back to Shine's own location search.

## `experienceLevel` (type: `string`):

Years of experience band, as offered by Shine's own filter.

## `salaryRange` (type: `string`):

Annual CTC band, as offered by Shine's own filter.

## `employmentType` (type: `string`):

Employment type, as offered by Shine's own filter.

## `shiftType` (type: `string`):

Full-time or part-time, as offered by Shine's own filter.

## `sortBy` (type: `string`):

Relevance (Shine's default ranking) or Freshness (newest postings first — useful with Monitor mode).

## `maxJobs` (type: `integer`):

Maximum number of jobs to scrape across all keywords. Hard cap 1000.

## `includeJobDescription` (type: `boolean`):

If true, include the full job description text. If false, descriptions are truncated to 500 characters.

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

Run on a schedule and deliver ONLY results not seen in a previous run. You are charged per new result, not for the whole feed each time. Ideal for daily monitoring. Requires the same input across runs.

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

Apify proxy. Shine.com's job-search JSON endpoint is publicly accessible with no anti-bot challenge, so a proxy is optional — leave the default (Apify auto/datacenter) unless you are running very high volume.

## Actor input object example

```json
{
  "searchKeywords": [
    "python developer",
    "data scientist"
  ],
  "location": "Bangalore",
  "experienceLevel": "",
  "salaryRange": "",
  "employmentType": "",
  "shiftType": "",
  "sortBy": "relevance",
  "maxJobs": 5,
  "includeJobDescription": false,
  "monitorMode": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "searchKeywords": [
        "python developer"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("themineworks/shine-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 = {
    "searchKeywords": ["python developer"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("themineworks/shine-jobs-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 '{
  "searchKeywords": [
    "python developer"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call themineworks/shine-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/lIoxGW5MMoPcisFMV/builds/acdGGDbF32V6zhuhO/openapi.json