# Dice Tech Jobs Scraper (`scrapeworks/dice-tech-jobs-scraper`) Actor

Scrape technology job listings from Dice.com in bulk - job title, company, location, remote type, salary range, employment type, posted date and apply URL. Search many keywords and locations at once, paginated deep. One clean JSON/CSV/Excel row per job. No login or API key required.

- **URL**: https://apify.com/scrapeworks/dice-tech-jobs-scraper.md
- **Developed by:** [Nicolas van Arkens](https://apify.com/scrapeworks) (community)
- **Categories:** Jobs, Lead generation, Business
- **Stats:** 1 total users, 0 monthly users, 95.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.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.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#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 Tech Jobs Scraper — export Dice.com job listings to JSON, CSV & Excel

Scrape **technology job listings from [Dice.com](https://www.dice.com/jobs)** in bulk — no
login, no API key, no browser automation. Give it a list of keywords (job titles or skills)
and, optionally, a list of locations, and it returns one clean, structured row per job:
title, company, location, remote type, **salary range**, employment type, posted date and a
direct apply link.

Dice is one of the largest U.S. tech-focused job boards. This actor turns its search results
into a spreadsheet or dataset you can filter, dedupe and load anywhere.

***

### What you can do with it

- **Recruiting & sourcing** — track who is hiring for a stack or role across cities, feed an ATS/CRM.
- **Job-market & salary research** — pull thousands of postings to analyze pay ranges, remote share, in-demand skills.
- **Aggregators & job boards** — syndicate fresh Dice tech listings into your own site.
- **Sales & lead gen** — companies actively hiring engineers are companies with budget and growth.
- **Competitive intelligence** — watch which competitors are staffing up and for what.

***

### Features

- ✅ **Bulk by design** — every input is a **list**. Search many keywords × many locations in one run (a cross product).
- ✅ **Deep pagination** — automatically walks every result page (30 jobs/page) up to your limit; bounded by Dice's own last-page marker so it never loops.
- ✅ **Structured salary** — parses Dice's messy salary strings into `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod`, keeping the raw text too.
- ✅ **Rich fields** — company, location breakdown, remote/hybrid/on-site, employment type, posted & modified dates, summary, apply URL.
- ✅ **Global de-duplication** — the same posting seen under multiple searches is returned (and billed) only once.
- ✅ **Filters** — remote-only, employment type (Full-time / Contract / Part-time / Third Party), posted-within-days, search radius.
- ✅ **Power-user URLs** — paste any `dice.com/jobs` search URL (with filters already applied) and it scrapes it deep.

***

### Input

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array of strings | Keywords / job titles / skills, e.g. `["python", "data engineer"]`. Each is searched in each location. Leave empty to scrape the whole feed. |
| `locations` | array of strings | Dice-format locations, e.g. `["New York, NY, USA", "Austin, TX, USA"]`. Empty = nationwide. |
| `remoteOnly` | boolean | Only remote-eligible jobs. |
| `employmentTypes` | array | Any of `Full-time`, `Contract`, `Part-time`, `Third Party`. Empty = all. |
| `postedWithinDays` | integer | `1` = Today, `2-3` = Last 3 days, `4-7` = Last 7 days (Dice's only windows). |
| `radiusMiles` | integer | Radius around each location, in miles. |
| `searchUrls` | array of strings | Full `dice.com/jobs?...` URLs to scrape deep (power users). |
| `maxResultsPerSearch` | integer | Max jobs per keyword+location pair. Default `300`. |
| `proxyConfiguration` | object | Apify Residential/US recommended; the actor auto-rotates on a block. |

#### Example input

```json
{
  "searchTerms": ["python", "data engineer"],
  "locations": ["New York, NY, USA"],
  "remoteOnly": false,
  "employmentTypes": ["Full-time", "Contract"],
  "maxResultsPerSearch": 300,
  "proxyConfiguration": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```

***

### Output

Each job is one dataset item. Real sample (a live Dice listing):

```json
{
  "jobId": "43d7cbc4c085fc2da43f6fffa5a6c4a1",
  "guid": "c5c1cbfa-6056-495e-be9b-9dcec380d537",
  "title": "Lead Software Engineer (Java, Python, AWS)",
  "company": "Capital One",
  "companyLogo": "https://d3qscgr6xsioh.cloudfront.net/...muselogo.webp?format=webp",
  "companyProfileId": "3a49da6b-f646-4a86-a7fb-6800d711de1c",
  "clientBrandId": "10225989",
  "employmentType": "Full-time",
  "employerType": "Direct Hire",
  "city": "New York",
  "state": "New York",
  "region": "NY",
  "country": "USA",
  "location": "New York, New York, USA",
  "isRemote": false,
  "workplaceTypes": ["On-Site"],
  "postedDate": "2026-07-17T20:51:58Z",
  "modifiedDate": "2026-07-18T20:55:40Z",
  "salaryRaw": "USD 215,200.00 - 245,600.00 per year",
  "salaryMin": 215200.0,
  "salaryMax": 245600.0,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "easyApply": false,
  "score": 11361.719,
  "summary": "Lead Software Engineer (Java, Python, AWS) Do you love building and pioneering...",
  "jobUrl": "https://www.dice.com/job-detail/c5c1cbfa-6056-495e-be9b-9dcec380d537",
  "searchTerm": "python",
  "searchLocation": "New York, NY, USA",
  "scrapedAt": "2026-07-19T12:00:00Z"
}
```

#### Field notes

- **`salaryMin` / `salaryMax` / `salaryPeriod`** — Dice salary text is free-form and
  inconsistent (`"USD 215,200 - 245,600 per year"`, `"60 - 65"`, `"Depends on Experience"`).
  The actor extracts the numbers and reads/infers the period (hourly vs annual) best-effort;
  `salaryRaw` always keeps the original. Not every job posts a salary.
- **`workplaceTypes`** — a list, e.g. `["Remote"]`, `["On-Site", "Hybrid"]`.
- **`jobUrl`** — `dice.com/job-detail/...` for most jobs, `dice.com/direct-apply/...` for Easy Apply.

***

### How many results can I get?

As many as Dice lists. A single keyword+location commonly has **thousands** of postings
across ~170 pages; the actor paginates to `maxResultsPerSearch`. For very large pulls, add
several locations — each is searched independently and results are de-duplicated globally.

***

### FAQ

**Do I need a Dice account or API key?** No. The data is read from Dice's public,
server-rendered search pages.

**Is this allowed?** The actor collects only publicly available job-posting data. Respect
Dice's Terms of Service and applicable law; you are responsible for how you use the output.

**Why Apify Residential proxy?** Dice can throttle high-volume datacenter traffic. Residential
US is the safe default; the actor rotates to a fresh session automatically if a page is blocked.

**Some rows have no salary / location.** Those fields are simply not present on every Dice
posting — that is a gap in the source, not the scraper.

**Can I filter by experience level or salary?** Apply that filter on dice.com in your browser,
copy the URL, and paste it into `searchUrls`.

***

### Pricing

This actor is **pay-per-result**: you are charged once per job row returned. Blocked or empty
pages are never charged, and duplicate postings are billed only once.

# Actor input Schema

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

One or more keywords to search Dice for - a job title like 'software engineer', a skill like 'python', 'aws' or 'react', or a company name. Every search term is run against every location below (so 4 terms x 3 locations = 12 searches), and each search is paginated deep. Results are billed per job row, so more terms = more rows. Leave empty to scrape the whole Dice jobs feed (optionally narrowed by the filters below).

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

Locations to filter by, in Dice's format - 'City, ST, USA' (e.g. 'New York, NY, USA', 'Austin, TX, USA') or just a city/metro. Each search term is searched in each location (a cross product). Leave empty to search every term nationwide. For remote roles use 'Remote jobs only' below instead of a city.

## `remoteOnly` (type: `boolean`):

If enabled, only remote-eligible jobs are returned (Dice's Remote workplace filter). Combine with Search terms to get, e.g., remote Python jobs. Leave off to include on-site and hybrid roles too.

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

Optional: restrict to one or more employment types. Leave empty to include all. Allowed values: 'Full-time', 'Contract', 'Part-time', 'Third Party'.

## `postedWithinDays` (type: `integer`):

Optional: only return jobs posted within this many days. Dice offers 1-, 3- and 7-day windows: 1 -> Today, 2-3 -> Last 3 Days, 4-7 -> Last 7 Days. Values above 7 return all open jobs (Dice has no older bucket). Leave empty for all open jobs regardless of age.

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

Optional: how far around each location to search, in miles (e.g. 30, 50, 100). Only used when a Location is set. Leave empty for Dice's default radius.

## `searchUrls` (type: `array`):

Optional: paste full dice.com/jobs URLs (e.g. 'https://www.dice.com/jobs?q=java\&location=Chicago,%20IL,%20USA\&filters.employmentType=CONTRACTS') with your own filters already applied in the browser. Each URL is scraped and paginated deep. Use this to apply any Dice filter (experience level, salary, willing-to-sponsor, easy-apply) that the fields above don't cover.

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

Maximum jobs to return for EACH term+location pair (and each pasted URL). The actor paginates automatically (30 jobs per Dice page). Set high to pull a whole keyword or location deeply; duplicate jobs (same posting across searches) are removed automatically.

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

Proxy used to reach dice.com. The default (Apify Residential proxy, US) is recommended - Dice can throttle datacenter traffic at volume. The actor automatically rotates to a fresh proxy session if a page is blocked.

## Actor input object example

```json
{
  "searchTerms": [
    "software engineer",
    "python",
    "data engineer",
    "devops"
  ],
  "locations": [
    "New York, NY, USA",
    "Austin, TX, USA",
    "Remote"
  ],
  "remoteOnly": false,
  "employmentTypes": [
    "Full-time",
    "Contract"
  ],
  "searchUrls": [
    "https://www.dice.com/jobs?q=java&location=Chicago,%20IL,%20USA",
    "https://www.dice.com/jobs?q=cybersecurity&filters.workplaceTypes=Remote"
  ],
  "maxResultsPerSearch": 300,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# 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": [
        "software engineer"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

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

# Run the Actor and wait for it to finish
run = client.actor("scrapeworks/dice-tech-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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": [
    "software engineer"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapeworks/dice-tech-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapeworks/dice-tech-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/zhXQDDfPMiH7Jmmca/builds/mkyRGUVbGXf68rlBV/openapi.json