# Dice Jobs Scraper — New Posting Alerts (`magnova/dice-jobs-monitor`) Actor

Search Dice tech jobs by keyword, location and Dice's own filters. Get title, company, location, workplace type, salary as written plus parsed min/max, posted and modified times and an excerpt. Monitoring mode delivers only new and changed postings. $0.001 per job, no start fee.

- **URL**: https://apify.com/magnova/dice-jobs-monitor.md
- **Developed by:** [Magnova](https://apify.com/magnova) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Features:** Limited permissions, Single-tenant, Server interface
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 job records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Dice Jobs Scraper — New Posting Alerts

Search **Dice** tech jobs by keyword, location and Dice's own filters — and get structured posting records: title, company, location, workplace and employment type, the salary exactly as the employer wrote it plus a parsed min/max, posted and last-modified times, and a description excerpt. Run it on a schedule with **monitoring mode** and later runs deliver **only new postings — and postings that changed**.

No start fee. No proxy to configure. No API key. You pay **$0.001 per job record delivered** — and only for records actually delivered.

### What a record looks like

A real record, delivered by this Actor (a live Dice posting, captured 2026-11-17):

```json
{
  "recordType": "JOB",
  "diceJobId": "02e028e2-f6c3-4d25-b319-d21f87018537",
  "legacyId": "d13e41bed1c891109d73cf82ae381571",
  "jobTitle": "Python Developer - Locals",
  "company": "IT Trailblazers, LLC.",
  "companyId": "21dc0365-bb46-4d5c-ae58-c900ad556979",
  "companyLogoUrl": "https://assets.dice.com/external/images/empLogos/acaf0d453e688bfdd6fbc6f6578d9b36.png",
  "location": "Alpharetta, Georgia, USA",
  "city": "Alpharetta",
  "state": "Georgia",
  "country": "USA",
  "isRemote": false,
  "workplaceTypes": ["Hybrid"],
  "employmentType": "Contract",
  "employerType": "Direct Hire",
  "easyApply": true,
  "salary": "$$60 - $77",
  "salaryMin": 60.0,
  "salaryMax": 77.0,
  "salaryCurrency": "USD",
  "salaryPeriod": null,
  "postedDate": "2026-11-16T22:16:44Z",
  "modifiedDate": "2026-11-16T22:16:44Z",
  "summary": "Title: Python Developer Location: Alpharetta, GA - Hybrid Job Description: Python Developer Data Protection Services The mission of the Data Protection (DP) group is to implement the Firm's Data Cybersecurity Strategy…",
  "jobUrl": "https://www.dice.com/job-detail/02e028e2-f6c3-4d25-b319-d21f87018537"
}
```

### Fields

| Field | What it is | Coverage |
|---|---|---|
| `diceJobId` | Dice's unique job ID (GUID) — the dedupe key | every record |
| `jobTitle` | Job title | every record |
| `jobUrl` | The posting's public Dice page | every record |
| `company` | Employer name as listed | ≥ 95% |
| `postedDate` | When the posting was published (UTC) | ≥ 95% |
| `location`, `city`, `state`, `country` | Location as listed | ≥ 75% (Dice lists no location at all for some fully-remote postings) |
| `employmentType` | Full-time, Contract, … as listed | ≥ 90% |
| `modifiedDate` | When the posting last changed (UTC) | ≥ 90% |
| `summary` | Description excerpt, contact details removed | ≥ 90% |
| `salary` | The salary **exactly as the employer wrote it** | where the employer lists one |
| `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod` | Parsed from `salary` where the format allows (`USD 209,000.00 - 238,500.00 per year` → 209000 / 238500 / USD / year). Unparseable strings ("Depends on Experience") leave these null — the raw string always ships. | where parseable |
| `isRemote`, `workplaceTypes` | Remote flag and workplace types (Remote / Hybrid / On-Site) | every record |
| `employerType` | e.g. Direct Hire | where listed |
| `easyApply` | Whether the posting takes a Dice Easy Apply | every record |
| `companyId`, `companyLogoUrl`, `legacyId` | Employer's Dice profile ID, logo, and Dice's legacy job ID | where listed |
| `changeType` | Monitoring mode only: `NEW` or `UPDATED` | monitor runs |

Every run also ends with one `SUMMARY` record (counts, filters applied, whether the state store was used, and plain-language notes) and, if the search itself could not be checked, an `ERROR` record saying why. Neither is ever charged.

### Two ways to run it

**Corpus mode (default).** One run delivers the current matching postings, up to your per-run cap. Use it for market snapshots, salary research and one-off pulls.

**Monitoring mode.** Pick one of your key-value stores in the *Monitor state store* input and schedule the run (hourly or daily is typical). The first run delivers the current matches as a baseline — or, with *Start monitoring silently* on, remembers them without delivering or charging anything. Later runs deliver only:

- **NEW** postings — never delivered before, and
- **UPDATED** postings — remembered postings whose modified time moved (a salary change, a repost, an edit).

Unchanged postings are never re-delivered or re-charged. The store also remembers postings your filters excluded, so widening a filter later doesn't flood you with old jobs. Your own `publishedSince` date cursor works independently of the store, for backfills and bootstraps.

### Inputs

- **Search query** — keywords, e.g. `software engineer`, `python developer`, `devops`.
- **Location** — `Austin, TX`, a state, `Remote`, or `United States`. Plus a **radius** in miles.
- **Employment types** — Full-time, Part-time, Contract, Third Party (Dice's own filter).
- **Workplace types** — Remote, Hybrid, On-Site (Dice's own filter).
- **Easy Apply only**, and **Posted within** — any time, or the last 1 / 3 / 7 days.
- **Dice search URL** — paste a search you built on dice.com and run exactly that.
- **Maximum jobs per run** (default 100, up to 1,000) and an optional **maximum total charge** hard stop you control.

### Use it as an API (Server Actor)

This Actor also runs in server mode — no run to start, no dataset to poll. Send one HTTP request, get the jobs back in the response:

```bash
curl -X POST "https://magnova--dice-jobs-monitor.apify.actor/" \
  -H "Authorization: Bearer <redacted>" \
  -H "Content-Type: application/json" \
  -d '{"query": "software engineer", "maxResults": 10}'
```

The body takes the same fields as the normal input (`query`, `searchUrl`, `location`, `radius`, `employmentTypes`, `workplaceTypes`, `easyApply`, `postedDate`, `publishedSince`, `maxResults`, `maxTotalChargeUsd`). The response is `{"records": [...], "summary": {...}}` with the same record shapes described above. Server mode is a snapshot lookup — one request returns up to 100 jobs, and the monitor store / only-new delivery stays a scheduled-run feature (see Monitoring mode). Delivered jobs are charged at the same $0.001 per job; ERROR rows are never charged. Works from apps, workflow tools, and AI agents that need current postings mid-conversation.

### Pricing

**$0.001 per job record delivered. No start fee.** Higher Apify plan tiers pay less per record (SILVER $0.00085, GOLD and above $0.0007).

What that means in practice — **$1.00 buys 1,000 job records**:

- A one-off pull of 500 matching postings costs **$0.50**.
- A daily monitoring run over a focused search typically delivers 5–25 new postings: **$0.005–$0.025 a day, roughly $0.15–$0.75 a month** per watched search.

**Not charged:** postings already delivered, duplicates, postings your filters exclude, silently seeded postings (`monitorOnlyNew`), `ERROR` records, and the run `SUMMARY`. If Dice can't be reached, the run delivers an `ERROR` record and charges nothing.

### Use it from your AI agent

This Actor is agent-ready. Point any MCP client at the Apify MCP server with this Actor as a tool:

```
https://mcp.apify.com?tools=magnova/dice-jobs-monitor
```

Or call it over the Apify API like any Actor — the input is plain JSON (`query`, `location`, `postedDate`, `maxResults`, …) and the dataset items are the records above.

### Notes

Dice's search results can shift slightly between runs (its index updates continuously), and some postings list no salary — those ship with `salary` null and the parsed fields null. A run that hits Dice rate limits retries with backoff; if Dice refuses outright, you get an `ERROR` record and no charge, and monitoring state is not advanced, so the next run catches up.

### Legal

This Actor reads Dice's public job search — the same postings dice.com shows every logged-out visitor — with no login, no account and no bypass of any access control. Records carry the postings' public business facts only; email addresses and phone numbers found in posting text are removed before delivery, and no contact data is collected or sold. This Actor is not affiliated with Dice or DHI Group, Inc.

# Actor input Schema

## `easyApply` (type: `boolean`):

Only postings that accept a Dice Easy Apply application.

## `employmentTypes` (type: `array`):

Only postings of these employment types. Leave empty for all types.

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

City and state ("Austin, TX"), a state, "Remote", or "United States" for anywhere. Leave empty to search everywhere Dice lists jobs.

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

The most job records one run delivers (and charges for). Dice serves 30 postings per page; the run stops cleanly at this cap.

## `maxTotalChargeUsd` (type: `number`):

A hard stop you control: the run stops delivering once its charged total would pass this amount. Leave empty for no cap (the per-run result cap still applies).

## `monitorOnlyNew` (type: `boolean`):

Off (default): the first run delivers the search's current jobs as a baseline batch (charged), later runs deliver only new or changed ones. On: the first run silently remembers the current jobs without delivering or charging anything, and only jobs posted afterwards are ever delivered. Only applies when a monitor store is selected; without a store every run is a baseline run.

## `postedDate` (type: `string`):

How recent the postings must be: ANY time, the last ONE day, THREE days or SEVEN days (Dice's own posted-date filter).

## `publishedSince` (type: `string`):

Your own cursor: only deliver postings whose posted date is on or after this ISO date (e.g. 2026-11-14). Independent of the actor's monitor state — use it to re-fetch a window or to bootstrap.

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

Keywords for Dice's own search — a job title, a skill, or both, e.g. "software engineer" or "python developer". Ignored when a search URL is pasted below.

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

How far around the location to search, in miles. Only applies when a location is set.

## `searchUrl` (type: `string`):

Paste a full Dice job search URL (https://www.dice.com/jobs?...) to run exactly that search. The filters above are ignored; paging is handled for you.

## `stateStoreId` (type: `string`):

A key-value store this Actor may read and write to remember which jobs it has already seen — this is what makes only-new delivery work across runs. Pick any store you own; the Actor keeps one small state record in it. Without a store, every run delivers the search's jobs as a baseline and remembers nothing. If the store is missing or cannot be opened, the run continues in baseline mode and the SUMMARY record says so — it never crashes. The Actor remembers every job it processed (including filtered-out ones), so widening your filters later does not re-deliver old jobs. In monitoring mode a remembered job whose posting changed is delivered once more as an UPDATED record.

## `workplaceTypes` (type: `array`):

Only postings for these workplace types. Leave empty for all.

## Actor input object example

```json
{
  "easyApply": false,
  "employmentTypes": [],
  "location": "Austin, TX",
  "maxResults": 100,
  "maxTotalChargeUsd": 1,
  "monitorOnlyNew": false,
  "postedDate": "ANY",
  "publishedSince": "2026-11-14",
  "query": "software engineer",
  "radius": 30,
  "searchUrl": "https://www.dice.com/jobs?q=java&location=Remote",
  "workplaceTypes": []
}
```

# 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 = {
    "easyApply": false,
    "employmentTypes": [],
    "location": "United States",
    "maxResults": 100,
    "monitorOnlyNew": false,
    "postedDate": "ANY",
    "query": "software engineer",
    "radius": 30,
    "workplaceTypes": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("magnova/dice-jobs-monitor").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 = {
    "easyApply": False,
    "employmentTypes": [],
    "location": "United States",
    "maxResults": 100,
    "monitorOnlyNew": False,
    "postedDate": "ANY",
    "query": "software engineer",
    "radius": 30,
    "workplaceTypes": [],
}

# Run the Actor and wait for it to finish
run = client.actor("magnova/dice-jobs-monitor").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 '{
  "easyApply": false,
  "employmentTypes": [],
  "location": "United States",
  "maxResults": 100,
  "monitorOnlyNew": false,
  "postedDate": "ANY",
  "query": "software engineer",
  "radius": 30,
  "workplaceTypes": []
}' |
apify call magnova/dice-jobs-monitor --silent --output-dataset

```

## MCP server setup

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

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/YYGe1r58Cxd02CO48/builds/npNUwYTXKXCEt1Ynh/openapi.json
