# Tackle Warehouse Scraper (`scrapyspider/tackle-warehouse-scraper`) Actor

Scrapes product data from TackleWarehouse.com, including names, prices, images, descriptions, variations, brand info, and SKUs. Supports category pages, subcategories, and direct product URLs. Uses residential proxies for reliable access.

- **URL**: https://apify.com/scrapyspider/tackle-warehouse-scraper.md
- **Developed by:** [ScrapySpider](https://apify.com/scrapyspider) (community)
- **Categories:** E-commerce
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

### Tackle Warehouse Product Scraper

Extract comprehensive product data from Tackle Warehouse (tacklewarehouse.com) — including color/size variations with dynamic pricing, brand details, and full navigation hierarchy — all returned as structured JSON.

- Comprehensive color and size variation extraction with per-variation pricing captured via dynamic button clicks
- Full hierarchical navigation data: listing → category → subcategory → product
- Manufacturer/brand details including logo, description, and dedicated brand page URL
- Infinite scroll handling to load all products in large category pages
- Resource blocking for faster, more efficient scraping
- Clean, normalized JSON output ready for spreadsheets, databases, or APIs

#### What data does it extract?

Each product result contains:

**Navigation hierarchy:** listingUrl, listingName, categoryUrl, categoryName, categoryTitle, subcategoryUrl, subcategoryName, subcategoryTitle

**Product details:** Url, productName, Price, maxPrice, productImage (array of image URLs), productMaker (brand), productSKU, customerRatingCount, starRating, Description, productNameSlug, productMakerSlug

**Color variations:** Array of objects with colorName, colorImage, sku, price, and availableSizes — one entry per color option on the product page

**Size/weight variations:** Array of objects with size and price — extracted by clicking each variation button to capture dynamic pricing changes

**Brand/maker info:** makerUrl, makerName, makerImage, makerContent (brand description)

**Metadata:** timestamp

Output is available as JSON, CSV, or Excel via the Apify dataset export.

#### Use cases

- **Competitive price monitoring:** Track fishing tackle prices and color/size availability across Tackle Warehouse to adjust your own e-commerce pricing strategy
- **Product catalog building:** Build a complete product database with images, descriptions, and variation details for a fishing tackle comparison site or affiliate portal
- **Inventory and availability tracking:** Monitor which color and size combinations are in stock for popular lures, rods, or reels
- **Brand analysis:** Aggregate product counts, price ranges, and customer ratings by manufacturer to identify top-performing fishing tackle brands
- **Market research:** Analyze pricing trends and product offerings across bait categories, swimbaits, crankbaits, and other tackle segments
- **Dropshipping product sourcing:** Identify high-rated, competitively priced fishing products with complete variation data for your online store

#### How to use

1. Click **Try for free** on the Actor page
2. In the **Input** tab, add one or more Tackle Warehouse URLs under **Start URLs** (defaults to the baits listing page)
3. Adjust **Max items** if you want to limit the number of products scraped
4. Click **Start** and wait for the run to complete (a full category with 500+ products typically takes 15–30 minutes)
5. Download your results as JSON, CSV, or Excel from the **Output** tab

#### Input parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `startUrls` | Array | Yes | Tackle Warehouse URLs to begin scraping from. Accepts listing, category, or subcategory pages. Default: `https://www.tacklewarehouse.com/baits.html` |
| `maxConcurrency` | Integer | No | Maximum number of pages scraped in parallel. Range: 1–20. Default: `3`. Increase for faster runs, decrease if you encounter blocks. |
| `maxRequestRetries` | Integer | No | Maximum number of retry attempts per failed request. Range: 0–10. Default: `3` |
| `maxItems` | Integer | No | Maximum number of products to scrape. Set to `0` for unlimited. Default: `0` |
| `proxyConfiguration` | Object | No | Proxy settings for the scraper. Defaults to Apify Proxy. Recommended to leave as default for best success rates. |

#### Output example

```json
{
    "listingUrl": "https://www.tacklewarehouse.com/baits.html",
    "listingName": "Baits - Tackle Warehouse",
    "categoryUrl": "https://www.tacklewarehouse.com/catpage-SWMBTHRD.html",
    "categoryName": "SWMBTHRD",
    "categoryTitle": "Hard Body Swimbaits - Tackle Warehouse",
    "subcategoryUrl": "https://www.tacklewarehouse.com/catpage-WAKBILHSB.html",
    "subcategoryName": "WAKBILHSB",
    "subcategoryTitle": "Waking & Billed Hard Swimbaits - Tackle Warehouse",
    "Url": "https://www.tacklewarehouse.com/Deps_Highsider_172_Swimbait/descpage-DHSSB.html",
    "productName": "Deps Highsider 172 Swimbait",
    "Price": "$75.00",
    "productImage": [
        "https://img.tacklewarehouse.com/watermark/rs.php?path=DHSSB-BHR-1.jpg&nw=455"
    ],
    "productMaker": "Deps",
    "productSKU": "HS172HF/11",
    "customerRatingCount": null,
    "starRating": null,
    "Description": "Inspired by the sight of fleeing dace from a flock of monster bass...",
    "colorVariations": [
        {
            "colorName": "Blue Back Herring",
            "colorImage": null,
            "sku": "HS172HF/11",
            "price": "$75.00",
            "availableSizes": ["High-Float"]
        }
    ],
    "Variations": [
        {
            "size": "High-Float",
            "price": "$75.00"
        }
    ],
    "maxPrice": "$75.00",
    "productNameSlug": "deps-highsider-172-swimbait",
    "productMakerSlug": "deps",
    "makerUrl": "https://www.tacklewarehouse.com/catpage-DEPS.html",
    "makerName": "Deps",
    "makerImage": null,
    "makerContent": "Deps was established in 1996 by monster fish hunter, Kazumasa Okumura...",
    "timestamp": "2025-09-22T03:27:50.689Z"
}
````

#### Pricing

This Actor is **free to use** — you only pay for Apify platform compute time and proxy usage. The scraper uses a headless browser (Playwright), so runs consume more resources than simple HTTP scrapers.

A typical run of 100 products costs approximately $0.10–$0.25 in Apify platform credits depending on the number of color/size variations per product.

New Apify accounts receive $5 in free credits — enough to scrape several hundred products.

#### Technical notes

- **No account needed:** This Actor does not require a Tackle Warehouse login or cookies to operate
- **Proxy recommended:** Uses Apify Proxy by default for reliable access. Residential proxies are recommended for large runs
- **Dynamic content:** Product variation pricing is extracted by programmatically clicking size/color buttons, ensuring accurate per-variation prices rather than just the default displayed price
- **Infinite scroll:** Category and subcategory pages use infinite scroll to load products. The scraper automatically scrolls to load all items before extracting links
- **Rate limits:** For large-scale runs (1,000+ products), keep `maxConcurrency` at 3–5 to avoid triggering rate limiting
- **Data freshness:** All data is scraped live on each run — no cached or stale data

#### Integrations

Outputs are compatible with:

- **Google Sheets:** Export dataset directly as CSV and import into your spreadsheet
- **Make (formerly Integromat):** Use the Apify module to trigger runs and push data to Google Sheets, Airtable, or databases
- **Zapier:** Connect Actor runs to 5,000+ apps via the Apify Zapier integration
- **REST API:** Run the Actor programmatically and retrieve results via the [Apify API](https://docs.apify.com/api)

#### Support

Have questions or found a bug? Reach out:

- **Email:** ScrapySpider@protonmail.com
- **Website:** [ScrapySpider.com](https://scrapyspider.com)
- **Apify:** Open a support issue on this Actor page
- **Response time:** Within 24–48 hours on weekdays

# Actor input Schema

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

List of Tackle Warehouse URLs to start scraping from. Can be main category pages (e.g., baits.html), subcategory pages (e.g., catpage-NEWCREELS.html), or individual product pages.

## `maxConcurrency` (type: `integer`):

Maximum number of pages to process in parallel. Higher values are faster but use more memory and may trigger rate limiting.

## `maxRequestRetries` (type: `integer`):

Maximum number of times a failed request will be retried.

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

Maximum number of products to scrape. Set to 0 for unlimited. Useful for testing with a small number.

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

Proxy settings for the scraper. Residential proxies are required — Tackle Warehouse blocks datacenter IPs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tacklewarehouse.com/baits.html"
    }
  ],
  "maxConcurrency": 3,
  "maxRequestRetries": 3,
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `dataset` (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 = {
    "startUrls": [
        {
            "url": "https://www.tacklewarehouse.com/baits.html"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapyspider/tackle-warehouse-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 = {
    "startUrls": [{ "url": "https://www.tacklewarehouse.com/baits.html" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapyspider/tackle-warehouse-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.tacklewarehouse.com/baits.html"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call scrapyspider/tackle-warehouse-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapyspider/tackle-warehouse-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tackle Warehouse Scraper",
        "description": "Scrapes product data from TackleWarehouse.com, including names, prices, images, descriptions, variations, brand info, and SKUs. Supports category pages, subcategories, and direct product URLs. Uses residential proxies for reliable access.",
        "version": "1.0",
        "x-build-id": "ijdCFbwqJihxYqCwW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapyspider~tackle-warehouse-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapyspider-tackle-warehouse-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/scrapyspider~tackle-warehouse-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapyspider-tackle-warehouse-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/scrapyspider~tackle-warehouse-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapyspider-tackle-warehouse-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "List of Tackle Warehouse URLs to start scraping from. Can be main category pages (e.g., baits.html), subcategory pages (e.g., catpage-NEWCREELS.html), or individual product pages.",
                        "default": [
                            {
                                "url": "https://www.tacklewarehouse.com/Daiwa_Steez_SV_Light_TW_100_Casting_Reels/descpage-DSSVLT.html"
                            }
                        ],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of pages to process in parallel. Higher values are faster but use more memory and may trigger rate limiting.",
                        "default": 3
                    },
                    "maxRequestRetries": {
                        "title": "Max Request Retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Maximum number of times a failed request will be retried.",
                        "default": 3
                    },
                    "maxItems": {
                        "title": "Max Products",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of products to scrape. Set to 0 for unlimited. Useful for testing with a small number.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for the scraper. Residential proxies are required — Tackle Warehouse blocks datacenter IPs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
