# B-Stock Amazon Liquidation Auctions Scraper (`parseforge/bstock-scraper`) Actor

Scrapes B-Stock Amazon liquidation auction lots from US and EU marketplaces. Returns bid, MSRP, bid-to-MSRP ratio, cost per unit, condition, seller, and product images.

- **URL**: https://apify.com/parseforge/bstock-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, E-commerce, Developer tools
- **Features:** Limited permissions
- **Stats:** 15 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner-v4.webp)](https://apify.com/parseforge?fpr=vmoqkp)

### B-Stock Amazon Liquidation Auctions Scraper

**Scrape B-Stock Amazon liquidation auctions for pallets and truckloads of customer returns, up to a million lots per run.** Every lot comes with its bid, MSRP, bid-to-MSRP ratio, cost per unit, condition, seller, and product images. No login or API key. Export to CSV, JSON, Excel, or XML.

B-Stock's Amazon liquidation marketplaces sell returned and overstock merchandise in bulk lots, but the site has no public API and manual browsing is slow. This Actor reads the public auction listings directly from both the US and EU storefronts, filters them by country, currency, condition, offer type, lot size, and shipment type, and returns each match in one fixed schema. It also fetches each auction's detail page for seller, category, lot ID, and up to 50 product images.

| Who uses it | What they scrape B-Stock Amazon Liquidation Auctions for |
|---|---|
| Resellers and liquidation buyers | Find profitable pallets and truckloads of Amazon returns to bid on |
| Market analysts | Track liquidation pricing and inventory volume across Amazon marketplaces |
| E-commerce businesses | Source bulk inventory for refurbishment or resale |
| Competitive intelligence teams | Monitor what Amazon liquidation lots competitors are bidding on |

### What it does

This Actor collects B-Stock Amazon liquidation auction lots from the US and EU marketplaces and returns each lot as a flat row with listing and detail-page fields.

- 🌍 **Two marketplaces:** Amazon Liquidation Auctions (US, USD) and Amazon Europe Online Liquidation Auctions (UK/EU, GBP/EUR).
- 🔍 **Sidebar filters:** country, currency, condition, offer type, product type, shipment type, and inventory type.
- 📊 **Computed signals:** bid-to-MSRP ratio and cost per unit, derived from the listing data.
- 🖼️ **Detail enrichment:** seller, condition, category, lot ID, and up to 50 product images per auction.
- 📁 **Flexible output:** CSV, JSON, Excel, or XML, with a flat row per lot.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with B-Stock Amazon Liquidation Auctions data

**📦 Source liquidation inventory.**

A reseller runs the Actor on the US marketplace with condition set to Customer Returns and offer type Auctions, then bids on lots where the bid-to-MSRP ratio is below 20%.

**📈 Track liquidation pricing.**

A market analyst scrapes both marketplaces daily, filters by product type Full Truckload, and charts average cost per unit over time to spot pricing trends.

**🌍 Compare US and EU lots.**

An e-commerce business scrapes the EU marketplace with country set to United Kingdom and currency GBP, then compares lot composition and pricing against US lots.

**🖼️ Inspect product images.**

A buyer enables detail-page fetching with 20 images per auction to visually assess the condition of returned merchandise before bidding.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | Scrapes the public B-Stock Amazon auction pages directly, no registration or OAuth |
| **Both marketplaces** | Covers Amazon Liquidation Auctions (US) and Amazon Europe Online Liquidation Auctions (UK/EU) |
| **Detail-page data** | Fetches seller, category, lot ID, and product images for every auction |
| **Computed ratios** | Includes bid-to-MSRP ratio and cost per unit to evaluate lot profitability |

### How it compares

This Actor focuses exclusively on B-Stock's Amazon liquidation marketplaces, while the competitor covers multiple retailers including Amazon, Walmart, and Target.

| Feature | ParseForge | B-Stock Liquidation Auction Scraper - Pallets & Truckloads |
|---|---|---|
| Amazon US marketplace | Yes | Yes |
| Amazon EU marketplace | Yes | Not listed |
| Detail-page enrichment (seller, category, images) | Yes | Not listed |
| Bid-to-MSRP ratio and cost per unit | Yes | Yes |
| Filters for country, currency, offer type, lot size | Yes | Not listed |
| Walmart, Target, and 65+ other retailers | No | Yes |

### Configure the run

Drive the Actor from the US and EU marketplaces, alone or together, and filters run as each lot is read so only matches reach your dataset. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10
}
```

A larger pull:

```json
{
 "maxItems": 200
}
```

### Pricing

Pay-per-result: **$0.021 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $2.10 |
| 1,000 results | $21.00 |
| 10,000 results | $210.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [B-Stock Amazon Liquidation Auctions Scraper](https://apify.com/parseforge/bstock-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to B-Stock Amazon Liquidation Auctions through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=parseforge/bstock-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check your filters. If you set country to Spain but the EU marketplace has no lots from Spain at the moment, the result will be empty. Try clearing filters or selecting both marketplaces.

**Why are some fields empty in the output?**

Some fields, like seller or category, come from the detail page. Make sure fetchDetails is enabled. Also, some lots may not have all fields populated on B-Stock.

**The run is slow. How can I speed it up?**

Disable fetchDetails to skip detail-page requests. This returns only listing-page data and runs much faster.

**I only got 10 auctions but I set maxItems to 100.**

The Actor stops when it reaches maxItems or when there are no more listings matching your filters. If the marketplace has fewer than 100 matching lots, you will get fewer.

### FAQ

| Question | Answer |
|---|---|
| Do I need a B-Stock account or API key? | No. The Actor scrapes the public auction pages directly, so no login or API key is required. |
| Which B-Stock Amazon marketplaces does this cover? | Both the US marketplace (Amazon Liquidation Auctions, USD) and the EU marketplace (Amazon Europe Online Liquidation Auctions, GBP/EUR). You can select one or both. |
| What filters can I apply? | Country, currency, condition, offer type (Buy Now vs. Auctions), product type (lot size), shipment type, and inventory type. Leave any filter blank to return all values. |
| What extra data do I get from detail pages? | When fetchDetails is enabled, the Actor fetches each auction's detail page and returns seller, condition, category, lot ID, and up to 50 product images. |
| How many auctions can I scrape in one run? | You can set maxItems from 1 to 1,000,000. The Actor stops after collecting that many lots. |
| Can I sort the results? | Yes. Sort by closes in, start time, current bid, number of bids, or name, in ascending or descending order. |
| What output formats are supported? | CSV, JSON, Excel, and XML. Each lot is returned as a flat row. |
| Does the Actor compute any derived metrics? | Yes, it includes bid-to-MSRP ratio and cost per unit, calculated from the listing data. |
| Is the EU marketplace data in English? | The listing fields are in English, but country and currency filters let you target specific EU markets like the UK, Spain, Italy, Poland, and Slovakia. |
| Can I scrape only Buy Now lots? | Yes, set offerType to Buy Now to return only fixed-price lots, or Auctions for bidding lots, or leave blank for both. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by B-Stock Solutions, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

## `marketplaces` (type: `array`):

Which B-Stock Amazon storefronts to scrape. Defaults to both the US and EU marketplaces.

## `country` (type: `string`):

Country of dispatch (Amazon EU marketplace only). Leave blank for all countries.

## `currency` (type: `string`):

Currency the lot is priced in (Amazon EU marketplace only). Leave blank for all currencies.

## `condition` (type: `string`):

Lot condition. Leave blank for all conditions.

## `offerType` (type: `string`):

Buy Now vs. Auctions. Leave blank for both.

## `productType` (type: `string`):

Lot size. Leave blank for all sizes.

## `shipmentType` (type: `string`):

Shipping format. Leave blank for all.

## `inventoryType` (type: `string`):

Inventory source type. Leave blank for all.

## `sortOrder` (type: `string`):

Field used to sort the listing.

## `sortDirection` (type: `string`):

Ascending or descending.

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

How many liquidation auctions to collect per run.

## `fetchDetails` (type: `boolean`):

When enabled (recommended), each auction detail page is fetched for extra fields: seller, condition, category, lot ID, and product images. Disable for faster runs that return only listing-page data.

## `imagesPerAuction` (type: `integer`):

Maximum number of product images to return per auction (the first is also used as the primary imageUrl). Each auction can have up to about 17 representative ASIN images.

## Actor input object example

```json
{
  "marketplaces": [
    "amazon",
    "amazoneu"
  ],
  "sortOrder": "end_time",
  "sortDirection": "asc",
  "maxItems": 10,
  "fetchDetails": true,
  "imagesPerAuction": 10
}
```

# Actor output Schema

## `results` (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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/bstock-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 = { "maxItems": 10 }

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

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

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

```

## CLI example

```bash
echo '{
  "maxItems": 10
}' |
apify call parseforge/bstock-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/bstock-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/aXpFLYCL0wcvRbMDF/builds/cwE6dgoeibiYEeSrf/openapi.json