# Dice Jobs Scraper — US Tech Jobs with Salaries & Skills (`fabrikit/dice-jobs-scraper`) Actor

Dice.com tech jobs scraper for the US: search by keyword, city or state, posting date, employment type, remote/hybrid, employer type and visa sponsorship. Gets company, salary, dates and optional descriptions with skills. No login, no API key.

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

## Pricing

from $0.65 / 1,000 job scrapeds

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 Jobs Scraper — US Tech Jobs with Salaries & Skills

Dice Jobs Scraper extracts technology job listings from dice.com, the US tech job board, **without a login, cookies or API key**. Search by keyword and US city or state, filter by posting date, employment type (full-time, part-time, contract, third party), remote / hybrid / on-site, employer type (direct hire or recruiter), Easy Apply and visa sponsorship, and download clean JSON, CSV or Excel with the job title, company, location, salary, dates and URL. Turn on `includeDetails` to add the full description, the skills list and the structured salary from each job page.

You pay per job saved. Job details are an optional add-on, charged per job enriched.

### What you get

**Every job (search data, event `job-result`):** `jobId` and public `url`, `title`, `company` with `companyId`, `companyUrl` and `companyLogo`, `employerType` (Direct Hire / Recruiter / Other), `location` with `city`, `state`, `stateCode` and `country`, `isRemote` and `workplaceTypes` (Remote, Hybrid, On-Site), `employmentType` and `employmentTypes` (Full-time, Part-time, Contract, Third Party), the salary text as posted (`salary`) plus the parsed `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod` (hour / year), `easyApply`, `willingToSponsor`, `postedAt` and `updatedAt` (ISO dates), a `summary` of the description, the search that found the job (`searchKeyword`, `searchLocation`) and `scrapedAt`.

**With `includeDetails` (event `job-details`):** `description` as plain text, `skills` (the tags Dice shows on the job page, e.g. Python, Django, Kubernetes), the structured pay from the page (`salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryText`), `validThrough` (expiry date), `postalCode`, `jobLocationType`, `employmentTypesSchema`, header `badges` with `travelRequirement` (e.g. "No Travel Required", "25% Travel Required") and `contractDuration` (e.g. "6 Months"), the employer's `companyDiceId` and the `positionId`.

No personal data: the Actor never collects recruiter names or profiles, and e-mail addresses, phone numbers, personal profile links and named contacts are removed from summaries and descriptions.

### How it works

The Actor calls the same lightweight JSON search endpoint that the dice.com search page uses (100 jobs per request), so a 1,000-job crawl takes about ten requests and a few seconds. Deep pagination works (10,000 jobs per search); for bigger crawls add more keywords, locations or filters, and the Actor de-duplicates by `jobId` across all searches. If the JSON endpoint ever stops answering, the Actor reads the dice.com search pages instead, which embed the same data.

Job details open one page per job (about two pages per second). Requests are paced, rotate proxy sessions and, if Dice ever blocks them, switch automatically to Apify **RESIDENTIAL** proxies for the rest of the run.

Dice's own filters apply as on the website: `postedWithin` offers today, 3 days and 7 days; a location search includes remote jobs unless you turn `includeRemoteJobs` off; `radiusMiles` only matters for city locations. The salary text on Dice is free-form ("$50 - $55", "USD 135,000.00 - 162,000.00 per year", "Depends on Experience"): `salaryMin` / `salaryMax` / `salaryPeriod` are parsed from it with simple rules (figures under 500 are read as hourly) and replaced by the page's structured values when you use `includeDetails`.

### Input examples

Remote contract Python roles posted this week, with full descriptions and skills:

```json
{
  "keywords": ["python developer"],
  "locations": ["Austin, TX"],
  "postedWithin": "7",
  "employmentTypes": ["contract", "third-party"],
  "workplaceTypes": ["remote"],
  "includeDetails": true,
  "maxItems": 200
}
```

Several titles across several states, direct-hire employers only, newest first, search data only:

```json
{
  "keywords": ["data engineer", "machine learning engineer"],
  "locations": ["Texas", "New York, NY", "Seattle, WA"],
  "radiusMiles": 50,
  "employerTypes": ["direct-hire"],
  "sortBy": "date",
  "maxItems": 1000
}
```

Jobs with visa sponsorship anywhere in the US, from a search URL copied from dice.com:

```json
{
  "searchUrls": ["https://www.dice.com/jobs?q=java&filters.willingToSponsor=true&filters.employmentType=FULLTIME"],
  "maxItems": 500
}
```

### Input fields

