# Dice Tech Jobs Scraper — IT Jobs, Salary & Remote API (`bovi/dice-jobs-scraper`) Actor

Scrape tech job postings from Dice.com via the public search API. Get title, company, location, salary, remote type, seniority, employer type, easy-apply flag and sponsor flag. Multi-query batch, keyword filters, zero auth, zero proxy.

- **URL**: https://apify.com/bovi/dice-jobs-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Jobs, Lead generation
- **Stats:** 7 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.87 / 1,000 job results

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?

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 | $0.90/1K — Salary + Visa Sponsor Data

For tech recruiters targeting H1B/OPT candidates, data teams benchmarking US tech salaries, and job aggregators building US tech boards.

**Pricing: $0.90/1,000 jobs** — flat per-result; salary, remote type and the visa-sponsor flag are all included, with no add-on fees.

Dice.com is the #1 US tech job board with 90,000+ live listings. Unlike generic scrapers, you get **structured salary ranges** and a **willing-to-sponsor visa flag** — both rare in job data. **No login, no proxy.**

Scrape tech job postings from **Dice.com** using the public search API. Get structured data on 90,000+ live US tech jobs with no auth, no proxy, and no browser required.

### What you get

One dataset row per job posting with 22 fields:

| Field | Description |
|---|---|
| `job_id` | Dice internal job hash |
| `title` | Job title |
| `company` | Company name |
| `location` | Full location display name |
| `city` / `state` / `country` | Location components |
| `remote_type` | `remote` / `hybrid` / `onsite` (inferred from authoritative `workFromHomeAvailability` flag) |
| `seniority` | `senior` / `mid` / `lead` / `manager` / etc. (inferred from title) |
| `salary` | Salary string (e.g. `USD 120,000 - 150,000 per year`) |
| `employment_type` | `Full-time`, `Part-time`, `Contract`, etc. |
| `employer_type` | `Direct Hire` or `Recruiter` |
| `easy_apply` | One-click Dice Easy Apply available |
| `willing_to_sponsor` | Employer willing to sponsor a work visa |
| `posted_at` | ISO 8601 posting date |
| `url` | Direct link to the Dice job detail page |
| `summary` | ~500-char job description teaser |
| `global_id` | Stable `dice:<job_id>` identifier for deduplication |
| `parse_confidence` | Quality score 0.0–1.0 (our differentiator — no competitor has this) |
| `warnings` | List of data-quality warnings |

### Why this scraper

- **Dice-specific**: unlike generic job scrapers, targets the 90k+ Dice US tech job database directly.
- **Authoritative remote flag**: Dice provides `workFromHomeAvailability` as a boolean — no guessing from location text.
- **Salary data**: Dice consistently populates structured salary ranges (USD min–max format).
- **Recruiter vs. Direct Hire**: `employer_type` tells you if you're talking to the hiring company or an agency.
- **Visa sponsor flag**: unique to Dice — great for filtering H1B/OPT-eligible roles.
- **Easy Apply flag**: know before you scrape whether one-click apply is available.
- **parse\_confidence**: every row includes a quality score — catch API changes before they break your pipeline.
- **Zero cost infra**: public API, no proxy, no auth, $0 COGS.

### Input

```json
{
  "searchQueries": ["python developer", "data engineer"],
  "location": "San Francisco, CA",
  "maxItems": 200,
  "sort": "relevance",
  "workFromHome": false,
  "employmentType": "FULLTIME",
  "postedDate": "ONE_WEEK"
}
```

| Parameter | Default | Description |
|---|---|---|
| `searchQueries` | required | One or more keyword queries |
| `location` | blank (US-wide) | Location filter string |
| `countryCode` | `US` | 2-letter ISO country code |
| `maxItems` | 100 | Total jobs cap (0 = unlimited) |
| `sort` | `relevance` | `relevance` or `date` |
| `workFromHome` | `false` | API-level remote filter |
| `employmentType` | blank | `FULLTIME` / `PARTTIME` / `CONTRACTS` / `THIRD_PARTY` |
| `postedDate` | blank | `ONE_DAY` / `THREE_DAYS` / `ONE_WEEK` / `TWO_WEEKS` / `ONE_MONTH` |
| `titleKeyword` | blank | Post-fetch title substring filter |
| `locationKeyword` | blank | Post-fetch location substring filter |
| `remoteOnly` | `false` | Post-fetch: keep only `remote_type=remote` |
| `easyApplyOnly` | `false` | Post-fetch: keep only Easy Apply jobs |
| `willingToSponsorOnly` | `false` | Post-fetch: keep only sponsor-willing jobs |

### Pricing example

| Run | Jobs returned | Cost |
|---|---|---|
| Trial (1 query, 100-cap default) | 100 | $0.09 |
| 1,000 jobs (2 queries) | 1,000 | $0.90 |
| 10,000 jobs | 10,000 | $9.00 |

Pay per result. You are charged per job pushed to the dataset.

### Use cases

- **Tech recruiters**: source candidates from live Dice listings at scale.
- **Market intelligence**: salary benchmarks, demand by skill, remote vs. on-site ratios.
- **Job aggregators**: pull fresh US tech jobs daily with structured salary + remote data.
- **Research**: employer type distribution (direct hire vs recruiter), sponsor rates by company.

### Output sample

```json
{
  "job_id": "abc12345xyz",
  "title": "Senior Python Developer",
  "company": "Acme Corp",
  "location": "San Francisco, CA",
  "remote_type": "remote",
  "seniority": "senior",
  "salary": "USD 140,000 - 175,000 per year",
  "employment_type": "Full-time",
  "employer_type": "Direct Hire",
  "easy_apply": true,
  "willing_to_sponsor": false,
  "posted_at": "2026-06-01T14:00:00+00:00",
  "url": "https://www.dice.com/job-detail/abc12345xyz",
  "parse_confidence": 1.0,
  "scraped_at": "2026-06-05T10:00:00+00:00"
}
```

