# Dice.com Job Scraper 💰 $0.99/1K Structured Salary & Monitoring (`corvuslab/dice-scraper`) Actor

Scrape tech job listings from Dice.com with structured salary data (min/max/currency), skills, contacts, and descriptions in text/HTML/Markdown. Includes incremental monitoring with repost detection and multi-channel notifications.

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

## Pricing

from $0.99 / 1,000 results

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?

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

### What does Dice.com Job Scraper do?

Dice.com is the largest tech-focused job board in the United States, with thousands of IT, engineering, and developer positions posted daily. This actor extracts Dice job listings as clean, structured records with parsed salary ranges (min, max, currency, type), tagged skills, recruiter contact details, and full descriptions in text, HTML, or Markdown. It is one of the fastest and lowest-cost ways to collect Dice data at scale — no browser, no proxy, and no login required. Export to JSON, CSV, or Excel, pull results from the API, or feed them straight into an AI agent via MCP.

Give it a search keyword like `python developer` or `data engineer` and optional filters (location, employment type, workplace, posted date, visa sponsorship) and it returns every matching Dice listing as a structured record. For each job you get the title, company, location breakdown (city, state, country, postal code), parsed salary, employment type, employer type, and posting dates. Turn on **Fetch full details** to also pull the full job description, required skills list, and contact details extracted from the listing text. You can also paste Dice.com search or detail URLs directly instead of running a keyword search.

> New to Apify? You can sign up for free and use the included monthly platform credit to try this Actor.

**Why this scraper**

- ⚡ **Fast & low-cost** — lightweight direct requests with no browser or proxy overhead, so large runs stay cheap.
- 🧾 **Rich, typed records** — 50+ structured fields per job, not raw HTML.
- ♻️ **Cheap to monitor** — incremental mode re-scrapes only what changed (see below).
- 🔔 **Notifications built in** — Telegram, Slack, Discord, WhatsApp or any webhook.
- 🤖 **AI- & API-ready** — compact output, MCP-friendly, one-click integrations.

***

### 📚 What data can you extract from Dice.com?

Every record carries **53 fields**, grouped like this:

| Group | What you get |
|---|---|
| **Core listing** | `jobId`, `title`, `postalCode`, `employmentType`, `workplaceTypes`, `isSponsored`, `easyApply`, `willingToSponsor`, `validThrough`, `skills`, `diceJobId`, `positionId` …and 7 more |
| **Contacts & demand signals** | `applicantLocationRequirements`, `extractedEmails`, `extractedPhones`, `socialProfiles`, `phoneNumber`, `applyEmail`, `contactName` |
| **Company** | `company`, `companyUrl`, `companyLogo`, `companyProfileUrl`, `employerType` |
| **Pay & budget** | `salaryText`, `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryType` |
| **Location** | `location`, `city`, `state`, `country`, `region` |
| **Description** | `summary`, `description`, `descriptionHtml`, `descriptionMarkdown`, `descriptionLength` |
| **Dates & change tracking** | `postedDate`, `modifiedDate`, `changeType` |

Every field is nullable — missing values come back as `null`. **Compact mode** returns
the core fields only for lean AI/MCP payloads, and **`excludeEmptyFields`** drops empties
entirely.

### ✨ Key features

- 🔎 **Search or URL scraping** — run a keyword + filter search, or paste Dice.com search and detail URLs directly.
- 💰 **Structured salary parsing** — every listing gets parsed salary fields (min, max, currency, type) extracted from the page's structured data, not just the raw text string.
- 🛠️ **Skills extraction** — required skills are pulled as a clean array from each job's detail page.
- 🎚️ **Rich filters** — location, radius, employment type, workplace type (remote / on-site / hybrid), posted date, Easy Apply, visa sponsorship, employer type — all applied server-side.
- 📇 **Contact extraction** — emails, phone numbers, URLs, and social profiles pulled from each listing; filter with `requireContact` for instant lead-gen lists.
- ♻️ **Incremental monitoring with repost detection** — schedule it and get only what changed (NEW / UPDATED / REAPPEARED / EXPIRED); unchanged items are skipped before their page is even fetched. Reposted jobs are flagged automatically so you never double-count them, and returning jobs are tagged REAPPEARED.
- 🔔 **Multi-channel notifications** — Telegram, Slack, Discord, WhatsApp, or any webhook (n8n / Make / Zapier).
- 📝 **Three description formats** — plain text, HTML, and Markdown, with optional truncation for leaner payloads.
- 🤖 **AI-ready** — compact + drop-empty output modes keep payloads small for LLMs and MCP tools.