| Field | Description |
|---|---|
| `keywords` | Job titles, skills or technologies, one search each |
| `locations` | US cities ("Austin, TX") or states ("Texas"), one search each; empty = whole US |
| `radiusMiles` | Distance around each city, 1-500 (default 30) |
| `postedWithin` | `any`, `1` (today), `3`, `7` days |
| `employmentTypes` | `full-time`, `part-time`, `contract`, `third-party` |
| `workplaceTypes` | `remote`, `hybrid`, `on-site` |
| `employerTypes` | `direct-hire`, `recruiter`, `other` |
| `easyApplyOnly` | Only jobs with an application form on Dice |
| `visaSponsorshipOnly` | Only employers willing to sponsor a work visa |
| `includeRemoteJobs` | Keep remote jobs in location searches (default true) |
| `sortBy` | `relevance` (default) or `date` |
| `searchUrls` | dice.com/jobs?... URLs copied from the site (keyword, location, radius and filters are read from them) |
| `includeDetails` | Add description, skills and structured salary (add-on price, one extra request per job) |
| `maxItems` | Exact number of unique jobs to return (default 50) |
| `proxyConfiguration` | Apify Proxy; datacenter by default, RESIDENTIAL fallback is automatic |

### Output example

```json
{
  "jobId": "7c59549f-df9e-4047-8795-6e30dceaeed3",
  "diceJobId": "4bc8df2e34424de7002c8f097a113c67",
  "positionId": "892747",
  "url": "https://www.dice.com/job-detail/7c59549f-df9e-4047-8795-6e30dceaeed3",
  "title": "Python & JS Developer / Chicago / Remote",
  "company": "Motion Recruitment Partners, LLC",
  "companyId": "10105282",
  "companyUrl": "https://www.dice.com/company/10105282",
  "companyLogo": "https://d3qscgr6xsioh.cloudfront.net/mYivInZASxip5W4N3Dhp_transformed.png?format=webp",
  "employerType": "Recruiter",
  "location": "Chicago, Illinois, USA",
  "city": "Chicago",
  "state": "Illinois",
  "stateCode": "IL",
  "country": "USA",
  "isRemote": true,
  "workplaceTypes": ["Remote", "On-Site"],
  "employmentType": "Full-time",
  "employmentTypes": ["Full-time"],
  "salary": "$100000 - $140000",
  "salaryMin": 100000,
  "salaryMax": 140000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "easyApply": true,
  "willingToSponsor": false,
  "postedAt": "2026-10-17T00:04:08Z",
  "updatedAt": "2026-10-20T12:03:41Z",
  "summary": "Located in Chicago, IL, this full-time opportunity is with a highly respected global professional services organization ...",
  "searchKeyword": "python developer",
  "searchLocation": "Austin, TX",
  "scrapedAt": "2026-10-20T15:26:39.364Z",
  "description": "Located in Chicago, IL, this full-time opportunity is with a highly respected global professional services organization undergoing a large-scale Data & AI transformation. The team is building a modern, cloud-native data platform using Databricks, Python, SQL, and Azure ...",
  "skills": ["JavaScript", "Machine Learning (ML)", "Data Engineering", "Databricks", "Python", "SQL", "Data Modeling", "Microsoft Azure", "..."],
  "badges": ["Full Time", "On-site", "$100000 - $140000/yr"],
  "travelRequirement": null,
  "contractDuration": null,
  "employmentTypesSchema": ["Full-time"],
  "jobLocationType": "TELECOMMUTE",
  "postalCode": "60603",
  "validThrough": "2026-11-20T13:03:41.000Z",
  "companyDiceId": "10105282",
  "salaryText": "$100000 - $140000/yr"
}
```

Without `includeDetails` the record stops at `scrapedAt`.

### Pricing

| Event | When it is charged |
|---|---|
| Job scraped (`job-result`) | Each job saved to the dataset |
| Job details (`job-details`, only with `includeDetails`) | Each job enriched with its description and skills |

Platform compute and proxy usage are included in the event prices. `maxItems` is exact and duplicates are never charged. See the Pricing tab for current prices; paid Apify plans get lower rates.

### How it compares

This Actor returns the parsed salary range, the skills list, the employer type and the sponsorship flag as separate fields so you can filter in a spreadsheet without reading each description. It only covers what Dice shows publicly: no applicant or recruiter data.

