# CommentSold Scraper - Products, Stock & Live Shopping Videos (`abotapi/commentsold-com-scraper`) Actor

Scrape CommentSold boutique shops by name or URL. Extract product catalogs, descriptions, variant prices, stock availability and product details. Collect live shopping status, show replays and shoppable videos. Supports scraping single or multiple shops.

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

## Pricing

from $1.20 / 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.
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?

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

## CommentSold Shop Scraper: Products, Prices, Live Shows

CommentSold Shop Scraper turns CommentSold boutique shops into a clean product data API. Walk one or many shops across their collections and get catalog products with variant prices and stock, full image galleries, descriptions, product details, live-show status, replays and shoppable videos, then export to JSON, CSV or Excel, or pull the results straight into your app through the API.

### Why This Scraper?

- **Three ways in.** Walk shops by name, paste shop, collection, product and live links, or combine both across one run. No need to learn each shop's layout.
- **One actor, every shop.** The platform serves all of its boutiques from one shared storefront, so a single shop list covers N catalogues with per-shop progress in the log.
- **Prices and stock, honestly counted.** Every variant carries its price, sale price and quantity; the row reports the price range, total units and an in-stock flag computed over the whole table.
- **Details on demand.** Switch the full detail page on or off per run: shop collections, related products, sizing guides and shoppable videos, billed only when they land in your dataset.
- **Live surface included.** Each shop yields its live-show status row, its replays and its shoppable videos in the same run, under their own output tabs.
- **Built for schedules.** Incremental mode returns only new and changed products on recurring runs, and a refused or login-gated shop fails loudly instead of returning an empty dataset.

### Use Cases

- **Who:** boutique aggregators and market researchers. **What:** track assortments, brands and price ranges across many independent shops from one actor.
- **Who:** repricers and deal hunters. **What:** watch variant prices and restocks per shop on a daily schedule with incremental mode.
- **Who:** live-commerce analysts. **What:** monitor which shops are live, what they feature, and which replays and shoppable videos they publish.
- **Who:** inventory planners. **What:** collect variant-level stock counts and sizing data to spot gaps and best sellers.
- **Who:** affiliate and curation teams. **What:** build product shortlists with photos, badges and shop attribution.

### Data You Get

> Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `recordType` | `"product"` (also `"show"`, `"clip"`) |
| `shopSlug` | `"samplestore"` |
| `productId` | `"12345"` |
| `name` | `"Sample Cardigan"` |
| `brand` | `"Sample Brand"` |
| `badge` | `"RESTOCK"` |
| `description` | `"A soft knit cardigan ..."` |
| `priceMin` / `priceMax` | `24.99` / `34.99` |
| `currency` | `"USD"` |
| `inStock` / `totalStock` | `true` / `42` |
| `variantCount` / `variants` | `6` / color, size, price, sale price, quantity per variant |
| `imageUrl` / `imageUrls` | cover photo / full gallery |
| `videoUrl` | product video when the shop attached one |
| `detailCollections` | shop collections carrying the product (details on) |
| `relatedProductIds` | related products (details on) |
| `sizingGuide` | sizing text (details on) |
| `collectionKey` | `"all-items"` |
| `url` | product detail address on the shop |
| `changeType` / `changedFields` | incremental mode: `"UPDATED"` / `["priceMin"]` |
| `firstSeenAt` / `lastSeenAt` | incremental mode timestamps |

Show rows carry the live status, viewer count and featured-product count; video rows carry the featured products. Every row carries the shop slug, the shop address and the scraped timestamp.

### How to Use

1. Pick a **mode**: `search` (walk shops by name) or `url` (paste links).
2. Fill in the fields for that mode: shop names and collections, or a mix of shop, collection, product and live links.
3. Switch product details and the live surface on or off, set **Max items** to control run size and cost, then click **Start**.
4. Download the dataset as JSON, CSV or Excel, or read it through the API.

**Walk one shop's full catalogue:**