***

### 🚀 How to scrape Dice.com

1. Open the actor and enter a **search keyword** (e.g. `data engineer`) and/or pick filters like location, employment type, or workplace — or paste a Dice.com URL.
2. Set **Max results** and choose whether to **Fetch full details** (on by default).
3. (Optional) Turn on **incremental mode** and a **notification** channel, then **Schedule** it for ongoing monitoring.
4. Click **Start**.
5. Download the data as **JSON, CSV or Excel**, or pull it from the **API**.

New to Apify? Create a free account — it comes with monthly credit, no credit card required.

***

### ⚙️ Input

Configure it in the visual editor — no code needed — or pass JSON via the API.

| Field | What it does |
|---|---|
| `query` | Keyword search (comma-separate for multiple searches). |
| `startUrls` | Scrape specific Dice.com search or job-detail URLs. |
| `location` | City, state, or zip code (e.g. `New York, NY`, `94105`). |
| `employmentType` | Full-time, Contract, Part-time, Third Party (multi-select). |
| `workplaceType` | Remote, On-Site, Hybrid (multi-select). |
| `postedDate` | Last 24 hours, 3 days, or 7 days. |
| `easyApply` | Only jobs with Dice Easy Apply. |
| `willingToSponsor` | Only employers willing to sponsor a visa. |
| `includeDetails` | Fetch each job's detail page for richer fields (salary, skills, description). |
| `requireContact` | Keep only listings with an email, phone, or both — built-in lead-gen filter. |
| `compact` | Return only core fields — ideal for AI agents and MCP clients. |
| `incrementalMode` | Emit only what changed since the last run. |
| `skipReposts` | Exclude jobs detected as reposts (same content, new listing ID). |
| `notifyOnlyChanges` | Only notify on NEW / UPDATED / REAPPEARED records. |
| `maxResults` | Cap the number of records (0 = unlimited). |

...and **40 inputs** in total — the table shows the essentials; the rest cover notification channels (Telegram, Slack, Discord, WhatsApp, webhook), description formats, output/AI modes, and advanced tuning, all in the visual editor.

#### Example inputs

**Basic search**

```json
{ "query": "python developer", "maxResults": 100 }
```

**Filtered search — remote data engineering jobs posted this week**

```json
{
  "query": "data engineer",
  "location": "Austin, TX",
  "employmentType": ["full-time"],
  "workplaceType": ["remote"],
  "postedDate": "7",
  "maxResults": 50
}
```

**Incremental monitoring — daily DevOps watch with Slack alerts**

```json
{
  "query": "devops engineer",
  "incrementalMode": true,
  "slackWebhookUrl": "https://hooks.slack.com/services/T00/B00/xxx",
  "maxResults": 200
}
```

***

### 📤 Output

Each item in the dataset is one Dice.com job listing. Every record includes the core fields; enabling **Fetch full details** (on by default) adds the full description, structured salary breakdown, skills list, and contact details. Here is a real example record (descriptions truncated for readability):

```json
{
  "id": "ac169ca1-1532-4084-b999-2dcd6756ab4e",
  "title": "Python Developer",
  "url": "https://www.dice.com/job-detail/ac169ca1-1532-4084-b999-2dcd6756ab4e",
  "company": "Randstad Digital",
  "companyUrl": "https://www.dice.com/company/cxsapwma1",
  "companyProfileUrl": "https://www.dice.com/company-profile/ee3855f3-d056-5325-bc31-ad5f53052a28",
  "location": "Jersey City, New Jersey, USA",
  "city": "Jersey City",
  "state": "New Jersey",
  "country": "USA",
  "region": "NJ",
  "postalCode": "07310",
  "salaryText": "USD55 - USD65",
  "salaryMin": 55.0,
  "salaryMax": 55.0,
  "salaryCurrency": "USD",
  "salaryType": "unknown",
  "employmentType": "Contract",
  "employerType": "Recruiter",
  "easyApply": false,
  "willingToSponsor": false,
  "postedDate": "2026-08-07T15:06:22Z",
  "modifiedDate": "2026-08-28T21:00:27Z",
  "validThrough": "2026-09-28T21:00:27.000Z",
  "summary": "The Cleared Derivatives Risk Technology (CDRT) team has an opportunity for a Senior Python (Quartz) Developer...",
  "descriptionLength": 3871,
  "applicantLocationRequirements": "USA",
  "source": "dice.com",
  "searchKeyword": "python developer",
  "scrapedAt": "2026-08-28T22:24:11.068668+00:00",
  "detailFetched": true,
  "contentHash": "e7b2249a6b80e9507f1044be6713a493cf3226da"
}
```

