# Amazon Haul Deals (`sentry/amazon-haul-deals`) Actor

Amazon Haul deals scraper for cheap product discovery, bargain hunting, price-led product research, and discount-style Amazon Haul sourcing by keyword.

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

## Pricing

from $5.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/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

## Amazon Haul Deals

Amazon Haul Deals is an **Amazon Haul deals scraper** for finding cheap products, bargain listings, and low-price Amazon Haul opportunities by keyword.

It is built for users who want a cleaner **Amazon Haul deal finder** instead of a generic search export. Use it to discover cheap Amazon Haul products, surface better-value listings, and collect structured Amazon Haul deal data with prices, ratings, reviews, badges, and product URLs.

### What this actor does

This actor searches Amazon Haul by keyword and returns deal-focused product results ranked for bargain hunting and cheap product research.

It helps you:

- find cheap Amazon Haul products
- discover Amazon Haul deals by keyword
- collect Amazon Haul ASINs for low-price products
- export Amazon Haul prices, ratings, and review counts
- identify value-oriented listings with strong ratings or review volume
- build bargain-hunting datasets for ecommerce sourcing and product research

### Best use cases

- Amazon Haul product sourcing
- cheap product discovery
- Amazon Haul bargain hunting
- low-ticket ecommerce product research
- Amazon Haul ASIN collection
- deal-oriented catalog building
- Amazon Haul keyword research
- finding affordable products with rating and review signals

### Inputs

Run the actor with one or more Amazon Haul queries.

#### Main inputs

- `queries`
  - one or more Amazon Haul search queries
- `query`
  - optional single-query fallback
- `maxItems`
  - maximum number of accepted deal rows to emit
- `maxPages`
  - maximum search-result pages per query
- `maxDealPrice`
  - optional price ceiling for deals
- `minDealScore`
  - minimum deal score required
- `minRating`
  - optional minimum star rating
- `minReviewsCount`
  - optional minimum review count
- `includeBadges`
  - include badge and label text when available

#### Example queries

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

### Output

Each dataset row is one accepted Amazon Haul deal candidate.

#### Key output fields

- `query`
- `search_rank`
- `asin`
- `product_title`
- `product_url`
- `deal_price_text`
- `deal_price_value`
- `rating_value`
- `reviews_count`
- `badges`
- `deal_score`
- `deal_tier`
- `deal_signals`
- `deal_summary`

### Why use Amazon Haul Deals

Amazon Haul has a lot of low-price inventory, but not every result is equally useful for bargain hunting or cheap product research.

This actor is designed to make Amazon Haul more useful for:

- price-led product discovery
- cheap product sourcing
- deal-focused Amazon Haul research
- sorting through Amazon Haul results faster

### Who this actor is for

- ecommerce operators
- product researchers
- deal researchers
- Amazon-focused sourcing teams
- marketplace analysts
- low-ticket product hunters

### Notes

- `deal_price_text` and `deal_price_value` reflect the current displayed Amazon Haul price captured during the scrape.
- The actor is deal-focused, not a full Amazon catalog scraper.
- No proxy is the default. Enable proxy only if your specific Amazon Haul runs need the extra reliability.

### Search terms this actor is relevant for

Amazon Haul deals scraper, Amazon Haul deal finder, Amazon Haul cheap product scraper, Amazon Haul bargain finder, Amazon Haul low price product scraper, Amazon Haul ASIN scraper, Amazon Haul product research scraper, Amazon Haul keyword scraper, cheap Amazon products scraper, Amazon Haul bargain research.

# 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.
## `maxDealPrice` (type: `number`):

Optional price ceiling for deals. Lower values keep the output focused on cheap Amazon Haul finds.
## `minDealScore` (type: `integer`):

Keep only rows at or above this deal score. Higher values are stricter and more selective.
## `minRating` (type: `number`):

Optional minimum star rating for accepted deals.
## `minReviewsCount` (type: `integer`):

Optional minimum review count for accepted deals.
## `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`):

Optional proxy settings. Leave this off for the cheapest default behavior and only enable proxy if your runs actually need it.

## Actor input object example

```json
{
  "queries": [
    "phone case",
    "makeup bag"
  ],
  "query": "",
  "maxItems": 200,
  "maxPages": 3,
  "maxDealPrice": 25,
  "minDealScore": 35,
  "minRating": 4,
  "minReviewsCount": 0,
  "includeBadges": true,
  "debugAnomalies": false,
  "requestTimeoutSec": 45,
  "maxConcurrency": 1,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

# 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("sentry/amazon-haul-deals").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("sentry/amazon-haul-deals").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 '{
  "queries": [
    "phone case",
    "makeup bag"
  ]
}' |
apify call sentry/amazon-haul-deals --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=sentry/amazon-haul-deals",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Amazon Haul Deals",
        "description": "Amazon Haul deals scraper for cheap product discovery, bargain hunting, price-led product research, and discount-style Amazon Haul sourcing by keyword.",
        "version": "1.0",
        "x-build-id": "FynZBS7JLGtaGnoub"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sentry~amazon-haul-deals/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sentry-amazon-haul-deals",
                "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/sentry~amazon-haul-deals/runs": {
            "post": {
                "operationId": "runs-sync-sentry-amazon-haul-deals",
                "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/sentry~amazon-haul-deals/run-sync": {
            "post": {
                "operationId": "run-sync-sentry-amazon-haul-deals",
                "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",
                "properties": {
                    "queries": {
                        "title": "Queries",
                        "type": "array",
                        "description": "Amazon Haul search queries. One query per line in the Apify UI.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "query": {
                        "title": "Single Query Fallback",
                        "type": "string",
                        "description": "Optional fallback if `queries` is empty.",
                        "default": ""
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of product results to emit.",
                        "default": 200
                    },
                    "maxPages": {
                        "title": "Max Pages Per Query",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum result pages to crawl per query.",
                        "default": 3
                    },
                    "maxDealPrice": {
                        "title": "Max Deal Price",
                        "minimum": 0,
                        "type": "number",
                        "description": "Optional price ceiling for deals. Lower values keep the output focused on cheap Amazon Haul finds.",
                        "default": 25
                    },
                    "minDealScore": {
                        "title": "Minimum Deal Score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Keep only rows at or above this deal score. Higher values are stricter and more selective.",
                        "default": 35
                    },
                    "minRating": {
                        "title": "Minimum Rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "number",
                        "description": "Optional minimum star rating for accepted deals.",
                        "default": 4
                    },
                    "minReviewsCount": {
                        "title": "Minimum Reviews Count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional minimum review count for accepted deals.",
                        "default": 0
                    },
                    "includeBadges": {
                        "title": "Include Badge Text",
                        "type": "boolean",
                        "description": "Include lightweight badge and label text extracted from result cards.",
                        "default": true
                    },
                    "debugAnomalies": {
                        "title": "Debug Null/Anomaly Logs",
                        "type": "boolean",
                        "description": "Log extra detail for rare rows where price/rating/review fields come back partially null.",
                        "default": false
                    },
                    "requestTimeoutSec": {
                        "title": "Request Timeout (seconds)",
                        "minimum": 10,
                        "maximum": 180,
                        "type": "integer",
                        "description": "Per-page timeout.",
                        "default": 45
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "How many pages to process in parallel.",
                        "default": 1
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Optional proxy settings. Leave this off for the cheapest default behavior and only enable proxy if your runs actually need it.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
