# 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:** E-commerce, Lead generation
- **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?

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 — Tech Jobs, Salary, Skills & Companies

Collect **Dice.com** technology and IT job postings as clean, structured data. Search by keyword and location, filter by posted date or workplace type, or paste job URLs — every matching job comes back with a full record: title, company, location, remote/on‑site, employment type, **salary range**, **required skills**, posted date, **application deadline** and the **complete job description**.

Built for **tech recruiters, staffing agencies, job seekers, salary and market analysts, and data teams** who need Dice job data in JSON, CSV or Excel instead of paging through search results by hand.

***

### ✨ Why use this scraper

- **Full job records, not just titles** — each job includes company, structured location, salary, skills, employment type, posted date, deadline and the complete description.
- **Tech‑skill tags** — the specific skills each role asks for (Python, AWS, Kubernetes, React …), ready for filtering and matching.
- **Structured salary** — minimum, maximum and currency where the employer publishes it, plus the raw salary text.
- **Powerful targeting** — search any keyword, scope to a city, state or Remote, and filter by posted date or workplace type.
- **Deep pagination** — collect hundreds or thousands of jobs per keyword, not just the first page.
- **Direct job lookups** — already have a list of Dice job URLs or IDs? Paste them in and get full records back.
- **Clean, typed output** — numbers as numbers, booleans as booleans, skills as arrays — ready for spreadsheets, databases and BI tools.
- **Export anywhere** — JSON, CSV, Excel, HTML or via the Apify API and integrations.

***

### 🚀 Quick start

1. Enter one or more **search keywords** (for example `Python Developer`, `Java`, `DevOps Engineer`).
2. *(Optional)* Set a **location** (`New York`, `Texas`, `Remote`).
3. *(Optional)* Filter by **posted date** and **workplace type**.
4. Set **Maximum jobs** and click **Start**.

The scraper paginates the search, collects every matching job, and (by default) enriches each one with its full description, skills and salary.

***

### 📥 Input

| Field | Type | Description |
|---|---|---|
| **Search keywords** (`searchQueries`) | array | Job keywords — role, skill, technology or company. Each keyword is searched and paginated. |
| **Location** (`location`) | string | Optional location applied to every keyword — a US city, state, or `Remote`. |
| **Posted date** (`postedDate`) | select | Keep only jobs posted within `Past 24 hours`, `Past 3 days`, `Past 7 days`, or `Any`. |
| **Workplace type** (`workplaceType`) | select | Keep only `Remote`, `Hybrid`, `On-Site`, or `Any`. |
| **Job URLs** (`jobUrls`) | array | Dice job‑detail URLs or GUIDs to scrape directly. |
| **Enrich with full job details** (`includeJobDetails`) | boolean | Add full description, skills, structured salary and deadline. On by default. |
| **Maximum jobs** (`maxItems`) | integer | Maximum number of job records to save. Default `100`. |
| **Concurrent detail requests** (`maxConcurrency`) | integer | How many detail pages to fetch in parallel. Recommended 6–10. |
| **Proxy configuration** (`proxyConfiguration`) | object | Apify Proxy is recommended for reliable access. |

#### Example 1 — role in a city

```json
{
  "searchQueries": ["Python Developer"],
  "location": "New York",
  "maxItems": 200
}
```

#### Example 2 — remote jobs posted this week

```json
{
  "searchQueries": ["Data Engineer", "Machine Learning"],
  "workplaceType": "Remote",
  "postedDate": "Past 7 days",
  "maxItems": 300
}
```

#### Example 3 — fast listing pull (no detail enrichment)

```json
{
  "searchQueries": ["Java", "Golang", "Rust"],
  "includeJobDetails": false,
  "maxItems": 500
}
```

#### Example 4 — specific jobs

```json
{
  "jobUrls": [
    "https://www.dice.com/job-detail/209494b1-644d-416f-b9e6-d0c5c1b70bbb"
  ]
}
```

***

### 📤 Output

Each job is one dataset item. Example (fields trimmed for readability):

