# RadioShack Product Scraper (USA) (`rl1987/radio-shack-scraper`) Actor

Scrapes e-commerce product data (name, price, stock, specs, images) from radioshack.com as seen from the USA.

- **URL**: https://apify.com/rl1987/radio-shack-scraper.md
- **Developed by:** [R.L.](https://apify.com/rl1987) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 plp data rows

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

### What does RadioShack Product Scraper do?

**RadioShack Product Scraper** extracts e-commerce product data from [radioshack.com](https://www.radioshack.com/), the official RadioShack online store, **as seen from the USA**. Run it in one of three modes — by **search query**, by **category**, or a **full catalog crawl** — and it returns structured product data — name, price, stock status, brand, specifications, images, and more — ready to download or feed into another system. In every mode you can optionally fetch each product's full detail page for the complete record. It runs on the Apify platform, so you get automatic retries, US-based residential proxy rotation, scheduling, and API/webhook access to your results without managing any infrastructure.

### Why use RadioShack Product Scraper?

- **Price monitoring** — track price and discount changes across RadioShack's catalog over time.
- **Catalog research** — build a dataset of RadioShack's product range, specs, and availability for market or competitor analysis.
- **Reselling and comparison tools** — feed structured product data into a price-comparison site, chatbot, or inventory system.
- **US market snapshot** — the Actor is configured to browse the site through US residential IPs, matching what a shopper in the United States sees (USD pricing, English store).

### How to use RadioShack Product Scraper

1. Click **Try for free** (or **Run**) on this Actor's page.
2. Pick a **Scraping mode**:
   - **Search query** — enter one or more search terms in **Search queries** (e.g. `radio`).
   - **Category** — enter one or more category listing URLs in **Category URLs** (e.g. `https://www.radioshack.com/c/audio/radios`).
   - **Full catalog crawl** — no further input needed; it crawls the entire store starting from `/c`.
3. Leave **Fetch full product detail (PDP) data** on (default) for complete records, or turn it off for a faster run that only returns listing-page data (name, price, thumbnail).
4. Optionally set **Max products to scrape** to limit the run.
5. Click **Start** and wait for the run to finish.
6. Open the **Dataset** tab to view, filter, and export the scraped products.

### Input

The Actor accepts a JSON input with the following fields (see the **Input** tab for the full form):

| Field | Type | Description |
|---|---|---|
| `mode` | string | `search`, `category`, or `full`. Defaults to `full`. |
| `searchQueries` | array | Search terms to crawl (used when `mode` is `search`). |
| `categoryUrls` | array | Category listing URLs to crawl (used when `mode` is `category`). |
| `fetchProductDetails` | boolean | Also visit each product's detail page for the full record. Defaults to `true`; set `false` for a listing-data-only run. |
| `maxItems` | integer | Stop after this many products are scraped. `0` = unlimited. |
| `proxyConfiguration` | object | Proxy settings. Defaults to Apify Residential proxies geolocated to the US, so the store is browsed the way a US shopper sees it. |

Example input (category mode, full detail):

```json
{
    "mode": "category",
    "categoryUrls": [{ "url": "https://www.radioshack.com/c/audio/radios" }],
    "fetchProductDetails": true,
    "maxItems": 200,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US"
    }
}
```

Example input (search mode, listing data only — faster, fewer requests):

```json
{
    "mode": "search",
    "searchQueries": ["radio", "bluetooth speaker"],
    "fetchProductDetails": false
}
```

### Output

Each scraped product is stored as one item in the dataset. Example output:

```json
{
    "url": "https://www.radioshack.com/classic-style-radio-with-bluetooth/p",
    "sku": "469582500016",
    "name": "RadioShack Retro AM FM Radio 4001796 Bluetooth Dual Speakers Vintage Design",
    "brand": "RadioShack",
    "price": 119.99,
    "regular_price": 139.99,
    "discount_percent": 14,
    "currency": "USD",
    "in_stock": true,
    "description": "Rediscover the charm of classic audio with the RadioShack Retro AM/FM Radio...",
    "specifications": {
        "Brand": "RadioShack",
        "Model": "4001796",
        "AM / FM Radio": "AM, FM",
        "Power source": "DC",
        "Technology": "Analogue"
    },
    "images": ["https://www.radioshack.com/media/catalog/product/..."],
    "breadcrumbs": ["Home", "Products", "Audio", "Radios"],
    "category": "Radios"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

When **Fetch full product detail (PDP) data** is turned off, only listing-page fields are populated (`url`, `name`, `price`, `regular_price`, `discount_percent`, `currency`, `images` with a single thumbnail); `sku`, `brand`, `in_stock`, `description`, `specifications`, `breadcrumbs`, and `category` come back empty/`null`.

#### Data table

| Field | Description |
|---|---|
| `url` | Canonical product page URL |
| `sku` | Product identifier (UPC/SKU shown on the page) |
| `name` | Product title |
| `brand` | Brand, parsed from the specifications table |
| `price` | Current selling price (USD) |
| `regular_price` | Original price before discount, if on sale |
| `discount_percent` | Discount percentage, if on sale |
| `in_stock` | Whether the product is currently in stock |
| `description` | Full product description text |
| `specifications` | Key/value map of the product's spec sheet |
| `images` | List of product image URLs |
| `breadcrumbs` | Category breadcrumb trail |
| `category` | Leaf category name |

### Pricing / Cost estimation

This Actor runs on the [Apify platform](https://apify.com) under the pay-per-usage pricing model — you pay for the compute units and proxy traffic your runs consume. Scraping a single category (a few dozen products) typically costs a fraction of a compute unit; the free Apify plan's monthly credits comfortably cover light, recurring use. Larger full-catalog runs cost more, mainly driven by residential proxy bandwidth.

### Tips and advanced options

- Use `category` or `search` mode instead of a full catalog crawl to scrape faster and cheaper when you only need part of the store.
- Turn off **Fetch full product detail (PDP) data** when you only need names, prices, and thumbnails — it skips one request per product.
- Use `maxItems` to cap runs during testing before scaling up.
- Residential proxies are recommended (and set by default) for reliable, US-geolocated access; you can switch to a different proxy group in the **Proxy configuration** input if needed.
- Schedule the Actor (Apify **Schedules**) to monitor prices and stock over time.

### FAQ, disclaimers, and support

This Actor only collects publicly available product information from radioshack.com. It respects the site's `robots.txt`. Use it in compliance with radioshack.com's Terms of Service and applicable laws; you are responsible for how you use the scraped data. Selectors are based on the site's current Magento storefront and may need updates if RadioShack changes its page markup — please report issues via the Actor's **Issues** tab. Need a custom version (variants, reviews, different country/store, or a different site entirely)? Reach out through the Issues tab or Apify's contact options.

### Did you find this useful?

⭐ Rate this actor on Apify! Your feedback helps other users find it and helps us keep improving it.

# Actor input Schema

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

Search: crawl the results of one or more search queries. Category: crawl one or more category listing pages. Full crawl: crawl the entire catalog.

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

Search terms to look up on radioshack.com (used when Scraping mode is "Search query").

## `categoryUrls` (type: `array`):

Category listing page URLs to crawl, e.g. https://www.radioshack.com/c/audio/radios (used when Scraping mode is "Category").

## `fetchProductDetails` (type: `boolean`):

In addition to what's shown on the listing page (name, price, image), visit each product's detail page for the full record: description, specifications, all images, brand, sku, and exact stock status. Disable for a faster, cheaper run that only needs listing-level data.

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

Stop the run after this many products have been scraped. Set to 0 for unlimited.

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

Proxy servers used to fetch pages as seen from the USA. Residential proxies with US country targeting are recommended so the store is browsed with a US IP address (radioshack.com serves its default English/USD store to US visitors).

## Actor input object example

```json
{
  "mode": "category",
  "searchQueries": [
    "radio"
  ],
  "categoryUrls": [
    {
      "url": "https://www.radioshack.com/c/audio/radios"
    }
  ],
  "fetchProductDetails": true,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

Scraped product rows: name, price, stock, brand, specifications, images, and more. Rows scraped with "Fetch full product detail" off only carry listing-page fields (name/price/image); with it on, every field is populated.

# 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 = {
    "searchQueries": [
        "radio"
    ],
    "categoryUrls": [
        {
            "url": "https://www.radioshack.com/c/audio/radios"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rl1987/radio-shack-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 = {
    "searchQueries": ["radio"],
    "categoryUrls": [{ "url": "https://www.radioshack.com/c/audio/radios" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rl1987/radio-shack-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 '{
  "searchQueries": [
    "radio"
  ],
  "categoryUrls": [
    {
      "url": "https://www.radioshack.com/c/audio/radios"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call rl1987/radio-shack-scraper --silent --output-dataset

```

## MCP server setup

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