# Monster Jobs Scraper - Jobs, Salaries, Companies & Contacts (`abotapi/monster-com`) Actor

Scrape Monster.com job listings from search and direct job URLs. Extract full descriptions, salaries, companies, locations, geo data, application details, classifications, compliance fields, and public email addresses.

- **URL**: https://apify.com/abotapi/monster-com.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 job records

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

## Monster Scraper: Job Listings, Salaries and Employer Details

Monster Scraper turns Monster job search into structured data. Run a keyword and location search with filters for recency, employment type and remote work, or paste Monster search and direct job-opening links and let the actor page through them. Each record carries title, employer, salary, location and geo, dates, employment type, application links, the full HTML and plain-text description, optional public emails found in the listing, and the complete source object. Export to JSON, CSV or Excel, or pull results straight into your app through the API.

### Why This Scraper?

- **Two ways in.** Run a structured keyword and location search, or paste Monster search and direct job-opening links; the same recency, employment type, company and sort filters narrow a pasted search link just like a structured search.
- **Server-side filters.** On searches, recency, employment type and remote-only are applied by Monster itself, so filtered-out jobs are never fetched or charged.
- **Full description, twice over.** The complete HTML description and a stripped plain-text version are both included, so you don't have to parse HTML yourself.
- **Compensation, flattened, with optional emails.** Salary range, currency, employment type, industry and Monster's own normalized title and skill enrichment come out as plain top-level fields, plus public emails from the listing when enabled.
- **Nothing thrown away.** The complete source job object rides along in `raw`, so a field this actor doesn't flatten today is still in the record.
- **Incremental mode.** Schedule the same search and receive only NEW, UPDATED and REAPPEARED jobs, with EXPIRED rows for jobs that disappeared.
- **Cost stays predictable.** Max items and Max pages cap how far a run goes before it grows unexpectedly.

### Use Cases

- **Recruiters and staffing agencies:** track which employers are actively hiring, and for which roles and salary bands.
- **Job board and aggregator sites:** mirror Monster listings into your own search product with structured, exportable fields.
- **Labor market researchers:** sample salary, employment-type and location data across cities and industries.
- **Sales and business development teams:** build outreach lists from companies posting new roles.
- **Compliance and market-rate teams:** monitor posted salary ranges by employment type and region.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `jobId` | `"11111111-2222-3333-4444-555555555555"` |
| `seoJobId` | `"senior-backend-engineer-austin-tx--11111111-2222-3333-4444-555555555555"` |
| `title` | `"Senior Backend Engineer"` |
| `companyName` | `"Cascade Analytics Inc."` |
| `companyLogo` | `https://media.example.com/logo.png` |
| `location` | `"Austin, TX, US"` |
| `latitude` / `longitude` | `30.2672` / `-97.7431` |
| `datePosted` | `"2026-01-01T00:00:00.000Z"` |
| `dateRecency` | `"3 days ago"` |
| `validThrough` | `"2026-03-01T00:00:00.000Z"` |
| `status` | `"ACTIVE"` |
| `employmentTypesText` | `"FULL_TIME"` |
| `salaryMin` / `salaryMax` | `95000` / `130000` |
| `salaryCurrency` | `"USD"` |
| `remote` | `true` |
| `applyUrl` | `https://www.monster.com/job-openings/sample-role` |
| `jobUrl` | `https://www.monster.com/job-openings/sample-role--11111111-2222-3333-4444-555555555555` |
| `descriptionText` | `"Sample job description text."` |
| `contactEmail` | `"jobs@example.com"` |
| `skills` | Object with `extractions` and `scoredExtractions` (each entry has a `name` such as `KBSkills` and a list of `{id, value, score}` skills), or empty when Monster's own enrichment provides none |
| `raw` | the complete source job object |

When no live job matches, the dataset instead gets one diagnostic row (`error: true`, `code: "ZERO_RESULTS"`) rather than nothing at all. When every connection attempt to Monster is refused, the run fails with the message "Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search. Please try again later."

### How to Use

