# Monster Jobs Scraper (`khadinakbar/monster-jobs-scraper`) Actor

Scrape Monster.com jobs with salary, company, location, posted date, and apply URLs. HTTP-only, no login, MCP-ready. Charged $0.005 per returned job.

- **URL**: https://apify.com/khadinakbar/monster-jobs-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Jobs, MCP servers, Automation
- **Stats:** 10 total users, 3 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 job founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are 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

## Monster Jobs Scraper

Monster Jobs Scraper collects public Monster.com job listings and returns one record per job. It accepts a keyword search with an optional location, or pasted Monster search and job-detail URLs. Each record can include title, company, company URL, location details, salary text and parsed salary fields, employment type, posted date, description, job URL, apply URL, source, and scrape timestamp. This Apify Actor is HTTP-only, works without login, and is usable through Apify MCP.

### Best fit and connected workflows

Use this Actor when your workflow starts with Monster.com job discovery and you need structured records for recruiting, salary research, talent mapping, or downstream automation.

Common workflow connections include:

- Recruiting pipelines that collect live Monster listings into a dataset for review or enrichment.
- Job-board aggregation workflows that combine Monster records with data from other boards.
- Market research and salary analysis processes that compare title, location, and compensation fields.
- Agent workflows through Apify MCP that need one tool for Monster search or pasted Monster URLs.

When your sourcing brief points to another board or region, these verified related Actors fit the same downstream pattern with their own source coverage:

