# Dice Scraper — Tech Jobs, Salaries, Skills & Hiring Companies (`logiover/dice-scraper`) Actor

Dice.com jobs scraper: export US tech jobs with salary ranges, contract types (W2, 1099, Corp-to-Corp), skills, full descriptions and the hiring company's website, size and industry. Search or export all ~110,000 jobs. No login. Not affiliated with Dice.

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

## Pricing

from $1.00 / 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.
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 Scraper

> Independent tool. Not affiliated with, endorsed by, or sponsored by Dice or DHI Group, Inc. "Dice" is a trademark of its owner and is used here only to describe the website this Actor reads.

**Dice Scraper** exports job listings from **Dice.com** — the largest US job board for technology professionals — into clean JSON, CSV or Excel. Search by keyword, city, state, ZIP code or "Remote", filter by **employment type (full-time, contract W2 / 1099, Corp-to-Corp)**, workplace (on-site, remote, hybrid), employer type (direct hire vs. recruiter), posting date, Easy Apply and **visa sponsorship**, or **export every job on Dice in one run** (about 110,000 jobs in under two minutes). No Dice account, no login, no cookies and no browser are needed.

Every row comes with the **salary range** (parsed into min / max / currency / period), the **full job description**, Dice's **skills list**, the **contract types** the employer accepts (W2, 1099, C2C), the employer's own **position / requisition id**, and the **hiring company's website, size, founding year, headquarters, industries and company type** (employer or staffing agency). Use it as a **Dice API alternative**, a **Dice jobs scraper** for recruiting and staffing sales, a source for **tech salary benchmarks**, or a daily feed of new tech jobs for your ATS, CRM or job board.

***

### What you get