Hiring outside the US? The Dice Actor grew out of our [Reed Jobs Scraper](https://apify.com/fabrikit/reed-jobs-scraper), built for reed.co.uk in the UK. Both use the same flat record style (`title`, `company`, `companyUrl`, `salaryMin` / `salaryMax` / `salaryCurrency` / `salaryPeriod`, ISO `postedAt`, `url`), exact `maxItems` counting and contact redaction, so a US + UK tech-hiring sheet needs only a few column renames.

### Integrations

Run it on a schedule and send new jobs to Google Sheets, Airtable, Slack, a webhook or your database with Apify integrations, or call it from n8n, Make and Zapier. Every run is available through the Apify API (`/v2/acts/.../runs` and the dataset endpoints) and through the Apify MCP server, so AI agents can search Dice jobs as a tool.

### FAQ

**Is this legal?** The Actor collects job advertisements that Dice shows publicly to anyone, and stores no personal data. You are responsible for using the data in line with Dice's terms and the laws that apply to you (CCPA, GDPR and similar). It is not affiliated with or endorsed by Dice or DHI Group.

**Do I need a proxy?** The default Apify datacenter proxy is expected to be enough; the Actor switches to RESIDENTIAL automatically if Dice blocks the requests. The run summary (`SUMMARY` in the key-value store) tells you which proxy rung and which data source were used.

**Why does `location` come back empty for some jobs?** Remote-only postings carry no city on Dice; `isRemote` is true and `workplaceTypes` contains "Remote".

**Why is `salaryMin` empty?** About half of Dice's postings say "Depends on Experience". The field is filled whenever the posting shows figures.

**Is the location filter strict?** Dice's search is a radius search that also includes remote jobs by default (`includeRemoteJobs: false` turns that off) and may return nearby towns. Unrecognised locations are reported in the log and the search falls back to the whole US.

**Why are some descriptions missing?** A job can be removed between the search and the detail request; the Actor logs each case in `SUMMARY.errors` and keeps the search data.

### Use cases

Tech job-market research and salary dashboards, lead generation (companies and staffing firms hiring for a stack or in a region), tracking competitors' hiring, feeding niche job boards and newsletters, alerting candidates to new remote or sponsored roles, and training data for job-classification models.

### Changelog

- **0.1** (October 2026) — First release: keyword + location search through Dice's JSON endpoint with the HTML page as fallback, date / employment type / workplace / employer type / Easy Apply / sponsorship filters, `sortBy`, search URLs, exact `maxItems`, de-duplication, optional job details (description, skills, structured salary, expiry), proxy ladder with automatic RESIDENTIAL fallback, personal-data redaction.

***

### En español

Scraper de **ofertas de empleo tecnológicas de Dice.com (Estados Unidos)** sin cuenta ni API key: busca por palabra clave y ciudad o estado, filtra por fecha, tipo de contrato (full-time, part-time, contract, third party), remoto/híbrido/presencial, tipo de empleador y patrocinio de visa, y entrega título, empresa, ubicación, salario (texto y rango numérico), fechas y enlace; con `includeDetails` agrega la descripción completa, la lista de skills y el salario estructurado. Consulta la pestaña Pricing para ver los precios actuales; los planes de pago de Apify tienen tarifas más bajas. No entrega nombres, correos ni teléfonos de reclutadores.

# Actor input Schema

## `keywords` (type: `array`):

Job titles, skills or technologies, one search per entry (for example: python developer, data engineer, 'react native'). Each keyword is combined with each location.

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

Cities or states as typed on Dice, one search per entry (for example: Austin, TX; New York, NY; Texas). Leave empty to search the whole United States.

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

Distance around each city location, 1-500 miles. Dice's default is 30.

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

Only jobs posted in this period (Dice offers today, 3 days and 7 days).

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

Only these employment types. Leave empty for all. 'Third party' = corp-to-corp / staffing-agency placements.

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

Remote, hybrid and/or on-site. Leave empty for all.

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

Direct hire (the employer itself), recruiter / staffing agency, or other. Leave empty for all.

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

Only jobs that accept applications directly on Dice.

## `visaSponsorshipOnly` (type: `boolean`):

Only jobs whose employer states it is willing to sponsor a work visa.

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

When searching a city or state, also include remote jobs (as Dice does by default). Turn off to keep only jobs located within the radius.

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

Order of the results: Dice relevance (default) or newest first.

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

Optional: dice.com job search URLs copied from the website (https://www.dice.com/jobs?q=...\&location=...\&filters....). Their keyword, location, radius and filters are used; added to the searches above.

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

Open each job page to add the full description (plain text), the skills list, the structured salary (min, max, currency, period), the expiry date, badges such as travel requirements and the employer's Dice ID. One extra request per job, charged as the 'job-details' event. Off = fastest and cheapest.

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

Stop after this many unique jobs across all searches (exact; duplicates are removed before counting).

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

Apify Proxy settings. The Actor starts on the configured proxy (datacenter by default) and switches to Apify RESIDENTIAL automatically if Dice blocks the requests.

## Actor input object example

```json
{
  "keywords": [
    "python developer"
  ],
  "locations": [
    "Austin, TX"
  ],
  "radiusMiles": 30,
  "postedWithin": "any",
  "easyApplyOnly": false,
  "visaSponsorshipOnly": false,
  "includeRemoteJobs": true,
  "sortBy": "relevance",
  "includeDetails": false,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

All jobs collected during the 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 = {
    "keywords": [
        "python developer"
    ],
    "locations": [
        "Austin, TX"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/dice-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 = {
    "keywords": ["python developer"],
    "locations": ["Austin, TX"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/dice-jobs-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 '{
  "keywords": [
    "python developer"
  ],
  "locations": [
    "Austin, TX"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call fabrikit/dice-jobs-scraper --silent --output-dataset

```

## MCP server setup

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