```json
{
  "mode": "search",
  "shops": ["shopthemasonjar"],
  "maxItems": 20
}
```

**Keyword search across two shops, in stock only:**

```json
{
  "mode": "search",
  "shops": ["shopthemasonjar"],
  "searchQuery": "dress",
  "inStockOnly": true,
  "maxItems": 20
}
```

**Paste links (shop, collection, product, live):**

```json
{
  "mode": "url",
  "urls": [
    "https://shopthemasonjar.commentsold.com/",
    "https://shopthemasonjar.commentsold.com/collections/all-items",
    "https://shopthemasonjar.commentsold.com/api/products/32291",
    "https://shopthemasonjar.commentsold.com/live"
  ]
}
```

A bare shop slug (`shopthemasonjar`) works anywhere a shop link does. Platform pages and custom domains that carry no shop name are reported and skipped, never guessed at.

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/commentsold-com-scraper").call(run_input={"mode": "search", "shops": ["shopthemasonjar"], "maxItems": 20})
for product in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(product["name"], product["priceMin"], product["inStock"])
```

JavaScript:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/commentsold-com-scraper').call({ mode: 'search', shops: ['shopthemasonjar'], maxItems: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((p) => [p.name, p.priceMin, p.inStock]));
```

#### Resume and recurring updates

- **Resume** (`resumeFromRunId`) continues one interrupted run: paste its run or dataset ID and the actor skips everything already collected there, so you don't pay twice.
- **Incremental mode** (`incrementalMode`) is for scheduled runs over the same shops. Each record is classified `NEW`, `UPDATED` (with `changedFields`), `UNCHANGED` (suppressed and not billed unless `emitUnchanged` is on), `REAPPEARED` or `EXPIRED` (only after a run that scanned the whole scope, and only with `emitExpired`). `stateKey` names or shares the stored state. Price, stock and availability changes are the signal; the actor's own timestamp and the live viewer counter never mark a row changed. `ignoreFieldsForChanges` adds your own fields to that ignore set. With incremental mode off, output is exactly as before.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step **after** the scrape: the Apify dataset is never changed.

**What gets written to the connector:** a condensed, human-readable **summary** of each record, not the full JSON. Each item becomes one entry with a **title** and its key fields flattened to plain text. The **complete record always stays in the Apify dataset**.