```json
{
  "guid": "b93fcb85-0d3f-445b-a611-7ff48a9ecc18",
  "title": "Senior Python Developer",
  "companyName": "Apex Systems",
  "companyProfileId": "a1d7df75-e170-5701-a217-...",
  "location": "Jersey City, New Jersey, USA",
  "city": "Jersey City",
  "state": "NJ",
  "postalCode": "07097",
  "country": "US",
  "isRemote": false,
  "workplaceTypes": ["On-Site"],
  "employmentType": "Full-time",
  "salary": "$68 - $73",
  "salaryMin": 68,
  "salaryMax": 73,
  "salaryCurrency": "USD",
  "skills": ["Python", "SQL", "RESTful", "Microservices", "AngularJS"],
  "postedDate": "2026-08-24T09:43:01Z",
  "modifiedDate": "2026-08-24T09:43:01Z",
  "validThrough": "2026-09-23T21:06:41.000Z",
  "easyApply": true,
  "applyType": "Internal",
  "employerType": "Direct Hire",
  "summary": "Senior Python Developer needed for a capital-markets platform...",
  "description": "Full job description text, cleaned to readable plain text...",
  "companyLogoUrl": "https://d3qscgr6xsioh.cloudfront.net/....png?format=webp",
  "companyProfileUrl": "https://www.dice.com/company-profile/a1d7df75-...",
  "url": "https://www.dice.com/job-detail/b93fcb85-0d3f-445b-a611-7ff48a9ecc18",
  "detailEnriched": true,
  "sourceMode": "search",
  "scrapedAt": "2026-08-24T10:05:44.000Z"
}
```

#### Field reference

**Job**

| Field | Description |
|---|---|
| `guid` | Unique Dice job identifier. |
| `title` | Job title. |
| `summary` | Short description snippet from the search results. |
| `description` | Full job description (from the detail page, cleaned to plain text). Requires detail enrichment. |
| `skills` | Array of skills the role asks for. Requires detail enrichment. |
| `url` | Canonical job‑detail URL. |

**Company**

| Field | Description |
|---|---|
| `companyName` | Hiring company. |
| `companyProfileId` | Dice company profile ID. |
| `companyProfileUrl` | Link to the company profile on Dice. |
| `companyLogoUrl` | Company logo image. |
| `employerType` | Employer type (for example Direct Hire, Recruiter). |

**Location & work model**

| Field | Description |
|---|---|
| `location` | Display location. |
| `city`, `state`, `postalCode`, `country` | Structured location (postalCode/country from detail enrichment). |
| `isRemote` | Whether the job is remote. |
| `workplaceTypes` | Array such as `Remote`, `Hybrid`, `On-Site`. |

**Compensation & terms**

| Field | Description |
|---|---|
| `employmentType` | Full‑time, Contract, Third Party, etc. |
| `salary` | Raw salary text as shown on Dice. |
| `salaryMin`, `salaryMax`, `salaryCurrency` | Structured salary range when published. |
| `easyApply` | Whether Dice Easy Apply is available. |
| `applyType` | Application type (Internal / External). |

**Dates & meta**

| Field | Description |
|---|---|
| `postedDate`, `modifiedDate` | When the job was posted / last modified. |
| `validThrough` | Application deadline when published. |
| `detailEnriched` | Whether full detail was fetched for this record. |
| `sourceMode` | How the job was found (`search`, `direct`). |
| `scrapedAt` | ISO timestamp of the scrape. |

***

### 💡 Use cases

- **Recruiters & staffing agencies** — monitor demand for roles and skills, benchmark competitors' postings, and build sourcing lists by company and location.
- **Job seekers** — track new postings for your stack the moment they appear, with salary and deadline in one place.
- **Salary & compensation analysts** — aggregate `salaryMin`/`salaryMax` by role, skill, city and employment type to build up‑to‑date pay benchmarks.
- **Market & talent intelligence** — measure hiring trends, remote‑vs‑on‑site mix, and which skills are rising across the tech market.
- **Competitive intelligence** — see who is hiring, for what, and where — a live signal of a company's roadmap and growth.
- **ATS / CRM feeds** — pipe structured jobs into applicant‑tracking systems, dashboards and lead tools.
- **Researchers & data teams** — build clean datasets of the US tech labor market for analysis and modeling.

***

### 🎯 Filters & tips

- **Be specific.** `Senior Python Developer` returns more relevant results than `Python`. Combine role + seniority + stack for tight targeting.
- **Use several keywords.** Each keyword is paginated independently, so a handful of related terms (`React`, `Vue`, `Angular`) covers a segment quickly.
- **Scope by location.** Set a city, a state, or `Remote`. Leave it blank to search nationwide.
- **Filter by recency.** Use `Past 24 hours` for a daily fresh‑jobs feed, or `Past 7 days` for a weekly sweep.
- **Turn off enrichment for speed.** If you only need titles, companies, locations and the search snippet, set `includeJobDetails` to `false` for a faster, lighter run — then re‑run with enrichment on the jobs you care about.
- **Filter after export.** Pull a wide net, then filter on `skills`, `salaryMin`, `employmentType`, `isRemote` or `state` in your spreadsheet or database.

***

### 📈 Getting more results

- Each keyword is **paginated deeply**, so a single keyword can return hundreds of jobs. Raise **Maximum jobs** to collect more.
- Add **more keywords** to widen coverage — by role, by technology, or by company name.
- Combine **location** and **filters** to slice the market precisely (for example remote data‑engineering jobs posted this week).