Each record can also include `description`, `descriptionHtml`, and `descriptionMarkdown` — choose the format with the **Description format** input. When incremental mode is on, records carry a `changeType` field (`NEW` / `UPDATED` / `REAPPEARED` / `EXPIRED`) and repost-detection fields (`isRepost`, `repostOfId`).

#### Data fields

- **Core** — id, title, url, company, location, salaryText, employmentType, postedDate, source, scrapedAt.
- **Structured salary** — salaryMin, salaryMax, salaryCurrency, salaryType (parsed from the page's structured data).
- **Location breakdown** — city, state, country, region, postalCode, applicantLocationRequirements.
- **Job details** (with `includeDetails`) — summary, description (text / HTML / Markdown), descriptionLength, skills, workplaceTypes, isSponsored, easyApply, willingToSponsor, employerType, validThrough.
- **Company** — companyUrl, companyLogo, companyProfileUrl.
- **Contacts & signals** — extractedEmails, extractedPhones, extractedUrls, socialProfiles, phoneNumber, applyEmail, contactName.
- **Monitoring** — changeType, isRepost, repostOfId, repostDetectedAt, contentHash.

Every field is present in standard mode (missing values are `null`); **compact mode** returns the core fields only, for lean AI/MCP payloads. With **`excludeEmptyFields`** enabled, null/empty fields are omitted entirely.

***

### ♻️ How to monitor Dice.com with incremental mode

Schedule the actor and turn on **incremental mode**: each run compares against the last and emits only **NEW / UPDATED / REAPPEARED / EXPIRED** records — unchanged items are skipped *before* their detail page is fetched, so a daily watch costs a fraction of a full re-scrape. Jobs that disappear and then come back are tagged `REAPPEARED`. Reposted jobs (same content under a new listing ID) are automatically flagged with `isRepost` and linked back to the original via `repostOfId`, so you never double-count them — or enable `skipReposts` to drop them entirely.

**Example: monitoring 1,000 jobs daily for a month (30 runs)**

| Daily churn | of 1,000 tracked | billable records | you save |
|---|---|---|---|
| 5 % | 1,000 | 50 | **95 %** |
| 15 % | 1,000 | 150 | **85 %** |
| 30 % | 1,000 | 300 | **70 %** |

The first run seeds the baseline and bills in full; every run after that bills only the delta.

***

### 🔔 How to set up Dice.com alerts

Get pinged the moment a matching record appears. Fill in only the channels you want:

| Channel | What to configure |
|---|---|
| ✈️ **Telegram** | `telegramToken` (from @BotFather) + `telegramChatId` |
| 💬 **Slack** | `slackWebhookUrl` (Incoming Webhook URL) |
| 🎮 **Discord** | `discordWebhookUrl` (channel webhook URL) |
| 🪝 **Webhook** | `webhookUrl` receives structured JSON — ideal for n8n / Make / Zapier |

Credentials are secret inputs — encrypted at rest, masked in the UI and never written to the
run log. Every channel fires independently, so a broken channel can't stop the scrape or the
others. Pair **incremental mode** with **notify only about changes** to hear only about
genuinely new records, with no duplicates across runs.

### 💡 What can you do with Dice.com data?

- **Lead generation** — filter for jobs with recruiter emails or phone numbers and build targeted outreach lists for staffing, tools, or services.
- **Tech salary research** — analyze structured salary ranges across roles, locations, and employment types to benchmark compensation.
- **Job monitoring** — schedule it with incremental mode + notifications for a live change feed of new, updated, and expired listings.
- **Skills-gap analysis** — aggregate the skills arrays across thousands of listings to map which technologies employers demand most.
- **Enrichment & aggregation** — feed clean job data into your own app, spreadsheet, or data warehouse.
- **AI agents & pipelines** — compact output plugs straight into LLM/MCP workflows for automated job matching or market analysis.

***

### 💰 How much does it cost to scrape Dice.com?

This Actor uses Apify's **pay-per-event** model: a small fee when a run starts, plus a
per-record fee. See the Actor's **Pricing** tab for the current numbers — they're rendered
live, so this page never goes stale.

Two things cut your bill further:

- **Site-side filters** — records you filtered out are never fetched and never billed.
- **Incremental mode** — after the baseline run you pay only for what actually changed.

| Daily churn | of 1,000 tracked | billable records | you save |
|---|---|---|---|
| 5 % | 1,000 | 50 | **95 %** |
| 15 % | 1,000 | 150 | **85 %** |
| 30 % | 1,000 | 300 | **70 %** |

### 🔌 Integrations & export

Export to **JSON, CSV, Excel** or an HTML table, or pull from the **REST API** and the **JavaScript / Python** clients. Runs on a **schedule**, connects to **Google Sheets, Slack, Make, Zapier and n8n**, and works as an **MCP tool** for AI agents — compact mode keeps token usage small.

***

### 🔗 Using the API

You can run this Actor from your own code. Example with the Apify Python client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "query": "python developer",
    "location": "New York, NY",
    "employmentType": ["full-time"],
    "maxResults": 50,
}