1. Authorize a connector once under **Apify → Settings → Integrations** (Notion, Linear, Airtable, or Apify).
2. Select it in the **"Pipe results into your apps"** input field. (If the picker is empty, you haven't authorized a connector yet.)
3. For **Notion**, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third-party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` or `url`. |
| `shops` | array | `["shopthemasonjar"]` | Shop slugs or shop links (search mode). |
| `urls` | array | sample | Shop, collection, product and live links (url mode). |
| `collections` | array | `["all-items"]` | Collection keys walked per shop. |
| `searchQuery` | string | (none) | Keyword narrowing per collection. |
| `inStockOnly` | boolean | `false` | Only products currently in stock. |
| `fetchDetails` | boolean | `true` | Full detail page per product (adds a per-product surcharge). |
| `includeLive` | boolean | `true` | Live-show status, replays and shoppable videos per shop. |
| `minPrice` | number | (none) | Floor on the product's lowest variant price, USD. |
| `maxPrice` | number | (none) | Cap on the product's lowest variant price, USD. |
| `maxItems` | integer | `20` | Stop after this many records (`0` = no limit). |
| `maxPages` | integer | `0` | Page ceiling per shop or link (`0` = no page limit). |
| `ignoreFieldsForChanges` | array | (none) | Extra fields ignored by incremental change detection. |
| `proxy` | object | Apify Proxy | Connection settings. |
| `resumeFromRunId` | string | (none) | Continue one interrupted run. |
| `incrementalMode` | boolean | `false` | Return only new and changed records on scheduled runs. |
| `stateKey` | string | (none) | Name or share an incremental-mode state. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) unchanged records. |
| `emitExpired` | boolean | `false` | Also return (and bill) expired records. |
| `mcpConnectors` | array | (none) | Optional: send a summary of each record to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which records are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. |

### Output Example

> Sample shape: values are illustrative placeholders, not from a live record.

**Product record:**

```json
{
  "recordType": "product",
  "shopSlug": "samplestore",
  "shopUrl": "https://samplestore.commentsold.com/",
  "productId": "12345",
  "name": "Sample Cardigan",
  "slug": "sample-cardigan",
  "brand": "Sample Brand",
  "sku": "10010012345",
  "badge": "RESTOCK",
  "description": "A soft knit cardigan with cuffed sleeves.",
  "priceMin": 24.99,
  "priceMax": 34.99,
  "currency": "USD",
  "inStock": true,
  "totalStock": 42,
  "variantCount": 6,
  "variants": [{ "variantId": 1, "color": "Oatmeal", "size": "M", "price": 29.99, "salePrice": 24.99, "quantity": 7, "inStock": true }],
  "imageUrl": "https://example-cdn.com/sample.jpg",
  "imageUrls": ["https://example-cdn.com/sample.jpg"],
  "videoUrl": null,
  "detailCollections": ["Sample Tops"],
  "relatedProductIds": ["12346"],
  "collectionKey": "all-items",
  "url": "https://samplestore.commentsold.com/api/products/12345",
  "searchMode": "search",
  "searchQuery": null,
  "scrapedAt": "2026-10-11T12:00:00Z"
}
```

**Live-show record:** Live-show rows carry `showId`, `title`, `status` (`live` or `idle`), `isLiveNow`, `viewerCount`, `productCount` and the show link; shoppable-video rows carry `clipId`, `title`, `productIds` and the video link. Every row carries the shop slug, the shop address and the scraped timestamp.

### Plan Requirement

The default proxy setting works out of the box, and the actor rotates connections automatically when one is refused. For large or frequent runs, the residential proxy group gives more headroom; pick it under Connection. If your Apify plan does not include proxy access, the run fails with a clear message instead of returning an empty result; a paid plan with proxy access is required.

### FAQ

#### How much does it cost?

You pay per record returned, with product details billed only when you switch them on and they land in your dataset. The **Pricing** tab shows the current rates. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape CommentSold shops?

This actor collects only publicly available shop data. You are responsible for how you use it: follow the shops' terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Product facts such as prices and stock levels are generally facts, but photos, descriptions and videos may be subject to third-party rights.

#### Can I get only new or changed products on a schedule?

Yes. Schedule the actor from the **Schedules** tab and turn on **Incremental mode**. Each run then returns only new and updated records, and unchanged ones are not billed. Price, stock and availability changes are the signal.

#### Why did a run return fewer products than the shop shows?

Search mode stops at **Max items**, first shops and collections first. Set it higher, or to `0`, to collect whole catalogues. A keyword or stock filter also narrows the walk, and detail enrichment never drops a product whose detail read failed.

#### Why did my run fail instead of returning an empty dataset?

If every shop refused the connection, or every shop requires shoppers to log in, the run stops with a clear message so "no products today" is never confused with "nothing could be read". Run it again in a few minutes. If only some shops could be read, you still get what was found, with a note naming the shops that were skipped.

#### Do shops have product reviews?

No. The shops do not publish ratings or review texts on their public pages, so there is nothing to collect. If a shop adds them later, they will appear in a later version of this actor.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 Want more e-commerce data?

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>👗 <a href="https://apify.com/abotapi/24s-com-scraper"><b>24S Scraper</b></a><br>Scrape 24S luxury fashion by category, filters, or URL. Extract brand, name, price...</td><td>🏷️ <a href="https://apify.com/abotapi/2dehands-2ememain-scraper"><b>2dehands &amp; 2ememain</b></a><br>Scrape classifieds from 2dehands.be and 2ememain.be by keyword, filters, or URLs. Returns...</td></tr>
<tr><td>🛒 <a href="https://apify.com/abotapi/a101-product-scraper"><b>A101 Turkey Scraper</b></a><br>Scrape A101.com.tr products across A101 Ekstra and A101 Kapıda. Extract 80+ fields...</td><td>🥦 <a href="https://apify.com/abotapi/aldi-com-au-scraper"><b>ALDI AU Scraper</b></a><br>Scrape ALDI Australia (aldi.com.au) products: name, brand, price, was-price, savings...</td></tr>
<tr><td>🛒 <a href="https://apify.com/abotapi/amazon-au-scraper"><b>Amazon Australia Product &amp; Reviews Scraper</b></a><br>Scrape Amazon Australia (amazon.com.au) products and customer reviews. Search by keyword...</td><td>🛒 <a href="https://apify.com/abotapi/americanas-com-br-scraper"><b>Americanas Brazil</b></a><br>Scrape Americanas Brazil (americanas.com.br) by keyword, department or pasted link...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support & custom scrapers

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/commentsold-com-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <contact@abotapi.com> or message [Telegram @abotapi](https://t.me/abotapi).
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

## `mode` (type: `string`):

Choose 'search' to walk shops by name across their collections, or 'url' to scrape pasted links.

## `shops` (type: `array`):

One or more shops, as slugs (shopthemasonjar) or full shop links (https://shopthemasonjar.commentsold.com/). Each shop is walked across the collections below.

## `urls` (type: `array`):

Mix freely: shop links (https://shopthemasonjar.commentsold.com/), collection links (.../collections/all-items), single-product links (.../api/products/32291) and live links (.../live). Platform pages and custom domains that carry no shop name are reported and skipped.

## `collections` (type: `array`):

Only walk these collections of each shop, given as the collection key in its address, for example 'all-items'. A key a shop does not carry is reported and skipped for that shop. Leave the default to walk the shop's full catalogue.

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

Only return products matching this keyword, for example 'dress' or 'jeans'. Leave empty to walk the whole collection. A keyword that matches nothing ends that scope quietly with no results.

## `inStockOnly` (type: `boolean`):

Only return products the shop currently holds stock of. Off by default so sold-out products still show up (marked out of stock).

## `fetchDetails` (type: `boolean`):

Adds the shop's own collections, related products, sizing guide and shoppable video to every product. On by default; every product already carries prices, stock, variants, galleries and descriptions without it. Products are still returned when a detail read fails, without the surcharge.

## `includeLive` (type: `boolean`):

Also return each shop's live-show status row, its replays and its shoppable videos. These are small extra reads per shop, never per product, and never add a surcharge.

## `minPrice` (type: `number`):

Only return products priced at or above this amount in US dollars. Applied by this actor to each product's own lowest variant price. Products with no price, shows and videos are never dropped by a price bound.

## `maxPrice` (type: `number`):

Only return products priced at or below this amount in US dollars, applied the same way as the minimum above.

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

Maximum number of results returned across the whole run. This is the run's cap. Use 0 for unlimited.

## `maxPages` (type: `integer`):

Maximum collection pages walked per shop or link, at 20 products a page. 0 means no page limit: the run then stops only at Max results, or when the shop runs out of products.

## `proxy` (type: `object`):

The default connection works on every plan and Residential is recommended for the most reliable results. Switch only if a run reports that requests were refused.

## `resumeFromRunId` (type: `string`):

Paste a previous run id or dataset id to continue a large crawl without returning results already collected there. Use this after an interrupted run. For recurring daily monitoring of the same shops, use Incremental mode below instead.

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

Turn this on for daily or recurring monitoring. The first run returns everything matching as NEW. Later runs normally return only NEW, UPDATED and REAPPEARED results, which is how you catch a price change, a restock, a new arrival or a shop going live. The actor's own timestamp and the live viewer counter are deliberately ignored when deciding what changed, because they drift constantly and would otherwise mark every result as changed on every run. State is kept separately for each shop set, collection set and filter setup, so two different shop lists never mix.

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

Optional. Name this monitoring campaign to keep its state stable, or to deliberately share state across differently configured runs. Leave empty to let the actor derive a key from the shops, links and filters.

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

Off by default. Turn on to also return results that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have, so leave it off unless you want the full snapshot every run.

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

Off by default. Turn on to also return results that were present in a previous run but are no longer found, marked EXPIRED, which is how a sold-out product disappearing shows up. Only produced once a run has fully scanned the tracked shops, never when Max results capped it or Resume was used. This returns, and bills, extra rows.

## `ignoreFieldsForChanges` (type: `array`):

Field names to ignore when deciding whether a tracked product changed, for example a field your downstream does not care about. The actor already ignores its own timestamp and the live viewer counter. Documented in the README.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API and Integrations, then select it here. Notion gets a rich page per item; other connectors get a best-effort write or digest. Leave empty to skip; this never changes the dataset output. Supported: Notion (https://mcp.notion.com/mcp), Linear (https://mcp.linear.app/sse), Airtable (https://mcp.airtable.com/mcp), Apify (https://mcp.apify.com).

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## Actor input object example

```json
{
  "mode": "search",
  "shops": [
    "shopthemasonjar"
  ],
  "urls": [
    "https://shopthemasonjar.commentsold.com/",
    "https://shopthemasonjar.commentsold.com/collections/all-items",
    "https://shopthemasonjar.commentsold.com/api/products/32291",
    "https://shopthemasonjar.commentsold.com/live"
  ],
  "collections": [
    "all-items"
  ],
  "inStockOnly": false,
  "fetchDetails": true,
  "includeLive": true,
  "maxItems": 20,
  "maxPages": 0,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

## `products` (type: `string`):

No description

## `detail` (type: `string`):

No description

## `shows` (type: `string`):

No description

## `clips` (type: `string`):

No description

## `changes` (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 = {
    "mode": "search",
    "shops": [
        "shopthemasonjar"
    ],
    "urls": [
        "https://shopthemasonjar.commentsold.com/",
        "https://shopthemasonjar.commentsold.com/collections/all-items",
        "https://shopthemasonjar.commentsold.com/api/products/32291",
        "https://shopthemasonjar.commentsold.com/live"
    ],
    "collections": [
        "all-items"
    ],
    "searchQuery": "",
    "inStockOnly": false,
    "fetchDetails": true,
    "includeLive": true,
    "proxy": {
        "useApifyProxy": true
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/commentsold-com-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 = {
    "mode": "search",
    "shops": ["shopthemasonjar"],
    "urls": [
        "https://shopthemasonjar.commentsold.com/",
        "https://shopthemasonjar.commentsold.com/collections/all-items",
        "https://shopthemasonjar.commentsold.com/api/products/32291",
        "https://shopthemasonjar.commentsold.com/live",
    ],
    "collections": ["all-items"],
    "searchQuery": "",
    "inStockOnly": False,
    "fetchDetails": True,
    "includeLive": True,
    "proxy": { "useApifyProxy": True },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/commentsold-com-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 '{
  "mode": "search",
  "shops": [
    "shopthemasonjar"
  ],
  "urls": [
    "https://shopthemasonjar.commentsold.com/",
    "https://shopthemasonjar.commentsold.com/collections/all-items",
    "https://shopthemasonjar.commentsold.com/api/products/32291",
    "https://shopthemasonjar.commentsold.com/live"
  ],
  "collections": [
    "all-items"
  ],
  "searchQuery": "",
  "inStockOnly": false,
  "fetchDetails": true,
  "includeLive": true,
  "proxy": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false
}' |
apify call abotapi/commentsold-com-scraper --silent --output-dataset

```

## MCP server setup

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