# Dice Jobs Scraper: US Tech Jobs, Salary, Remote, Skills (`redfoxscout/dice-jobs-scraper`) Actor

Scrape Dice.com job listings by keyword, location, remote or hybrid, contract or full-time, and posting date. Returns title, company, location, salary as numbers, workplace type, employer type, posted date and job URL. Optional skills and description. Not affiliated with Dice. $0.90 per 1,000 jobs.

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

## Pricing

from $0.68 / 1,000 jobs

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

Scrape **Dice.com job listings** by keyword, location, remote or hybrid, contract or full-time, and posting date. Each job has its **title, company, location, salary as numbers, workplace type, employer type, posted date** and **job URL**. Set **"posted on or after"** and run it on a schedule to get **only new jobs**. Optionally add each job's **skills and full description**. **No login, no cookies, no API keys**, and not affiliated with Dice.

**Price: $0.90 per 1,000 jobs.** Failed searches and error rows are free, and a job that two searches return is charged once. Apify's free plan ($5 monthly credit) covers about 5,500 jobs a month.

![Dice Jobs Scraper output table: title, company, location, salary, employment type and workplace for python developer jobs in Austin, TX](https://raw.githubusercontent.com/TikTop-Data/apify-store-assets/main/images/dice-jobs-scraper-output.png)

### Questions it answers

- Which new tech jobs were posted on Dice since yesterday for a skill or title?
- How many remote, hybrid and on-site roles are open for a keyword in one city?
- Which companies hire direct and which jobs come from recruiters?
- What pay do Dice contract and full-time listings show for a role?
- Which skills do data engineer or DevOps listings ask for most?

### Who uses this

- 📈 **Recruiters and talent teams:** track open roles and competing employers for a skill.
- 💼 **Job seekers and career coaches:** collect fresh listings by role, workplace type and pay.
- 📊 **Market researchers:** measure demand and advertised pay for US tech roles.
- 🤖 **Developers and AI agents:** feed a job board, spreadsheet or agent with structured Dice listings.

### Why this Dice Jobs Scraper

- 🆕 **Only new jobs on a schedule:** set `postedAfter` to a date and each run returns just the jobs posted since then, so repeat runs stay cheap.
- 💵 **Salary as numbers:** "USD 197,300.00 - 225,100.00 per year" becomes a minimum, a maximum, a currency and a period, and the original wording is kept.
- 🎯 **Filters that match Dice:** workplace type, employment type, employer type (skip recruiters), Easy Apply and visa sponsorship.
- 🧩 **Skills and full description:** tick one box to open each job page and add the skills list and the description text.
- 📈 **More than 750 jobs per search:** unfiltered searches are split automatically when Dice caps a search at 750.
- 🏷️ **$0.90 per 1,000 jobs:** one charge per job, with no start fee and no add-on charges.

### How to use the Dice Jobs Scraper

1. Click **Try for free** (a free Apify account is enough).
2. Enter keywords such as `python developer`, or paste a Dice search link, one per line.
3. Optional: add a location, workplace and employment types, an employer type or a posting date.
4. Click **Start**, then download as JSON, CSV or Excel, or schedule it for a daily feed.

### Input

| Field | Default | What it does |
|---|---|---|
| `searches` | – | Dice keywords or Dice search links, one per line. Required. |
| `location` | – | City and state for keyword searches, e.g. `Austin, TX`. Empty means all of the US. |
| `radius` | – | Miles around the location, 1 to 500. |
| `workplaceTypes` | – | Only `Remote`, `Hybrid` or `On-Site` jobs. Empty means all. |
| `employmentTypes` | – | Only `FULLTIME`, `PARTTIME`, `CONTRACTS` or `THIRD_PARTY`. Empty means all. |
| `postedWithin` | – | Only jobs posted `ONE` (today), `THREE` (3 days) or `SEVEN` (7 days) ago. |
| `postedAfter` | – | Only jobs posted since a date (`2026-11-01`) or a window (`3 days`, `24 hours`, `2 weeks`). Windows suit scheduled runs. |
| `employerType` | – | `Direct Hire`, `Recruiter` or `Other`. |
| `easyApplyOnly` | `false` | Only jobs you can apply to on Dice. |
| `willingToSponsorOnly` | `false` | Only jobs where the employer is willing to sponsor a visa. |
| `includeDetails` | `false` | Open each job page to add `skills` and `description`. Slower. |
| `maxItems` | 100 | Jobs per search (max 10,000). |

Example (the input behind the output below):

```json
{ "searches": ["python developer"], "location": "Austin, TX", "workplaceTypes": ["Remote", "Hybrid"], "postedWithin": "SEVEN", "maxItems": 15 }
```

### Output

One row per job. A real row from that run:

```json
{
  "jobId": "fe86b1db-60f6-4152-8ce9-7e9f5efa422a",
  "url": "https://www.dice.com/job-detail/fe86b1db-60f6-4152-8ce9-7e9f5efa422a",
  "title": "Fulltime-Permanent Hire - Fullstack Python Developer",
  "company": "Prodware Solutions",
  "companyProfileUrl": "https://www.dice.com/company-profile/06aee37b-158c-522f-8a9e-feccdac2068a",
  "location": null,
  "city": null,
  "state": null,
  "country": null,
  "workplaceTypes": ["Remote"],
  "isRemote": true,
  "employmentType": "Full-time",
  "employerType": "Direct Hire",
  "salaryText": "100000 - 120,000",
  "salaryMin": 100000,
  "salaryMax": 120000,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "postedAt": "2026-11-02T21:02:17Z",
  "modifiedAt": "2026-11-02T22:03:49Z",
  "easyApply": true,
  "applyUrl": null,
  "summary": "Job Description: 5+ years of Python experience. Required: Git, GitHub, CI/CD, Linux, Bash, and Agile development experience. GitHub Actions experience...",
  "skills": null,
  "description": null,
  "logoUrl": "https://d3qscgr6xsioh.cloudfront.net/...",
  "searchQuery": "python developer"
}
```

- `summary` is Dice's own search-result summary (about 400 characters). Tick `includeDetails` to fill `skills` and `description`; otherwise both are `null`.
- `salaryMin`, `salaryMax`, `salaryCurrency` and `salaryPeriod` come from `salaryText` when Dice shows a number. Many listings say "Depends on Experience" and have no numbers. When the text has no period, an amount under 500 is read as per hour and 10,000 or more as per year.
- Remote jobs often have no `location`.
- `searchQuery` is the search a job came from. A failed search adds one row with an `error` field and no charge. Emails and phone numbers inside text fields are replaced with `[email removed]` and `[phone removed]`.

### Example tasks

Ready-made inputs you can open, change and run:

- [Get only new Dice tech jobs from the last 3 days](https://apify.com/redfoxscout/dice-jobs-scraper/examples/dice-new-tech-jobs-last-3-days)

### Monitor new jobs on a schedule

Create a schedule in Apify (daily or hourly), and set `postedAfter` to a window such as `24 hours` (or a date), or use `postedWithin` set to `ONE` for a daily run. Only jobs posted in that window are returned and charged, so a daily feed of a narrow search costs a few cents a month.

### How much does it cost?

$0.90 per 1,000 jobs.

- 100 jobs: about $0.09
- 10,000 jobs: about $9.00
- Failed searches and error rows: free. A job that two searches return is charged once.

Apify's free plan gives $5 of credit every month, enough for about 5,500 jobs. `includeDetails` adds run time (one extra page per job) but no extra charge per job.

### FAQ

**Is this legal?** The Actor reads job listings that Dice shows to any visitor without logging in. It does not log in, use cookies or accounts, solve CAPTCHAs, or collect personal details of applicants or recruiters. This is not legal advice, so check the terms and rules that apply to how you use the data.

**How many jobs can one search return?** Dice shows at most 750 jobs (25 pages of 30) per search. A search with no workplace or employment filter is split into smaller slices automatically, so it can return more than 750, up to the `maxItems` you set (max 10,000). With a filter set, the 750 limit applies, so narrow the search by location or posting date instead.

**Can I sort by newest?** Dice's search page returns jobs by relevance and does not take a sort order. Use `postedWithin` or `postedAfter` to get the newest jobs.

**Why is the location empty on some jobs?** Dice leaves it out for some remote jobs. The `workplaceTypes` and `isRemote` fields still tell you the workplace.

### Related Actors

- [XING Jobs Scraper](https://apify.com/redfoxscout/xing-jobs-scraper): jobs in Germany, Austria and Switzerland with salary ranges.
- [SEEK Jobs Scraper](https://apify.com/redfoxscout/seek-jobs-scraper): job listings from seek.com.au and seek.co.nz with salary as numbers.
- [LinkedIn Jobs Scraper](https://apify.com/redfoxscout/linkedin-jobs-scraper): LinkedIn job listings by keyword and location, with full descriptions and no login.
- [ATS Jobs Scraper](https://apify.com/redfoxscout/ats-jobs-scraper): every open job from a company's Greenhouse, Lever, Ashby or other career site.
- [Jobs Index](https://apify.com/redfoxscout/jobs-index): open jobs from thousands of Greenhouse, Lever and Ashby career sites in one search.

# Actor input Schema

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

Dice keywords or full Dice search URLs, one per line, e.g. python developer or https://www.dice.com/jobs?q=data%20engineer\&location=Austin%2C%20TX.

## `location` (type: `string`):

City and state for keyword searches, e.g. Austin, TX or Remote; leave empty for all of the US.

## `radius` (type: `integer`):

Search distance around the location, e.g. 30 for 30 miles; leave empty for Dice's default.

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

Only these workplace types, e.g. Remote and Hybrid; leave empty for all.

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

Only these employment types, e.g. Contract; leave empty for all.

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

Only jobs posted in this window, e.g. Today for fresh jobs; leave empty for any date.

## `postedAfter` (type: `string`):

Only jobs posted since a date or window, e.g. 2026-11-01 or 3 days. A window like 3 days or 24 hours suits scheduled runs that return only new jobs.

## `employerType` (type: `string`):

Only jobs from this kind of employer, e.g. Direct Hire to skip recruiters; leave empty for all.

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

Only jobs you can apply to on Dice itself, e.g. tick to skip external applications.

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

Only jobs where the employer is willing to sponsor a work visa, e.g. tick for visa-friendly roles.

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

Open each job page to add the skills list and the full description, e.g. for skills analysis; runs slower.

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

Stop each search after this many results.

## `maxConcurrency` (type: `integer`):

How many searches run at once.

## Actor input object example

```json
{
  "searches": [
    "python developer"
  ],
  "location": "Austin, TX",
  "easyApplyOnly": false,
  "willingToSponsorOnly": false,
  "includeDetails": false,
  "maxItems": 100,
  "maxConcurrency": 3
}
```

# Actor output Schema

## `results` (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 = {
    "searches": [
        "python developer"
    ],
    "location": "Austin, TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("redfoxscout/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 = {
    "searches": ["python developer"],
    "location": "Austin, TX",
}

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

```

## MCP server setup

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