run = client.actor("corvuslab/dice-scraper").call(run_input=run_input)

print("Results: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

The Actor also works with the JavaScript/TypeScript client, the Apify CLI and the REST API.

***

### ❓ FAQ

**Do I need a proxy or login?** No — it works out of the box with no proxy and no login. Apify Proxy is available under Advanced settings if you ever need it for high-volume runs.

**Can I get only new items on a schedule?** Yes — turn on incremental mode and schedule it; each run emits only what changed and can notify your Slack, Telegram, Discord, or webhook channel.

**What about reposted jobs?** The actor detects when a job is reposted under a new ID and flags it with `isRepost` and `repostOfId`, so you can filter out duplicates in your pipeline.

**What formats can I export?** JSON, CSV, Excel, HTML table, or via the API.

**Is it good for AI agents?** Yes — enable compact mode; the output is MCP-friendly and keeps token usage low.

**How many records can I get?** As many as Dice returns for your search — set `maxResults` to cap the count (0 = unlimited).

**Can it notify me when new jobs appear?** Yes — add a Telegram, Slack, Discord, WhatsApp, or generic webhook target under Notifications, and combine with incremental mode + `notifyOnlyChanges` so you only get pinged about new and updated listings.

**Is scraping Dice.com legal?** This actor collects only **publicly available** data on Dice.com. You are responsible for how you use the extracted data — in particular any personal information — and for complying with the site's terms and applicable law (including the GDPR where it applies). Not affiliated with, endorsed by, or sponsored by DHI Group, Inc. or Dice.

***

**Keywords:** dice scraper · dice.com scraper · dice api · dice job scraper · dice.com job scraper · scrape dice jobs · dice data extraction · dice salary data · tech job scraper · dice job monitoring · export dice jobs CSV · dice.com jobs JSON · job board scraper · no-code scraper · MCP tool for AI agents · tech recruiting data · dice remote jobs · dice job alerts

# Actor input Schema

## `query` (type: `string`):

Keywords to search for (e.g. "python developer", "data engineer"). Separate multiple searches with commas — each runs as its own search and results are merged and de-duplicated.

## `queries` (type: `array`):

Run several searches in one run. Each entry is a separate keyword search — results are merged and de-duplicated. Alternative to comma-separated `query`.

## `startUrls` (type: `array`):

Paste Dice search or job-detail URLs to scrape directly. Detail-page URLs (dice.com/job-detail/...) are fetched individually.

## `maxResults` (type: `integer`):

Maximum number of jobs to return. Set 0 for unlimited (bounded by how many the search has).

## `ignoreUrlFailures` (type: `boolean`):

Skip URLs that cannot be interpreted instead of failing the whole run.

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

City, state, or zip code — e.g. "New York, NY", "Austin, TX", "94105". Dice geocodes this automatically.

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

Search radius in miles from the location. Only used when a location is set.

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

Two-letter country code. Dice is US-focused; change only if targeting another market.

## `employmentType` (type: `array`):

Filter by employment type. Multiple values widen the search (OR).

## `workplaceType` (type: `array`):

Filter by work setting. Multiple values widen the search (OR).

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

Only jobs posted within this time window.

## `easyApply` (type: `boolean`):

Only return jobs with Dice Easy Apply enabled.

## `willingToSponsor` (type: `boolean`):

Only return jobs from employers willing to sponsor a visa.

## `employerType` (type: `array`):

Filter by employer type.

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

Sort order for results.

## `requireContact` (type: `string`):

Keep only jobs that include a contact. off = keep everything; email / phone = require that channel; either = at least one; both = email and phone. Screened at emit time, so it also trims what you're billed for.

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

Fetch each job's detail page for the richer fields (full description, structured salary, skills, postal code). Turn off for the fastest, cheapest runs.

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

Which representation(s) of the job description to include.

## `descriptionMaxLength` (type: `integer`):

Truncate descriptions to this many characters. Leave empty for full text.

## `compact` (type: `boolean`):

Emit only the core fields (id, title, url, company, location, salary, employment type, posted date). Ideal for AI agents and MCP clients.

## `excludeEmptyFields` (type: `boolean`):

Remove null, empty-string and empty-array fields from each record.

## `incrementalMode` (type: `boolean`):

Track state between runs and tag every job with a changeType (NEW / UPDATED / UNCHANGED / EXPIRED).

## `stateKey` (type: `string`):

Stable name for the tracked search. Leave empty to derive one automatically from your search settings.

## `emitUnchanged` (type: `boolean`):

Also emit jobs that have not changed since the previous run.

## `skipReposts` (type: `boolean`):

Exclude jobs detected as reposts (same content under a new listing ID). Only effective in incremental mode.

## `emitExpired` (type: `boolean`):

Emit records for jobs present last run but gone now.

## `telegramToken` (type: `string`):

Bot token from @BotFather.

## `telegramChatId` (type: `string`):

Chat or channel ID, e.g. "-100123456789" or "@yourchannel".

## `slackWebhookUrl` (type: `string`):

Slack incoming-webhook URL.

## `discordWebhookUrl` (type: `string`):

Discord incoming-webhook URL.

## `whatsappPhoneNumberId` (type: `string`):

Phone Number ID from Meta Business Manager (not the phone number itself). Required for WhatsApp notifications.

## `whatsappAccessToken` (type: `string`):

Permanent token from Meta Cloud API.

## `whatsappTo` (type: `string`):

Recipient phone number in E.164 format, e.g. "+14155551234".

## `webhookUrl` (type: `string`):

Any HTTPS endpoint. Receives a JSON POST with the matched jobs — works with n8n, Make and Zapier.

## `webhookHeaders` (type: `object`):

Extra headers for the webhook request, e.g. {"Authorization": "Bearer xyz"}.

## `notificationLimit` (type: `integer`):

How many jobs to include in each notification message.

## `notifyOnlyChanges` (type: `boolean`):

Only send notifications for NEW, UPDATED, or REAPPEARED records. Requires incremental mode.

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

Optional. Dice works without a proxy — only enable if your IP is rate-limited.

## `maxRequestRetries` (type: `integer`):

How many times to retry a failed request before giving up on it.

## `detailConcurrency` (type: `integer`):

How many detail pages to fetch in parallel. Higher = faster but more memory.

## Actor input object example

```json
{
  "query": "python developer",
  "maxResults": 25,
  "ignoreUrlFailures": true,
  "countryCode": "US",
  "postedDate": "",
  "easyApply": false,
  "willingToSponsor": false,
  "sortBy": "relevance",
  "requireContact": "off",
  "includeDetails": true,
  "descriptionFormat": "all",
  "compact": false,
  "excludeEmptyFields": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "skipReposts": false,
  "emitExpired": false,
  "notificationLimit": 5,
  "notifyOnlyChanges": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "maxRequestRetries": 3,
  "detailConcurrency": 8
}
```

# Actor output Schema

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

No description

## `allItems` (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 = {
    "query": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("corvuslab/dice-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 = { "query": "" }

# Run the Actor and wait for it to finish
run = client.actor("corvuslab/dice-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 '{
  "query": ""
}' |
apify call corvuslab/dice-scraper --silent --output-dataset

```

## MCP server setup

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