| | |
|---|---|
| **Jobs** | Title, Dice job id, URL, posting and update dates, expiry date, apply type (on Dice or on the employer's site) |
| **Pay** | Salary text as posted + parsed `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` (hour / week / month / year) |
| **Contract details** | Employment type (full-time, part-time, contract, third party) and contract types: **W2**, **Independent (1099)**, **Corp-to-Corp (C2C)** |
| **Location** | City, state, state code, ZIP code, country, remote flag, workplace types (on-site / remote / hybrid) |
| **Requirements** | Full description (plain text and HTML), Dice's skills list, Easy Apply flag, visa sponsorship flag |
| **Employer** | Company name, Dice company id, employer type (direct hire / recruiter / other), logo, Dice company profile |
| **Company profile** | Website, employee count, founded year, headquarters, office locations, industries, company type (employer or staffing agency), description, tech stack, social links |
| **Scale** | 1,000 jobs per request; searches above Dice's 10,000-result limit are split automatically; the whole board (~110,000 jobs) in one run |

All numbers on this page were measured on the Apify platform on **2026-10-15** (see [How much data can I get?](#how-much-data-can-i-get)).

***

### Use cases

#### Recruiting and sourcing

Pull every open **Java, Python, DevOps, data, cloud or cybersecurity** role in a metro area, with salary ranges and required skills, to see what competing employers offer and which skills are in demand. Filter to **direct-hire** postings to skip agency duplicates.

#### Staffing agency business development (companies hiring = leads)

Every job is a buying signal. Export the companies hiring for the skills you place, with their **website, size, headquarters and industry**, and hand the list to your sales team. Filter by **employer type = direct hire** to reach the end client, or by **recruiter** to map competing agencies.

#### Contract and C2C market

Dice is the main US board for **contract and Corp-to-Corp** IT work. Filter `employmentTypes` to `CONTRACTS` and `THIRD_PARTY` and get the hourly rate, the accepted contract types (**W2 / 1099 / C2C**) and the client location for every requirement — the daily bench-sales feed in one CSV.

#### Salary benchmarking and labor-market research

\~56% of Dice jobs carry a parsable pay range (99.6% of the ones that state a number are parsed). Build hourly and annual pay distributions by title, skill, state and employer type; track them weekly by scheduling the Actor.

#### Visa sponsorship (H-1B) job lists

`willingToSponsorOnly: true` returns only the jobs whose employer marked **willing to sponsor** — useful for international candidates and immigration-focused job boards.

#### Job boards, aggregators and ATS feeds

Schedule a run with `postedWithin: "1"` every morning and push only the last 24 hours of Dice jobs into your board, Slack channel, Airtable or database. `descriptionHtml` keeps the original formatting for re-publishing.

#### AI agents and LLM pipelines

Feed structured job data (skills, pay, location, company) to your RAG index or agent through the API or the Apify MCP server.

***

### How it works

1. The Actor calls the same public JSON search API that dice.com uses, **1,000 jobs per request**, over a direct connection (no proxy cost).
2. Dice answers at most **10,000 results per search**. When you ask for more, the search is split along Dice's own exact filters — remote / employer type / Easy Apply / sponsorship / work-from-home / employment type, then **state by state and country by country** — until every slice fits, and each job is de-duplicated by its Dice id.
3. With **Include full job details** on (default), each job page is read for the full description, skills, contract types, position id, apply type, ZIP code and expiry date (40 pages in parallel).
4. With **Include company profile** on (default), the hiring companies' Dice profiles are fetched **50 companies per request** and cached, so the cost is almost zero.
5. Rows stream into the dataset as they are ready. A run that cannot reach Dice fails with the reason instead of returning an empty "success".

***

### Input

#### 1. Keyword search (nationwide)

```json
{
  "searchTerms": ["data engineer", "snowflake"],
  "maxItems": 2000
}
```

#### 2. Location + filters

```json
{
  "searchTerms": ["java developer"],
  "locations": ["Austin, TX", "Dallas, TX"],
  "radiusMiles": 50,
  "includeRemoteJobs": false,
  "workplaceTypes": ["On-Site", "Hybrid"],
  "employerTypes": ["Direct Hire"],
  "postedWithin": "7",
  "maxItems": 1000
}
```

Locations accept a US city (`"Austin, TX"`), a state (`"Texas"` or `"TX"`), a ZIP code (`"94105"`) or `"Remote"` for remote-only jobs. A few international cities work too (Dice lists a few hundred jobs in Canada, India, the UK and Mexico).

#### 3. Contract / Corp-to-Corp (C2C) requirements

```json
{
  "searchTerms": ["salesforce", "sap", "servicenow"],
  "employmentTypes": ["CONTRACTS", "THIRD_PARTY"],
  "postedWithin": "1",
  "maxItems": 5000
}
```

#### 4. Jobs from specific companies

```json
{
  "companies": ["Booz Allen Hamilton", "Capital One", "Kforce Technology Staffing"],
  "maxItems": 3000
}
```

Company names are matched the way Dice spells them (case does not matter). If Dice cannot filter a company (some employers post through job-ad distributors), the Actor searches the name and keeps only that company's jobs.

#### 5. Export every job on Dice

```json
{
  "maxItems": 0,
  "includeDetails": false,
  "includeCompanyDetails": true
}
```

Leave the search empty and set `maxItems` to `0`. Measured: **111,324 unique jobs in 104 seconds** with company profiles. Turn `includeDetails` on for full descriptions and skills (~45 jobs per second, about 40 minutes for the whole board). Make sure your **Maximum cost per run** covers the number of results (see below).

#### 6. Paste Dice URLs

```json
{
  "startUrls": [
    { "url": "https://www.dice.com/jobs?q=devops&location=Seattle,%20WA&radius=50&filters.employmentType=CONTRACTS&filters.workplaceTypes=Hybrid" },
    { "url": "https://www.dice.com/job-detail/4cdb2d7b-eda3-474f-b5ff-6ff95c99ca1a" }
  ]
}
```

Search pages keep their filters; job pages are scraped directly.

#### All input fields

| Field | Type | Default | What it does |
|---|---|---|---|
| `searchTerms` | array | `[]` | Keywords, titles or skills. Each is one Dice search. Empty = all jobs. |
| `locations` | array | `[]` | City, state, ZIP or `"Remote"`. Combined with every term. Empty = nationwide. |
| `radiusMiles` | integer | `30` | Radius around a city or ZIP, 1–300 miles. |
| `includeRemoteJobs` | boolean | `true` | Dice's default: location searches also list remote jobs. Turn off for local jobs only. |
| `employmentTypes` | array | `[]` | `FULLTIME`, `PARTTIME`, `CONTRACTS` (W2 / 1099), `THIRD_PARTY` (Corp-to-Corp). |
| `workplaceTypes` | array | `[]` | `On-Site`, `Remote`, `Hybrid`. |
| `employerTypes` | array | `[]` | `Direct Hire`, `Recruiter`, `Other`. |
| `postedWithin` | string | `any` | `1`, `3`, `7` (Dice's filter), `14`, `30` days (date cut-off). |
| `easyApplyOnly` | boolean | `false` | Only Easy Apply jobs. |
| `willingToSponsorOnly` | boolean | `false` | Only jobs marked "willing to sponsor". |
| `companies` | array | `[]` | Company names; each is its own search. |
| `startUrls` | array | `[]` | Dice search pages and/or job pages. |
| `sortBy` | string | `newest` | `newest` or `relevance`. |
| `maxItems` | integer | `1000` | Max unique jobs per run. `0` = no limit. |
| `includeDetails` | boolean | `true` | Read job pages: description, skills, contract types, position id, apply type, ZIP, expiry. |
| `includeCompanyDetails` | boolean | `true` | Add the company profile: website, size, founded, HQ, industries, type. |
| `proxyConfiguration` | object | Apify Proxy | Fallback only — the Actor uses a direct connection first. |

Filter values are validated: Dice silently returns zero results for misspelled filter values, so the input only offers the values Dice actually accepts.

***

### Output data dictionary

One row per job. Fields that do not apply are `null` (never an empty string or a guessed 0).

| Field | Example | Description |
|---|---|---|
| `jobId` | `3673fefb-c98e-482d-8250-376b1cd0001a` | Dice's public job id (used in the URL). Unique per row. |
| `legacyJobId` | `868fb7d818f8693e81caa49d9882de96` | Dice's internal job id. |
| `url` | `https://www.dice.com/job-detail/…` | Job page on dice.com. |
| `applyUrl` | `https://www.dice.com/direct-apply/…` | Direct-apply link when the employer takes applications on its own site. |
| `title` | `Cloud Engineer` | Job title. |
| `companyName` | `Booz Allen Hamilton` | Hiring company as shown on Dice. |
| `companyDiceId` | `booz` | Dice company id ("Dice Id" on the job page). |
| `companyProfileId` / `companyProfileUrl` | `3ea34b07-…` | The company's Dice profile. |
| `companyLogoUrl` | `https://…png` | Company logo. |
| `location` | `Seattle, Washington, USA` | Location as Dice lists it. |
| `city`, `state`, `stateCode`, `country`, `postalCode` | `Seattle`, `Washington`, `WA`, `USA`, `98141` | Parsed location; ZIP from the job page. |
| `isRemote` | `false` | Dice's remote flag. |
| `workplaceTypes` | `On-Site \| Hybrid` | On-site / remote / hybrid (several possible). |
| `workFromHomeAvailable` | `true` | Dice's work-from-home flag. |
| `employmentType` | `Contract, Third Party` | Employment type as posted. |
| `contractTypes` | `W2 \| Corp-to-Corp (C2C)` | Contract arrangements accepted: W2, Independent (1099), Corp-to-Corp (C2C). Contract jobs only. |
| `employerType` | `Direct Hire` | Direct hire (employer), Recruiter (agency) or Other. |
| `easyApply` | `true` | One-click apply on Dice. |
| `willingToSponsor` | `false` | Employer is willing to sponsor a visa. |
| `salary` | `USD 86,900.00 - 198,000.00 per year` | Pay exactly as posted. |
| `salaryMin`, `salaryMax` | `86900`, `198000` | Parsed pay range (numbers). |
| `salaryCurrency` | `USD` | Currency of the range. |
| `salaryPeriod` | `YEAR` | `HOUR`, `DAY`, `WEEK`, `MONTH` or `YEAR`. |
| `postedAt`, `updatedAt` | `2026-10-15T08:06:22.000Z` | Posting and last-update time (ISO 8601). |
| `validThrough` | `2026-11-15T09:06:22.000Z` | When the posting expires. |
| `summary` | `Job Number: R0251658 …` | First ~500 characters of the description (from search). |
| `description` | full text | Full job description, plain text with line breaks. |
| `descriptionHtml` | `<b>Job Number…` | Full description with the original HTML formatting. |
| `skills` | `Python \| Terraform \| Kubernetes \| …` | Dice's skills list for the job. |
| `positionId` | `R0251658` | The employer's own requisition / position id. |
| `applyType` | `External` | `Internal` = apply on Dice, `External` = employer's site. |
| `isFeatured` | `false` | Featured listing. |
| `companyProfileName` | `Booz Allen Hamilton` | Name on the company profile (can differ after a rebrand, e.g. Apex Systems → Everforth). |
| `companyWebsite` | `https://www.boozallen.com/` | Company website. |
| `companySize` | `10,000+` | Employee count band. |
| `companyFounded` | `1914` | Year founded. |
| `companyType` | `Employer` | `Employer` or `Staffing & Recruiting`. |
| `companyIndustries` | `Government \| Information Technology` | Industries on the profile. |
| `companyHeadquarters` | `McLean, VA, USA` | Headquarters. |
| `companyLocations` | `McLean, VA, USA` | Office locations on the profile. |
| `companyOfficePolicy` | `Remote & Onsite` | Office policy. |
| `companyDescription` | `Booz Allen is …` | Company description (up to 4,000 characters). |
| `companyTechnologies` | `Linux \| Ansible` | Tech stack listed on the profile. |
| `companySocialLinks` | `https://twitter.com/BoozAllen` | Social profiles. |
| `searchTerm`, `searchLocation` | `engineer`, `null` | Which search found the job (useful in multi-search runs). |
| `scrapedAt` | `2026-10-15T11:01:15Z` | When the row was collected. |

The Output tab has three views: **Overview**, **Job details** (pay, contract types, skills, description) and **Hiring companies** (website, size, type, HQ).

***

### Output example

Real rows from a platform run on 2026-10-15 (long texts shortened, some fields left out for space):

```json
{
  "jobId": "3673fefb-c98e-482d-8250-376b1cd0001a",
  "url": "https://www.dice.com/job-detail/3673fefb-c98e-482d-8250-376b1cd0001a",
  "title": "Cloud Engineer",
  "companyName": "Booz Allen Hamilton",
  "companyDiceId": "booz",
  "location": "Maryland, USA",
  "city": "Annapolis Junction",
  "stateCode": "MD",
  "postalCode": "20701",
  "isRemote": false,
  "workplaceTypes": "On-Site | Hybrid",
  "employmentType": "Full-time",
  "employerType": "Direct Hire",
  "easyApply": false,
  "willingToSponsor": false,
  "salary": "USD 86,900.00 - 198,000.00 per year",
  "salaryMin": 86900,
  "salaryMax": 198000,
  "salaryCurrency": "USD",
  "salaryPeriod": "YEAR",
  "postedAt": "2026-10-15T08:06:22.000Z",
  "description": "Job Number: R0251658\n\nCloud Engineer\nThe Opportunity:\n\nEveryone is trying to \"harness the cloud,\" …",
  "skills": "IT Infrastructure | Microsoft Azure | DevOps | IaaS | Terraform | Python | Kubernetes | Amazon EKS | FedRAMP | Splunk | Security Clearance | …",
  "positionId": "R0251658",
  "applyType": "External",
  "validThrough": "2026-11-15T09:06:22.000Z",
  "companyWebsite": "https://www.boozallen.com/",
  "companySize": "10,000+",
  "companyFounded": 1914,
  "companyType": "Employer",
  "companyIndustries": "Government | Information Technology",
  "companyHeadquarters": "McLean, VA, USA",
  "companySocialLinks": "https://twitter.com/BoozAllen | https://www.instagram.com/boozallen/"
}
```

```json
{
  "jobId": "1bdc6518-5b18-442c-9832-eb4b647bbf5a",
  "title": "Software Development Engineer",
  "companyName": "BCforward",
  "location": "Seattle, Washington, USA",
  "postalCode": "98141",
  "employmentType": "Contract",
  "contractTypes": "W2",
  "employerType": "Direct Hire",
  "easyApply": true,
  "salary": "$68 - $72.14 per hour",
  "salaryMin": 68,
  "salaryMax": 72.14,
  "salaryPeriod": "HOUR",
  "positionId": "411003-513",
  "applyType": "Internal",
  "companyWebsite": "http://www.bucherandchristian.com",
  "companySize": "501-1000",
  "companyType": "Staffing & Recruiting",
  "companyHeadquarters": "Indianapolis, IN, USA"
}
```

***

### How much data can I get?

Dice lists roughly **110,000–113,000 jobs** at any time (mostly US technology, engineering and IT roles, plus some healthcare, finance and government work). Measured on the Apify platform on **2026-10-15**:

| Run | Result | Time |
|---|---|---|
| Prefill / first run (100 jobs, job pages + company profiles) | 100 jobs | **5.9 s** |
| 1,000 jobs, default settings | 1,000 jobs, 0 duplicates | **28.8 s** |
| 10,000 jobs with full job pages + company profiles | 10,000 jobs, 0 duplicates, 99.8% with description | **211 s** |
| **The whole Dice job board** (company profiles on, job pages off) | **111,324 unique jobs, 0 duplicates** (98.4% of the 113,187 Dice reported at that moment) | **104 s** |

Coverage notes:

- One Dice search stops at 10,000 results; the Actor splits bigger searches automatically (12 splits and 85 slices for the whole board).
- About 1.5% of Dice jobs have no state or country at all (and are not marked remote); Dice offers no filter for them, so the Actor reaches them through the newest and the most relevant 10,000 of their slice. That is why a full export lands at ~98.5%, not 100%.

Fill rates measured on the 10,000-job run: description 99.8%, skills 97.8%, position id 99.8%, location 91%, ZIP code 88%, pay text 76%, parsed pay range 56% (99.6% of the pay texts that contain a number), company profile 81%, company website 61%, contract types on 92% of contract jobs. Fields are empty only when Dice has no value — e.g. "Depends on Experience" pay, or jobs posted through job-ad distributors, whose company profile belongs to the distributor and is therefore left out instead of being attached to the wrong employer.

#### Big runs need a big enough "Maximum cost per run"

Apify stops every pay-per-result run at its **Maximum cost per run** (set in the run options; the platform also sets a default). The Actor reads that limit at start, stops cleanly when it is reached and tells you so: *"Saved 37 jobs — this run's maximum cost ($0.05) covers 37 results at the current price. Raise 'Maximum cost per run' to get more."* The run still ends as **Succeeded** and you pay only for the jobs saved. For a full-board export (110,000+ jobs) raise the limit to cover it.

***

### What you pay

**A fixed price per job in the dataset** — compute, proxies and the job-page / company-profile requests are included. No monthly rental, no charge for duplicates or for jobs that were filtered out.

| Apify plan | Price per 1,000 jobs |
|---|---|
| Free | $1.50 |
| Bronze | $1.33 |
| Silver | $1.17 |
| Gold, Platinum, Diamond | $1.00 |

***

### Integrations

#### API (curl)

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~dice-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms":["python developer"],"locations":["New York, NY"],"maxItems":200}'
```

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('logiover/dice-scraper').call({
    searchTerms: ['devops engineer'],
    employmentTypes: ['CONTRACTS', 'THIRD_PARTY'],
    postedWithin: '1',
    maxItems: 1000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].salaryMin, items[0].contractTypes);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/dice-scraper").call(run_input={
    "searchTerms": ["data engineer"],
    "locations": ["Texas"],
    "maxItems": 2000,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["companyName"], job["salaryMin"], job["companyWebsite"])
```

#### Make, Zapier and n8n

Use the Apify app / node: "Run Actor" with `logiover/dice-scraper` and your input, then "Get dataset items" to map fields into Google Sheets, HubSpot, Salesforce, Airtable, Slack or email.

#### Google Sheets

Export the dataset as CSV/Excel from the run page, or use the Apify Google Sheets integration to append new jobs to a sheet after every scheduled run.

#### Webhooks

Add a webhook on "Run succeeded" to call your endpoint with the dataset id — ideal for a daily new-jobs feed (`postedWithin: "1"`, schedule every morning).

#### MCP and AI agents

The Actor works through the Apify MCP server, so Claude, ChatGPT or your own agent can call it as a tool ("find remote Python contract jobs posted today with C2C") and receive structured rows.

***

### Comparison

| | This Actor | Copying from dice.com | Typical one-page scrapers |
|---|---|---|---|
| Jobs per request | 1,000 | 20 per page | 20–100 |
| Past Dice's 10,000-result limit | Yes, automatic split | No | No |
| Whole board in one run | ~111,000 in ~2 min | No | No |
| Contract types (W2 / 1099 / C2C) | Yes | Manually | Rarely |
| Parsed salary range | Yes | No | Rarely |
| Company website, size, HQ, type | Yes (50 companies per request) | Manually | No |
| Login / cookies needed | No | — | Sometimes |
| Honest failure when Dice is unreachable | Yes (run fails with the reason) | — | Often "succeeds" with 0 rows |

***

### Limits and tips

- **Max 10,000 per search on Dice** — handled automatically; you never need to split searches yourself.
- **Job pages are the slow part** (~45 jobs/second). For 50,000+ jobs, consider `includeDetails: false` first and enrich only the jobs you need by pasting their URLs into `startUrls`.
- **Dice's keyword search is broad**: "software engineer" matches ~79,000 jobs because Dice searches descriptions too. Combine terms with filters, or use quotes and specific titles.
- **Dice is US-focused**. A few hundred jobs are located in Canada, India, the UK, Mexico and elsewhere; they are included in full-board exports.
- **Pay**: about a quarter of jobs say "Depends on Experience" — those keep `salary` and leave the parsed range empty.
- **Locations Dice cannot place** (typos, unknown towns) are reported and skipped instead of silently searching the whole country.

***

### FAQ

#### What is Dice Scraper?

An Apify Actor that exports job listings from Dice.com — title, company, location, pay, employment and contract type, skills, full description and the hiring company's profile — as JSON, CSV or Excel, by keyword, location, filters, company or for the whole board.

#### Is there an official Dice API?

Dice does not offer a public jobs API for third parties. This Actor reads the same public search API and job pages that dice.com shows to every visitor, without logging in, and turns them into structured data.

#### Do I need a Dice account, login or cookies?

No. Everything the Actor reads is public. No account, cookies or API key of yours are needed.

#### Do I need proxies?

No. The Actor uses a direct connection first; if Dice ever refuses it, it switches to Apify datacenter proxies and then to the proxy in your input, and goes back to the cheaper route when it works again.

#### How many jobs can I get per run?

Up to the whole board: 111,324 unique jobs were exported in one run on 2026-10-15. Searches over 10,000 results are split automatically.

#### How fast is it?

1,000 jobs with full details in ~30 seconds; 10,000 in ~3.5 minutes; the whole board without job pages in under 2 minutes.

#### How much does it cost?

A fixed $1.00–$1.50 per 1,000 jobs depending on your Apify plan, everything included. See [What you pay](#what-you-pay).

#### Can I get only contract or C2C (Corp-to-Corp) jobs?

Yes: `"employmentTypes": ["CONTRACTS", "THIRD_PARTY"]`. With job details on, `contractTypes` shows which of W2, 1099 and C2C the employer accepts.

#### Can I filter by salary?

Dice has no salary filter, but every row has `salaryMin`, `salaryMax` and `salaryPeriod`, so you can filter the dataset (or the CSV) by pay after the run.

#### Can I scrape only jobs posted today?

Yes: `"postedWithin": "1"` (last 24 hours). Schedule the Actor daily for a fresh feed. 14 and 30 days are supported too.

#### How do I get only jobs in one city without remote jobs?

Set `locations` to the city and `includeRemoteJobs` to `false`. Dice's default mixes nationwide remote jobs into local searches.

#### Why is the company website empty for some jobs?

Some employers post on Dice through job-ad distributors (Appcast, JobTarget, Recruitics …). Their jobs point to the distributor's profile, not the employer's, so the Actor leaves the company fields empty rather than attaching the wrong company. Other employers have a Dice profile without a website.

#### Why did my run stop before Max results?

Either Dice had no more matching jobs (the status message says "every matching job read"), or the run reached its **Maximum cost per run** (the status message says so and shows how many results the limit covers). Raise the limit in the run options for bigger exports.

#### What happens if Dice is down or blocks the run?

The Actor retries, changes route (direct → datacenter proxy → your proxy) and, if nothing works, **fails** with the reason in the log and in the `SUMMARY` record — it never reports an empty dataset as a successful search.

#### Can I scrape a list of Dice job URLs?

Yes. Put `https://www.dice.com/job-detail/...` URLs into `startUrls`; each becomes a full row (description, skills, pay, company).

#### Can I monitor new jobs for specific companies?

Yes: `companies` + `postedWithin: "1"` + a daily schedule.

#### I need a field or a filter that is missing. Can you add it?

Yes — open an issue on the Actor's Issues tab and describe what you need.

***

### Is it legal to scrape Dice?

This Actor reads only publicly available job postings — the same information any visitor sees on dice.com without logging in — and does not collect personal data about candidates. Job postings are business information published to be seen. You are responsible for using the data in line with Dice's terms, applicable laws (including GDPR/CCPA where personal data is concerned) and your own policies. If in doubt, consult a lawyer.

**Legal & trademark disclaimer:** This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Dice, DHI Group, Inc. or any of their subsidiaries. All trademarks mentioned are the property of their respective owners.

***

### Changelog

- **1.0 (2026-10-15)** — First release: Dice search API with 1,000 jobs per request; automatic splitting past Dice's 10,000-results-per-search limit (remote, employer type, Easy Apply, sponsorship, work from home, employment type, then state by state and country by country); job pages (full description, skills, contract types W2 / 1099 / C2C, position id, apply type, ZIP, expiry); company profiles 50 per request (website, size, founded, HQ, industries, type); job-ad distributor profiles detected and left out; pay-per-result budget handled cleanly.

***

### Support

Questions, bugs or a feature request? Open an issue on the **Issues** tab — we reply **within 24 hours**. If a run did something unexpected, include the run link so we can see the log.

# Changelog

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

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords, job titles or skills to search, e.g. "data engineer", "python", "salesforce developer". Each term is one Dice search. Leave empty (with no locations or companies) to export every job on Dice.

## `locations` (type: `array`):

Optional. US city ("Austin, TX"), state ("Texas" or "TX"), ZIP code ("94105") or "Remote" for remote-only jobs. Every search term is combined with every location. Empty = nationwide.

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

Search radius around a city or ZIP code, 1–300 miles (Dice's own range). Ignored for states and "Remote".

## `includeRemoteJobs` (type: `boolean`):

Dice's default: a search for "Austin, TX" also lists remote jobs that can be done from anywhere. Turn off to keep only jobs located in the area.

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

Any of: full-time, part-time, contract (W2 / 1099) or third party (Corp-to-Corp, C2C). Empty = all.

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

On-site, remote or hybrid. Empty = all.

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

Direct hire (the employer posts the job), recruiter (staffing agency) or other. Empty = all.

## `postedWithin` (type: `string`):

Only jobs posted in this window. 1, 3 and 7 days use Dice's own filter; 14 and 30 days sort by date and stop at the cut-off.

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

Only jobs you can apply to on Dice in one click.

## `willingToSponsorOnly` (type: `boolean`):

Only jobs whose employer marked "willing to sponsor".

## `companies` (type: `array`):

Optional. Company names as shown on Dice, e.g. "Apex Systems", "Capital One", "Booz Allen Hamilton". Each company is its own search (combined with the terms and locations). Names are matched the way Dice spells them; if Dice cannot filter a company, its name is searched and only that company's jobs are kept.

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

Optional. Paste Dice search pages (https://www.dice.com/jobs?q=...\&location=...) with any filters, or job pages (https://www.dice.com/job-detail/...). If you only give URLs, only the URLs are scraped.

## `sortBy` (type: `string`):

Newest first (best for monitoring and big exports) or Dice's relevance ranking.

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

Stop after this many unique jobs across all searches. 0 = no limit (every matching job; all of Dice is ~110,000 jobs). One Dice search returns at most 10,000 results — above that the scraper splits the search automatically.

## `includeDetails` (type: `boolean`):

Reads each job page: full description (text and HTML), skills list, contract types (W2 / 1099 / Corp-to-Corp), employer's position id, apply type (on Dice or on the employer's site), ZIP code and expiry date. Turn off for the fastest bulk export (search data only: ~1,000 jobs per second).

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

Adds the hiring company's website, size, founding year, headquarters, industries, company type (employer or staffing agency), description and tech stack from its Dice company profile. Fetched once per company, 50 companies per request — almost no extra time.

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

Used only as a fallback. The scraper talks to Dice over a direct connection first (no proxy cost); if Dice refuses it, it switches to Apify datacenter proxies and then to this proxy.

## Actor input object example

```json
{
  "searchTerms": [
    "data engineer"
  ],
  "locations": [],
  "radiusMiles": 30,
  "includeRemoteJobs": true,
  "employmentTypes": [],
  "workplaceTypes": [],
  "employerTypes": [],
  "postedWithin": "any",
  "easyApplyOnly": false,
  "willingToSponsorOnly": false,
  "companies": [],
  "startUrls": [],
  "sortBy": "newest",
  "maxItems": 100,
  "includeDetails": true,
  "includeCompanyDetails": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All jobs collected in this run.

# 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 = {
    "searchTerms": [
        "data engineer"
    ],
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/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 = {
    "searchTerms": ["data engineer"],
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/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 '{
  "searchTerms": [
    "data engineer"
  ],
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call logiover/dice-scraper --silent --output-dataset

```

## MCP server setup

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