- Use [APEC Jobs Scraper](https://apify.com/khadinakbar/apec-jobs-scraper) when your search is centered on APEC-focused sourcing and the workflow needs that board's geography.
- Use [Ashby Jobs Scraper](https://apify.com/khadinakbar/ashby-jobs-scraper) when roles are published on Ashby-powered company pages and your pipeline follows those employer-hosted listings.
- Use [Bayt Jobs Data Scraper for MENA Listings](https://apify.com/khadinakbar/bayt-jobs-scraper) when your workflow targets Bayt.com sourcing in MENA markets and the board coverage matches that brief.

### Practical scenario

Maya, a recruiter, starts with the search query `registered nurse` and the location `Texas`. The Actor returns records with `title`, `company`, `location`, `salaryText`, `employmentType`, `postedAt`, and `applyUrl`. Maya reviews the salary range and remote flag, then opens the `applyUrl` for the roles that match her hiring band and geography.

### Input

Use `searchQuery` and `location` for keyword-based discovery, or provide Monster URLs in `startUrls`. When `startUrls` is set, the search query and location fields are ignored.

| Field | Type | Default | Notes |
|---|---:|---|---|
| `searchQuery` | string | `software engineer` | Monster keyword or role name. |
| `location` | string | `""` | City, state, area, or `Remote`. |
| `maxResults` | integer | `50` | Maximum number of jobs returned in one run, from 1 to 1000. |
| `enrichDetails` | boolean | `true` | Fetches each job's Monster detail page for the full description and extra fields. |
| `startUrls` | array | empty | Monster search URLs or Monster job-detail URLs. |
| `maxConcurrency` | integer | `8` | Parallel request count for run tuning, from 1 to 20. |
| `debugDumpHtml` | boolean | `false` | Saves raw HTML for troubleshooting empty pages under `DEBUG-` keys. |
| `proxyConfiguration` | object | residential by default | Proxy selection for fetching Monster pages. Residential proxies are enabled by default. |

#### Focused input example

```json
{
  "searchQuery": "software engineer",
  "location": "New York, NY",
  "maxResults": 25,
  "enrichDetails": true,
  "startUrls": [
    {
      "url": "https://www.monster.com/jobs/search?q=software%20engineer&where=New%20York%2C%20NY"
    }
  ],
  "maxConcurrency": 8,
  "debugDumpHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Output

Results are written to the default dataset, one record per Monster job. The key-value store also contains a `RUN_SUMMARY` record with run-level totals, warnings, cost counters, and input context.

| Field | Type | Description |
|---|---:|---|
| `jobId` | string or null | Monster job identifier parsed from page data or the job URL. |
| `title` | string or null | Job title shown on Monster. |
| `company` | string or null | Hiring company or employer name. |
| `companyUrl` | string or null | Company page or profile link when available. |
| `location` | string or null | Human-readable location text. |
| `city` | string or null | Parsed city when Monster exposes structured location. |
| `state` | string or null | Parsed state or region when available. |
| `country` | string or null | Country code or name when available. |
| `isRemote` | boolean or null | Remote indicator from the listing. |
| `salaryText` | string or null | Raw salary text as shown on Monster. |
| `salaryMin` | number or null | Parsed lower salary bound when available. |
| `salaryMax` | number or null | Parsed upper salary bound when available. |
| `salaryCurrency` | string or null | Salary currency code when available. |
| `salaryPeriod` | string or null | Pay period such as year, hour, or month. |
| `employmentType` | string or null | Employment type such as Full-Time or Contract. |
| `postedAt` | string or null | Posting date in ISO 8601 when parseable. |
| `postedAtText` | string or null | Raw posting recency text. |
| `description` | string or null | Plain-text job description. |
| `jobUrl` | string or null | Canonical Monster.com URL for the job posting. |
| `applyUrl` | string or null | Direct apply URL when Monster exposes one, otherwise the job URL. |
| `source` | string or null | Always `monster.com`. |
| `scrapedAt` | string or null | ISO 8601 timestamp when the record was scraped. |

#### Illustrative output record

```json
{
  "jobId": "a1b2c3d4-0000-0000-0000-000000000000",
  "title": "Senior Software Engineer",
  "company": "Acme Corp",
  "companyUrl": "https://www.monster.com/company/acme-corp",
  "location": "New York, NY",
  "city": "New York",
  "state": "NY",
  "country": "US",
  "isRemote": false,
  "salaryText": "$120,000 - $150,000 per year",
  "salaryMin": 120000,
  "salaryMax": 150000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "employmentType": "Full-Time",
  "postedAt": "2026-06-10T00:00:00.000Z",
  "postedAtText": "3 days ago",
  "description": "We are hiring a senior engineer to ...",
  "jobUrl": "https://www.monster.com/job-openings/senior-software-engineer-new-york-ny--a1b2c3d4",
  "applyUrl": "https://www.monster.com/job-openings/senior-software-engineer-new-york-ny--a1b2c3d4/apply",
  "source": "monster.com",
  "scrapedAt": "2026-06-14T12:00:00.000Z"
}
```

### How it works

The Actor reads Monster.com search and job pages over HTTP and extracts structured job data from page payloads. It can start from a keyword search or from pasted Monster URLs. When detail enrichment is enabled, the Actor fetches each job detail page to add the full description and extra fields. It returns records to the dataset and a run summary to the key-value store.

### Pricing

This Actor uses Apify pay per event pricing plus Apify platform usage. The primary billed event is `Job found`, which is charged per returned job. When `Fetch job detail pages` is enabled, enriched jobs also add the `Job detail enriched` event. There is also a small `Actor start` event.

The Actor is charged $0.005 per returned job, and the event-based model means your total scales with the number of records the Actor returns. For example, a run that returns fifty jobs bills fifty `Job found` events, and when detail enrichment is enabled it also bills the matching enrichment events for those records.

For current pricing and any usage-based platform charges, check the live Pricing tab on the Actor page in Apify Console.

### Use with AI agents (MCP)

This Actor is exposed through Apify MCP as a tool for Monster job search and Monster job-detail retrieval. The exact Actor identity is `khadinakbar/monster-jobs-scraper`.

Tool description: retrieve structured Monster.com job listings from keyword searches or Monster URLs, with optional detail-page enrichment for fuller records.

> Search Monster.com for "data analyst" roles in Chicago, return up to 10 records, and include salary, posted date, and apply URL so I can shortlist openings for review.

Output interpretation:

- `title`, `company`, and `location` identify each listing.
- `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, and `salaryPeriod` support compensation review.
- `postedAt` and `postedAtText` help with recency checks.
- `jobUrl` and `applyUrl` provide source and action links.
- `description` expands when `Fetch job detail pages` is enabled.

Provenance and scope:

- Records come from Monster.com search or Monster job-detail pages.
- `source` is always `monster.com`.
- `scrapedAt` shows when each record was collected.
- `startUrls` takes precedence over `searchQuery` and `location` when both are supplied.

Pagination and cost guidance:

- Use `maxResults` to cap returned jobs and billed `Job found` events.
- `maxConcurrency` adjusts request parallelism.
- Keep `enrichDetails` on when your workflow needs fuller records; turn it off when listing-level fields are enough for the task.

### Apify API example

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const actor = client.actor('khadinakbar/monster-jobs-scraper');

const run = await actor.call({
  searchQuery: 'software engineer',
  location: 'New York, NY',
  maxResults: 5,
  enrichDetails: true,
  proxyConfiguration: {
    useApifyProxy: true,
    apifyProxyGroups: ['RESIDENTIAL'],
  },
});

const datasetId = run.defaultDatasetId;
const { items } = await client.dataset(datasetId).listItems({ clean: true });

console.log(items);
```

### Best results and outcome guidance

- Start with a role or keyword that matches how Monster titles listings, such as `registered nurse`, `warehouse associate`, or `software engineer`.
- Add `location` when your workflow is geography-specific.
- Use `startUrls` when you already have Monster search results or a specific job page to process.
- Keep `enrichDetails` enabled when salary, description, or apply-link review is part of the workflow.
- Use the default residential proxy setup for runs that need consistent access to Monster pages.
- When you want a quick list for screening, keep `maxResults` aligned with the number of jobs your team will review in one pass.

### Design note

I found that the output contract separates `results` in the default dataset from `summary` in the key-value store, which makes job records and execution metadata easy to consume independently.

### FAQ

**When should I use `searchQuery` instead of `startUrls`?**\
Use `searchQuery` for fresh Monster discovery by role. Use `startUrls` when you already have a Monster search page or job page and want to scrape those URLs directly.

**What fields are most useful for hiring workflows?**\
`title`, `company`, `location`, `salaryText`, `employmentType`, `postedAt`, and `applyUrl` are the core fields for shortlist review.

**How can I get fuller descriptions?**\
Set `enrichDetails` to `true`. The Actor then fetches the Monster detail page for each job and adds the richer `description` field.

**Which inputs work well for location targeting?**\
`location` accepts a city, state, area, or `Remote`, such as `New York, NY`, `Texas`, or `Remote`.

**When does the Bayt related Actor fit a workflow?**\
Use [Bayt Jobs Data Scraper for MENA Listings](https://apify.com/khadinakbar/bayt-jobs-scraper) when the sourcing brief shifts to Bayt.com and MENA job coverage, while keeping the same downstream dataset review pattern.

**How do the related Actors fit adjacent workflows?**\
Use the APEC and Ashby Actors when your sourcing workflow shifts to those boards or their covered regions, while keeping the same downstream dataset review pattern.

### Responsible use

Use this Actor for publicly available Monster.com job information and handle the resulting data in line with applicable laws, data-protection requirements, and Monster's terms. Keep access patterns aligned with the source site, and review any downstream processing before sharing or storing personal data.

# Actor input Schema

## `searchQuery` (type: `string`):

Use this when you want Monster.com jobs for a role or keyword. Enter plain text such as 'software engineer' or 'registered nurse'. Defaults to 'software engineer'. This is not a Monster URL; paste URLs into Start URLs instead.

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

Use this to limit jobs to a city, state, or area. Enter text such as 'New York, NY', 'Texas', or 'Remote'. Defaults to blank, which returns jobs across the United States. This is not a country code.

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

Use this to cap the number of Monster jobs returned and billed in one run. Accepts 1 to 1000; the default is 50. The actor stops before charging past this limit. This is not a page count.

## `enrichDetails` (type: `boolean`):

Use this to fetch each job's full description and extra fields from its Monster detail page. When true, results are richer but each enriched job adds a small detail charge. Defaults to true. When false, only listing-level fields are returned.

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

Use this when you already have Monster search or job-detail URLs. Accepts URLs like https://www.monster.com/jobs/search?q=nurse\&where=Texas or https://www.monster.com/job-openings/... . When set, Search query and Location are ignored. This is not for LinkedIn, Indeed, or Glassdoor URLs.

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

Use this to tune how many requests run in parallel. Accepts 1 to 20; the default is 8. Lower it if you see blocks; raise it for faster large runs. This does not change how many jobs are returned.

## `debugDumpHtml` (type: `boolean`):

Use this only when troubleshooting empty results. When true, raw HTML of blocked or empty pages is saved to the key-value store under DEBUG- keys. Defaults to false. This adds storage but no extra billing events.

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

Use this to choose proxies. Monster.com is protected by DataDome, so Apify residential proxies are strongly recommended and enabled by default. Datacenter proxies will usually be blocked. This is required for reliable results.

## Actor input object example

```json
{
  "searchQuery": "software engineer",
  "location": "New York, NY",
  "maxResults": 1,
  "enrichDetails": true,
  "maxConcurrency": 1,
  "debugDumpHtml": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

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

Structured Monster.com job records with title, company, location, salary, posted date, description, and apply URL.

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

Run-level totals, warnings, cost counters, and input context.

## `output` (type: `string`):

Stable terminal outcome and accounting fields for API clients.

# 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 = {
    "searchQuery": "software engineer",
    "location": "New York, NY",
    "maxResults": 1,
    "enrichDetails": false,
    "maxConcurrency": 1,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/monster-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 = {
    "searchQuery": "software engineer",
    "location": "New York, NY",
    "maxResults": 1,
    "enrichDetails": False,
    "maxConcurrency": 1,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/monster-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 '{
  "searchQuery": "software engineer",
  "location": "New York, NY",
  "maxResults": 1,
  "enrichDetails": false,
  "maxConcurrency": 1,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call khadinakbar/monster-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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