# Dell Scraper - Laptop & Desktop Price and Deal Watch (USA) (`superslowsloth/dell-products`) Actor

Dell scraper: dell.com/en-us laptop and desktop listings to one row per product line with starting price in USD, deal and promotion, percent off, rating, review count, model, display size, key features and image. For Dell laptop and desktop price and deal watching.

- **URL**: https://apify.com/superslowsloth/dell-products.md
- **Developed by:** [Superslow Sloth](https://apify.com/superslowsloth) (community)
- **Categories:** E-commerce, Automation
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.49 / 1,000 product scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Dell scraper: laptop and desktop price and deal watch (USA)

This Dell scraper reads the laptop and desktop listings on [dell.com/en-us](https://www.dell.com/en-us)
and returns one flat row per Dell product line: the **starting price in USD**,
whether the line is on a deal and how big the deal is, rating and review count,
model number, display size, the key-feature bullets, colours, the product link
and the photo. Run it on a schedule and diff the dataset to get a **Dell laptop
and desktop price and deal watch**: which XPS, Dell Pro, Alienware or Precision
lines dropped, which went on a "$300.00 off select configuration" deal, and what
is new.

No account, no API key, no login, no browser. One request returns 12 products.

### Input

| Field | Notes |
|---|---|
| `categories` | One or more Dell listings, one per line: `laptop` or `desktop`, or the page URL (`https://www.dell.com/en-us/shop/laptop-computers/scr/laptop`). To read one of Dell's filters, add its `appref` segment exactly as it appears in the page address: `laptop/appref=alienware-product-line` or `https://www.dell.com/en-us/shop/laptop-computers/scr/laptop/appref=16-gb-memory`. One `appref` filter per line. A filter Dell does not know returns no products and costs nothing. Only the dell.com/en-us laptop and desktop listings are supported: monitors and accessories are a different kind of Dell page, and another country's Dell site is a different store. |
| `maxItems` | Products to read per listing (default 100, up to 1,000). 12 per page. The whole laptop listing was 89 products and the desktop one 44 on 2026-11-02. |
| `proxyConfiguration` | Apify RESIDENTIAL proxy by default. dell.com refuses a request that does not look like a browser, and some addresses. |

Example input:

```json
{
  "categories": ["laptop", "desktop", "laptop/appref=alienware-product-line"],
  "maxItems": 100
}
```

### Output

Prices are numbers in US dollars; `currency` is `USD`. **One row is one product
line**, not one configuration: Dell sells a line such as "Dell 15 Laptop" (model
DC15250) in dozens of configurations, and the listing shows the line once.
`product_id` is the unique key within a category.

| Field | Notes |
|---|---|
| `category`, `refinement`, `position` | The listing the row was read from (`laptop` or `desktop`), the `appref` filter if you used one (null otherwise), and the place in the listing counting from 1, as Dell's own "13 to 24 of 89" pager numbers it. Dell's default order drifts a little between requests. |
| `product_id`, `offer_id`, `model` | Dell's id for the line (the last part of its page address, `dell15laptopdc15250`), the offer code of the line's base configuration (`dc15250_so_6`; add it to the `url` for that configuration's page), and the model number Dell prints (`DC15250`). |
| `name`, `url`, `image_url` | The name as the tile shows it, the product line's page, and the tile photo. |
| `price` | The line's **starting price**: Dell's "Starting AT" price for the pre-configured base configuration with recommended services. It is already net of any deal on that configuration. A configuration you build on Dell's page costs more or less. |
| `on_deal` | True when the tile carries Dell's Hot Deal marker. It always came with a promotion line in the 133 rows checked. It is what Dell says, not a comparison against any price history. |
| `promotion`, `promotion_amount_off` | The promotion line as shown (`$100.00 off select configuration`) and its dollar amount. **Null when there is no promotion**, never 0. The saving is on a *select* configuration, which is not necessarily the one `price` is for. |
| `deal_max_percent_off`, `deal_offer_count` | The largest percentage off among the line's deal configurations (14.29 is 14.29% off), from the deal data the tile carries, and how many configurations are on a deal. Null and 0 when the line has no deal. |
| `rating`, `review_count` | The average star rating (1 to 5, one decimal) and the number of reviews. **Both null for a line with no reviews**: the tile then shows no rating (47 of 133 laptops and desktops). |
| `display_inches` | The size from the tile's "Display" line (`15.6`). **Null when the tile prints none**: all 89 laptops had one, 7 of 44 desktops (all-in-ones). |
| `features` | The tile's key-feature bullets as shown, in order (five on 130 of 133 rows, six on 3). |
| `colors`, `badges` | Colour names the tile offers (`black`, `silver`; empty when it lists none) and its badges (`New`; empty when none). |
| `currency` | `USD`. |

Example row (real values, 2026-11-02, `laptop` listing):

```json
{
  "category": "laptop",
  "refinement": null,
  "position": 6,
  "product_id": "dell15laptopdc15250",
  "offer_id": "dc15250_so_6",
  "model": "DC15250",
  "name": "Dell 15 Laptop",
  "url": "https://www.dell.com/en-us/shop/laptop-computers/spd/dell15laptopdc15250",
  "image_url": "https://i.dell.com/is/image/DellContent/content/dam/ss2/product-images/dell-client-products/notebooks/dell/dell-15-intel-3530/media-gallery/laptop-dell-dc15250nt-bk-plastic-gallery-1.psd?fmt=png-alpha&pscan=auto&scl=1&hei=402&wid=627&qlt=100,0&resMode=sharp2&size=627,402",
  "currency": "USD",
  "price": 599.99,
  "on_deal": true,
  "promotion": "$100.00 off select configuration",
  "promotion_amount_off": 100.0,
  "deal_max_percent_off": 14.29,
  "deal_offer_count": 1,
  "rating": 4.5,
  "review_count": 4305,
  "display_inches": 15.6,
  "features": [
    "Intel® Core™ Processors",
    "Windows 11 Home or Windows 11 Pro",
    "Built for everyday computing",
    "Enhanced usability for home learning",
    "Essential productivity features"
  ],
  "colors": ["black", "silver"],
  "badges": []
}
```

#### Honest nulls, and what the listing does not carry

A field the tile did not show is `null`, never `0` or `""`. `features`, `colors`
and `badges` are empty lists when there are none.

- **No list price.** Dell's listing grid prints one price, the starting price, and
  no struck-through "was" price, so there is no original-price column and no
  computed one. `promotion_amount_off` and `deal_max_percent_off` are the savings
  Dell states on the tile.
- **No specs table.** The listing carries five or six marketing bullets, not
  processor, memory and storage as separate values, so `features` is text as Dell
  writes it. Per-configuration specs, stock and delivery dates are on the product
  pages, which this actor does not read.
- **No sort or price filter.** The sort values and price limits tried against the
  call this actor makes were ignored (the same list came back), so none is offered. Sort the
  dataset by `price` or `deal_max_percent_off`.
- **Dell lists a few lines twice.** On 2026-11-02 the 89 laptop tiles were 87 distinct
  product lines. A line is returned and charged once per listing.

### Pricing

Pay per event:

- **$0.002** per run (`actor-start`), charged only after your input is
  validated, so a run that fails on bad input costs nothing.
- **$0.003493** per product written (`product-scraped`), i.e. $3.49 per 1,000
  products. A row that is not written is not charged: a repeat of a product the
  same listing already returned, and a listing that fails, are free.

### How it fetches

dell.com puts an Akamai edge in front of its pages. The listing page itself is
2.3 to 2.6 MB of HTML for 12 products and answered HTTP 403 ("Access Denied") to
26 of 32 requests from the machine this actor was built on (eight browser
fingerprints, four requests each). Its own page-turning does not load another page: it
calls Dell's JSON endpoint
(`POST /shopapi/plp/v1/getpartialvm/en-us/cnsr/stusa11000386`), which answers
the 12 product tiles and the pager (`resultsCount`, `lastPage`, `pageStart`) in
0.4 to 0.8 MB. This actor asks for that, with a browser's TLS fingerprint through
Apify's RESIDENTIAL proxy, rotating the exit address and the browser fingerprint on every refused
attempt. Plain HTTP clients without a browser fingerprint are answered 403.

If Dell's call is refused on a page after its retries (or answers "No Results" for
a whole laptop or desktop listing, which only happens when the request is wrong), the
actor reads that page from the listing page's own HTML instead
(`https://www.dell.com/en-us/shop/laptop-computers/scr/laptop?page=2`), through the
same parser: the same rows, positions and de-duplication, at 2.3 to 2.6 MB a page.
The attempts are split between the two routes, so a page nothing answers still costs
`attempts` requests, and the route that answered is tried first for the rest of the
run. The two routes returned the same 13 products in the same order for a
two-page listing read in the same minute. Dell redirects an unknown `appref` filter,
and a second page of a one-page filter, to the unfiltered listing with HTTP 200; the
page route checks which filter the page was rendered for and reads those as no
results, never as the unfiltered products.

Things worth knowing, all measured on 2026-11-02:

- **Paging and the end.** The pager says how many results and pages there are; the
  actor reads page 1, then pages 2 up to the last, and stops. A page past the end is
  HTTP 200 with no tiles and the last page's number, which the actor treats as the
  end. A page that is not the page asked for is treated as a refusal.
- **An unknown address is not an error on dell.com.** The website serves the *laptop*
  list for `/shop/monitors/scr/monitors` with HTTP 200. The actor checks the category
  itself and accepts only `laptop` and `desktop` (`laptops`, `desktops` and Dell's
  `laptop-computers` and `desktop-computers` address names are accepted too).
- **Filters.** `appref=` filters agree with the website: `alienware-product-line` read
  6 products and `16-gb-memory` read 78 in both. A filter name Dell does not know
  returns no products, not the unfiltered list.
- **Depth.** 12 products per page and no page-size setting; at most 1,000 products
  per listing are read.
- **Weight.** About 0.7 MB a page, so a 30-product run is three requests and a few
  seconds.

If Dell changes the call or the tile layout, the run fails with a message instead
of returning empty rows.

# Actor input Schema

## `categories` (type: `array`):

Dell US listings to read, one per line: laptop or desktop, or the page URL (https://www.dell.com/en-us/shop/laptop-computers/scr/laptop). To read one of Dell's filters, add its appref segment as it appears in the page address: laptop/appref=alienware-product-line, or https://www.dell.com/en-us/shop/laptop-computers/scr/laptop/appref=16-gb-memory. One appref filter per line; a filter Dell does not know returns no products and costs nothing. Only the dell.com/en-us laptop and desktop listings are supported (monitors and accessories are a different kind of Dell page).

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

Read at most this many products for each listing. Dell lists 12 per page, so 30 reads three pages. The whole laptop listing is about 90 products and the desktop one about 45; up to 1,000 are accepted.

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

Use Apify's RESIDENTIAL proxy group (the default). dell.com sits behind Akamai: a probe from the Apify platform read the Dell page through RESIDENTIAL addresses 8 of 10 times and datacenter ones 5 of 10 when this actor was built. A refused request is retried from a fresh address and a different browser fingerprint.

## Actor input object example

```json
{
  "categories": [
    "laptop"
  ],
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `items` (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 = {
    "categories": [
        "laptop"
    ],
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("superslowsloth/dell-products").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 = {
    "categories": ["laptop"],
    "maxItems": 30,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("superslowsloth/dell-products").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 '{
  "categories": [
    "laptop"
  ],
  "maxItems": 30,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call superslowsloth/dell-products --silent --output-dataset

```

## MCP server setup

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

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/XvaPPAEGYFdh4pyLV/builds/km1zWbISxsgets23z/openapi.json