# Dice.com Job Scraper (`datascrapers/dice-scraper`) Actor

Dice.com job dataset from keywords, URLs, and filters, including optional job details, company profiles, and company job listings.

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

## Pricing

from $1.70 / 1,000 job scrapeds

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.com Job Scraper** creates a structured dataset of job listings collected from [Dice.com](https://www.dice.com). Each dataset item represents one Dice job and can include identifiers, title, summary, salary, dates, company fields, employment and workplace type, location, and optional job-detail, company-profile, and company-jobs objects. Query the source with keywords, Dice URLs, or a company brand ID, plus location and filter fields. Control the result limit with `maxItems`, and retrieve records through the Apify Dataset API or export them as JSON, CSV, Excel, XML, or another supported format.

### Dataset at a glance

| Property | Value |
|---|---|
| Source | dice.com (technology job listings) |
| Record unit | One Dice job, with optional nested job details, company profile, and company jobs |
| Input methods | Keyword search (`searchQuery`, `searchQueries`), Dice URLs (`startUrls`), or company brand ID (`clientBrandId`) |
| Main identifiers | `guid`, `detailsPageUrl` |
| Delivery | Apify Dataset and API |
| Export formats | JSON, CSV, Excel, XML, HTML (Apify dataset exports) |
| Update model | Fresh records per Actor run |
| Pricing | $2.00 per 1,000 jobs; +$2.50 per 1,000 job details; +$2.00 per 1,000 company details; +$2.00 per 1,000 company jobs |

### Coverage and available records

The Actor collects public Dice.com job listings from these entry points. They can be combined in one run.

- **Search-based**: Set `searchQuery` (prefill `python`) and optional extra keywords in `searchQueries`. Each query is a separate search. Apply `location`, `radius` (default `30`), `radiusUnit` (`mi` or `km`, default `mi`), `employmentTypes`, `workplaceTypes`, `postedDate`, `employerTypes`, `easyApply`, and `isRemote`.
- **URL-based**: Pass Dice jobs search URLs or company job-listing URLs in `startUrls`. Filters encoded in the URL are used for that search.
- **Company-based**: Set `clientBrandId` to collect jobs for one Dice company brand, or pass a Dice company jobs URL in `startUrls`.

Record types and limits:

- **Listing records** are always collected: identifiers, title, summary, salary, dates, company name and URLs, employment type, employer type, workplace flags, location, and score.
- **Job details** are conditional: a `jobDetails` object is returned only when `includeJobDetails` is enabled.
- **Company details** are conditional: a `companyDetails` object is returned only when `includeCompanyDetails` is enabled. The profile is collected once per unique `companyProfileId` and attached to each job from that company.
- **Company jobs** are conditional: a `companyJobs` array is returned only when `includeCompanyJobs` is enabled, capped by `maxCompanyJobs` (`0` means unlimited, the default). Those extra jobs are attached onto the listing row; they are not separate dataset items.
- **Result cap**: `maxItems` limits search-result jobs written to the dataset (`0` means unlimited; default `10`).

Known exclusions: content Dice only shows behind login is not collected; each run captures listing state at run time (no historical snapshots); enrichment objects are omitted when their toggle is off or the source does not return them.

### Data dictionary

Field names below match dataset record JSON properties exactly. Fields marked *conditional* appear only when the corresponding input toggle is enabled. `guid` is the recommended deduplication key; `detailsPageUrl` is a reasonable secondary key. Dates are ISO 8601 timestamps as returned by Dice (for example `2026-08-20T20:06:16Z`). `salary` is a formatted string, not a numeric range.

#### Listing fields

| Field | Type | Nullable | Description | Example |
|---|---|---:|---|---|
| `id` | string | Yes | Dice listing identifier | Source listing value |
| `guid` | string | Yes | Dice job GUID; best stable deduplication key | `d7c60634-b836-4f3d-acb7-4b6ddf6a6f7b` |
| `title` | string | Yes | Job title | `Senior Python Software Engineer` |
| `summary` | string | Yes | Search-result summary snippet | `Job Number: R0247450 Python Software Engineer, Senior...` |
| `salary` | string | Yes | Salary text as shown on Dice | `USD 112,800.00 - 257,000.00 per year` |
| `postedDate` | string | Yes | Posted timestamp (ISO 8601) | `2026-08-20T20:06:16Z` |
| `modifiedDate` | string | Yes | Last-modified timestamp (ISO 8601) | Source listing value |
| `detailsPageUrl` | string | Yes | Job detail URL; secondary deduplication key | `https://www.dice.com/job-detail/d7c60634-b836-4f3d-acb7-4b6ddf6a6f7b` |
| `companyPageUrl` | string | Yes | Dice company page URL | `https://www.dice.com/company/booz` |
| `companyLogoUrl` | string | Yes | Company logo image URL | Source listing value |
| `companyName` | string | Yes | Hiring company name | `Booz Allen Hamilton` |
| `employmentType` | string | Yes | Employment type as shown on Dice | `Full-time` |
| `employerType` | string | Yes | Employer type as shown on Dice | Source listing value |
| `clientBrandId` | string | Yes | Dice company brand identifier | Source listing value |
| `companyProfileId` | string | Yes | Dice company profile identifier | Source listing value |
| `recruiterId` | string | Yes | Recruiter identifier when present | Source listing value |
| `easyApply` | boolean | Yes | Whether Dice Easy Apply is available | `false` |
| `isRemote` | boolean | Yes | Whether the listing is marked remote | `true` |
| `workFromHomeAvailability` | string | Yes | Work-from-home availability text | Source listing value |
| `workplaceTypes` | string\[] | Yes | Workplace labels (`Remote`, `Hybrid`, `On-Site`) | `["Remote"]` |
| `location` | string | Yes | Display location from `jobLocation.displayName` | Source listing value |
| `jobLocation` | object | Yes | Location object as returned by Dice | See `location` |
| `score` | number | Yes | Search relevance score as returned by Dice | Source listing value |

#### Job details (conditional — `includeJobDetails`)

| Field | Type | Nullable | Description |
|---|---|---:|---|
| `jobDetails` | object | Yes | Detail object attached to the job row |
| `jobDetails.jobDescriptionHtml` | string | Yes | Full job description (HTML) |
| `jobDetails.jobDescriptionText` | string | Yes | Full job description (plain text) |
| `jobDetails.diceId` | string | Yes | Dice identifier from the detail page |
| `jobDetails.diceCompanyId` | string | Yes | Dice company identifier from the detail page |
| `jobDetails.positionId` | string | Yes | Position identifier from the detail page |
| `jobDetails.skills` | string | Yes | Skills text when present |
| `jobDetails.experienceLevel` | string | Yes | Experience level when present |
| `jobDetails.postedLabel` | string | Yes | Posted-age label when present |
| `jobDetails.applyUrl` | string | Yes | Apply URL when present |
| `jobDetails.externalApplyUrl` | string | Yes | External apply URL when present |

#### Company details (conditional — `includeCompanyDetails`)

`companyDetails` is the Dice company profile object, attached once the profile is collected for that `companyProfileId`. Observed groups include `company_info` (name, website, founded, employees, locations, social links), `general_information` (overview), `technologies`, `company_technologies`, `benefits`, and `awards_and_accomplishments`. Nested keys follow the source profile; fields Dice does not return are omitted or null.

#### Company jobs (conditional — `includeCompanyJobs`)

`companyJobs` is an array of listing-shaped job objects for the same `clientBrandId`. Each item uses the listing fields above. These jobs are nested on the parent dataset item and are not extra dataset rows. `maxCompanyJobs` caps the array (`0` = unlimited).

### Example dataset record

Representative listing-only record from a `python` search with remote, full-time filters. Conditional objects are omitted because enrichment was off.

```json
{
  "guid": "d7c60634-b836-4f3d-acb7-4b6ddf6a6f7b",
  "title": "Senior Python Software Engineer",
  "companyName": "Booz Allen Hamilton",
  "salary": "USD 112,800.00 - 257,000.00 per year",
  "employmentType": "Full-time",
  "workplaceTypes": ["Remote"],
  "isRemote": true,
  "easyApply": false,
  "postedDate": "2026-08-20T20:06:16Z",
  "detailsPageUrl": "https://www.dice.com/job-detail/d7c60634-b836-4f3d-acb7-4b6ddf6a6f7b",
  "companyPageUrl": "https://www.dice.com/company/booz",
  "summary": "Job Number: R0247450 Python Software Engineer, Senior..."
}
```

The record above was produced with this input:

```json
{
  "searchQuery": "python",
  "workplaceTypes": ["Remote"],
  "employmentTypes": ["FULLTIME"],
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

`jobDetails`, `companyDetails`, and `companyJobs` appear on the same row when `includeJobDetails`, `includeCompanyDetails`, and `includeCompanyJobs` are enabled.

### Query and input reference

| Input | Type | Required | Default | Accepted values | Description |
|---|---|---:|---|---|---|
| `searchQuery` | string | No\* | — | Free text (prefill `python`) | Primary keyword search |
| `searchQueries` | string\[] | No\* | `[]` | Job titles, skills, or keywords | Additional keyword searches; each runs separately |
| `startUrls` | array (requestListSources) | No\* | `[]` | Dice jobs search or company job-listing URLs | URL-based entry point; filters in the URL are used |
| `location` | string | No | `""` | Free text (e.g. `New York`, `Remote`) | Geographic filter for search mode |
| `radius` | integer | No | `30` | `1` or greater | Search radius around `location` |
| `radiusUnit` | string | No | `mi` | `mi`, `km` | Unit for `radius` |
| `employmentTypes` | string\[] | No | `[]` | `FULLTIME`, `PARTTIME`, `CONTRACTS`, `THIRD_PARTY` | Employment-type filter (OR) |
| `workplaceTypes` | string\[] | No | `[]` | `Remote`, `Hybrid`, `On-Site` | Workplace-type filter |
| `postedDate` | string | No | `""` | `""` (any time), `ONE` (today), `THREE`, `SEVEN` | Posted-recency filter |
| `employerTypes` | string\[] | No | `[]` | `Direct Hire`, `Recruiter`, `Other` | Employer-type filter |
| `easyApply` | boolean | No | `false` | `true` / `false` | When `true`, return only Easy Apply jobs |
| `isRemote` | boolean | No | `false` | `true` / `false` | When `true`, return only remote jobs |
| `clientBrandId` | string | No\* | `""` | Dice company brand ID | Collect jobs for one company brand |
| `includeJobDetails` | boolean | No | `false` | `true` / `false` | Attach `jobDetails` (charged as job-details) |
| `includeCompanyDetails` | boolean | No | `false` | `true` / `false` | Attach `companyDetails` (charged as company-details, once per unique company) |
| `includeCompanyJobs` | boolean | No | `false` | `true` / `false` | Attach `companyJobs` (charged as jobs-by-company per nested job) |
| `maxCompanyJobs` | integer | No | `0` | `0` or any positive integer | Cap nested company jobs; `0` = unlimited |
| `detailConcurrency` | integer | No | `5` | `1`–`20` | Parallel enrichment requests when detail toggles are on |
| `maxItems` | integer | No | `10` | `0` or any positive integer | Maximum search-result jobs; `0` = unlimited |
| `proxyConfiguration` | object | No | Apify proxy, `RESIDENTIAL` group | Apify proxy groups or custom proxies | Residential proxies are recommended |

\* Provide at least one of `searchQuery`, `searchQueries`, `startUrls`, or `clientBrandId` (or equivalent filter-only input).

Minimal request:

```json
{ "searchQuery": "python" }
```

Advanced request (filters plus enrichment):

```json
{
  "searchQuery": "python",
  "workplaceTypes": ["Remote"],
  "employmentTypes": ["FULLTIME"],
  "includeJobDetails": true,
  "includeCompanyDetails": true,
  "includeCompanyJobs": true,
  "maxCompanyJobs": 10,
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### Retrieve the data through the API

The Actor runs on the Apify platform, so there is no server to host and no crawling infrastructure to maintain.

1. Start the Actor with a JSON input (console or API).
2. Wait for the run to finish, or use a synchronous endpoint if you want the response inline.
3. Retrieve items from the run's default dataset.
4. Paginate or export the dataset.

Python example:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR-APIFY-TOKEN")

run_input = {
    "searchQuery": "python",
    "workplaceTypes": ["Remote"],
    "employmentTypes": ["FULLTIME"],
    "includeJobDetails": True,
    "maxItems": 10,
}

run = client.actor("datascrapers/dice-scraper").call(run_input=run_input)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["guid"], item["title"], item["companyName"])
```

Apify generates ready-to-run Python, JavaScript, and cURL examples on the Actor's [API tab](https://apify.com/datascrapers/dice-scraper/api). Do not put a real API token in shared code or URLs.

### Data quality and record handling

- **Conditional fields**: `jobDetails`, `companyDetails`, and `companyJobs` are present only when their input toggle is enabled and the source returns data. Listing-only runs return a leaner record.
- **Source values**: salary, dates, workplace labels, and location text are taken from Dice as published. Unreadable fields are returned as null rather than fabricated.
- **Attached enrichments**: company profile and company jobs nest on the job row. A company with 40 open jobs still produces one dataset item per search-result job.
- **Deduplication**: each run appends fresh records. Search configurations are de-duplicated within a run; job rows are not de-duplicated across runs. Use `guid` as the stable key, or `detailsPageUrl` as a secondary key, and filter repeated runs against previously stored values.
- **Enrichment fallback**: listing data is returned even when a detail or company request fails; that failed enrichment is not charged.
- **Normalization**: `workplaceTypes` is a string array; `easyApply` and `isRemote` are booleans; `score` is a number; `location` is the display name from `jobLocation`.

### Export and pipeline examples

| Destination | Recommended method | Typical use |
|---|---|---|
| PostgreSQL / Supabase | Dataset API poll or webhook consumer | Store Dice listings alongside talent tables |
| Google Sheets | Apify Google Sheets integration | Share role shortlists with recruiting teams |
| CRM / ATS pipeline | Webhook on run completion | Push new listings into applicant tracking |
| S3 / cloud storage | Scheduled export via Apify scheduler + integration | Archival of labor-market snapshots |

### Pricing and cost examples

The Actor uses pay-per-event pricing. A run also incurs an Actor-start charge of $0.00005.

| Event | Trigger | Rate |
|---|---|---|
| Actor start | Once per run | $0.00005 |
| dataset-item | Every search-result job pushed to the dataset | $0.002 / job ($2.00 per 1,000 jobs) |
| job-details | `includeJobDetails` enabled and detail data returned | $0.0025 / job ($2.50 per 1,000 jobs) |
| company-details | `includeCompanyDetails` enabled, once per unique company | $0.002 / company ($2.00 per 1,000 companies) |
| jobs-by-company | `includeCompanyJobs` enabled, per nested company job | $0.002 / job ($2.00 per 1,000 company jobs) |

Example costs at the published event rates (Actor start is $0.00005 per run):

| Records | Configuration | Estimated base cost |
|---:|---|---:|
| 1,000 jobs | Listing only | $2.00 |
| 10,000 jobs | Listing only | $20.00 |
| 1,000 jobs | Listing + job details | $4.50 |
| 1,000 jobs + 200 unique companies | Listing + company details | $2.40 |
| 1,000 jobs + 500 nested company jobs | Listing + company jobs | $3.00 |
| 1,000 jobs + details + 200 companies + 500 company jobs | All enrichments | $5.90 |

Paid Apify plans may apply lower tiered event rates. Compute units consumed by the run are billed by your Apify plan. Estimates depend on the verified pricing model, unique-company count, nested company-job volume, and the options selected for the run.

### Limitations and responsible data use

- The Actor collects publicly accessible data from Dice.com pages only.
- Field availability depends on what Dice renders at run time; some values can be null or missing, and site changes can alter fields.
- Company details and company jobs attach onto job rows; they are not standalone dataset items.
- The Actor does not provide historical snapshots unless you store them yourself.
- Residential proxies are recommended; coverage may degrade without them.
- You are responsible for compliance with Dice's terms of service, applicable privacy law, and any contractual obligations before using the data.

### Dataset questions

#### What does one dataset item represent?

One Dice job listing. `jobDetails`, `companyDetails`, and `companyJobs` attach onto that same row when enabled. A job whose company has many open roles still produces a single dataset item.

#### Which field should I use as a unique identifier?

`guid` is the Dice job GUID and is the recommended deduplication key. `detailsPageUrl` is a reasonable secondary key.

#### Are fields nullable or conditional?

Yes. `jobDetails` exists only when `includeJobDetails` is enabled; `companyDetails` exists only when `includeCompanyDetails` is enabled; `companyJobs` exists only when `includeCompanyJobs` is enabled. Within listing records, fields Dice does not publish for a job are returned as null.

#### How do I collect jobs for one company?

Set `clientBrandId` to the Dice brand ID, or pass a Dice company jobs URL in `startUrls`. Enable `includeCompanyJobs` to nest that company's listings on each result, and use `maxCompanyJobs` to cap the array.

#### Can I retrieve the records as CSV or JSON?

Yes. The dataset can be exported as JSON, CSV, Excel, XML, or HTML from the Apify Console, and queried through the Dataset API.

#### Does the Actor return historical data?

No. Each run captures the state of the listings at run time. To track posting or salary changes, schedule repeated runs and store the outputs yourself.

#### What counts as a billable result?

Four pay-per-event charges apply after a $0.00005 Actor-start charge: a dataset-item charge for every search-result job ($2.00 per 1,000), a job-details charge for each enriched job ($2.50 per 1,000), a company-details charge once per unique company ($2.00 per 1,000), and a jobs-by-company charge per nested company job ($2.00 per 1,000). A listing-only run incurs Actor start plus dataset-item charges.

### Related datasets from Data Scrapers

- **[Naukri Job Scraper](https://apify.com/datascrapers/naukri-scraper)** — India job listings that can be compared with Dice rows by title, company, and skills.
- **[Glassdoor Jobs Scraper](https://apify.com/datascrapers/glassdoor-jobs-scraper)** — Job listings with employer ratings that can be joined to Dice jobs by company name and title.
- **[ZipRecruiter Job Scraper](https://apify.com/datascrapers/ziprecruiter-scraper)** — US job listings for cross-board labor-market comparison against Dice technology roles.
- **[StepStone Jobs Scraper](https://apify.com/datascrapers/stepstone-jobs-scraper)** — European job listings useful for multi-region hiring-volume analysis.
- **[LinkedIn Company Scraper](https://apify.com/datascrapers/linkedin-company-scraper)** — Company profiles that can be joined with Dice jobs by company name.

### Data Scrapers support

Need an additional field, record type, or export workflow? Contact Data Scrapers at stardustspotlight@gmail.com. Include a sample source URL, required fields, expected record volume, and preferred delivery format.

# Actor input Schema

## `searchQuery` (type: `string`):

Keyword search term, e.g. python, data engineer, react.

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

Optional additional keyword searches. Each query runs as a separate search.

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

Dice jobs search URLs or company job listing URLs. Query parameters and filters are parsed from the URL.

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

Location text for the search, e.g. New York, Remote, San Francisco.

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

Search radius around the location.

## `radiusUnit` (type: `string`):

Unit for the search radius.

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

Filter by employment type. Multiple values are combined with OR logic.

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

Filter by workplace type.

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

Filter by posting recency.

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

Filter by employer type.

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

When enabled, return only jobs that support Dice Easy Apply.

## `isRemote` (type: `boolean`):

When enabled, return only remote jobs.

## `clientBrandId` (type: `string`):

Optional Dice company brand ID to scrape jobs from one company directly.

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

Fetch full job descriptions and extra detail fields. Billed as job-details events.

## `includeCompanyDetails` (type: `boolean`):

Fetch full company profile data such as overview, social links, benefits, and technologies. Billed as company-details events.

## `includeCompanyJobs` (type: `boolean`):

Fetch all jobs posted by each company found in results. Billed as jobs-by-company events per company job returned.

## `maxCompanyJobs` (type: `integer`):

Maximum number of jobs to fetch per company when includeCompanyJobs is enabled (0 = unlimited).

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

How many jobs to enrich in parallel when optional detail fields are enabled.

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

Maximum number of search-result jobs to scrape (0 = unlimited).

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

Proxy settings for anti-bot protection.

## Actor input object example

```json
{
  "searchQuery": "python",
  "searchQueries": [],
  "startUrls": [],
  "location": "",
  "radius": 30,
  "radiusUnit": "mi",
  "employmentTypes": [],
  "workplaceTypes": [],
  "postedDate": "",
  "employerTypes": [],
  "easyApply": false,
  "isRemote": false,
  "clientBrandId": "",
  "includeJobDetails": false,
  "includeCompanyDetails": false,
  "includeCompanyJobs": false,
  "maxCompanyJobs": 0,
  "detailConcurrency": 5,
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

## `runStats` (type: `string`):

No description

## `input` (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 = {
    "searchQuery": "python",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("datascrapers/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 = {
    "searchQuery": "python",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("datascrapers/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 '{
  "searchQuery": "python",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call datascrapers/dice-scraper --silent --output-dataset

```

## MCP server setup

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