### FAQ

**Do I need an API key or proxy?**
No. Dice's public search API requires no login or proxy.

**What formats can I export?**
JSON, CSV, Excel, or JSONL — from the Apify dataset UI or REST API.

**Can I filter to visa-sponsor-only jobs?**
Yes — set `willingToSponsorOnly: true`. Only rows where Dice marks the employer as willing to sponsor are returned.

**What if a query returns 0 results?**
The actor logs the query as returning no results and continues — no crash, no charge for that query.

### Notes

- Dice.com is a US-focused tech job board; most results are US-based.
- The `summary` field is a ~500-char teaser. Full job description HTML requires a logged-in session and is not available without auth.
- Skills are not returned as a structured array by the public API; they appear in the title and summary text.
- `parse_confidence=1.0` means all mandatory fields (id, title, company, location, url, date) were present and parsed cleanly.

### Use with AI agents (MCP)

This actor is available via Apify's MCP server. Connect it to any MCP-compatible agent (Claude, n8n, Make) to pull live Dice tech job data on demand — no code required.

```
https://mcp.apify.com/?tools=bovi/dice-jobs-scraper
```

### Vs. competitors

| Feature | This actor | Indeed scraper | LinkedIn scraper |
|---|---|---|---|
| Salary (structured range) | Yes | Partial | Rarely |
| Visa sponsor flag | Yes (unique to Dice) | No | No |
| Recruiter vs Direct Hire | Yes | No | No |
| Easy Apply flag | Yes | No | No |
| `parse_confidence` | Yes | No | No |
| Zero auth | Yes | Yes | No (needs cookie) |
| US tech focus | Yes (90K+ jobs) | Generic | Generic |
| Price | $0.90/1K | $3–5/1K | $5–10/1K |

*This actor is not affiliated with or endorsed by Dice.com or DHI Group, Inc.*

### Integrations

Built for tech recruiters and salary-benchmarking teams extracting structured US tech job listings with pay and visa fields — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### More scrapers from our toolkit

Building a data pipeline? These actors pair well with this one — each runs on your own Apify account with the same pay-per-result pricing, no subscription:

- [Glassdoor Scraper](https://apify.com/bovi/glassdoor-scraper)
- [Greenhouse Job Scraper](https://apify.com/bovi/greenhouse-job-scraper)
- [Greenhouse, Lever & Ashby Job Scraper](https://apify.com/bovi/greenhouse-lever-ashby-job-scraper)
- [Jobstreet Jobs Scraper](https://apify.com/bovi/jobstreet-jobs-scraper)
- [Lever Job Scraper](https://apify.com/bovi/lever-job-scraper)
- [Naukri Jobs Scraper](https://apify.com/bovi/naukri-jobs-scraper)

Chain any of them together from the **Integrations** tab (the *Run succeeded* trigger) to build a multi-step workflow — one actor's output feeds the next.

# Actor input Schema

## `searchQueries` (type: `array`):

One or more keyword queries to run on Dice.com. Examples: "python developer", "data engineer", "devops aws". Each query runs independently and results are combined.

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

Optional location string to narrow results. Examples: "New York, NY", "San Francisco, CA", "Austin, TX". Leave blank for US-wide results.

## `countryCode` (type: `string`):

2-letter ISO country code. Default "US". Dice is primarily US-focused.

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

Maximum total jobs to return across all queries. Default 100 keeps trial runs cheap. Set to 0 for unlimited.

## `sort` (type: `string`):

"relevance" returns best-match jobs first. "date" returns newest jobs first.

## `workFromHome` (type: `boolean`):

When enabled, filter to jobs where Dice marks workFromHomeAvailability=TRUE.

## `employmentType` (type: `string`):

Filter by employment type. Leave blank for all types. Options: FULLTIME, PARTTIME, CONTRACTS, THIRD\_PARTY.

## `postedDate` (type: `string`):

Filter to jobs posted within this window. Leave blank for all dates.

## `titleKeyword` (type: `string`):

Keep only jobs whose title contains this text (case-insensitive). Applied after fetching. Example: "senior". Leave blank to return all titles.

## `locationKeyword` (type: `string`):

Keep only jobs whose location contains this text (case-insensitive). Applied after fetching. Example: "Texas". Leave blank for all locations.

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

Post-fetch filter: keep only jobs where remote\_type='remote'. Use workFromHome for API-level filtering; use this for stricter check after enrichment.

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

Keep only jobs where Dice's Easy Apply is enabled (one-click application).

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

Keep only jobs where the employer indicates willingness to sponsor a visa.

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

Apify proxy used for all requests. Defaults to the Apify RESIDENTIAL group for reliable access from the cloud. Billed to the run owner.

## Actor input object example

```json
{
  "searchQueries": [
    "python developer",
    "data engineer"
  ],
  "countryCode": "US",
  "maxItems": 100,
  "sort": "relevance",
  "workFromHome": false,
  "employmentType": "",
  "postedDate": "",
  "remoteOnly": false,
  "easyApplyOnly": false,
  "willingToSponsorOnly": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing Dice Jobs Scraper records (title, company, location, remote\_type, seniority, salary, employment\_type, easy\_apply, willing\_to\_sponsor, posted\_at, url, parse\_confidence).

# 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 = {
    "searchQueries": [
        "python developer",
        "data engineer"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/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 = { "searchQueries": [
        "python developer",
        "data engineer",
    ] }

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

```

## MCP server setup

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