1. Pick a **mode**: `search` (structured keyword and location filters) or `url` (paste Monster search or job-opening links).
2. In search mode, fill in Keywords and Location. In url mode, paste one or more Monster links. The shared filters (recency, employment type, company, sort) narrow every search, whether structured or pasted as a link; a direct job-opening link is narrowed by Company only.
   With the Start URLs field left unedited, url mode scrapes one example of each supported shape (search with page, filtered search, SEO keyword and keyword+location pages, and a direct job-opening link). Search URLs honour `page` (start page) and `rad` (radius in miles); `where=remote` selects remote jobs. A pasted link without a location (for example a keyword-only page) searches the whole United States; Location and Workplace apply to search mode only. Keywords and Radius also come only from the link (a link without `rad` uses 30 miles, and a link without `q` has no keyword filter).
3. Set **Max items** and **Max pages** to control how far each source pages and how many rows you pay for.
4. Start the run, then download the dataset as JSON, CSV or Excel, or read it through the API.

**Basic keyword search:**

```json
{
  "mode": "search",
  "query": "product manager",
  "location": "Chicago, IL",
  "maxItems": 20
}
```

**Remote jobs, posted this week, newest first:**

```json
{
  "mode": "search",
  "query": "data engineer",
  "location": "United States",
  "workplace": "remote",
  "datePosted": "week",
  "sortBy": "date",
  "maxItems": 50
}
```

**Paste a Monster search link:**

```json
{
  "mode": "url",
  "startUrls": [
    "https://www.monster.com/jobs/search?q=nurse&where=Dallas%2C+TX"
  ],
  "maxPages": 3,
  "maxItems": 60
}
```

**Paste a direct job-opening link, filtered to one employer:**

