# Amazon Haul Search (`deepmine/amazon-haul-search`) Actor

Scrape Amazon Haul search results by keyword and extract product titles, ASINs, prices, ratings, review counts, images, and product URLs for Amazon product research.

- **URL**: https://apify.com/deepmine/amazon-haul-search.md
- **Developed by:** [DeepMine](https://apify.com/deepmine) (community)
- **Categories:** E-commerce, Automation, Developer tools
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $25.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Amazon Haul Search

Amazon Haul Search is an **Amazon Haul scraper** for collecting **Amazon Haul search results** by keyword. It extracts structured **Amazon product data** from the Amazon Haul surface, including **product titles, ASINs, prices, ratings, review counts, images, and product URLs**.

This actor is built for users who need a reliable **Amazon Haul product scraper** for:

- Amazon Haul product research
- Amazon Haul keyword research
- low-price product discovery
- ecommerce catalog collection
- Amazon ASIN extraction
- Amazon price and review analysis
- competitor and assortment research

### What this Amazon Haul scraper does

Use this actor to search Amazon Haul and export product-level results from Amazon Haul search pages.

It can help you:

- scrape Amazon Haul products by keyword
- collect Amazon Haul ASINs at scale
- export Amazon Haul prices, ratings, and review counts
- capture Amazon Haul product images and product links
- build keyword-based Amazon product datasets
- compare Amazon Haul search results across multiple niches

### Key features

- Amazon Haul keyword search scraping
- Amazon Haul product result extraction
- Amazon Haul ASIN export
- Amazon Haul price extraction
- Amazon Haul star rating extraction
- Amazon Haul review count extraction
- Amazon Haul product image extraction
- Amazon Haul product URL extraction
- multi-query runs
- multi-page crawling
- structured dataset output for downstream workflows

### Input

Run the actor with one or more Amazon Haul search queries.

#### Supported input fields

- `queries`
  - List of Amazon Haul search queries
  - One query per line in the Apify UI
- `query`
  - Optional single-query fallback
- `maxItems`
  - Maximum number of output rows
- `maxPages`
  - Maximum search-result pages per query
- `includeBadges`
  - Include badge or label text when available
- `debugAnomalies`
  - Optional diagnostic logging for rare partial-null rows
- `requestTimeoutSec`
  - Per-page timeout
- `maxConcurrency`
  - Parallel page-processing limit
- `proxyConfiguration`
  - Residential proxies are recommended for Amazon

#### Example queries

- `phone case`
- `makeup bag`
- `water bottle`
- `travel organizer`
- `car accessories`

### Output

Each dataset item is one Amazon Haul search result.

#### Output fields

- `query`
- `page_number`
- `search_rank`
- `asin`
- `product_title`
- `product_url`
- `image_url`
- `price_text`
- `price_value`
- `rating_text`
- `rating_value`
- `reviews_text`
- `reviews_count`
- `badges`
- `source_url`
- `scraped_at`

### Example use cases

- scrape Amazon Haul search results into a dataset
- export Amazon Haul products for product research
- collect Amazon Haul ASINs for downstream enrichment
- build low-price Amazon product catalogs by keyword
- analyze Amazon Haul pricing by niche
- compare rating and review density across search terms
- collect Amazon Haul product links and images for internal review

### Why use Amazon Haul Search

Amazon Haul behaves differently from a generic Amazon search experience. If you want a tool built specifically for **Amazon Haul product discovery** and **Amazon Haul search result extraction**, this actor gives you a cleaner dataset than a generic Amazon scraper aimed at the broader marketplace.

This is a good fit if you need:

- an **Amazon Haul scraper**
- an **Amazon Haul search scraper**
- an **Amazon Haul product scraper**
- an **Amazon Haul ASIN scraper**
- an **Amazon Haul price scraper**
- an **Amazon Haul review scraper**

### Important notes

- `source_url` is the Amazon Haul search page where the item was found.
- `product_url` usually points to the Amazon product page URL associated with that result.
- Amazon can show slightly different prices depending on offer state, variation state, or how the listing is rendered at that moment.
- `asin` is the most stable field for joins, deduplication, and downstream enrichment.

### Best practices

- Use residential proxies for better reliability on Amazon.
- Keep query sets focused when testing new niches.
- Use `asin` as your primary product identifier.
- Use `price_value`, `rating_value`, and `reviews_count` for filtering and analysis.
- Use `debugAnomalies` only when auditing rare edge cases.

### Who this actor is for

- ecommerce operators
- product researchers
- marketplace analysts
- deal researchers
- catalog teams
- Amazon-focused data users

### Search keywords this actor targets

This actor is relevant for users searching for:

- Amazon Haul scraper
- Amazon Haul search scraper
- Amazon Haul product scraper
- Amazon Haul ASIN scraper
- Amazon Haul data scraper
- Amazon Haul price scraper
- Amazon Haul reviews scraper
- Amazon Haul keyword scraper
- Amazon product data scraper
- Amazon ASIN scraper

### FAQ

#### Does this scrape Amazon Haul search results or normal Amazon search?

This actor is designed for **Amazon Haul search results**.

#### Does it return ASINs?

Yes. The actor returns `asin` for each result whenever available.

#### Does it return numeric price, rating, and review fields?

Yes. In addition to raw text fields, the actor returns:

- `price_value`
- `rating_value`
- `reviews_count`

#### Why does the product URL sometimes look like a normal Amazon URL?

Amazon Haul is a discovery surface, but the product links associated with results commonly resolve to standard Amazon product detail URLs.

### Summary

If you need an **Amazon Haul scraper** that can search Amazon Haul by keyword and export **product titles, ASINs, prices, ratings, review counts, images, and product URLs**, Amazon Haul Search is built for that job.

# Actor input Schema

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

Amazon Haul search queries. One query per line in the Apify UI.

## `query` (type: `string`):

Optional fallback if `queries` is empty.

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

Maximum number of product results to emit.

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

Maximum result pages to crawl per query.

## `includeBadges` (type: `boolean`):

Include lightweight badge and label text extracted from result cards.

## `debugAnomalies` (type: `boolean`):

Log extra detail for rare rows where price/rating/review fields come back partially null.

## `requestTimeoutSec` (type: `integer`):

Per-page timeout.

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

How many pages to process in parallel.

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

Residential proxies are recommended for Amazon.

## Actor input object example

```json
{
  "queries": [
    "phone case",
    "makeup bag"
  ],
  "query": "",
  "maxItems": 200,
  "maxPages": 3,
  "includeBadges": true,
  "debugAnomalies": false,
  "requestTimeoutSec": 45,
  "maxConcurrency": 1,
  "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 = {
    "queries": [
        "phone case",
        "makeup bag"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("deepmine/amazon-haul-search").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": [
        "phone case",
        "makeup bag",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("deepmine/amazon-haul-search").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": [
    "phone case",
    "makeup bag"
  ]
}' |
apify call deepmine/amazon-haul-search --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,deepmine/amazon-haul-search"
        }
    }
}

```

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/MrxMpolr5vIqIt02z/builds/it4S7InQVna4E1DtY/openapi.json