***

### 🔍 Popular searches to try

Use these as starting points in **Search keywords** — mix roles, stacks and seniority to match exactly what you need.

**By role**

- `Software Engineer`, `Senior Software Engineer`, `Full Stack Developer`
- `Data Engineer`, `Data Scientist`, `Machine Learning Engineer`
- `DevOps Engineer`, `Site Reliability Engineer`, `Platform Engineer`
- `Cloud Architect`, `Solutions Architect`, `Security Engineer`
- `Business Analyst`, `Project Manager`, `Scrum Master`
- `QA Engineer`, `Automation Engineer`, `Mobile Developer`

**By technology / stack**

- Languages: `Python`, `Java`, `JavaScript`, `TypeScript`, `Go`, `Rust`, `C#`, `Scala`
- Frontend: `React`, `Angular`, `Vue`, `Next.js`
- Cloud & infra: `AWS`, `Azure`, `Google Cloud`, `Kubernetes`, `Terraform`, `Docker`
- Data & AI: `Snowflake`, `Databricks`, `Spark`, `LLM`, `Generative AI`, `PyTorch`
- Security: `Cybersecurity`, `Penetration Tester`, `SOC Analyst`, `IAM`

**By clearance / arrangement**

- `Remote` (with the Workplace type filter), `Contract`, `Corp to Corp`, `W2`
- `Security Clearance`, `TS/SCI`, `Public Trust`

> Tip: combine a role and a stack (`Senior Java AWS`) for tightly targeted results, and set **Posted date** to `Past 24 hours` for a daily fresh‑jobs feed.

***

### 🧩 What you can build with the data

- **A live salary benchmark** — aggregate `salaryMin`/`salaryMax` by role, skill and city, refreshed on a schedule.
- **A skills‑demand tracker** — count how often each skill appears in `skills` over time to see what the market is asking for.
- **A recruiting pipeline** — feed new postings by company and location straight into your CRM or ATS.
- **A job‑alert product** — run `Past 24 hours` searches on a schedule and notify users the moment a matching role appears.
- **A competitive hiring dashboard** — track which companies are posting, for what roles, and where.
- **A remote‑work index** — measure the share of `Remote`, `Hybrid` and `On-Site` roles across the tech market.

***

### 🔌 Run it your way

- **Apify Console** — fill in the form and click Start.
- **API** — start runs and pull the dataset programmatically.
- **Scheduler** — run hourly or daily to keep a fresh jobs feed.
- **Integrations** — push results to Google Sheets, Zapier, Make, webhooks, Slack, S3 and more.

***

### ❓ FAQ

**How many jobs can I collect?**
As many as you need. Each keyword is paginated, so you can pull hundreds or thousands of jobs across several keywords in one run.

**Do I get the full job description?**
Yes, when **Enrich with full job details** is on (the default). Each job's page is opened to add the full description, skills, structured salary and application deadline. Turn it off for a faster, listing‑only run.

**Are salaries always included?**
Only when the employer publishes them. Many tech postings show a range, some show "Depends on Experience", and some show none — the scraper returns whatever is available in `salary`, `salaryMin` and `salaryMax`.

**Can I filter by remote or posted date?**
Yes. Use the **Workplace type** and **Posted date** filters. You can also filter the exported dataset on `isRemote`, `workplaceTypes` and `postedDate`.

**Which region does Dice cover?**
Dice focuses on the United States technology job market. Use US proxies for the most complete results.

**Can I re‑scrape specific jobs?**
Yes. Save the `url` or `guid` of jobs you follow and pass them back in **Job URLs** to refresh their status, salary and deadline.

**In what format is the data?**
Structured JSON by default, exportable to CSV, Excel, HTML and more.

**Can I run it on a schedule?**
Yes — use the Apify Scheduler for recurring runs, or start runs through the Apify API and its integrations.

***

### ⚖️ Legal & responsible use

This tool collects **publicly available** job‑posting information for legitimate business use such as recruitment, market research and salary analysis. You are responsible for how you use the data and for complying with all applicable laws and regulations, the website's terms, and data‑protection rules (including GDPR/CCPA where relevant). Do not use the output to infringe intellectual‑property rights or for any unlawful purpose. This scraper is not affiliated with, endorsed by, or connected to Dice or its parent company; all trademarks belong to their respective owners.

***

#### Tags

`dice` · `dice scraper` · `dice.com` · `tech jobs` · `it jobs` · `job scraper` · `job listings` · `job postings` · `tech recruiting` · `salary data` · `tech skills` · `remote jobs` · `staffing` · `talent intelligence` · `labor market data`

# 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.

## `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,
  "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,
    "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,
    "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,
  "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/OXRdQTiS4OnRnqgGg/openapi.json