```json
{
  "mode": "url",
  "startUrls": [
    "https://www.monster.com/job-openings/sample-role--11111111-2222-3333-4444-555555555555"
  ],
  "company": "cascade"
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/monster-com").call(run_input={"mode": "search", "query": "data engineer", "location": "Austin, TX"})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["companyName"], job["salaryMin"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/monster-com').call({ mode: 'search', query: 'data engineer', location: 'Austin, TX' });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the **Integrations** tab.

#### How Max items and Max pages interact

**Max items** is a ceiling shared across every search and URL in one run, not a per-source guarantee: once it's reached, no further source is started. **Max pages** (default `2`) limits how many pages each individual source walks before moving on; set it to `0` to let a source page until Max items is reached or the site runs out of results. Within one run, each source stops as soon as one of its own pages returns no job the run hasn't already collected, so raising Max pages only helps if there are genuinely more unseen jobs left to find.

**Known limitation when pasted search links overlap.** The "no new job on this page" check compares against every job collected so far in the whole run, not just the current link's own jobs. So if a later link's page is made up entirely of jobs an earlier link already returned, that later link stops right there, even on its very first page, and its deeper pages are never requested. A page with even one job the run hasn't seen yet does not trigger this. Example, with Max items set high enough to reach both links: link A (nurse jobs in Dallas) returns jobs 1 to 20. Link B (registered nurse jobs in Dallas) would serve jobs 1 to 20 again on page 1 and jobs 21 to 40 on page 2. Page 1 of link B holds only jobs link A already returned, so link B stops on page 1 and jobs 21 to 40 are never collected, even with Max pages set to `0`. Raising Max pages does not help, because the stop happens before any page limit is reached. **Workaround:** when your links are likely to share results (the same keyword in nearby places, or similar keywords in one place), run each link as its own run, for example one saved task per link, for complete results.

### Send results into your apps (MCP connectors)

Optionally pipe a condensed summary of each saved job into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step after the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable summary of each job (title plus key fields as plain text), not the full JSON. The complete record always stays in the Apify dataset. Incremental rows that are unchanged (even when Also return unchanged jobs is on) or suppressed are not sent.

1. Authorize a connector once under **Apify > Settings > Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. If the picker is empty, you have not authorized a connector yet.
3. For **Notion**, also set the Notion parent page field to the page where items should be created.

The connection goes through Apify's MCP proxy, so this actor never sees your third-party credentials. The `maxNotifyListings` field caps how many items are sent to each connector per run. Leave `mcpConnectors` empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` (structured filters) or `url` (paste Monster links). |
| `query` | string | `software engineer` | Job title, skill, or keyword (search mode). |
| `location` | string | `New York, NY` | City, state, ZIP code, or country (search mode). |
| `radius` | integer | `30` | Search radius in miles around Location, 1 to 100 (search mode). |
| `workplace` | string | `all` | `all` workplaces or `remote` jobs only. |
| `startUrls` | array | sample URL | Monster search result URLs or direct job-opening URLs (url mode). |
| `datePosted` | string | `all` | Limit results by posting recency. Applies to structured searches and pasted search links (a link's own recency setting wins), not to direct job-opening links. |
| `employmentType` | string | `all` | Limit results to one employment type. Applies to structured searches and pasted search links, not to direct job-opening links. |
| `company` | string | empty | Case-insensitive employer name filter. Applies in both modes, including a single pasted job link. |
| `sortBy` | string | `relevance` | Sort by relevance or newest posting date. Applies to structured searches and pasted search links (a link's own sort setting wins). |
| `enrichEmails` | boolean | `true` | Extract public email addresses from the returned job content. |
| `maxItems` | integer | `20` | Maximum matching rows to save, shared across every source in the run. |
| `maxPages` | integer | `0` | Pages walked per source before moving on; `0` means no page limit (the run still stops at Max items, when results end, or when a page repeats). |
| `scrapeAllPages` | boolean | `false` | Ignore Max pages and walk every result page, still bounded by Max items. |
| `startPage` | integer | `1` | First result page for structured searches (pasted search links carry their own page). |
| `pageSize` | integer | `20` | Jobs requested per page, 1 to 50. |
| `address` | string | empty | Alias of `location`; wins when both are set. |
| `postedWithinDays` | string | `any` | `any`, `1`, `3`, `7`, `14` or `30` days; overrides `datePosted` when not `any`. Three days uses the last-week window trimmed to three days. |
| `country` | string | `US` | Monster serves the United States only. |
| `proxy` | object | Apify Residential | Connection settings; the actor also manages its own connection. |
| `incrementalMode` | boolean | `false` | Return only NEW, UPDATED and REAPPEARED jobs since the last run of the same search. |
| `stateKey` | string | empty | Optional name of the remembered baseline. |
| `emitUnchanged` | boolean | `false` | Incremental mode: also write UNCHANGED jobs (never charged). |
| `emitExpired` | boolean | `true` | Incremental mode: write EXPIRED rows for jobs no longer listed after a complete walk (never charged). |
| `resumeFromRunId` | string | empty | Skip jobs an earlier run already saved. |
| `mcpConnectors` | array | empty | Optionally send results into your apps via Model Context Protocol connectors. |
| `notionParentPageUrl` | string | none | Notion page under which exported items are created (Notion connector only). |
| `maxNotifyListings` | integer | `50` | Maximum items sent to each connector per run; the dataset is unaffected. |
| `ignoreFieldsForChanges` | array | empty | Incremental mode: extra fields that must not trigger UPDATED. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "jobId": "11111111-2222-3333-4444-555555555555",
  "seoJobId": "senior-backend-engineer-austin-tx--11111111-2222-3333-4444-555555555555",
  "title": "Senior Backend Engineer",
  "companyName": "Cascade Analytics Inc.",
  "location": "Austin, TX, US",
  "latitude": 30.2672,
  "longitude": -97.7431,
  "datePosted": "2026-01-01T00:00:00.000Z",
  "dateRecency": "3 days ago",
  "status": "ACTIVE",
  "employmentTypes": ["FULL_TIME"],
  "employmentTypesText": "FULL_TIME",
  "salaryMin": 95000,
  "salaryMax": 130000,
  "salaryCurrency": "USD",
  "remote": true,
  "applyUrl": "https://www.monster.com/job-openings/sample-role",
  "jobUrl": "https://www.monster.com/job-openings/sample-role--11111111-2222-3333-4444-555555555555",
  "descriptionText": "Sample job description text.",
  "contactEmail": "jobs@example.com",
  "raw": {},
  "scrapedAt": "2026-01-01T00:00:00.000Z"
}
```

#### Dataset views

The dataset ships with four tabs in the Console: **Jobs** (overview), **Salaries** (salary range, currency, unit and normalized salary), **Employers & contacts** (company, logo, contact emails, apply link) and **Locations** (city, region, postal code, country, coordinates). All views read the same records; the fields are typed and nullable, and `raw` still carries the complete source object.

### Plan Requirement

Monster sits behind a bot-protection interstitial. In our measurements plain datacenter connections were refused with an HTTP 403 on every search, filter, pagination, job-opening and home URL, so a datacenter proxy alone is not enough. The actor serves requests through its own managed connection and refreshes it when a request is refused, so the proxy group you pick under Connection is your own choice and cost and does not change which connection reads Monster. If every attempt is refused the run fails with a clear message, so retry later rather than raising Max items.

### FAQ

#### How much does it cost?

Billing uses two events: `apify-actor-start` is charged once per run, and `job-result` is charged once per saved job record. The diagnostic `ZERO_RESULTS` row, and in incremental mode UNCHANGED and EXPIRED rows, are never charged. The **Pricing** tab shows current rates. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape Monster?

This actor collects only publicly available job listings. You are responsible for how you use the data: follow Monster's terms and the laws that apply to you, and get legal advice before any commercial redistribution. Employer content such as logos and company descriptions may carry their own rights.

#### Can I schedule it to catch new postings?

Yes. Schedule the actor from the **Schedules** tab and switch on **Only report changes since the last run**. The actor remembers the jobs of the same search and writes only NEW, UPDATED and REAPPEARED jobs, each with `changeType`, `changedFields`, `firstSeenAt` and `lastSeenAt`. Unchanged jobs are skipped and not charged; with **Also return unchanged jobs** they are written as UNCHANGED, still not charged. Each row also carries the full `apply`, `jobPosting` and `brandingExt` blocks plus flattened `companyBannerUrl` and `companyPhotos`. Relative age labels (`dateRecency`, `formattedDate`), `scrapedAt` and `raw` never count as a change, while `datePosted` and `validThrough` do; add more with **Ignore fields when detecting changes**. With **Report jobs that are no longer listed**, baseline jobs missing from a run that walked the whole search are written as EXPIRED (not charged). A run capped by Max items or Max pages, or using direct job links, cannot prove a complete walk and reports no EXPIRED jobs. The baseline is keyed by your search settings, or by **State name** if set.

#### Why did my run return fewer jobs than Max items?

Max items is a ceiling shared across every search and URL in the run, not a per-source guarantee. A source stops early once its current page returns no job it hasn't already collected this run, once Max pages is reached, or once the site has no more results, whichever comes first. With several pasted links in one run, that first rule counts jobs collected by any earlier link, so a link whose first page repeats another link's jobs can stop before reaching its own new jobs; run overlapping links as separate runs for complete results (see **Known limitation when pasted search links overlap** above). Fewer live jobs can also simply mean fewer matches exist for your keywords, location, and filters.

#### Why does a single pasted job link sometimes return no job?

A direct job-opening link is filtered by Company only; Date posted, Employment type and Sort apply to searches and do not remove a directly linked job. If Company is set and that job's employer name doesn't contain the text you entered, the job is skipped, and the run saves only the `ZERO_RESULTS` diagnostic row described below.

#### Why did my run finish with one row, or fail?

If the connection works but nothing matches, the actor saves one diagnostic row (`code: "ZERO_RESULTS"`) suggesting broader keywords, a wider location, fewer filters or a different Proxy configuration. If every connection attempt to Monster is refused and nothing was saved, the run fails with "Could not load any results page (the requests failed), so nothing was collected. This is a connection problem, not an empty search. Please try again later." A run also fails outright when none of the pasted links are usable Monster search or job URLs.

#### Can I use it with AI agents or MCP?

Yes. Call it through the Apify API or SDKs like any other actor, and wire its dataset into an agent or automation platform through Apify's integrations.

### 🔗 Want more jobs data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>💼 <a href="https://apify.com/abotapi/irishjobs-ie"><b>IrishJobs.ie Scraper</b></a><br>Scrape job listings from IrishJobs.ie by keyword, location, job type, salary, recency, or...</td><td>💼 <a href="https://apify.com/abotapi/ziprecruiter-com-scraper"><b>ZipRecruiter Scraper</b></a><br>Scrape ZipRecruiter jobs with titles, companies, salaries, locations, benefits, apply...</td></tr>
<tr><td>💼 <a href="https://apify.com/abotapi/jobstreet-scraper"><b>JobStreet Scraper</b></a><br>Scrape JobStreet listings across Malaysia, Singapore, Indonesia, and the Philippines...</td><td>💼 <a href="https://apify.com/abotapi/seek-scraper"><b>SEEK Jobs Scraper</b></a><br>Scrape SEEK.com.au and SEEK.co.nz jobs by keyword, location, or filters. Extract full...</td></tr>
<tr><td>💼 <a href="https://apify.com/abotapi/dice-com-scraper"><b>Dice.com Scraper</b></a><br>Scrape tech job listings from Dice.com by keyword, filters, or URL. Extract job titles...</td><td>💼 <a href="https://apify.com/abotapi/remoteok-com-scraper"><b>RemoteOK Jobs Scraper</b></a><br>Scrape RemoteOK jobs by keyword or job URL. Extract title, company, location, remote...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/monster-com/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com>.
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

Choose structured search mode or URL mode.

## `query` (type: `string`):

Job title, skill, or keyword.

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

City, state, ZIP code, or country.

## `address` (type: `string`):

Alias of Location. When both are set, Address wins.

## `radius` (type: `integer`):

Search radius around the selected location.

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

Return all workplaces or remote jobs only.

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

Monster search URLs (/jobs/search?q=\&where=\&page=\&rad=, /jobs/q-<keyword>-jobs\[-l-<location>]) or direct /job-openings/<slug>-<id> links. Left unedited, url mode scrapes one example of each shape.

## `datePosted` (type: `string`):

Limit results by posting recency.

## `postedWithinDays` (type: `string`):

Alias of Date posted by day count. Overrides Date posted when not 'Any'. 3 days uses the last-week window trimmed to 3 days.

## `country` (type: `string`):

Monster serves the United States only.

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

Limit results to one employment type.

## `company` (type: `string`):

Optional case-insensitive employer filter.

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

Sort results by relevance or newest posting date.

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

Extract email addresses present in the returned job description and employer metadata.

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

Maximum matching rows to save. Fewer may be returned when fewer live jobs match.

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

Pages walked per source. 0 (default) means no page limit: the run still stops at Max items, when results end, or when a page repeats the previous one. Set a number to stop earlier.

## `scrapeAllPages` (type: `boolean`):

Ignore Max pages and page through every result page, still bounded by Max items.

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

First result page to fetch in search mode (pasted search URLs carry their own page).

## `pageSize` (type: `integer`):

Jobs requested per page (1-50).

## `proxy` (type: `object`):

Choose the Apify Proxy group used for requests. The actor also handles its own connection routing automatically, so the group you pick is your cost and choice; Residential is pre-selected, and you can switch group or country if you prefer.

## `incrementalMode` (type: `boolean`):

Remember the jobs from earlier runs of the same search and return only what changed: NEW, UPDATED (title, company, location, salary, description, posting or expiry date and other listing content changed) or REAPPEARED jobs. Relative age labels (such as '2 days ago'), the scrape time and the raw source copy never count as a change. Jobs that are unchanged are skipped and not charged.

## `stateKey` (type: `string`):

Name that identifies the remembered baseline. Leave empty to derive it from the search settings, so each distinct search keeps its own baseline.

## `emitUnchanged` (type: `boolean`):

Incremental mode only. Also write unchanged jobs to the dataset, marked UNCHANGED. They are never charged.

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

Incremental mode only. Write an EXPIRED row for baseline jobs missing from a run that walked the whole search. Skipped when the run was capped by Max items or Max pages, started mid-way, or used direct job links. EXPIRED rows are never charged.

## `resumeFromRunId` (type: `string`):

Run ID of an earlier interrupted run of this actor. Jobs it already saved are skipped. A resumed run never reports EXPIRED jobs.

## `ignoreFieldsForChanges` (type: `array`):

Extra output field names (dotted paths allowed for nested fields, for example enrichments.skills) that must not trigger UPDATED. Always ignored: scrapedAt, raw, dateRecency, formattedDate. Posting and expiry dates are compared.

## `mcpConnectors` (type: `array`):

Optionally send the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize a connector once under Apify → Settings → Integrations, then select it here. The connector receives a condensed, human-readable summary per item (title + key fields), not the full JSON — the complete record stays in the dataset. Leave empty to skip. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL (or id) of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "query": "software engineer",
  "location": "New York, NY",
  "radius": 30,
  "workplace": "all",
  "startUrls": [
    "https://www.monster.com/jobs/search?q=software+engineer&where=New+York%2C+NY&page=1",
    "https://www.monster.com/jobs/search?q=nurse&where=Texas&page=2",
    "https://www.monster.com/jobs/search?q=nurse&where=remote&rad=20",
    "https://www.monster.com/jobs/q-software-engineer-jobs-l-new-york-ny",
    "https://www.monster.com/jobs/q-nurse-jobs",
    "https://www.monster.com/job-openings/outpatient-registered-nurse-rn-midland-tx--5ca46a5f-bcfd-479d-a338-0eacf53af779"
  ],
  "datePosted": "all",
  "postedWithinDays": "any",
  "country": "US",
  "employmentType": "all",
  "sortBy": "relevance",
  "enrichEmails": true,
  "maxItems": 20,
  "maxPages": 0,
  "scrapeAllPages": false,
  "startPage": 1,
  "pageSize": 20,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": true,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `salaries` (type: `string`):

No description

## `employers` (type: `string`):

No description

## `locations` (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 = {
    "mode": "search",
    "startUrls": [
        "https://www.monster.com/jobs/search?q=software+engineer&where=New+York%2C+NY&page=1",
        "https://www.monster.com/jobs/search?q=nurse&where=Texas&page=2",
        "https://www.monster.com/jobs/search?q=nurse&where=remote&rad=20",
        "https://www.monster.com/jobs/q-software-engineer-jobs-l-new-york-ny",
        "https://www.monster.com/jobs/q-nurse-jobs",
        "https://www.monster.com/job-openings/outpatient-registered-nurse-rn-midland-tx--5ca46a5f-bcfd-479d-a338-0eacf53af779"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/monster-com").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 = {
    "mode": "search",
    "startUrls": [
        "https://www.monster.com/jobs/search?q=software+engineer&where=New+York%2C+NY&page=1",
        "https://www.monster.com/jobs/search?q=nurse&where=Texas&page=2",
        "https://www.monster.com/jobs/search?q=nurse&where=remote&rad=20",
        "https://www.monster.com/jobs/q-software-engineer-jobs-l-new-york-ny",
        "https://www.monster.com/jobs/q-nurse-jobs",
        "https://www.monster.com/job-openings/outpatient-registered-nurse-rn-midland-tx--5ca46a5f-bcfd-479d-a338-0eacf53af779",
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/monster-com").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 '{
  "mode": "search",
  "startUrls": [
    "https://www.monster.com/jobs/search?q=software+engineer&where=New+York%2C+NY&page=1",
    "https://www.monster.com/jobs/search?q=nurse&where=Texas&page=2",
    "https://www.monster.com/jobs/search?q=nurse&where=remote&rad=20",
    "https://www.monster.com/jobs/q-software-engineer-jobs-l-new-york-ny",
    "https://www.monster.com/jobs/q-nurse-jobs",
    "https://www.monster.com/job-openings/outpatient-registered-nurse-rn-midland-tx--5ca46a5f-bcfd-479d-a338-0eacf53af779"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call abotapi/monster-com --silent --output-dataset

```

## MCP server setup

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

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/fhymQM9ofQRZoy1eP/builds/r2fOFS0Qp8ttp9xjk/openapi.json