# Dice Tech Jobs API: Salary, W2/C2C, Skills (`norespi/dice-jobs`) Actor

Get Dice.com tech jobs for your keywords and US location: title, company, remote/hybrid/onsite, full-time or contract with W2/C2C, salary min/max if published, skills, date, URL. Public pages, no login. $0.75 per 1,000 jobs.

- **URL**: https://apify.com/norespi/dice-jobs.md
- **Developed by:** [Gabriel Jossic](https://apify.com/norespi) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.75 / 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.

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 Tech Jobs API** that returns the jobs **Dice.com** shows for your **keywords** and an optional **US location**, as clean rows: title, company, location, **remote / hybrid / onsite**, **full-time or contract with W2 / C2C**, **salary min/max when the employer publishes it**, Dice's **skills** tags, posting date and job URL.

Export to **JSON, CSV, Excel or Google Sheets**, call it from the **Apify API**, schedule it every morning, or let an **AI agent** use it through MCP.

No login, no account, no API key, no browser. The Actor reads the same public pages any visitor sees, only the paths Dice's robots.txt allows, at a slow pace. The prefilled input (Python jobs, 10 jobs) runs in about 4 seconds.

### What data does the Dice Tech Jobs API return?

| Field | Example |
|---|---|
| `title` | Senior Cloud Software Engineer (Python/AWS) |
| `company`, `companyUrl` | Pyramid Technology Solutions, Inc. and its Dice company page |
| `employerType` | `Direct Hire`, `Recruiter` or `Other`, as Dice labels the poster |
| `location`, `city`, `state`, `country` | `Houston, Texas, USA`, `Houston`, `TX`, `USA` (`Remote` when Dice gives no place) |
| `workplaceTypes`, `isRemote` | `["hybrid"]`, `["remote", "onsite"]`… and a plain `true` / `false` |
| `employmentType` | `full-time`, `part-time`, `contract`, `third-party` (one job can have several) |
| `contractTypes`, `contractTerm` | `["w2", "c2c", "independent"]` and `12 Months`, when the contract job states them |
| `salaryText` | Exactly what Dice shows: `USD 197,300.00 - 225,100.00 per year`, `$50 - $60`, `Depends on Experience` |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod` | `197300`, `225100`, `USD`, `year`, parsed from `salaryText` only |
| `salaryPeriodInferred` | `true` when Dice did not state hour/year and the Actor inferred it from the amount |
| `datePosted`, `dateUpdated`, `validThrough` | ISO 8601 dates |
| `skills` | Dice's skill tags for the job, e.g. `["Python", "Terraform", "DevOps"]` |
| `easyApply` | Whether Dice offers its Easy Apply button |
| `url`, `jobId` | The job page on Dice and its ID |
| `searchKeyword`, `searchLocation` | Which search produced the row |
| `detailStatus` | `ok` when the job page was read, otherwise why not |
| `scrapedAt` | When the row was collected |
| `description` | Optional plain-text excerpt (max 1,000 characters), recruiter contact details removed |

Fields Dice does not publish are `null` (or an empty list). Nothing is guessed, except `salaryPeriod` when `salaryPeriodInferred` says so.

### How to use the Dice Tech Jobs API

1. Click **Try for free**.
2. Type one or more **keywords** (e.g. `python`, `data engineer`, `salesforce`), optionally a **US location** (e.g. `Austin, TX`), and pick filters: **remote only**, **posted within N days**, **full-time / contract / W2 / C2C**.
3. Click **Start**. Download the jobs from the **Output** tab as JSON, CSV or Excel, or fetch them through the API.

Input example:

```json
{
  "keywords": ["python", "data engineer"],
  "location": "Dallas, TX",
  "remoteOnly": false,
  "postedWithinDays": 3,
  "employmentTypes": ["c2c"],
  "maxItems": 100,
  "includeDescription": true
}
```

#### Input fields

| Field | Default | What it does |
|---|---|---|
| `keywords` | `["python"]` (prefilled) | Job title, skill or company. Each keyword is one Dice search, up to 500 jobs. Several keywords share `maxItems` in turn. |
| `location` | empty (whole US) | US city, state or ZIP as typed on Dice, e.g. `New York, NY`. Dice searches 30 miles around it and adds remote jobs. |
| `remoteOnly` | `false` | Only jobs Dice marks as Remote. |
| `postedWithinDays` | none | Only jobs posted (or reposted) in the last N days. |
| `employmentTypes` | all | Any of `full-time`, `part-time`, `contract`, `third-party`, `w2`, `c2c`. |
| `maxItems` | 10 (prefilled), 50 | Maximum jobs saved and charged, in Dice's relevance order. |
| `includeDescription` | `false` | Add a plain-text excerpt of the ad, max 1,000 characters. |

### Output example

```json
{
  "jobId": "101bc9c8-ef1e-4c39-bd8a-3c153df00de9",
  "title": "Senior Cloud Software Engineer (Python/AWS)",
  "company": "Pyramid Technology Solutions, Inc.",
  "companyUrl": "https://www.dice.com/company-profile/719d8520-d7ca-5bda-a06a-7d43a4af2920",
  "employerType": "Direct Hire",
  "location": "Houston, Texas, USA",
  "city": "Houston",
  "state": "TX",
  "country": "USA",
  "workplaceTypes": ["hybrid"],
  "isRemote": false,
  "employmentType": ["contract"],
  "contractTypes": ["w2"],
  "contractTerm": null,
  "salaryText": "Depends on Experience",
  "salaryMin": null,
  "salaryMax": null,
  "salaryCurrency": null,
  "salaryPeriod": null,
  "salaryPeriodInferred": false,
  "datePosted": "2026-10-12T14:48:26.000Z",
  "dateUpdated": "2026-10-12T14:48:26.000Z",
  "validThrough": "2026-11-12T15:48:26.000Z",
  "skills": ["Amazon Web Services", "Cloud Architecture", "Microsoft Azure", "Python", "Terraform", "Microservices", "Orchestration", "Use Cases", "DevOps"],
  "easyApply": true,
  "url": "https://www.dice.com/job-detail/101bc9c8-ef1e-4c39-bd8a-3c153df00de9",
  "searchKeyword": "python",
  "searchLocation": null,
  "detailStatus": "ok",
  "scrapedAt": "2026-10-13T03:33:05.161Z"
}
```

A real record from the prefilled run on 2026-10-13. In the same run, Capital One's full-time job came back with `salaryMin: 197300`, `salaryMax: 225100`, `salaryPeriod: "year"`. A `RUN_SUMMARY` record in the key-value store lists each search (URL, pages read, total Dice reports), how many job pages were read, how many jobs each filter dropped, and any URL skipped because of robots.txt.

### How much does it cost to get Dice jobs?

**$0.75 per 1,000 jobs.** You pay only for jobs saved to the dataset; there is no start fee.

| You get | You pay |
|---|---|
| 10 jobs (prefilled input) | $0.0075 |
| 100 jobs | $0.075 |
| 500 jobs (one keyword, all pages) | $0.375 |
| 1,000 jobs | $0.75 |

Set `maxItems` to cap a run. Apify's free plan credit covers thousands of jobs a month.

### How to get new Dice jobs every day

Create a **schedule** in Apify (e.g. every morning at 7:00) with `postedWithinDays: 1`. Each run returns only the jobs posted in the last day for your keywords. Send them to **Slack, Google Sheets, email, Zapier, Make, n8n** or a **webhook** with Apify integrations.

### Use the Dice Tech Jobs API with AI agents (MCP)

Claude, Cursor and other MCP clients can call this Actor through the official Apify MCP server. Add `NORESPI/dice-jobs` to your Apify MCP configuration, then ask things like "find remote C2C data engineer contracts on Dice posted in the last 3 days, with the hourly rate".

### Use cases

- **Contractors and C2C vendors**: a daily list of W2 or Corp-to-Corp contracts for your stack, with rate and term.
- **Job alerts**: new Python, Java or DevOps jobs in your city, in Slack or a spreadsheet.
- **Salary research**: published pay ranges for a skill, split by full-time and contract, hourly and yearly.
- **Recruiting and sales research (company level)**: which companies and staffing firms hire for a skill right now.
- **Skills demand**: count Dice's skill tags across a few hundred jobs to see what a role asks for.

### Limits (stated up front)

- **500 jobs per keyword, at most.** Dice serves 25 result pages of 20 per search; asking for page 26 returns page 25 again. Add keywords (or a location) to get more.
- **US only.** Dice is a US tech job board. `location` must be a US place Dice knows. A place it does not know is ignored by Dice (you get the whole US, and the log and `RUN_SUMMARY` warn you); a place outside the US returns only remote jobs. `Remote` is not a location: use `remoteOnly`.
- **Location searches include remote jobs.** Dice adds remote jobs to every location search (30-mile radius). Use `workplaceTypes` or `isRemote` to split them.
- **Results are in Dice's relevance order**, not newest first. Use `postedWithinDays` for fresh jobs. Dice's "posted" date is reset when an employer reposts a job.
- **Salary is often text only.** Many ads say `Depends on Experience` or `DOE`: then `salaryMin`/`salaryMax` are `null` and `salaryText` keeps Dice's words. When the hour/year unit is missing, it is inferred from the amount (≤ 500 = hour, ≥ 15,000 = year) and `salaryPeriodInferred` is `true`. Currencies are not converted.
- **W2 / C2C only when stated.** `contractTypes` comes from the contract detail on the job page. Full-time jobs have none. With `w2` or `c2c` in `employmentTypes`, the Actor reads job pages until it finds enough matches, so a run can read more pages than it saves.
- **Skills are Dice's tags**, extracted by Dice from the ad. They are useful but noisy (a long ad can carry 60 tags, some off-topic).
- **Hyphens in keywords become spaces.** Dice's search URLs use `-` as a separator, so `front-end` is searched as `front end`.
- **One job page per saved job.** That is what makes skills, W2/C2C and descriptions possible. 1,000 jobs take roughly 5 minutes at the Actor's polite pace.
- **If Dice blocks the run** (HTTP 403/429 after retries, or a challenge page), the Actor stops and says so in the log and `RUN_SUMMARY`. It does not use proxies or tricks to get around it.

### Privacy

Company-level job data only. Dice's job pages hold the recruiter's apply e-mail; the Actor never reads or outputs it. Recruiter names, e-mail addresses and phone numbers are not output. In descriptions, everything from the sign-off on ("Thanks & Regards", "Please send your resume to…", "Jane | Sr. Technical Recruiter") is cut, and remaining e-mails, phone numbers, links, social profiles and named persons ("Mr …", "Ms …") are removed. Company logos are not collected.

### FAQ

#### Do I need a Dice account or an API key?

No. Only public pages are read, the same ones a visitor sees without logging in. The Actor does not call Dice's internal search API.

#### Is there an official Dice API for job search?

Not a public one for job seekers. This Actor reads Dice's public search pages and the schema.org data on each job page, and returns one clean format.

#### Why did I get fewer jobs than `maxItems`?

Dice had fewer matching jobs, or filters (date, remote, W2/C2C) dropped some. `RUN_SUMMARY` shows how many each filter removed and the total Dice reports per search.

#### What is the difference between `contract` and `third-party`?

They are Dice's labels. `third-party` jobs accept candidates through another company (usually Corp-to-Corp). Many contract jobs carry both.

#### Can I export Dice jobs to CSV, Excel or Google Sheets?

Yes, from the Output tab, the API, or the Google Sheets integration. List fields (`skills`, `workplaceTypes`) are flattened in CSV.

#### Is this Actor affiliated with Dice?

No. It is an independent tool, not affiliated with, endorsed by or connected to Dice or DHI Group, Inc. It reads public pages and links back to Dice on every row.

#### Is it allowed to use this data?

The Actor only reads pages open to anyone without an account, only on paths Dice's robots.txt allows (`/jobs`, `/job-detail`), at a slow pace, and stops on 403/429. It returns job facts (title, company, pay, skills) with a link back to Dice, never recruiter names, e-mails or phone numbers. Dice's terms of service restrict automated access; you remain responsible for how you use the data. Any removal request from Dice is honored within 7 days.

### Other job data Actors by NORESPI

| Actor | What it does | Price |
|---|---|---|
| [Career Page Jobs API](https://apify.com/NORESPI/ats-jobs-by-company) | Every open job of a list of companies, from Greenhouse, Lever, Ashby, Workable and 4 more ATS | $1 / 1,000 jobs |
| [Remote Jobs API](https://apify.com/NORESPI/remote-jobs-aggregator) | Remote jobs from Remote OK, We Work Remotely and Himalayas in one deduplicated dataset | $1.50 / 1,000 jobs |
| [HN Who Is Hiring Jobs API](https://apify.com/NORESPI/hn-who-is-hiring) | The monthly Hacker News "Who is hiring?" thread as structured jobs | $2 / 1,000 jobs |

Questions, bugs or a feature you need: open an issue in the **Issues** tab.

# Actor input Schema

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

Job title, skill or company to search on Dice, e.g. python, data engineer, salesforce. Each keyword is one Dice search and returns at most 500 jobs (Dice stops at 25 pages of 20). Several keywords share 'Max jobs' in rotation. Hyphens are read as spaces (front-end → front end).

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

US city, state or ZIP as you would type it on Dice, e.g. Austin, TX or New York, NY. Dice searches 30 miles around it and also returns remote jobs. Leave empty to search the whole US.

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

Keep only jobs Dice marks as Remote (Dice's workplace filter, checked again on every job).

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

Keep only jobs posted (or reposted) in the last N days, e.g. 1 for a daily alert, 7 for a weekly one. Empty = no date filter.

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

Keep only jobs of these types (any of them). W2 and C2C are read from the job page and only exist on contract or third-party jobs. Empty = all types.

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

Maximum number of jobs saved (and charged) in this run, in Dice's relevance order.

## `includeDescription` (type: `boolean`):

Add a plain-text excerpt of the job ad (max 1,000 characters). Recruiter names, e-mail addresses, phone numbers, links and the sign-off / contact block are removed.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "remoteOnly": false,
  "maxItems": 10,
  "includeDescription": false
}
```

# 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 = {
    "keywords": [
        "python"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("norespi/dice-jobs").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"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("norespi/dice-jobs").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"
  ],
  "maxItems": 10
}' |
apify call norespi/dice-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,norespi/dice-jobs"
        }
    }
}
```

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/ZmD5r2oQIHyECmZHJ/builds/hmiFZNje8cwZ0evOr/openapi.json