# Dice.com Job Scraper (`scraptivo/dice-scraper`) Actor

Collect Dice.com tech jobs by keyword, URL, and filters. Optionally add job details, company profiles, and each company's full job list.

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

## Pricing

from $1.70 / 1,000 job scrapeds

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?

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

**Dice.com Job Scraper** collects tech job listings from [Dice.com](https://www.dice.com) and turns them into structured data for recruiting research, salary benchmarking, and hiring-market monitoring. Provide a keyword such as "python", a Dice search or company URL, or a company brand ID, then export title, company, location, salary, employment type, and workplace to JSON, CSV, or Excel. Use it to build job databases, watch remote hiring, and schedule recurring collection. Pricing starts at **$2.00 per 1,000 jobs**, with optional job details at **$2.50 per 1,000** and company profiles or company job lists at **$2.00 per 1,000**.

### What can you automate with Dice.com Job Scraper?

- **Build targeted tech-job databases** — Search titles or skills such as "python" or "data engineer", then export company, salary, location, and workplace on every row.
- **Watch remote and hybrid hiring** — Filter by workplace type, employment type, posted date, and Easy Apply.
- **Collect one employer's live jobs** — Paste a Dice company URL or set `clientBrandId` to pull that company's openings.
- **Attach job and company context** — Optionally add full descriptions, company overviews, and each company's full job list.
- **Schedule recurring collection** — Run daily or weekly and push new listings into Sheets, a CRM, or an alert workflow.

### Who is this scraper for?

| Team | Workflow |
|---|---|
| Recruitment and staffing agencies | Build keyword pipelines of Dice openings and watch which employers are hiring this week. |
| Compensation and talent-intelligence teams | Compare disclosed salaries, employment types, and remote vs on-site mix. |
| Sales and lead-generation teams | Spot companies hiring for a skill, then enrich those accounts downstream. |
| Market researchers | Track posting recency and employer type (direct hire vs recruiter) by role. |

### What data can you collect from Dice?

| Data group | Example fields | How it helps |
|---|---|---|
| Job identity | `guid`, `id`, `title`, `detailsPageUrl`, `postedDate` | Identify each listing and deduplicate across runs with `guid`. |
| Employer | `companyName`, `companyPageUrl`, `clientBrandId`, `employerType` | See who is hiring and whether the posting is direct hire or recruiter. |
| Role terms | `location`, `salary`, `employmentType`, `workplaceTypes`, `isRemote`, `easyApply` | Filter by city, pay, contract type, and remote / hybrid / on-site. |
| Job details | `jobDetails` | Read the full description when **Include job details** is enabled. |
| Company profile | `companyDetails` | Add overview, social links, benefits, and technologies when **Include company details** is enabled. |
| Company jobs | `companyJobs` | Nest other openings from the same employer when **Include all company jobs** is enabled. |

Listing-card fields are always collected. `jobDetails`, `companyDetails`, and `companyJobs` appear only when their toggles are on. Salary is empty when Dice does not publish it.

### How to use Dice.com Job Scraper

1. Open the [Dice.com Job Scraper](https://apify.com/scraptivo/dice-scraper) on Apify.
2. Enter a search query such as "python" and an optional location, or paste Dice search / company URLs.
3. Set **Max items** (default 10; `0` means unlimited) and any employment, workplace, or posted-date filters.
4. Run the Actor — it writes one dataset row per search-result job.
5. Export the dataset or connect it to your workflow.

```json
{
    "searchQuery": "python",
    "workplaceTypes": ["Remote"],
    "employmentTypes": ["FULLTIME"],
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"]
    }
}
```

### Example workflow

#### Build a weekly list of remote Python jobs

1. Schedule a Monday run with `searchQuery` = `"python"`, `workplaceTypes` = `["Remote"]`, `employmentTypes` = `["FULLTIME"]`, and `postedDate` = `"SEVEN"`.
2. Keep rows that match your salary band and Easy Apply needs using the `salary` and `easyApply` fields.
3. Enable **Include job details** and **Include company details** on shortlisted employers when you need descriptions and profile data.
4. Send new records to Google Sheets or a CRM through a webhook after each run.
5. Deduplicate user-side against the stable `guid` field.

The Actor does not filter or merge results across runs — those steps happen in your pipeline.

### Automate and integrate your results

- **Schedules** — Run **daily** with `postedDate` = `"ONE"` for new-job alerts, or **weekly** with `"SEVEN"` for market snapshots. Create a separate scheduled task per query and location.
- **Webhooks** — Push completed runs into Google Sheets, Make, Zapier, Slack, a CRM, or an ATS.
- **Exports and API** — Download JSON, CSV, Excel, or HTML from the Apify Console, or start a run from the API:

```shell
curl -X POST "https://api.apify.com/v2/acts/scraptivo~dice-scraper/runs?token=YOUR-APIFY-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "python",
    "workplaceTypes": ["Remote"],
    "employmentTypes": ["FULLTIME"],
    "maxItems": 10
  }'
```

Deduplicate user-side with `guid`.

### Input reference

| Field | Type | Required | Default | What it controls |
|---|---|---:|---|---|
| `searchQuery` | string | No | — | Primary keyword, e.g. `python`. |
| `searchQueries` | array | No | `[]` | Extra keywords; each runs as a separate search. |
| `startUrls` | array | No | `[]` | Dice jobs search URLs or company job listing URLs. |
| `location` | string | No | `""` | Location text, e.g. `New York` or `Remote`. |
| `radius` | integer | No | `30` | Search radius around the location. |
| `radiusUnit` | string | No | `mi` | `mi` or `km`. |
| `employmentTypes` | array | No | `[]` | `FULLTIME`, `PARTTIME`, `CONTRACTS`, `THIRD_PARTY`. |
| `workplaceTypes` | array | No | `[]` | `Remote`, `Hybrid`, `On-Site`. |
| `postedDate` | string | No | `""` | `""` any time, `ONE` today, `THREE` last 3 days, `SEVEN` last 7 days. |
| `employerTypes` | array | No | `[]` | `Direct Hire`, `Recruiter`, `Other`. |
| `easyApply` | boolean | No | `false` | Return only Easy Apply jobs. |
| `isRemote` | boolean | No | `false` | Return only remote jobs. |
| `clientBrandId` | string | No | `""` | Dice company brand ID for one employer's jobs. |
| `includeJobDetails` | boolean | No | `false` | Add full descriptions (`job-details` event). |
| `includeCompanyDetails` | boolean | No | `false` | Add company profiles (`company-details` event). |
| `includeCompanyJobs` | boolean | No | `false` | Add each company's job list (`jobs-by-company` event). |
| `maxCompanyJobs` | integer | No | `0` | Cap per-company jobs; `0` is unlimited. |
| `detailConcurrency` | integer | No | `5` | Parallel detail requests (1–20). |
| `maxItems` | integer | No | `10` | Cap on search-result jobs; `0` is unlimited. |
| `proxyConfiguration` | object | No | Residential | Apify proxy settings. |

Provide a `searchQuery`, `searchQueries`, Dice `startUrls`, or `clientBrandId`. Filters such as `employmentTypes` apply to keyword searches.

### Output example

```json
{
    "guid": "d7c60634-b836-4f3d-acb7-4b6ddf6a6f7b",
    "title": "Senior Python Software Engineer",
    "companyName": "Booz Allen Hamilton",
    "salary": "USD 112,800.00 - 257,000.00 per year",
    "employmentType": "Full-time",
    "workplaceTypes": ["Remote"],
    "isRemote": true,
    "easyApply": false,
    "postedDate": "2026-08-20T20:06:16Z",
    "detailsPageUrl": "https://www.dice.com/job-detail/d7c60634-b836-4f3d-acb7-4b6ddf6a6f7b",
    "companyPageUrl": "https://www.dice.com/company/booz",
    "summary": "Job Number: R0247450 Python Software Engineer, Senior..."
}
```

### How much does it cost to scrape Dice?

Billing is pay-per-event. A one-time **Actor Start** fee of **$0.00005** applies per run.

| Event | When it is charged | Price |
|---|---|---|
| `dataset-item` (Job scraped) | Each search-result job row | **$2.00 per 1,000** |
| `job-details` | Each job enriched with **Include job details** | **$2.50 per 1,000** |
| `company-details` | Each company profile | **$2.00 per 1,000** |
| `jobs-by-company` | Each extra company job returned | **$2.00 per 1,000** |

A listing-only run of 1,000 jobs costs about **$2.00** plus Actor Start. The same 1,000 jobs with details enabled costs about **$4.50** plus Actor Start. Apify plan discounts may reduce these prices. Platform compute and proxy usage are billed separately on your Apify plan.

### Reliability and responsible use

- **Proxy** — Residential proxies are the default and recommended setting.
- **Conditional fields** — Descriptions, company profiles, and company job lists appear only when their toggles are on. Salary is omitted when Dice does not publish it.
- **Public data** — The Actor collects publicly visible job and company information from Dice.
- **Responsible use** — Only use the data in ways that comply with Dice's terms of service and applicable law.

### Frequently asked questions

#### Can I scrape Dice jobs by keyword and location?

Yes. Set `searchQuery` or `searchQueries` and an optional `location`. You can also paste Dice search URLs in `startUrls`; filters already in the URL are kept.

#### Can I schedule Dice.com Job Scraper to run automatically?

Yes. Open the **Scheduler** tab in Apify Console and set a recurring cadence — daily with `postedDate` = `"ONE"` for new listings, weekly with `"SEVEN"` for a market sweep. Create separate schedules per query and location.

#### What counts as one result?

A search-result job row is one `dataset-item` at **$2.00 per 1,000 jobs**. **Include job details** adds a `job-details` event per enriched job. **Include company details** adds a `company-details` event per company profile. **Include all company jobs** adds a `jobs-by-company` event per extra company job. A listing-only run charges only the job-row event plus Actor Start.

#### Why are some fields empty?

`jobDetails`, `companyDetails`, and `companyJobs` appear only when their toggles are on. Dice also omits salary on many listings.

#### How do I avoid duplicate records?

Within one run, listings are deduplicated by `guid`. Across runs the Actor appends results and does not merge them. When you combine datasets, keep the first row for each `guid`. Setting `maxItems` caps any single run.

#### Do I need a proxy?

The Actor works with the default Apify residential proxy. If a run returns unusually few jobs or keeps timing out, confirm that `proxyConfiguration` uses the RESIDENTIAL group before raising `detailConcurrency`.

#### Can I collect one company's jobs?

Yes. Add a Dice company URL to `startUrls` or set `clientBrandId`. Enable **Include all company jobs** when you also want other openings from companies found in a keyword search.

### Related Scraptivo automations

- [LinkedIn Job Scraper](https://apify.com/scraptivo/linkedin-job-scraper) — collect LinkedIn postings for global hiring research alongside Dice.
- [Glassdoor Jobs Scraper](https://apify.com/scraptivo/glassdoor-jobs-scraper) — add Glassdoor listings, ratings, and salaries to the same recruiting dataset.
- [ZipRecruiter Scraper](https://apify.com/scraptivo/ziprecruiter-scraper) — pull US job boards when you need coverage beyond Dice.
- [Upwork Jobs Scraper](https://apify.com/scraptivo/upwork-jobs-scraper) — monitor freelance openings that complement full-time Dice roles.
- [StepStone Jobs Scraper](https://apify.com/scraptivo/stepstone-jobs-scraper) — cover DACH and Benelux job markets with the same workflow.

### Support and custom workflows

Need a different field, source, or delivery workflow? Contact Scraptivo at scraptivo@gmail.com. Include the Actor name, sample URL, required fields, and expected volume so we can assess the request.

# Actor input Schema

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

Keyword search term, e.g. python, data engineer, react.

## `searchQueries` (type: `array`):

Optional additional keyword searches. Each query runs as a separate search.

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

Dice jobs search URLs or company job listing URLs. Query parameters and filters are parsed from the URL.

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

Location text for the search, e.g. New York, Remote, San Francisco.

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

Search radius around the location.

## `radiusUnit` (type: `string`):

Unit for the search radius.

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

Filter by employment type. Multiple values are combined with OR logic.

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

Filter by workplace type.

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

Filter by posting recency.

## `employerTypes` (type: `array`):

Filter by employer type.

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

When enabled, return only jobs that support Dice Easy Apply.

## `isRemote` (type: `boolean`):

When enabled, return only remote jobs.

## `clientBrandId` (type: `string`):

Optional Dice company brand ID to scrape jobs from one company directly.

## `includeJobDetails` (type: `boolean`):

Fetch full job descriptions and extra detail fields. Billed as job-details events.

## `includeCompanyDetails` (type: `boolean`):

Fetch full company profile data such as overview, social links, benefits, and technologies. Billed as company-details events.

## `includeCompanyJobs` (type: `boolean`):

Fetch all jobs posted by each company found in results. Billed as jobs-by-company events per company job returned.

## `maxCompanyJobs` (type: `integer`):

Maximum number of jobs to fetch per company when includeCompanyJobs is enabled (0 = unlimited).

## `detailConcurrency` (type: `integer`):

How many jobs to enrich in parallel when optional detail fields are enabled.

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

Maximum number of search-result jobs to scrape (0 = unlimited).

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

Proxy settings for anti-bot protection.

## Actor input object example

```json
{
  "searchQuery": "python",
  "searchQueries": [],
  "startUrls": [],
  "location": "",
  "radius": 30,
  "radiusUnit": "mi",
  "employmentTypes": [],
  "workplaceTypes": [],
  "postedDate": "",
  "employerTypes": [],
  "easyApply": false,
  "isRemote": false,
  "clientBrandId": "",
  "includeJobDetails": false,
  "includeCompanyDetails": false,
  "includeCompanyJobs": false,
  "maxCompanyJobs": 0,
  "detailConcurrency": 5,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runStats` (type: `string`):

No description

## `input` (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 = {
    "searchQuery": "python",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

# Run the Actor and wait for it to finish
run = client.actor("scraptivo/dice-scraper").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 '{
  "searchQuery": "python",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scraptivo/dice-scraper --silent --output-dataset

```

## MCP server setup

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

```

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/XUlEFcQmsTaeGGxHc/builds/5lgxUskZd4TcgEr0p/openapi.json