# Dice Job Alerts & Dice.com Jobs Scraper - New Tech Jobs (`kamerozkan/dice-job-alerts`) Actor

Dice job alerts and Dice.com jobs scraper: search US tech jobs by keyword and location, filter by posted date, contract or full-time, remote and easy apply, and get only new jobs since your last run. Salary, company, location, skills summary and apply link in one table.

- **URL**: https://apify.com/kamerozkan/dice-job-alerts.md
- **Developed by:** [Kamer Ozkan](https://apify.com/kamerozkan) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.72 / 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/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 Job Alerts & Dice.com Jobs Scraper - New Tech Jobs

Dice job alerts as data: search Dice.com tech jobs by keyword and US location, filter by posted date, contract or full-time, remote and Easy Apply, and with **only new jobs** switched on get just the jobs that appeared since your last run. Title, company, location, workplace type, employment type, salary text, posted date, summary and the Dice job URL in one table. $0.90 per 1,000 jobs.

### What does Dice Job Alerts do?

Type the searches you would type on Dice.com (for example `python developer`, `devops engineer` or `salesforce admin`), add a US city, state or ZIP if you want, and choose the same filters as on the Dice search page. The actor reads the Dice search result pages (30 jobs per page) and returns one row per job, without duplicates across your searches.

- **Dice job alerts mode**: switch on **Job alerts: only new jobs** and schedule the run daily. The actor remembers every job it delivered for that monitor name and returns, and charges, only jobs it has not delivered before. Run several alerts side by side with different monitor names.
- **Filters**: posted today, last 3 days or last 7 days; full-time, part-time, contract or third party (C2C); remote, on-site or hybrid; Easy Apply only; radius in miles.
- **Bulk**: many searches in one run, up to 1,500 jobs per search.

It needs no login, no Dice account and no proxy setup on your side.

### Who is it for?

- **IT staffing firms and tech recruiters**: a daily feed of new contract and C2C jobs for the skills you place, straight into a sheet or CRM.
- **Job seekers and job boards**: Dice tech jobs and remote jobs for a skill, with salary text and the Easy Apply flag.
- **Labor-market and HR analysts**: track which companies post which tech roles, where, and at what pay.

### What data can you get?

| Field | Example |
|---|---|
| `jobId` | 7252c65a-ef31-4a0c-901b-f5319e994a4f (Dice job id) |
| `title` | Python Developer |
| `company` | Acadia Technologies, Inc. |
| `location` | Kyle, Texas, USA (or `Remote`) |
| `city` / `state` / `country` | Kyle / TX / USA |
| `workplaceTypes` | \["On-Site"] (Remote, On-Site, Hybrid) |
| `isRemote` | false |
| `employmentType` | Full-time (also Contract, Third Party, Part-time) |
| `employerType` | Recruiter or Direct Hire |
| `salary` | $60,000 - $80,000 (as the employer wrote it) |
| `easyApply` | true |
| `postedDate` / `updatedDate` | 2026-10-15T16:00:49Z / 2026-10-23T14:20:28Z |
| `summary` | First lines of the job description |
| `url` | https://www.dice.com/job-detail/7252c65a-ef31-4a0c-901b-f5319e994a4f |
| `companyLogoUrl` | Company logo image |
| `searchQuery` / `searchLocation` | python developer / null |
| `isNew` | true (only in job alerts mode) |
| `scrapedAt` | When the run collected the row |

Fields stay empty (null) when Dice does not show that detail. The actor returns job postings only; it does not collect recruiters' personal contact details.

### How much does it cost?

You pay only for jobs delivered: **$0.90 per 1,000 jobs** ($0.0009 per job) on the Free plan, with Store discounts on paid Apify plans: Bronze $0.81, Silver $0.765, Gold and above $0.72 per 1,000 jobs. In job alerts mode, jobs you already received are skipped and not charged. A search without results costs nothing.

Worked example: a daily alert for 5 skills that finds about 40 new jobs a day = about 1,200 jobs a month = **about $1.08 a month** on the Free plan.

Set "Max jobs per query", "Max jobs in total" or a maximum cost per run to cap spending.

### How to use it

1. Click **Try for free**.
2. Enter one or more **Search queries** and, if you want, a **Location** and **Radius**.
3. Pick **Posted date**, **Employment type**, **Workplace type** and **Easy Apply jobs only** as on Dice.com.
4. For Dice job alerts, switch on **Job alerts: only new jobs**, give the alert a **Monitor name** and create a daily schedule in Apify.
5. Click **Start**, then download the results as JSON, CSV or Excel, or read them through the API.

### Input example

```json
{
  "queries": ["devops engineer", "data engineer"],
  "location": "Austin, TX",
  "radiusMiles": 50,
  "postedDate": "7days",
  "employmentTypes": ["contract", "thirdparty"],
  "onlyNewJobs": true,
  "monitorName": "austin-contract-devops",
  "maxResultsPerQuery": 90
}
```

### Output example

Row from a QA run on 2026-10-24 (devops engineer, Austin, TX, contract and third party, last 7 days):

```json
{
  "jobId": "d83bc1c0-ee1c-4b41-887a-1e79b06399e6",
  "title": "Sr. DevOps Engineer",
  "company": "WB Solutions LLC",
  "location": "Austin, Texas, USA",
  "city": "Austin",
  "state": "TX",
  "country": "USA",
  "workplaceTypes": ["On-Site", "Hybrid"],
  "isRemote": false,
  "employmentType": "Contract",
  "employerType": "Direct Hire",
  "salary": "Depends on Experience",
  "easyApply": true,
  "postedDate": "2026-10-19T14:00:34Z",
  "updatedDate": "2026-10-23T22:09:39Z",
  "summary": "Greetings from WB Solutions We have an Urgent requirement for a Senior DevOps Engineer at Austin, TX Long-Term Contract...",
  "url": "https://www.dice.com/job-detail/d83bc1c0-ee1c-4b41-887a-1e79b06399e6",
  "companyLogoUrl": "https://d3qscgr6xsioh.cloudfront.net/tI35jt77Qjep00to5y7u_12d78c81166d5b7972d7b84587da01cf.png?format=webp",
  "searchQuery": "devops engineer",
  "searchLocation": "Austin, TX",
  "scrapedAt": "2026-10-24T16:17:42+00:00"
}
```

### Integrations and API

Run it from your code with the Apify API or the `apify-client` package, schedule it in Apify, or connect it to Make, n8n, Zapier, Google Sheets, Slack or a webhook. A daily schedule plus a Slack or email integration gives you Dice job alerts in your team channel.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("kamerozkan/dice-job-alerts").call(run_input={
    "queries": ["java developer"],
    "workplaceTypes": ["remote"],
    "postedDate": "today",
    "onlyNewJobs": True,
    "monitorName": "remote-java",
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["company"], item["salary"], item["url"])
```

### FAQ

**How do Dice job alerts work here?** With **only new jobs** on, the actor stores the ids of the jobs it delivered under your monitor name. The next run with the same monitor name skips those and returns only new postings. The first run returns every matching job. Use a new monitor name to start a fresh alert.

**How many jobs can I get per search?** Dice shows 30 jobs per page; the actor reads pages until your limit (up to 1,500 per search) or the end of the results. Use more specific searches or filters for more jobs in total.

**Does a location search include remote jobs?** Yes, Dice adds remote jobs to location searches. Set **Workplace type** to on-site or hybrid if you want local jobs only.

**Do I get the full job description?** You get the first lines of the description (`summary`) and the job URL. The full text is on the Dice job page.

**What happens when a search has no results?** The run still succeeds; the status message and the OUTPUT record list the searches without results, and nothing is charged for them.

**Is it legal to collect this data?** It collects publicly visible job postings. You are responsible for how you use the data, including privacy laws like GDPR.

### Related Actors

- [LinkedIn Jobs Scraper](https://apify.com/kamerozkan/linkedin-jobs-scraper): the same kind of job feed from LinkedIn.
- [Google Jobs Scraper](https://apify.com/kamerozkan/google-jobs-scraper): jobs from many boards through Google Jobs.

### Support and feedback

- Found a bug or missing a field? Open an issue on the **Issues** tab of this Actor. We reply within
  48 hours and ship most fixes within a few days.
- Have an idea for a feature? Issues are the fastest way to get it built.
- If the Actor saves you time, a short review on this page helps other users find it.

# Actor input Schema

## `queries` (type: `array`):

Job titles, skills or keywords, the same as in the Dice.com search box. One search per line, for example 'python developer' or 'devops engineer'.

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

US city, state or ZIP, for example 'New York, NY' or 'Austin, TX'. Leave empty to search all of Dice.com. Dice also returns remote jobs for a location search.

## `radiusMiles` (type: `integer`):

Search radius around the location. Dice uses 30 miles when empty.

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

Only jobs posted in this period.

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

Leave empty for all. Choose one or more.

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

Leave empty for all. Choose remote, on-site or hybrid.

## `easyApplyOnly` (type: `boolean`):

Only jobs with Dice Easy Apply.

## `onlyNewJobs` (type: `boolean`):

Remember every job this monitor delivered and return (and charge) only jobs that were not delivered before. Schedule the run daily for Dice job alerts. The first run returns all matching jobs.

## `monitorName` (type: `string`):

Name of the job alert memory used with 'only new jobs'. Use a different name for each alert (letters, digits, dashes).

## `maxResultsPerQuery` (type: `integer`):

Stop each search after this many jobs (30 jobs per Dice page).

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

Stop the run after this many jobs. You are charged per job, so this also caps the cost of the run.

## Actor input object example

```json
{
  "queries": [
    "python developer"
  ],
  "location": "New York, NY",
  "postedDate": "any",
  "easyApplyOnly": false,
  "onlyNewJobs": false,
  "monitorName": "default",
  "maxResultsPerQuery": 30,
  "maxItems": 100
}
```

# Actor output Schema

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

One row per result in the default dataset.

# 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 = {
    "queries": [
        "python developer"
    ],
    "location": "New York, NY",
    "maxResultsPerQuery": 30,
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("kamerozkan/dice-job-alerts").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 = {
    "queries": ["python developer"],
    "location": "New York, NY",
    "maxResultsPerQuery": 30,
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("kamerozkan/dice-job-alerts").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 '{
  "queries": [
    "python developer"
  ],
  "location": "New York, NY",
  "maxResultsPerQuery": 30,
  "maxItems": 100
}' |
apify call kamerozkan/dice-job-alerts --silent --output-dataset

```

## MCP server setup

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

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/7n8lpoQshVozJjbjZ/builds/xVUmuZZjpqq2PQstN/openapi.json