# Dice.com Job Scraper — Tech Jobs, Salary, Skills & Companies (`haketa/dice-scraper`) Actor

Scrape Dice.com tech & IT job listings: title, company, location, remote/on-site, employment type, salary range, required skills, posted date, application deadline & full description. Search by keyword & location, filter by date or workplace, or paste job URLs. Export JSON/CSV/Excel.

- **URL**: https://apify.com/haketa/dice-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Jobs, Lead generation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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/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.com Job Scraper — Tech Jobs, Salary, Skills & Companies

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-blue?logo=apify)](https://apify.com/haketa/dice-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/dice-scraper)
[![Data Format](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)](https://apify.com/haketa/dice-scraper)
[![Pagination](https://img.shields.io/badge/Pagination-1%2C000%2B%20Deep%20Crawl-success)](https://apify.com/haketa/dice-scraper)
[![Zero Duplicate](https://img.shields.io/badge/Deduplication-GUID%20Verified-blueviolet)](https://apify.com/haketa/dice-scraper)

Scrape [Dice.com](https://www.dice.com) technology and IT job postings into clean, structured datasets — without account credentials, browser overhead, or manual data entry. This **Dice scraper** executes deep pagination over keywords and locations, filters by posted date or workplace model, or accepts direct job detail URLs, delivering comprehensive tech market intelligence: **job title, hiring company, structured location, remote/on‑site classification, employment type, structured salary range, required skills array, posted date, application deadline, and sanitized full job descriptions**.

Export structured data to **JSON, CSV, Excel, or consume directly via the Apify REST API**.

> Built for **tech recruiters, staffing agencies, compensation analysts, talent intelligence researchers, job market aggregators, and enterprise engineering teams** requiring reliable, scalable Dice job data extraction without limits.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Platform** | Dice.com (United States Tech & IT Careers) |
| **Data Types** | Tech Job Postings, Employer Profiles, Salary Benchmarks, Skill Tags |
| **Search Options** | Multi-keyword list, US city/state/remote location, job URLs |
| **Pagination Mode** | Automated deep pagination (unlimited or bounded per keyword) |
| **Throughput Speed** | ~150–500 jobs / minute with parallel detail enrichment |
| **Data Enrichment** | Skills array, min/max salary parsing, deadline, HTML-stripped description |
| **Output Formats** | JSON, CSV, XML, Excel (XLSX), HTML Table, RSS |
| **Default Concurrency** | 8 concurrent workers (configurable up to 12) |
| **Proxy Compatibility** | Apify Proxy (Datacenter or Residential, US IPs recommended) |

***

### 🔎 Why scrape Dice.com?

**Dice.com** stands as the definitive recruitment exchange for technology, software development, cloud infrastructure, cybersecurity, and enterprise IT roles across North America. Postings on Dice carry dense, high-signal information: exactly which organizations are scaling, the technology frameworks required, compensation floors and ceilings, and the evolving distribution of remote versus hybrid arrangements.

Manually inspecting Dice job postings is labor-intensive. Search result previews redact complete skill profiles, compensation nuances, application deadlines, and full role specifications behind individual job detail views. This **Dice.com scraper** streamlines extraction into an automated workflow: paginating deep across multiple queries, harvesting metadata, opening job details in parallel, and returning a normalized, deduplicated dataset.

#### Common enterprise use cases

- **B2B Tech Lead Generation**: Identify companies actively investing in specific software stacks (e.g., Snowflake, Kubernetes, Salesforce, Golang) to target recruitment services or B2B SaaS software.
- **Compensation & Salary Benchmarking**: Analyze granular `salaryMin` and `salaryMax` distributions segmented by geography, experience level, and tech stack to construct competitive compensation packages.
- **Skill Demand & Market Trends**: Track shifting technical requirements across time (e.g., LLM engineering, Rust, AWS migration) to inform workforce planning and curriculum design.
- **Automated ATS & Job Board Ingestion**: Programmatically sync current tech openings into specialized job discovery platforms, regional job feeds, and talent matching pipelines.
- **Competitive Intelligence**: Monitor rival tech teams' expansion velocity, organizational structures, and strategic engineering bets through active vacancy tracking.

***

### ✨ Core capabilities

- ✅ **Multi-Keyword Search**: Crawl multiple roles, skill terms, or company names simultaneously (`DevOps Engineer`, `Data Scientist`, `Kubernetes`). Each query executes independent pagination.
- ✅ **Geographic & Workplace Filtering**: Target nationwide positions, specific US metropolitan areas, or filter strictly by `Remote`, `Hybrid`, or `On-Site` environments.
- ✅ **Recency Window Selection**: Focus on freshly published opportunities with recency bounds (`Past 24 hours`, `Past 3 days`, `Past 7 days`, or `Any`).
- ✅ **Direct URL Ingestion**: Provide an array of specific Dice job URLs or GUIDs for targeted re-scraping and attribute verification.
- ✅ **Deep 1,000+ Pagination**: Unlocked pagination engine pages cleanly past 30-item listing thresholds, retrieving thousands of matching roles without artificial caps.
- ✅ **Dual-Source Salary Extraction**: Captures machine-readable compensation schemas and parses human-readable salary text into numerical `salaryMin` and `salaryMax` ranges.
- ✅ **Standardized Tech Skills Array**: Extracts specific developer skills and technology tags into structured arrays ready for filtering and indexing.
- ✅ **Clean Plaintext Descriptions**: Converts complex HTML markup into readable, whitespace-normalized plaintext descriptions without broken tags.
- ✅ **Native Deduplication**: Ensures every job record is uniquely validated by Dice `guid`, eliminating redundant rows across overlapping search queries.

***

### 🎯 Primary workflows

- **Recruitment & Executive Search**: Surface passive engineering openings, uncover hiring managers, and identify contract/C2C opportunities for specialized consultants.
- **HR Tech & Labor Analytics**: Conduct econometric studies on technical compensation, geographical wage premiums, and remote work adoption rates.
- **SaaS Sales Prospecting**: Discover high-growth companies that recently posted 20+ engineering roles to prioritize outbound enterprise sales motions.
- **Freelance & Contract Aggregation**: Filter specifically for contract and corp-to-corp designations to feed consultant placement workflows.

***

### 📥 Input parameters

The scraper accepts flexible inputs ranging from broad keyword discoveries to targeted direct URLs. All fields are optional; running without input initiates a default software engineering exploration.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchQueries` | Array of Strings | `["python developer"]` | Target job keywords, roles, technologies, or company names. |
| `location` | String | `""` | Optional location filter (US city, state code, or `Remote`). Leave empty for nationwide scope. |
| `postedDate` | Select | `"Any"` | Recency filter: `Any`, `Past 24 hours`, `Past 3 days`, or `Past 7 days`. |
| `workplaceType` | Select | `"Any"` | Workplace classification: `Any`, `Remote`, `Hybrid`, or `On-Site`. |
| `jobUrls` | Array of Strings | `[]` | Explicit Dice job URLs or GUIDs to scrape directly. |
| `includeJobDetails` | Boolean | `true` | When enabled, opens detail pages to capture full descriptions, skill arrays, structured pay, and deadlines. |
| `maxPages` | Integer | `0` | Maximum search result pages to fetch per query (30 jobs/page). Set to `0` for unlimited pagination. |
| `maxItems` | Integer | `100` | Total maximum job postings to retain across all keywords and direct URLs. |
| `maxConcurrency` | Integer | `8` | Parallel detail request concurrency limit (recommended 6–10). |
| `proxyConfiguration` | Object | `{ "useApifyProxy": true }` | Apify Proxy settings. US IP routing provides maximum coverage. |

***

### 📋 Ready-to-use input examples

#### Example 1: Full-detail remote software roles

```json
{
  "searchQueries": ["Full Stack Engineer", "Backend Developer"],
  "workplaceType": "Remote",
  "postedDate": "Past 7 days",
  "includeJobDetails": true,
  "maxItems": 150,
  "maxPages": 0
}
```

#### Example 2: High-speed enterprise discovery (listing summary)

```json
{
  "searchQueries": ["Data Engineer", "Machine Learning", "Cloud Architect"],
  "location": "New York",
  "includeJobDetails": false,
  "maxItems": 500,
  "maxPages": 0
}
```

#### Example 3: Targeted re-scraping via direct URLs

```json
{
  "jobUrls": [
    "https://www.dice.com/job-detail/37698878-e6a8-4218-97b3-5901bdce9e1c",
    "https://www.dice.com/job-detail/209494b1-644d-416f-b9e6-d0c5c1b70bbb"
  ],
  "includeJobDetails": true
}
```

***

### 📤 Output dataset structure

Every harvested vacancy produces a comprehensive JSON record. Below is a representative output record:

```json
{
  "guid": "37698878-e6a8-4218-97b3-5901bdce9e1c",
  "title": "Senior Cloud Infrastructure Engineer",
  "companyName": "Apex Systems",
  "companyProfileId": "8c2cf2a7-dcd7-42dc-b8d4-2b90acef1688",
  "location": "Merrimack, New Hampshire, USA",
  "city": "Merrimack",
  "state": "NH",
  "postalCode": "03054",
  "country": "US",
  "isRemote": false,
  "workplaceTypes": [
    "On-Site"
  ],
  "employmentType": "Full-time",
  "salary": "USD 130,000.00 - 155,000.00 per year",
  "salaryMin": 130000,
  "salaryMax": 155000,
  "salaryCurrency": "USD",
  "skills": [
    "AWS",
    "Terraform",
    "Kubernetes",
    "Docker",
    "Python",
    "CI/CD",
    "Linux"
  ],
  "postedDate": "2026-11-01T08:15:00Z",
  "modifiedDate": "2026-11-02T10:30:00Z",
  "datePosted": "2026-11-01T08:15:00.000Z",
  "validThrough": "2026-12-15T23:59:59.000Z",
  "easyApply": true,
  "applyType": "Internal",
  "employerType": "Recruiter",
  "summary": "Seeking a Senior Cloud Infrastructure Engineer to lead automated deployment architectures and multi-region AWS operations...",
  "description": "Full job description text formatted cleanly into readable paragraphs without extraneous HTML tags...",
  "companyLogoUrl": "https://d3qscgr6xsioh.cloudfront.net/logos/apex_systems.png",
  "companyProfileUrl": "https://www.dice.com/company-profile/8c2cf2a7-dcd7-42dc-b8d4-2b90acef1688",
  "url": "https://www.dice.com/job-detail/37698878-e6a8-4218-97b3-5901bdce9e1c",
  "detailEnriched": true,
  "sourceMode": "search",
  "scrapedAt": "2026-11-10T14:20:00.000Z"
}
```

***

### 📊 Field definitions & coverage

#### 💼 Core job metadata

| Field | Type | Description | Coverage |
|---|---|---|---|
| `guid` | String | Unique Dice job identifier and deduplication key | 🟢 High (100%) |
| `title` | String | Formal job title | 🟢 High (100%) |
| `url` | String | Canonical URL to the Dice job posting | 🟢 High (100%) |
| `summary` | String | Short excerpt shown on search result listings | 🟢 High (100%) |
| `description` | String | Full sanitized job description plain text | 🟢 High (99%) |
| `skills` | Array | Structured technology skill tags | 🟢 High (92%) |
| `easyApply` | Boolean | Flag indicating if Dice 1-click application is supported | 🟢 High (100%) |
| `applyType` | String | Application routing mechanism (`Internal` or `External`) | 🟢 High (98%) |

#### 🏢 Company & employer attributes

| Field | Type | Description | Coverage |
|---|---|---|---|
| `companyName` | String | Legal or operating employer name | 🟢 High (100%) |
| `companyProfileId` | String | Unique Dice internal employer identifier | 🟢 High (95%) |
| `companyProfileUrl` | String | Link to corporate Dice employer showcase | 🟢 High (95%) |
| `companyLogoUrl` | String | CDN URL to the corporate logo graphic | 🟡 Conditional (80%) |
| `employerType` | String | Hiring classification (`Direct Hire`, `Recruiter`, etc.) | 🟢 High (90%) |

#### 📍 Location & workplace arrangement

| Field | Type | Description | Coverage |
|---|---|---|---|
| `location` | String | Formatted display location string | 🟢 High (100%) |
| `city` | String | Municipal jurisdiction | 🟢 High (92%) |
| `state` | String | State or provincial code | 🟢 High (92%) |
| `postalCode` | String | ZIP or postal code identifier | 🟡 Conditional (75%) |
| `country` | String | ISO country code | 🟢 High (95%) |
| `isRemote` | Boolean | True if posting permits remote arrangement | 🟢 High (100%) |
| `workplaceTypes` | Array | Work model classifications (`Remote`, `Hybrid`, `On-Site`) | 🟢 High (100%) |

#### 💰 Compensation & engagement terms

| Field | Type | Description | Coverage |
|---|---|---|---|
| `employmentType` | String | Engagement category (`Full-time`, `Contract`, `Third Party`) | 🟢 High (100%) |
| `salary` | String | Original verbatim salary text as published | 🟡 Conditional (70%) |
| `salaryMin` | Number | Normalized minimum compensation value | 🟡 Conditional (65%) |
| `salaryMax` | Number | Normalized maximum compensation value | 🟡 Conditional (65%) |
| `salaryCurrency` | String | Standard currency denomination (`USD`, `CAD`, etc.) | 🟡 Conditional (65%) |

#### ⏱️ Timeline & tracking metadata

| Field | Type | Description | Coverage |
|---|---|---|---|
| `postedDate` | String | ISO timestamp of original publication | 🟢 High (100%) |
| `modifiedDate` | String | ISO timestamp of most recent listing update | 🟢 High (98%) |
| `validThrough` | String | Employer-specified application deadline | 🟡 Conditional (85%) |
| `detailEnriched` | Boolean | True if the posting was parsed via deep detail page inspection | 🟢 High (100%) |
| `sourceMode` | String | Discovery origin (`search` or `direct`) | 🟢 High (100%) |
| `scrapedAt` | String | ISO timestamp of scraper extraction | 🟢 High (100%) |

***

### 💡 Search strategies & best practices

To maximize the yield and precision of your Dice data collection, consider applying these proven search strategies:

1. **Target Specific Engineering Stacks**: Instead of broad queries like `"Developer"`, query role + core technology combinations such as `"Senior React Node Developer"`, `"Kubernetes Cloud Architect"`, or `"Golang Backend Engineer"`. Specific queries yield higher relevance and clearer salary benchmarks.
2. **Multi-Query Geographic Sweeps**: Provide a list of complementary keywords (e.g., `["Data Engineer", "Analytics Engineer", "BI Developer"]`) alongside a targeted metropolitan area (`"Austin"`, `"Seattle"`, `"New York"`) to harvest an entire regional talent market in a single execution.
3. **Daily Delta Monitoring**: Establish an Apify Scheduled Actor task running daily at 06:00 AM with `postedDate: "Past 24 hours"`. Pipe the new records directly to your recruiting database or ATS via webhooks for immediate outreach to newly posted positions.
4. **Two-Stage Extraction Pipeline**: When monitoring massive volumes (5,000+ positions), run a fast discovery crawl with `includeJobDetails: false`. Analyze high-level trends across title, company, and location. Then feed the harvested `guid` or `url` values back into the scraper with `includeJobDetails: true` only for high-priority targets.
5. **Deduplication Across Overlapping Roles**: When searching similar technology keywords, companies often cross-post the same opening under different tags. The actor's internal deduplication engine automatically discards redundant entries based on the canonical `guid`, guaranteeing zero duplicated records in your final dataset.

***

### ⚙️ How to use

1. **Configure Search Parameters**: Enter your target keywords into `searchQueries` (e.g., `["React Developer", "Node.js"]`), and specify an optional `location`.
2. **Select Enrichment Depth**: Keep `includeJobDetails: true` to collect full descriptions and skills, or set to `false` for high-velocity title/company directory pulls.
3. **Set Extraction Limits**: Define `maxItems` based on your project volume requirements. Leave `maxPages: 0` for automatic pagination across all pages.
4. **Execute Run**: Click **Start** in the Apify Console. Monitor live event logs as records stream directly into the Apify Dataset.
5. **Download or Integrate**: Export datasets in JSON, CSV, or Excel formats, or consume items programmatically via webhook notifications and REST endpoints.

***

### 💻 API & Integration examples

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~dice-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQueries": ["Python Developer"],
    "location": "San Francisco",
    "workplaceType": "Remote",
    "maxItems": 100,
    "includeJobDetails": true
  }'
```

#### Python

```python
from apify_client import ApifyClient

## Initialize client with your personal token
client = ApifyClient("YOUR_APIFY_TOKEN")

## Prepare payload
run_input = {
    "searchQueries": ["Data Engineer"],
    "location": "Remote",
    "postedDate": "Past 7 days",
    "maxItems": 250,
    "includeJobDetails": True
}

## Run the actor and wait for completion
run = client.actor("haketa/dice-scraper").call(run_input=run_input)

## Fetch dataset items
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"{item.get('title')} at {item.get('companyName')} - {item.get('salary', 'N/A')}")
```

#### Node.js / JavaScript

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

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const runInput = {
    searchQueries: ['DevOps Engineer'],
    workplaceType: 'Remote',
    maxItems: 100,
    includeJobDetails: true,
};

const run = await client.actor('haketa/dice-scraper').call(runInput);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Retrieved ${items.length} job records.`);
```

#### Webhook & Zapier Automation

Connect this scraper directly to your workflow tools:

- **Make (Integromat)**: Create a scenario triggered by an Apify "Run Succeeded" webhook. Parse the resulting dataset and automatically append records to Google Sheets or Airtable.
- **Zapier**: Connect the Apify app, listen for dataset item creation, and send Slack alerts whenever a target company posts a new executive technology role.
- **AWS S3 / Google Cloud Storage**: Use Apify Integrations to automatically sync every completed dataset to cloud storage buckets for enterprise data lakes.

***

### ❓ Frequently Asked Questions

**How does deep pagination function on Dice?**
Dice delivers search results in 30-item pages. When `maxPages` is set to `0`, the scraper automatically advances sequentially through all available pages until `maxItems` is satisfied or the total available result count reported by Dice is exhausted.

**Why are some salary values null?**
Compensation disclosures on Dice are contingent upon employer publication. Many employers choose not to publish salary amounts or mark them as "Competitive" or "Depends on Experience". When a numeric salary or range is provided anywhere in the posting, the scraper extracts and parses it into `salaryMin` and `salaryMax`.

**What is the difference between search summary and full detail mode?**
In search summary mode (`includeJobDetails: false`), the scraper extracts metadata visible on search result cards (title, company, display location, snippet, posted date) at very high speeds (~1,000 items in seconds). In full detail mode (`includeJobDetails: true`), the actor concurrently visits each posting's dedicated view to extract full HTML-stripped descriptions, technology skill tags, application deadlines, and structured compensation schemas.

**Can I run scheduled sweeps for fresh postings?**
Yes. You can configure an Apify Schedule (e.g., daily at 08:00 UTC) with `postedDate: "Past 24 hours"` to build an automated pipeline capturing new vacancies every morning without duplicates.

**Can I scrape by specific Dice job URLs or GUIDs?**
Yes. If you have an existing list of vacancy links (e.g. from an internal database or previous crawls), populate the `jobUrls` input array. The scraper will bypass keyword search and directly harvest the detailed records for those exact positions.

**How does deduplication work across multiple search queries?**
If multiple keywords return the same posting (e.g., a role tagged under both "Kubernetes" and "DevOps"), the actor tracks previously saved positions by their unique Dice `guid`. Redundant entries are skipped instantly, ensuring zero duplicate rows in your dataset.

**What proxy settings are recommended?**
Dice primarily services the North American market. Leaving the default `{ "useApifyProxy": true }` configuration automatically utilizes Apify Proxy with US IP addresses for optimal routing, low latency, and maximum data completeness.

**Can I export data directly to Excel or CSV?**
Yes. From the Apify Dataset tab, you can download all extracted fields in CSV, Excel (XLSX), JSON, XML, or HTML table formats with a single click.

***

### 🔗 Complementary scrapers

- [SimplyHired Jobs Scraper](https://apify.com/haketa/simplyhired-scraper) — Extract nationwide US job opportunities and employer ratings.
- [CutShort Jobs Scraper](https://apify.com/haketa/cutshort-scraper) — Source tech talent and developer compensation across Indian tech hubs.
- [ZipRecruiter Jobs Scraper](https://apify.com/haketa/ziprecruiter-scraper) — Scrape multi-country job boards with parsed compensation data.
- [Glassdoor Jobs Scraper](https://apify.com/haketa/glassdoor-jobs-scraper) — Comprehensive company reviews, salaries, and open positions.

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Deep Pagination Engine**: Fully unlocked 1,000+ continuous result pagination with configurable `maxPages` (0 = auto/unlimited) and removal of legacy page bounds.
- **Fast Prefill Optimization**: Streamlined default execution parameters ensuring sample test runs complete in under 30 seconds.
- **Dual-Source Salary Parsing**: Enhanced regular expression parsing capturing salary ranges from both structured schema tags and natural-language text.
- **Deduplication Safeguards**: Hardened GUID verification preventing duplicate items across overlapping multi-keyword search queries.
- **Input Schema Standardization**: Updated limit boundaries to support minimum 0 values and zero-parameter empty runs with graceful software engineering fallback.

#### v1.1 (2026-10)

- Improved plaintext description cleaning with unescaped newline normalization.
- Enhanced skill array extraction matching both standard and custom tags.

#### v1.0 (2026-09)

- Initial production release supporting multi-keyword discovery, workplace filtering, and structured JSON/CSV exports.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/dice-scraper/changelog.md

# Actor input Schema

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

Job keywords to search — role, skill, technology or company. Each keyword is searched and paginated. Example: Python Developer, Java, DevOps Engineer.

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

Optional location applied to every keyword — a US city, state, or 'Remote'. Leave empty to search nationwide.

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

Only keep jobs posted within this window.

## `workplaceType` (type: `string`):

Only keep jobs of this workplace type.

## `jobUrls` (type: `array`):

Dice job-detail URLs (or job GUIDs) to scrape directly. Example: https://www.dice.com/job-detail/209494b1-644d-416f-b9e6-d0c5c1b70bbb

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

Open each job to add the full description, required skills, structured salary (min/max) and application deadline. Turn off for a faster, lighter run.

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

Maximum search result pages to fetch per keyword (30 jobs per page). Set to 0 for unlimited / automatic pagination governed by Maximum jobs.

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

Maximum number of job records to save across all keywords.

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

How many job-detail pages to fetch in parallel. Recommended 6–10.

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

Apify Proxy is recommended for reliable access. US IPs return the most complete results.

## Actor input object example

```json
{
  "searchQueries": [
    "Python Developer",
    "DevOps Engineer"
  ],
  "location": "New York",
  "postedDate": "Any",
  "workplaceType": "Any",
  "jobUrls": [
    "https://www.dice.com/job-detail/209494b1-644d-416f-b9e6-d0c5c1b70bbb"
  ],
  "includeJobDetails": true,
  "maxPages": 0,
  "maxItems": 15,
  "maxConcurrency": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "searchQueries": [
        "python developer"
    ],
    "jobUrls": [],
    "includeJobDetails": true,
    "maxPages": 0,
    "maxItems": 15,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "searchQueries": ["python developer"],
    "jobUrls": [],
    "includeJobDetails": True,
    "maxPages": 0,
    "maxItems": 15,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/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 '{
  "searchQueries": [
    "python developer"
  ],
  "jobUrls": [],
  "includeJobDetails": true,
  "maxPages": 0,
  "maxItems": 15,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/dice-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,haketa/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/Dny8ScHF9QBifUrLt/builds/G4BNndzmE5cNWXQHu/openapi.json