# Tackle Warehouse Scraper (`lexis-solutions/tacklewarehouse-com-scraper`) Actor

Tackle Warehouse scraper for fishing tackle product data: rods, reels, lures, baits, prices, reviews and stock for price monitoring and market research in fishing ecommerce niche.

- **URL**: https://apify.com/lexis-solutions/tacklewarehouse-com-scraper.md
- **Developed by:** [Lexis Solutions](https://apify.com/lexis-solutions) (community)
- **Categories:** E-commerce, AI, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.90 / 1,000 products

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/platform/actors/running/actors-in-store#pay-per-event

## 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

![banner](https://i.ibb.co/XfV9G6HS/tackle-warehouse-home.png)

## Tackle Warehouse Scraper

Tackle Warehouse is one of the largest online fishing tackle retailers in the United States, offering thousands of rods, reels, lures, baits, lines, and accessories from top brands like Shimano, Daiwa, Abu Garcia, and more. This scraper lets you extract structured product data from tacklewarehouse.com without any API key or account.

### Introduction

The Tackle Warehouse Scraper is an Apify Actor that crawls tacklewarehouse.com and extracts detailed product information from search results, category pages, and individual product detail pages. It returns clean, structured data ready for price monitoring, market research, or inventory analysis.

### Use Cases

- **Price monitoring**: Track price changes for rods, reels, lures, and other tackle products over time.
- **Competitor analysis**: Compare product assortments and pricing against other fishing tackle retailers.
- **Market research**: Identify trending brands, products, and categories in the fishing tackle market.
- **Inventory tracking**: Monitor stock availability for specific products or categories.

### Input

Provide the following fields:

- `startUrls` (array, required): URLs to start scraping from. Supports:
  - Search URLs: `https://www.tacklewarehouse.com/search-tackle.html?start=0&count=20&searchtext=fishing+rods`
  - Category URLs: `https://www.tacklewarehouse.com/catpage-SBWORM.html`
  - Product detail URLs: `https://www.tacklewarehouse.com/Daiwa_Presso_Air_AGS_Casting_Rods/descpage-PRAC.html`
- `maxItems` (integer, optional): Maximum number of products to scrape per start URL (default: 5).
- `proxyConfiguration` (object, optional): Proxy settings for the scraper.

### Input Examples

**1) Search for casting rods**

```json
{
  "startUrls": [
    {
      "url": "https://www.tacklewarehouse.com/search-tackle.html?start=0&count=20&searchtext=casting+rods"
    }
  ],
  "maxItems": 20
}
````

**2) Scrape a specific category**

```json
{
  "startUrls": [
    { "url": "https://www.tacklewarehouse.com/catpage-SBWORM.html" }
  ],
  "maxItems": 50
}
```

**3) Scrape a single product**

```json
{
  "startUrls": [
    {
      "url": "https://www.tacklewarehouse.com/Daiwa_Presso_Air_AGS_Casting_Rods/descpage-PRAC.html"
    }
  ],
  "maxItems": 1
}
```

### Output

Each dataset item contains the following fields:

```json
{
  "url": "https://www.tacklewarehouse.com/Daiwa_Presso_Air_AGS_Casting_Rods/descpage-PRAC.html",
  "title": "Daiwa Presso Air AGS Casting Rod",
  "brand": "Daiwa",
  "sku": "PRAC",
  "price": "$249.99",
  "originalPrice": null,
  "description": "The Daiwa Presso Air AGS is a high-performance ultralight casting rod...",
  "images": ["https://www.tacklewarehouse.com/images/products/PRAC_main.jpg"],
  "rating": "4.8",
  "reviewCount": "24",
  "availability": "InStock",
  "categories": ["Rods", "Casting Rods"],
  "scrapedAt": "2024-01-15T10:30:00.000Z"
}
```

### Why use the Tackle Warehouse Scraper?

- **Fast**: Uses CheerioCrawler for efficient HTTP-based scraping without a browser — processes hundreds of products per minute.
- **Easy to use**: Just provide a search URL, category URL, or product URL and you're ready to go.
- **Reliable**: Handles pagination automatically and retries failed requests up to 3 times.
- **Well-Maintained**: Built and maintained by Lexis Solutions, a certified Apify partner.

### FAQ

- **Do I need a Tackle Warehouse account to use this scraper?**

  No, the scraper works without any account or API key.

- **How many items can I scrape?**

  There is no hard limit. Use the `maxItems` field to control the number of results per start URL.

- **Is this scraper compliant with Tackle Warehouse's terms?**

  This scraper accesses only publicly available data. Always review the website's terms of service before scraping.

### Need to scrape other sporting goods sites?

Check out our other scrapers for similar websites:

- [Scheels Scraper](https://apify.com/lexis-solutions/scheels-scraper)

***

Got feedback or need an extension?

Lexis Solutions is a [certified Apify Partner](https://apify.com/partners/find).
We can help you with custom solutions or data extraction projects.

Contact us over [Email](mailto:scraping@lexis.solutions) or
[LinkedIn](https://www.linkedin.com/company/lexis-solutions)

### Support Our Work

If you're happy with our work and scrapers, you're welcome to leave us a
company review [here](https://apify.com/partners/find/lexis-solutions/review)

### Image Credit

Image credit: [tacklewarehouse.com](https://www.tacklewarehouse.com/)

# Actor input Schema

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

URLs to start scraping from. Supports search URLs (search-tackle.html), category URLs (/catpage-*.html), and product detail URLs (/descpage-*.html).

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

Maximum number of products to scrape per start URL.

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

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.tacklewarehouse.com/search-tackle.html?start=0&count=20&searchtext=fishing+rods"
    }
  ],
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (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/search-tackle.html?start=0&count=20&searchtext=fishing+rods"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("lexis-solutions/tacklewarehouse-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 = { "startUrls": [{ "url": "https://www.tacklewarehouse.com/search-tackle.html?start=0&count=20&searchtext=fishing+rods" }] }

# Run the Actor and wait for it to finish
run = client.actor("lexis-solutions/tacklewarehouse-com-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/search-tackle.html?start=0&count=20&searchtext=fishing+rods"
    }
  ]
}' |
apify call lexis-solutions/tacklewarehouse-com-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tackle Warehouse Scraper",
        "description": "Tackle Warehouse scraper for fishing tackle product data: rods, reels, lures, baits, prices, reviews and stock for price monitoring and market research in fishing ecommerce niche.",
        "version": "1.0",
        "x-build-id": "r4Fevhmtppqz5MPHf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/lexis-solutions~tacklewarehouse-com-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-lexis-solutions-tacklewarehouse-com-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/lexis-solutions~tacklewarehouse-com-scraper/runs": {
            "post": {
                "operationId": "runs-sync-lexis-solutions-tacklewarehouse-com-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/lexis-solutions~tacklewarehouse-com-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-lexis-solutions-tacklewarehouse-com-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": "URLs to start scraping from. Supports search URLs (search-tackle.html), category URLs (/catpage-*.html), and product detail URLs (/descpage-*.html).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum number of items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of products to scrape per start URL.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Select proxies to be used by your crawler.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```