# Dice.com Tech Job Scraper — Salaries, Skills & Remote (`lovely_radiologist/dice-job-scraper`) Actor

Scrapes Dice.com tech job listings — title, company, salary, location, employment type, workplace type, skills, and full description — without login.

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

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-usage

## 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 hero](https://lh3.googleusercontent.com/d/1dAX3RpNnjExS29f6XBCGgWqi9EtYu3pt)

## 🎲 Dice.com Job Scraper

Extract **US tech job listings** from [Dice.com](https://www.dice.com) — job titles, companies, salaries, locations, skills, workplace type, employment type, and full job descriptions — as clean, structured JSON, ready for market research, recruitment, or job-search apps.

***

***

Dice is where America's tech roles get posted — and this actor turns that firehose into a tidy dataset you can actually use.

Tell it what you're hunting for (a role, a skill, a city, a type of work) and it returns every matching opening with the details filled in: who's hiring, what they pay, where the job sits, whether it's remote, and the full job description — all without a login, a browser, or a Dice account.

***

### What You Get

**Complete job records, not just titles and links.** Every result carries:

- 🏢 **Company** — name, employer type (direct hire vs. recruiter), profile link, and logo
- 💰 **Salary** — raw text *plus* parsed min/max, currency, and pay period
- 📍 **Location** — city, state, region, and postal code, broken out into separate fields
- 🏠 **Workplace** — remote, hybrid, or on-site, plus an `isRemote` flag
- 📝 **Description** — full text in three formats: plain, HTML, and Markdown
- 🧩 **Skills** — the required-skills list pulled from each posting
- 📅 **Dates** — posted, last-modified, and the posting's expiry date
- 🔗 **Links** — direct job URL and company profile URL

**No login. No browser. No API key.** The actor reads the same public pages Google crawls, so there's nothing to authenticate and nothing to get blocked on.

***

### Search Any Way You Need

Filter your results down to exactly the roles that matter:

| Filter | Options |
|---|---|
| **Keyword** | Any role, skill, or title — "Python Developer", "Kubernetes", "DevOps" |
| **Location** | City + state, or "Remote" |
| **Radius** | Miles from the location |
| **Posted** | Last 1, 3, or 7 days |
| **Employment type** | Full-time, Part-time, Contract, Third Party |
| **Employer type** | Direct Hire, Recruiter, Other |
| **Workplace** | Remote, Hybrid, On-site |
| **Easy Apply** | Only Easy-Apply listings |
| **Sponsorship** | Only roles willing to sponsor visas |

Run **multiple searches at once**, or use **location fan-out** to sweep the same role across every major city in a single run.

***

### Who It's Built For

- **Recruiters & staffing firms** — watch who's hiring in real time and build candidate-ready pipelines
- **Job boards & aggregators** — keep a niche board stocked with fresh Dice listings
- **Market researchers** — track salary trends, skill demand, and hiring velocity by city or technology
- **Sales teams** — spot companies actively scaling their engineering orgs
- **Job seekers** — filter remote and contract roles in one pass, export to CSV, done

***

### Input

<img src="https://lh3.googleusercontent.com/d/12TJpaiqbJhQ2Ldvhw_GsGeE3vxXtGLwu" alt="Input" width="70%" />

```json
{
  "searches": [
    {
      "q": "Software Developer",
      "location": "New York, NY",
      "employmentTypes": ["FULLTIME"],
      "workplaceTypes": ["Remote"],
      "postedDate": "SEVEN",
      "easyApply": true,
      "willingToSponsor": true
    }
  ],
  "locations": ["New York, NY", "Austin, TX", "Remote"],
  "fetchDetails": true,
  "maxResults": 1000,
  "proxyConfiguration": { "useApifyProxy": true }
}
```

| Parameter | What it does |
|---|---|
| `searches` | One or more keyword/location searches, each with its own filters |
| `locations` | Fan-out — repeat every search once per city for wider coverage |
| `postedDateWindows` | Fan-out — split results by recency to bypass the per-query result cap |
| `startUrls` | Paste raw Dice listing or job-detail URLs to scrape directly |
| `fetchDetails` | Pull the full description, skills, and expiry from each job page |
| `maxResults` | Cap total output (0 = up to 5000) |
| `maxResultsPerSearch` | Cap each individual search |
| `pageSize` / `maxPages` | Pagination controls (Dice limits a query to ~25 pages) |
| `delayMs` / `maxRetries` | Politeness and resilience tuning |
| `resume` | Continue a previous run from where it stopped |
| `respectRobots` | Stay within Dice's allowed crawl paths (on by default) |
| `proxyConfiguration` | Datacenter or residential Apify proxy |

> **Tip:** a single Dice query returns roughly 500 results before its internal page cap. Use `locations` and `postedDateWindows` fan-out to slice one broad search into many smaller ones and pull thousands of unique jobs.

***

### Output

<img src="https://lh3.googleusercontent.com/d/1K1PHEd3cbeyoGZdeCnyhuFpxz9VLkZAI" alt="Output" width="70%" />

#### Output schema

| Group | Field | Type | Description |
|---|---|---|---|
| Identity | `scrapedAt` | string | When the record was collected (ISO 8601) |
| Identity | `id` | string | Dice's job identifier |
| Identity | `guid` | string | Position identifier (UUID) — the dedup key |
| Identity | `title` | string | Job title |
| Identity | `score` | number | Dice's relevance score |
| Company | `company` | string | Hiring company name |
| Company | `employerType` | string | `Recruiter` | `Direct Hire` | `Other` |
| Company | `clientBrandId` | string | Employer identifier |
| Company | `companyProfileId` | string | Dice company ID |
| Company | `companyProfileUrl` | string | Company profile URL |
| Company | `companyLogoUrl` | string | Company logo image URL |
| Employment | `employmentType` | string | `Full-time` | `Contract` | `Part-time` |
| Employment | `employmentTypeRaw` | string | `FULL_TIME` | `CONTRACTOR` | … |
| Employment | `workplaceTypes` | array | `Remote` | `On-Site` | `Hybrid` |
| Employment | `isRemote` | boolean | Fully-remote indicator |
| Employment | `workFromHomeAvailability` | string | `TRUE` / `FALSE` |
| Employment | `easyApply` | boolean | Easy-Apply availability |
| Location | `jobLocation` | object | `{ city, state, region, country, displayName, postalCode }` |
| Location | `city` | string | City (flattened) |
| Location | `state` | string | State (flattened) |
| Location | `country` | string | Country (flattened) |
| Location | `postalCode` | string | Zip/postal code |
| Salary | `salaryText` | string | Raw salary string |
| Salary | `salaryMin` | number | Parsed minimum |
| Salary | `salaryMax` | number | Parsed maximum |
| Salary | `salaryCurrency` | string | `USD`, `EUR`, … |
| Salary | `salaryPeriod` | string | `year` | `hour` | `month` | `week` | `day` |
| Dates | `postedDate` | string | Original posting date (ISO) |
| Dates | `modifiedDate` | string | Last updated (ISO) |
| Dates | `validThrough` | string | Posting expiry (ISO) |
| Content | `summary` | string | Listing snippet |
| Content | `description` | string | Full description (plain text) |
| Content | `descriptionHtml` | string | Full description (HTML) |
| Content | `descriptionMarkdown` | string | Full description (Markdown) |
| Content | `skills` | array | Required skills list |
| Provenance | `detailsPageUrl` | string | Direct job URL |
| Provenance | `searchQuery` | string | Search that produced this record |
| Provenance | `searchUrl` | string | The exact search URL |
| Provenance | `source` | string | Always `dice.com` |

#### Example record

```json
{
  "title": "Senior Data Engineer",
  "company": "ABC Technologies",
  "employerType": "Direct Hire",
  "employmentType": "Full-time",
  "employmentTypeRaw": "FULL_TIME",
  "jobLocation": {
    "city": "New York",
    "state": "New York",
    "region": "NY",
    "country": "USA",
    "displayName": "New York, New York, USA"
  },
  "workplaceTypes": ["Hybrid"],
  "isRemote": false,
  "salaryText": "$140,000 - $180,000",
  "salaryMin": 140000,
  "salaryMax": 180000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "postedDate": "2026-08-14T12:00:00Z",
  "validThrough": "2026-09-14T12:00:00Z",
  "skills": ["Python", "SQL", "Airflow", "Spark"],
  "easyApply": true,
  "detailsPageUrl": "https://www.dice.com/job-detail/8a904d2c-a81b-4ebe-b800-9337a939b1b3",
  "guid": "8a904d2c-a81b-4ebe-b800-9337a939b1b3",
  "source": "dice.com"
}
```

Every record exports to JSON, CSV, Excel, XML, or RSS — or flows straight into your pipeline through the Apify API.

***

### Answers to Common Questions

**Do I need a Dice account?**
No. Everything is collected from Dice's public pages — nothing to sign in to.

**Can it find remote-only roles?**
Yes — filter by `workplaceTypes: ["Remote"]`, or check the `isRemote` flag on results.

**Can it find visa-sponsoring employers?**
Yes. `willingToSponsor: true` returns only roles where the employer sponsors.

**Does it grab contract work?**
Yes — full-time, part-time, contract, and third-party listings are all supported.

**How much of the description do I get?**
The whole thing — plain text, HTML, and Markdown — plus a parsed skills list.

**Does it break when Dice updates their site?**
It recovers Dice's embedded job data directly and falls back to HTML parsing, so markup changes degrade gracefully rather than erroring out.

**How do I export the results?**
From the Apify dataset tab, export as JSON, CSV, Excel, XML, RSS, or HTML — or pull it via the API.

### 💰 Pricing & Billing

> **Pricing:** This actor is intended to use Apify's **Pay per usage** model. Under Pay per usage, users pay applicable Apify platform usage costs (compute units, proxy, and data transfer) for running the actor. Pricing and monetization models are configured in Apify Console; verify the active pricing model on the actor's Store page before running.

**Billing transition note:** This actor currently contains fallback charging hooks (`actor-start`, `search-item`, `result-item`) which are active only when Pay-Per-Event pricing is enabled in the Apify Console. When running under Pay per usage, platform usage costs apply and these event charges are ignored. No heavy browser overhead, keeping platform compute usage minimal.

***

### Reliability

- **Proxy rotation** — on a block or challenge, it grabs a fresh IP and retries
- **Adaptive backoff** — retries grow exponentially with longer waits on rate limits
- **Challenge detection** — bot-check pages are caught and never written as data
- **Deduplication** — the same job is never written twice, even across overlapping searches
- **Checkpoint & resume** — a killed run picks up where it left off with `resume: true`

***

### Notes & Limits

- A single Dice query caps at roughly 500 results (~25 pages) — fan-out is the way to go wider.
- Sponsorship is available as a *search filter*, not as a per-job field on Dice's public pages.
- Dice doesn't expose geo coordinates or company-size data on its server-rendered pages.

***

This actor is intended for research, recruitment, and market intelligence. You're responsible for using the data in line with Dice's terms and applicable law.

⭐ If this saves you time, a quick review goes a long way.

# Actor input Schema

## `searches` (type: `array`):

One or more searches to run. Each search has a keyword plus optional filters.

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

Run every search once per location (e.g. \['New York, NY', 'Austin, TX', 'Remote']). Dice caps any single query at ~25 pages, so fan-out greatly increases coverage.

## `postedDateWindows` (type: `array`):

Run every search once per recency window. Narrow windows slice a large result set into fully-fetchable chunks.

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

Optional raw Dice URLs to scrape instead of searches. Use path-form listing URLs (https://www.dice.com/jobs/q-...) or job-detail URLs.

## `fetchDetails` (type: `boolean`):

Visit each job's detail page for the full description, skills, and posting expiry date.

## `maxResults` (type: `integer`):

Maximum job records to push. 0 = system hard cap (5000).

## `maxResultsPerSearch` (type: `integer`):

Stop a single search after this many records. 0 = no per-search limit.

## `pageSize` (type: `integer`):

Results per page (Dice default is 20).

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

Max pages to paginate per search. Dice caps a query at ~25 pages.

## `delayMs` (type: `integer`):

Base delay between requests (random jitter is applied on top).

## `maxRetries` (type: `integer`):

Retry attempts per request.

## `resume` (type: `boolean`):

Resume from the stored checkpoint and skip already-seen jobs.

## `respectRobots` (type: `boolean`):

When true, refuse query-form /jobs?q=... URLs and only use the allowed path-form /jobs/q-... and /job-detail/... pages.

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

Proxy to use for scraping. Residential or datacenter Apify Proxy recommended to avoid blocks. The actor rotates the proxy automatically when blocked.

## Actor input object example

```json
{
  "searches": [
    {
      "q": "Python Developer"
    }
  ],
  "locations": [],
  "postedDateWindows": [],
  "startUrls": [],
  "fetchDetails": false,
  "maxResults": 100,
  "maxResultsPerSearch": 0,
  "pageSize": 20,
  "maxPages": 25,
  "delayMs": 1500,
  "maxRetries": 4,
  "resume": false,
  "respectRobots": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped job listings, stored as items in the default dataset. One record per job posting.

# 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 = {
    "searches": [
        {
            "q": "Python Developer"
        }
    ],
    "locations": [],
    "postedDateWindows": [],
    "startUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("lovely_radiologist/dice-job-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 = {
    "searches": [{ "q": "Python Developer" }],
    "locations": [],
    "postedDateWindows": [],
    "startUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("lovely_radiologist/dice-job-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 '{
  "searches": [
    {
      "q": "Python Developer"
    }
  ],
  "locations": [],
  "postedDateWindows": [],
  "startUrls": []
}' |
apify call lovely_radiologist/dice-job-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,lovely_radiologist/dice-job-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/Ar1kqX22LCjLFhfIf/builds/9vadFuCVstbcbsAhU/openapi.json
