# Dice Jobs Scraper & API: C2C, W2 & Recruiter Emails (`s_actors/dice-jobs-scraper`) Actor

Scrape dice.com tech jobs with the contract type of every job (W2, C2C, 1099) and a filter on it, the recruiter's apply email, contract term, travel, visa sponsorship, reposts and pay in numbers. 1,000 jobs a request, newest first, job alerts.

- **URL**: https://apify.com/s\_actors/dice-jobs-scraper.md
- **Developed by:** [Superior Actors](https://apify.com/s_actors) (community)
- **Categories:** Jobs, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.64 / 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

### Dice Jobs Scraper & API: C2C, W2, 1099 and Recruiter Emails

Scrape **Dice jobs** (dice.com, the US tech job board) to Excel, CSV or JSON **without login**, with the data Dice keeps inside each job. What sets it apart:

- **C2C, W2 or 1099 on every job, and a filter on it.** Recruiters set the tax terms of a contract job on Dice (Corp-to-Corp, W2, 1099 independent), but Dice's search has no filter for them and other scrapers do not return them. Here every row has `contractTypes`, `isC2C`, `isW2`, `is1099`, and **Contract type** keeps only the jobs you can take. In our test of 100 new jobs, 80 were contracts: **36 accept C2C**, 75 W2, 29 1099.
- **The recruiter's apply email.** Most contract jobs on Dice take applications by email: `applyEmail` holds the recruiter's or vendor's address (93 of 100 jobs in our test), or `applyUrl` the employer's own apply page. **Only jobs with an apply email** keeps those. No extra charge, no guessing from company websites.
- **Contract details:** term ("12 Months"), **contract to hire**, **travel** percent, **visa sponsorship** (H1B), hybrid office days ("3 days onsite"), employer or staffing firm.
- **Reposts exposed.** Dice shows the latest posting date; this Actor adds the **first posting date** (`firstPostedDate`, `isRepost`). In a "python, New York" search, 13 of the first 30 jobs were old jobs reposted. **Skip reposted jobs** drops them.
- **Pay in numbers:** hourly rates and salaries as min / max, and per year (hourly × 2,080), with a **minimum yearly pay** filter.
- **Big and fast:** 1,000 jobs a request (other scrapers read 20-100), up to 10,000 per search (Dice's limit; bigger searches are split by employment type), **newest first**, posted within 24 hours, 3 days, a week, 2 weeks or a month. **$0.80 per 1,000 jobs.**
- **Job alerts.** Schedule it and get only the jobs you have not seen, e.g. every new C2C Java job with an email, each hour.

```json
{ "keywords": ["java developer"], "contractTypes": ["c2c"], "postedWithin": "past24Hours", "onlyWithApplyEmail": true }
```

No Dice account, no cookies. Use it as a **Dice jobs API**: one call returns clean JSON with the fields above.

#### What you get

**One row per job.** Real examples, September 2026:

| job | company | location | contract | pay | apply email |
|---|---|---|---|---|---|
| Business Analyst | nLeague Services | Indianapolis, IN | C2C, 1099 | $40-45/hr | mark@nleague.com |
| Java + Alfresco | Applied Thought Auditors & Consultants | Charlotte, NC | W2, 1099 | $60-70/hr | ik@theappliedthought.com |
| Data/QA Engineer (financial services, API) | INSPYR Solutions | Remote | W2, C2C | $65-75/hr | dice.willisgroupus@jobdivaemail.com |
| Salesforce Architect | Tharu Technologies | Rockville, MD | W2, C2C, 1099 | $75/hr | (email) |
| Senior Python Developer | Randstad Digital | Jersey City, NJ | W2 | $55-65/hr | apply link |

In our test of 100 new jobs (python, java, data engineer, devops, salesforce): **80 had the contract type**, 93 an apply email, 66 the contract term, 44 the pay in numbers, 98 Dice's skill list and 100 the full description.

| Field | Description |
|---|---|
| `jobId`, `jobUrl`, `title`, `referenceCode` | The job, its Dice page, the employer's own job number |
| `contractTypes`, `isC2C`, `isW2`, `is1099` | Tax terms the contract accepts: W2, C2C (Corp-to-Corp), 1099 (independent) |
| `contractTerm`, `contractToHire`, `employmentType` | Length of the contract, contract to hire, Dice's employment type (Full-time, Contract, Third Party, Part-time) |
| `applyType`, `applyEmail`, `applyUrl`, `easyApply` | How to apply: the recruiter's email, the employer's apply page, Dice Easy Apply |
| `employerType`, `visaSponsorship`, `travelPercent` | Direct employer or recruiter, work visa sponsorship, travel required (0-100%) |
| `postedDate`, `postedAt`, `daysSincePosted`, `firstPostedDate`, `isRepost`, `expiresDate` | Current posting, first posting (reposts), when the job closes |
| `salaryText`, `salaryMin`, `salaryMax`, `salaryPeriod`, `salaryCurrency`, `salaryYearlyMin`, `salaryYearlyMax` | Pay as Dice shows it, in numbers, per hour or year, and per year |
| `companyName`, `companyUrl`, `companyId`, `companyLogo` | The company and its Dice profile |
| `location`, `city`, `state`, `postalCode`, `latitude`, `longitude` | Where the job is |
| `workplaceType`, `workplaceTypes`, `hybridDetails` | `remote`, `hybrid`, `on-site`; office days of hybrid jobs |
| `skills`, `extractedSkills`, `jobQualityScore` | Skills set by the employer, Dice's normalised skill list, Dice's quality score of the posting |
| `description`, `descriptionHtml`, `isClosed` | The full description; whether the job is closed |
| `searchKeyword`, `searchLocation`, `searchUrl`, `isNew`, `scrapedAt` | Which search found the job; job alerts |

Five table views: **Jobs**, **Contract & apply**, **Dates & reposts**, **Pay** and **Details**.

#### How it works

| Step | What happens |
|---|---|
| 1. Searches | Each keyword × location, and your Dice search links. Dice applies its own filters (employment type, workplace, date, employer type, Easy Apply, visa sponsorship); 1,000 jobs a request, relevance or newest first |
| 2. Job data | For each job: Dice's full job record (contract type, term, apply email, travel, first posting date, skills, description) |
| 3. Filters and clean-up | Contract type, apply email, reposts, travel, pay, title words, companies; closed jobs and copies are dropped. Removed jobs and jobs seen by a job alert are not charged |

#### Why this Actor

| | This Actor | Typical Dice scraper |
|---|---|---|
| Contract type: W2, C2C, 1099 | ✅ Every contract job, with a filter | ❌ (one returns it without a filter) |
| Recruiter apply email | ✅ Included | ❌ Or guessed from the company website for an extra fee |
| Contract term, contract to hire, travel | ✅ | ❌ |
| First posting date, reposts | ✅ | ❌ Or only from its own earlier runs |
| Pay per hour and per year in numbers | ✅ | ⚠️ Text |
| Jobs per request | 1,000 | 20-100 |
| Past 2 weeks, past month | ✅ | ⚠️ Some |
| Dice filters: employment, workplace, employer, Easy Apply, visa sponsorship | ✅ | ✅ Most |
| Job alerts (only new jobs) | ✅ Seen jobs not charged | ⚠️ Some |
| Price per 1,000 jobs | **$0.80** with everything | $0.60-$3 |

#### Pricing

Pay per event, no subscription needed. Apify Scale and Business plans pay less:

| Event | Free and Starter plans | Scale plan | Business plan |
|---|---|---|---|
| Run start | $0.0045 | $0.0045 | $0.0045 |
| Job (all fields: contract type, apply email, full description) | $0.0008 | $0.00072 | $0.00064 |

**1,000 jobs = $0.80.** Free: jobs removed by your filters, copies, closed jobs, jobs already seen by a job alert. Platform usage is included. Set a maximum cost per run in the run options: the Actor stops there.

#### Ready-made tasks

| Task | What it does |
|---|---|
| [Dice C2C Jobs With Recruiter Emails](https://apify.com/s_actors/dice-jobs-scraper/examples/dice-c2c-jobs) | Corp-to-Corp contract jobs from the past 24 hours with the recruiter's email, newest first |
| [Dice H1B Visa Sponsorship Jobs](https://apify.com/s_actors/dice-jobs-scraper/examples/dice-h1b-visa-sponsorship-jobs) | Tech jobs whose employer sponsors a work visa, past week |
| [Dice Remote Jobs](https://apify.com/s_actors/dice-jobs-scraper/examples/dice-remote-jobs) | Remote tech jobs from the past 3 days, newest first, reposts skipped |

#### Job alerts

1. Set your keywords, locations and filters (for example **Contract type: C2C** and **Only jobs with an apply email**), turn on **Only new jobs**, give the alert a name.
2. Save it as a task and add a **schedule** (every hour, or every morning with "Posted within: Past 24 hours").
3. Send the results by email, Slack, Google Sheets, Make, Zapier or **n8n** with Apify integrations.

The first run returns the current jobs, newest first; next runs return only jobs not seen before.

#### FAQ

**What do W2, C2C and 1099 mean?** They are the tax terms of a US contract. **W2**: you are on the payroll of the staffing firm. **C2C (Corp-to-Corp)**: your own company (or your employer's) bills the staffing firm; this is how most H1B consultants and bench sales teams work. **1099**: you work as an independent contractor. A job can accept several. The recruiter sets them on Dice; the Actor reads them for every job.

**Where does the apply email come from?** From the job itself: many contract jobs on Dice are set to "apply by email", and the address is part of the posting. Jobs that send candidates to the employer's site have `applyUrl` instead.

**Why do some jobs have no contract type?** Full-time (direct hire) jobs have none; `contractTypes` is empty and `isC2C` is false. Contract type filters keep contract and third-party jobs only.

**Can I get more than 10,000 jobs?** Dice shows at most 10,000 jobs for one search. The Actor splits bigger searches by employment type automatically; for the whole board use several keywords or locations.

**Which locations work?** Any US city, state or ZIP code Dice understands ("New York, NY", "Austin, TX", "Texas", "94105") and "Remote". The log shows how Dice read each place. Radius defaults to 30 miles.

**Do I need a Dice account?** No. Only job data any visitor can open is read. Candidate data is not collected.

#### Use with the API and AI agents

Run it from the Apify API, the JavaScript or Python client, **n8n**, Make or Zapier, or from AI agents through the [Apify MCP server](https://mcp.apify.com) (Claude, ChatGPT, Cursor). One call: `POST https://api.apify.com/v2/acts/s_actors~dice-jobs-scraper/run-sync-get-dataset-items` with the input above returns the jobs as JSON. Set **Description** to "None" for smaller answers.

#### Other job tools

| Actor | What it does |
|---|---|
| [LinkedIn Jobs Scraper](https://apify.com/s_actors/linkedin-jobs-scraper) | LinkedIn jobs without login: a remote filter that works, salaries from descriptions, job alerts |
| [Glassdoor Jobs Scraper](https://apify.com/s_actors/glassdoor-jobs-scraper) | Glassdoor jobs with salaries for almost every job and the company's employee ratings, filter by work-life balance |
| [Wellfound Jobs Scraper](https://apify.com/s_actors/wellfound-jobs-scraper) | Startup jobs from Wellfound (AngelList): salary and equity as numbers, stage, YC, visa sponsorship, job alerts |
| [StepStone Jobs Scraper](https://apify.com/s_actors/stepstone-jobs-scraper) | StepStone.de and .at jobs with salary estimates for most jobs, exact matches only, English jobs in Germany |

#### Is it legal?

The Actor reads public Dice job data that anyone can open without an account, as a visitor does. It does not log in or collect candidate profiles. Apply emails are the business contacts recruiters publish for applications; use them for job applications and according to the laws that apply to you (CAN-SPAM, GDPR, CCPA and similar) and Dice's terms.

# Actor input Schema

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

Job title, skill or technology, one per line: "python", "java developer", "data engineer", "salesforce", "devops". Dice's boolean search works too: ""data engineer" AND spark". Each keyword is its own search. Empty = every Dice job in the locations below (about 113,000 in the US).

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

US city, state or ZIP as on Dice: "New York, NY", "Austin, TX", "Texas", "94105", or "Remote". Dice finds the place itself and searches around it (radius below). Each location is its own search. Empty = the whole US.

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

Distance around each location. Empty = Dice's default of 30 miles.

## `contractTypes` (type: `array`):

Keep contract jobs that accept one of these tax terms, as the recruiter set them on Dice (Dice's own search has no such filter). Every row has contractTypes, isC2C, isW2, is1099. Removed jobs are free.

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

Dice's own filter; several = any of them. Empty = all (contract and third party when a contract type is chosen).

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

Dice's own filter; several = any of them. Hybrid jobs have the office days in hybridDetails ("3 days onsite").

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

By Dice's posting date (a repost counts as new; the first date is in firstPostedDate). 2 weeks and a month are read newest first and cut at the date.

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

Only jobs whose employer is willing to sponsor a work visa (Dice's own filter).

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

Dice's own filter: jobs posted by the employer itself or by a recruiting firm.

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

Only jobs with Dice's one-click Easy Apply.

## `maxJobsPerSearch` (type: `integer`):

Per keyword × location or link. The Actor reads Dice 1,000 jobs a request. Dice shows 10,000 jobs for one search; bigger searches are split by employment type.

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

Newest first = Dice's own date sort.

## `onlyWithApplyEmail` (type: `boolean`):

Keep jobs that take applications by email (the recruiter's or vendor's address is in applyEmail). Most contract jobs on Dice do.

## `excludeReposts` (type: `boolean`):

Recruiters repost old jobs to look new. On = drop jobs first published 2+ days before their current posting date (firstPostedDate vs postedDate). Every row has isRepost.

## `maxTravelPercent` (type: `integer`):

Keep jobs that ask for at most this much travel (0, 10, 25, 50, 75, 100 as set on Dice), e.g. 25. Jobs without a travel value pass.

## `onlyWithSalary` (type: `boolean`):

Keep jobs with a pay rate or salary in numbers (not "Depends on experience").

## `minYearlySalary` (type: `integer`):

Keep jobs whose top pay reaches this per year; hourly rates count as 2,080 hours ($60/hr = $124,800). Jobs without pay are removed.

## `titleMustMatchKeyword` (type: `boolean`):

On = only jobs whose title has every word of the keyword ("python" drops a "Backend Engineer" job that asks for Python). Removed jobs are free.

## `titleInclude` (type: `array`):

Keep only jobs whose title contains one of these words, e.g. "senior", "lead".

## `titleExclude` (type: `array`):

Remove jobs whose title contains one of these words, e.g. "intern", "manager".

## `companyExclude` (type: `array`):

Remove jobs of companies whose name contains one of these.

## `skipDuplicates` (type: `boolean`):

One job posted several times: same title + company + place = one row.

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

Search pages copied from the browser, e.g. https://www.dice.com/jobs?q=devops\&location=Austin,%20TX\&filters.employmentType=CONTRACTS: the link's own filters are used.

## `jobUrls` (type: `array`):

Links of single jobs, e.g. https://www.dice.com/job-detail/7015377a-0d8c-4367-86c2-c8de29fa55b8, or just the id.

## `includeJobDetails` (type: `boolean`):

Contract type (W2 / C2C / 1099), contract term, apply email or link, travel, first posting date, skills and the full description: one request per job, included in the price. Off = faster runs with the search fields only.

## `descriptionFormat` (type: `string`):

The full job description is included at no extra cost.

## `onlyNewJobs` (type: `boolean`):

Remembers the jobs of earlier runs with the same alert name and returns only new ones, newest first. Schedule the Actor hourly or daily for a Dice job alert to Slack, email or a sheet. Jobs already seen are free.

## `monitorName` (type: `string`):

Separate memory for each alert: use a different name for each search you schedule.

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

How many Dice requests run at once.

## `debugLog` (type: `boolean`):

Log every retry.

## Actor input object example

```json
{
  "keywords": [
    "python"
  ],
  "locations": [
    "New York, NY"
  ],
  "postedWithin": "anyTime",
  "visaSponsorshipOnly": false,
  "easyApplyOnly": false,
  "maxJobsPerSearch": 100,
  "sortBy": "relevance",
  "onlyWithApplyEmail": false,
  "excludeReposts": false,
  "onlyWithSalary": false,
  "titleMustMatchKeyword": false,
  "skipDuplicates": true,
  "includeJobDetails": true,
  "descriptionFormat": "text",
  "onlyNewJobs": false,
  "monitorName": "default",
  "maxConcurrency": 10,
  "debugLog": false
}
```

# Actor output Schema

## `overview` (type: `string`):

The main job fields with contract type and apply email.

## `contracts` (type: `string`):

W2 / C2C / 1099, term, contract to hire, travel, sponsorship, how to apply.

## `dates` (type: `string`):

Posting date, first posting date (reposts), expiry.

## `pay` (type: `string`):

Pay rate or salary in numbers, hourly and yearly.

## `details` (type: `string`):

Place, hybrid days, skills, description.

## `all` (type: `string`):

Every field of every job.

# 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"
    ],
    "locations": [
        "New York, NY"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("s_actors/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"],
    "locations": ["New York, NY"],
}

# Run the Actor and wait for it to finish
run = client.actor("s_actors/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"
  ],
  "locations": [
    "New York, NY"
  ]
}' |
apify call s_actors/dice-jobs-scraper --silent --output-dataset

```

## MCP server setup

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