# Slickdeals Scraper: Deals, Coupons & Discussion (`thescrapelab/slickdeals-deals-discussion-scraper`) Actor

Collect Slickdeals promotions, posted prices, merchant links and coupon or membership requirements, with optional linked public discussion and explicit coverage.

- **URL**: https://apify.com/thescrapelab/slickdeals-deals-discussion-scraper.md
- **Developed by:** [Inus Grobler](https://apify.com/thescrapelab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.30 / 1,000 saved deals

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

## Slickdeals Scraper: Deals, Coupons & Public Discussion

Collect Slickdeals deals and the public discussion around them as structured data. Track promotions for brands and products, find coupon and membership requirements, and connect each discussion reply to its deal using stable identifiers.

Built for deal publishers, retail promotion researchers, affiliate teams and developers building promotion monitoring tools. Search by keyword or provide public Slickdeals deal, search or forum URLs. Leave the search field empty to collect the newest Hot Deals.

### Use cases

- Deal publishers: collect promotion candidates and the restrictions editors need to review.
- Affiliate teams: retrieve available merchant destinations and published promotion terms.
- Retail researchers: compare offers and inspect linked public discussion for reported problems.

### What you get

- One record per unique deal, with a posted price, merchant, source URL and available direct merchant link.
- Source text describing coupons, membership, minimum spend, subscriptions, shipping, regional restrictions and expiry.
- Optional public replies in a separate dataset linked by `dealId`.
- Clear coverage indicators when details or discussion cannot be fully retrieved.

Deal prices describe the forum promotion at collection time. Merchant prices and availability are not checked. Votes, views and replies describe community activity; they are not purchase counts. Restrictions are extracted source evidence, not guaranteed eligibility decisions.

### Run from Apify Console

1. Enter product names, brands or public Slickdeals URLs under **Keywords or Slickdeals URLs**, or leave it empty for newest Hot Deals.
2. Set **Maximum deals**. The default is five, shared across all targets.
3. Optionally enable **Include public discussion**. The default reply cap is 50 per deal.
4. Set a spending limit, run the Actor, then export the Deals dataset as JSON, CSV or Excel. The run summary links to the discussion dataset when enabled.

#### Minimal input

```json
{}
```

Collect promotions for two brands:

```json
{
  "targets": ["Anker", "LEGO"],
  "maxItems": 100
}
```

Collect a specific deal and accessible discussion:

```json
{
  "targets": ["https://slickdeals.net/f/20080893-memzuoix-large-ergonomic-vertical-wireless-mouse-black-9-99-free-shipping-w-prime-or-on-35"],
  "maxItems": 1,
  "includeComments": true,
  "maxCommentsPerDeal": 50
}
```

| Input | Default | Meaning |
| --- | --- | --- |
| `targets` | `[]` | Keywords or public Slickdeals URLs. Empty means newest Hot Deals. Up to 100 targets. |
| `maxItems` | `5` | Global cap on unique deal records, from 1 to 10,000. |
| `includeComments` | `false` | Save accessible public replies in a linked dataset. |
| `maxCommentsPerDeal` | `50` | Reply cap per deal, used only with discussion enabled; 1–1,000. |

Search results depend on Slickdeals search matching and pagination. This Actor does not add a separate strict brand filter. Duplicate deal IDs across targets are saved once within the run. A maximum is a cap, not a promise that the source has that many results.

### Deal output

Each record preserves `dealId` and `dealUrl`. A compact example is shown below; full exports also include description, source price strings, source dates, views, tracking links and collection time.

```json
{
  "dealId": "20080893",
  "dealUrl": "https://slickdeals.net/f/20080893-memzuoix-large-ergonomic-vertical-wireless-mouse-black-9-99-free-shipping-w-prime-or-on-35",
  "title": "Memzuoix Large Ergonomic Vertical Wireless Mouse (black or pink)",
  "merchant": "Amazon",
  "merchantUrl": "https://www.amazon.com/gp/product/B07WCP4XQQ/ref=ox_sc_act_title_1?smid=A2A9JBW4JTK56I&th=1&psc=1",
  "price": 9.99,
  "currency": "USD",
  "requirements": {
    "coupon": [],
    "membership": [
      "Shipping is free with Prime or on $35+ orders."
    ],
    "minimumSpend": [
      "Shipping is free with Prime or on $35+ orders."
    ],
    "subscription": [],
    "shipping": [
      "Shipping is free with Prime or on $35+ orders."
    ],
    "regional": [],
    "expiry": []
  },
  "expired": false,
  "expiryText": [],
  "replyCount": 4,
  "detailCoverage": "complete",
  "commentsCollected": 4,
  "commentsCoverage": "complete",
  "commentsDatasetId": "o5b7blpfQn5J1YJa6",
  "merchantPriceVerified": false
}
```

`price` is a numeric published deal price when it can be parsed without guessing; otherwise it is `null`. `priceText` preserves the price source and `headlinePriceText` preserves the headline price, which may be rounded. Unknown fields are `null`; empty requirement arrays mean no matching evidence was extracted.

`merchantUrl` unwraps recognized redirects and removes known affiliate tracking while retaining product parameters. It can be `null` if no destination can be resolved. `merchantTrackingUrl` preserves the Slickdeals link with guest-specific parameters removed. Merchants are not visited to confirm the promotion.

#### Coverage fields

- `detailCoverage`: `complete` when the deal page was parsed, or `unavailable` when only a valid listing record was available. Complete means the supported page model was retrieved; individual values can still be missing.
- `commentsCoverage`: `not_requested`, `complete`, `capped` or `partial`. Complete means collected replies meet the page's published reply count at collection time.
- `commentsCollected`: number of replies saved for the deal.
- `commentsDatasetId`: dataset containing replies, or `null` when discussion is off.
- `merchantPriceVerified`: always `false`.

Discussion is bounded and favors the newest accessible replies. Pagination, dynamic loading, deletions and access restrictions can prevent complete discussion extraction. Quoted text is kept separately from the reply body.

### Discussion output

Each reply contains `dealId`, `postId`, `body`, `quotedText`, `postedAt`, `url` and `scrapedAt`. Join it to the Deals dataset on `dealId`. The discussion dataset ID is available on deal records and in the run's `SUMMARY` record. The first post is represented by the deal description rather than duplicated as a reply.

```json
{
  "dealId": "20080893",
  "postId": "186988206",
  "body": "No Bluetooth and marked frequently returned item.",
  "quotedText": [],
  "postedAt": "2026-10-01T12:05:24-07:00",
  "url": "https://slickdeals.net/f/20080893-memzuoix-large-ergonomic-vertical-wireless-mouse-black-9-99-free-shipping-w-prime-or-on-35?p=186988206#post186988206",
  "scrapedAt": "2026-10-01T21:06:05.866915+00:00"
}
```

### Pricing

| Event | Price |
| --- | --- |
| Saved unique deal | **$0.30 per 1,000 deals** ($0.0003 each) |
| Optional saved public reply | **$0.05 per 1,000 replies** ($0.00005 each) |
| Actor startup | **$0.005 per container startup** |

Standard run compute, storage and datacenter proxy usage are included. There is no additional platform-usage pass-through. Current pricing is configured for this private candidate; check the Pricing tab before running.

For example, 1,000 deals without discussion cost $0.305 including one startup. Five deals cost $0.0065. Twenty-five deals plus 500 saved replies cost $0.0375. Actual totals depend on delivered records and startup count.

The minimum initial spending limit is $0.0053, covering a startup and one deal. A resurrection incurs another startup event; allow for it when resuming a run.

Only delivered deal records and optional saved replies incur those result events. Failed request attempts and suppressed duplicates do not add result events. A run may stop with partial output at its spending limit; the startup fee still applies when a run starts without producing results. Set a limit appropriate to the deal and reply caps.

### Python API example

Install the official `apify-client==3.2.1` package and use your Apify API token:

```python
import os
from datetime import timedelta
from decimal import Decimal
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("thescrapelab/slickdeals-deals-discussion-scraper").call(
    run_input={"targets": ["Anker"], "maxItems": 25},
    memory_mbytes=1024,
    run_timeout=timedelta(seconds=300),
    max_total_charge_usd=Decimal("1"),
)
if run is None:
    raise RuntimeError("The run did not finish within the client's wait period")
for deal in client.dataset(run.default_dataset_id).iterate_items():
    print(deal["title"], deal["price"], deal["merchantUrl"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")
if summary and summary["value"].get("commentsDatasetId"):
    replies = client.dataset(summary["value"]["commentsDatasetId"]).iterate_items()
    for reply in replies:
        print(reply["dealId"], reply["body"])
```

### Availability and support

This Actor is currently a private development candidate. Public and commercial release require source permission and final release checks. It retrieves accessible public pages; it does not log into accounts or retrieve private messages.

Results are snapshots of published promotions and discussion. Expiry and restriction evidence may be missing or outdated. The Actor uses datacenter proxies with fresh-connection retries; it stops when access remains blocked rather than switching to expensive residential traffic. The Actor uses bounded retries and reports source access failures and partial extraction in `SUMMARY`; it does not create substitute deals to reach a target count.

For support, provide the Apify run URL, a sample deal URL and the expected field or behavior. Avoid sending credentials or private account data.

# Actor input Schema

## `targets` (type: `array`):

Enter brands, products, or public Slickdeals forum/search/deal URLs. Leave empty for newest Hot Deals.

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

Global cap on unique deals across all targets. Start small; source availability and access may limit results.

## `includeComments` (type: `boolean`):

Save accessible public discussion to a separate linked dataset. Adds requests and an optional reply fee.

## `maxCommentsPerDeal` (type: `integer`):

Used only when public discussion is enabled. Newest accessible replies; coverage is reported.

## Actor input object example

```json
{
  "targets": [],
  "maxItems": 5,
  "includeComments": false,
  "maxCommentsPerDeal": 50
}
```

# Actor output Schema

## `deals` (type: `string`):

No description

## `summary` (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 = {
    "maxItems": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("thescrapelab/slickdeals-deals-discussion-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 = { "maxItems": 5 }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thescrapelab/slickdeals-deals-discussion-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/zovWAftrz5ewBYU6c/builds/Uc7Pn8Fy4ZW5A5EGh/openapi.json