# Turntable Lab Products Scraper (`automation-lab/turntable-lab-products-scraper`) Actor

Export Turntable Lab products and variants with SKU, brand, category, price, availability, images, and canonical URL.

- **URL**: https://apify.com/automation-lab/turntable-lab-products-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.64 / 1,000 item extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Turntable Lab Products Scraper

Export **Turntable Lab products** and variants as structured records for price, availability, assortment, and catalog monitoring.

The Actor reads Turntable Lab's public storefront data and returns one dataset item per product variant. Each item can include the SKU, brand or artist, category, current and compare-at prices, availability, tags, images, timestamps, and canonical product URL.

No Turntable Lab account, browser automation, or user cookies are required.

### What can Turntable Lab Products Scraper do?

- Search the storefront for products by keyword.
- Export a specific Turntable Lab collection with automatic pagination.
- Extract one or more exact product URLs.
- Export the public catalog when no search or URL input is supplied.
- Preserve separate color, format, size, or edition variants.
- Capture current USD prices and source availability.
- Produce repeatable snapshots for scheduled monitoring workflows.
- Save results to an Apify dataset for JSON, CSV, Excel, XML, or RSS export.

### Who is it for?

#### Vinyl retailers and distributors

Compare public assortment, edition availability, and prices with another specialist retailer.

#### Record collectors and researchers

Build a structured list of releases, exclusives, formats, prices, and stock status instead of copying product pages manually.

#### Audio equipment analysts

Export turntables, cartridges, speakers, accessories, and related categories for product and price research.

#### Data and automation teams

Feed stable product and variant records into spreadsheets, warehouses, dashboards, change-detection jobs, or scheduled workflows.

### Why use this Actor?

Turntable Lab exposes useful product information across search, collection, and product surfaces. This Actor normalizes those routes into one variant-level schema.

It also:

- validates Turntable Lab URLs before requesting them;
- deduplicates records by stable variant ID;
- stops at the requested `maxItems` limit;
- retries only transient network, rate-limit, and server errors;
- fails clearly on invalid inputs or unexpected upstream responses;
- charges only for normalized variants saved to the dataset.

### What data can you extract?

| Field | Meaning |
| --- | --- |
| `productId` | Stable Turntable Lab / Shopify product ID |
| `variantId` | Stable variant ID used for deduplication |
| `sku` | Merchant SKU when the source provides one |
| `title` | Product title |
| `variantTitle` | Format, color, size, or other variant option |
| `brand` | Vendor, artist, label, or product brand |
| `category` | Turntable Lab product type |
| `tags` | Public storefront tags |
| `price` | Current variant price in USD |
| `compareAtPrice` | Original comparison price when exposed |
| `currency` | `USD` |
| `available` | Current variant availability flag |
| `productUrl` | Canonical Turntable Lab product URL |
| `imageUrl` | Primary product or variant image |
| `images` | All public product images |
| `description` | Optional plain-text product description |
| `publishedAt` | Source publication timestamp when exposed |
| `updatedAt` | Source update timestamp when exposed |
| `sourceType` | `catalog`, `collection`, `search`, or `product` |
| `sourceQuery` | Search term or URL that found the product |
| `scrapedAt` | Timestamp of this extraction |

A source field can be `null` when Turntable Lab does not expose it for that item. `description` is `null` unless `includeDescription` is enabled.

### How to scrape Turntable Lab products

1. Open the Actor in Apify Console.
2. Add product searches, Turntable Lab product or collection URLs, or leave both empty for a catalog export.
3. Choose the maximum number of product variants to save.
4. Enable descriptions only if your workflow needs the additional text.
5. Click **Start**.
6. Open the **Dataset** tab and export the results in your preferred format.

A quick search input:

```json
{
  "queries": ["direct drive turntable"],
  "maxItems": 10
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `queries` | string array | — | Up to 20 search terms, each 2–100 characters. Public predictive search returns up to 10 products per term. |
| `startUrls` | string array | — | Up to 100 `turntablelab.com` product or collection URLs. |
| `maxItems` | integer | `20` | Maximum unique variant records, from 1 to 10,000. |
| `includeDescription` | boolean | `false` | Include cleaned plain-text product descriptions. |

If both `queries` and `startUrls` are empty, the Actor exports the public catalog in source order.

Inputs can be combined. Results found through multiple routes are still deduplicated by variant ID.

### Search Turntable Lab products

Use `queries` for a focused product discovery task:

```json
{
  "queries": ["jazz vinyl", "record cleaning"],
  "maxItems": 20
}
```

Search uses Turntable Lab's public predictive-search surface. It is intended for focused discovery, not exhaustive keyword ranking. Use a collection or catalog export for bulk coverage.

### Export a Turntable Lab collection

Supply one or more collection URLs:

```json
{
  "startUrls": [
    "https://www.turntablelab.com/collections/turntables"
  ],
  "maxItems": 250
}
```

Collection extraction paginates automatically until the source is exhausted or `maxItems` is reached.

### Extract exact product URLs

Use exact URLs when you already know which products need monitoring:

```json
{
  "startUrls": [
    "https://www.turntablelab.com/products/andover-spinplay-all-in-one-turntable-w-speaker"
  ],
  "maxItems": 10,
  "includeDescription": true
}
```

All product variants are returned unless the global `maxItems` limit is reached.

### Output example

A real run produces records shaped like this:

```json
{
  "productId": "7656049475674",
  "variantId": "42516065288282",
  "sku": "tr-1147-black",
  "title": "Andover Audio: SpinPlay All-In-One Turntable w/ Speaker",
  "variantTitle": "Black",
  "brand": "Andover Audio",
  "category": "_STEREO-COMP-turntable",
  "tags": ["Automatic Turntables", "speakers", "turntables"],
  "price": 729,
  "compareAtPrice": null,
  "currency": "USD",
  "available": true,
  "productUrl": "https://www.turntablelab.com/products/andover-spinplay-all-in-one-turntable-w-speaker",
  "imageUrl": "https://cdn.shopify.com/s/files/1/0105/4542/files/spinplayblackfront.jpg",
  "images": ["https://cdn.shopify.com/s/files/1/0105/4542/files/spinplayblackfront.jpg"],
  "description": null,
  "publishedAt": "2025-11-26T14:33:59-05:00",
  "updatedAt": "2026-08-30T10:47:41-04:00",
  "sourceType": "collection",
  "sourceQuery": "https://www.turntablelab.com/collections/turntables",
  "scrapedAt": "2026-08-30T14:47:41.732Z"
}
```

Values change at the source. Treat this example as the schema shape, not a promise about current price or stock.

### How much does it cost to scrape Turntable Lab products?

This is a pay-per-event Actor. A one-time **Start** event is charged when a run begins, followed by one **Product variant** event for each unique variant saved.

The Start event costs **$0.005**. Apify plan tiers receive these strictly decreasing per-variant prices:

| Plan tier | Price per saved variant |
| --- | ---: |
| FREE | $0.005060 |
| BRONZE | $0.004400 |
| SILVER | $0.003432 |
| GOLD | $0.002640 |
| PLATINUM | $0.001760 |
| DIAMOND | $0.001232 |

Your estimated Actor charge is:

```text
$0.005 + (saved variants × your plan's product-variant price)
```

For example, a 25-variant collection run costs **$0.115 on BRONZE**: $0.005 + (25 × $0.0044). A 100-variant BRONZE run costs **$0.445**. An empty successful search charges only the $0.005 Start event. Failed or rejected records are not charged as product variants.

Platform usage may be billed according to your Apify plan and the pricing configuration shown in Console.

### Schedule price and availability monitoring

Create a schedule in Apify Console and run the same collection or product URL input daily or weekly. Send each dataset to your storage destination and compare by `variantId`.

Useful change keys include:

- `price` and `compareAtPrice`;
- `available`;
- `sku`;
- `updatedAt`;
- new or missing `variantId` values.

The Actor returns current snapshots. It does not store historical changes or send alerts by itself.

### Export to spreadsheets and data pipelines

From the run dataset you can:

- download CSV or Excel for a spreadsheet;
- use the dataset API from a warehouse job;
- connect Make or Zapier;
- trigger a webhook after completion;
- send records to Google Sheets, Airtable, BigQuery, Snowflake, or your own API.

Use `variantId` as the primary comparison key and `productId` to group variants belonging to one product.

### Run with the Apify API

Replace `YOUR_TOKEN` with an Apify API token stored securely.

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~turntable-lab-products-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":["https://www.turntablelab.com/collections/turntables"],"maxItems":25}'
```

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/turntable-lab-products-scraper').call({
    queries: ['direct drive turntable'],
    maxItems: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/turntable-lab-products-scraper').call(
    run_input={'queries': ['direct drive turntable'], 'maxItems': 10}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/turntable-lab-products-scraper"
```

#### Claude Desktop

Use this HTTP MCP server configuration in Claude Desktop:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/turntable-lab-products-scraper"
    }
  }
}
```

#### Cursor and VS Code

Use the same `mcpServers.apify.url` value in Cursor or VS Code's MCP configuration. No local command or browser process is required.

#### Example prompts

- “Search Turntable Lab for direct-drive turntables and return the first 10 variants with SKU, price, and availability.”
- “Export 100 variants from the Turntable Lab vinyl LP collection.”
- “Run the Turntable Lab product monitor for these product URLs and summarize changed prices.”

The final prompt requires your agent or workflow to compare the new dataset with a previously stored snapshot.

### Reliability, retries, and limits

The Actor uses public structured storefront endpoints rather than rendering full browser pages.

Transient network errors, HTTP 429 responses, and temporary server errors are retried up to three times with bounded backoff. Invalid URLs, deterministic client errors, and unexpected response shapes fail without blind repetition.

Current limits:

- 20 search terms per run;
- up to 10 public predictive-search products per term;
- 100 product or collection URLs per run;
- 10,000 output variants per run;
- direct public access only; no residential proxy or browser fallback.

Turntable Lab can change its storefront or data fields. A source change can require an Actor update.

### Troubleshooting

#### Why did my search return fewer than `maxItems`?

`maxItems` is a ceiling, not a guaranteed count. Predictive search returns up to 10 products per query, products can overlap between queries, and products can have different numbers of variants.

#### Why is `sku`, `category`, or `updatedAt` null?

The public endpoint does not expose every field for every route or product. Nulls preserve that distinction instead of inventing values.

#### Why did a collection return no records?

Confirm that the URL is a current Turntable Lab collection and contains public products. Collection handles can be renamed or retired.

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

An invalid input or unexpected upstream response is not a legitimate empty result. The Actor fails so monitoring workflows do not mistake a technical error for “no products.”

### Responsible use and legality

This Actor extracts public product catalog information. You are responsible for your use of the data and for complying with applicable laws, contracts, website terms, intellectual-property rights, and rate limits.

Do not use it to overload the source, evade access controls, republish protected descriptions or images without permission, or make deceptive pricing claims. Request only the scope your workflow needs and use reasonable schedules.

This Actor is not affiliated with or endorsed by Turntable Lab. Product names and trademarks belong to their respective owners.

### FAQ

#### Does it require a Turntable Lab login?

No. It uses public storefront product data.

#### Does it scrape customer or account data?

No. It extracts public product catalog records only.

#### Are prices normalized?

Yes. Prices are returned as numeric USD values. Compare-at prices are null when the source does not expose one.

#### Is each product one row?

Each product **variant** is one row. This keeps SKU, price, and availability aligned when a product has multiple options.

#### Can it monitor historical prices?

It produces current snapshots. Schedule recurring runs and compare datasets externally to create history.

#### Can it scrape arbitrary Shopify stores?

No. Inputs are restricted to Turntable Lab. This source-specific scope provides a simpler, safer input contract.

#### Does it download images?

No. It returns public image URLs, avoiding unnecessary storage and transfer.

### Related Actors

Explore other source-specific retail catalog tools from [automation-lab](https://apify.com/automation-lab), including:

- [Best Buy Product Catalog Scraper](https://apify.com/automation-lab/best-buy-product-catalog-scraper)
- [IKEA Product Catalog Scraper](https://apify.com/automation-lab/ikea-product-catalog-scraper)
- [Home Depot Product Scraper](https://apify.com/automation-lab/home-depot-product-scraper)

Use the source-specific Actor that matches the retailer you need rather than treating fields from different stores as automatically equivalent.

### Support

If the source changes or a valid input fails, open an issue from the Actor page. Include the run ID, a minimal reproducible input, and the expected behavior. Do not include API tokens, account credentials, or private data.

# Actor input Schema

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

Optional Turntable Lab search terms such as turntable, jazz vinyl, or record cleaning. The storefront returns up to 10 matching products per term.

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

Optional Turntable Lab product and collection URLs. Collection pages are paginated automatically.

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

Maximum number of unique product-variant records saved across all inputs.

## `includeDescription` (type: `boolean`):

Extract plain-text product descriptions. Disable for smaller, faster monitoring datasets.

## Actor input object example

```json
{
  "queries": [
    "turntable"
  ],
  "startUrls": [
    "https://www.turntablelab.com/collections/turntables"
  ],
  "maxItems": 20,
  "includeDescription": false
}
```

# Actor output Schema

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

Open the default dataset overview containing all saved Turntable Lab product-variant records.

# 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 = {
    "queries": [
        "turntable"
    ],
    "startUrls": [
        "https://www.turntablelab.com/collections/turntables"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/turntable-lab-products-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 = {
    "queries": ["turntable"],
    "startUrls": ["https://www.turntablelab.com/collections/turntables"],
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/turntable-lab-products-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 '{
  "queries": [
    "turntable"
  ],
  "startUrls": [
    "https://www.turntablelab.com/collections/turntables"
  ]
}' |
apify call automation-lab/turntable-lab-products-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/turntable-lab-products-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/34FkQx3mlXKYh2u9t/builds/H4I7kPtrUBPUeZVAg/openapi.json