# Boxhub Shipping Container Scraper (`crawlerbros/boxhub-shipping-container-scraper`) Actor

Scrape live shipping-container listings from Boxhub.com - sizes, conditions, container types, delivery pricing, and availability for B2B sourcing (storage, retail pop-ups, construction offices, container-home builds).

- **URL**: https://apify.com/crawlerbros/boxhub-shipping-container-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Agents, Automation, E-commerce
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Boxhub Shipping Container Scraper

Scrape live shipping-container listings from [Boxhub.com](https://boxhub.com) — America's largest shipping-container marketplace. Get sizes, structural types, condition grades, pricing, delivery options, and availability for every container Boxhub currently lists for your nearest depot. No login, no cookies, no paid proxy required.

### What this actor does

- Reads Boxhub's live catalog page and returns every distinct container listing as a structured record
- Filters by size (20ft/40ft), structural type, condition grade, delivery method, and price range
- Captures both tilt-bed truck delivery and depot self-pickup pricing for each listing
- Optionally includes currently sold-out listings alongside in-stock ones
- Omits empty fields instead of returning `null` or placeholder values

### Output per container

Each item in the output dataset is one distinct container listing (deduplicated across delivery methods), with:

- `title` — human-readable name (e.g. "40ft High Cube Cargo-Worthy Shipping Container")
- `sku`, `localizedSku`, `listingId` — Boxhub's own identifiers
- `sizeFeet` — 20 or 40
- `containerType` / `containerTypeLabel` — Standard, High Cube, High Cube (Side-Door), Standard (Side-Door), Specialty
- `condition` / `conditionLabel` — New/One-Trip, Wind & Water Tight, Cargo-Worthy, IICL Multi-Trip Certified, IICL Specialty Grade
- `isAvailable` — current stock status
- `listPrice`, `currency`, `discountedPrice`, `discountPercentage` — pricing (only present when the unit is in stock and actually priced)
- `deliveryOptions[]` — every delivery method Boxhub offers for this unit (`tiltbed` truck delivery and/or depot `pickup`), each with its own price
- `totalEstimatedPrice` — list price + cheapest available delivery option
- `imageUrl` — product photo (available for Standard and High Cube types)
- `regionId`, `locationCity`, `locationState` — the depot region the listing/pricing applies to
- `sourceUrl` — the live Boxhub page the data was read from
- `recordType`, `scrapedAt`

Empty/unavailable fields are always omitted — you'll never see `null`, `""`, or placeholder values in the output.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `size` | select | `all` | `20` or `40` (feet) |
| `containerType` | select | `all` | Standard / High Cube / High Cube (Side-Door) / Standard (Side-Door) / Specialty |
| `condition` | select | `all` | New/One-Trip / Wind & Water Tight / Cargo-Worthy / IICL Multi-Trip / IICL Specialty |
| `deliveryMethod` | select | `all` | Only keep listings offering tilt-bed delivery or depot pickup |
| `includeUnavailable` | boolean | `false` | Also emit currently sold-out listings (no price shown for these) |
| `minPrice` / `maxPrice` | integer | – | USD price bounds |
| `maxItems` | integer | `50` | Hard cap on emitted records |

No input is required — running the actor with defaults returns every in-stock container currently listed for Boxhub's default depot region.

#### Example: 40ft cargo-worthy containers under $3,000

```json
{
  "size": "40",
  "condition": "CWO",
  "maxPrice": 3000
}
````

#### Example: everything available for pickup (no delivery fee)

```json
{
  "deliveryMethod": "pickup"
}
```

#### Example: include sold-out listings

```json
{
  "includeUnavailable": true,
  "maxItems": 100
}
```

### Use cases

- **Storage & logistics buyers** comparing pricing across container sizes and condition grades before buying
- **Retail & events teams** sourcing containers for on-site storage or pop-up shops
- **Construction companies** pricing site offices or secure lockups
- **Container-home builders & architects** comparison-shopping grades and sizes
- **Price-monitoring tools** tracking Boxhub's container pricing over time
- **Procurement teams** feeding live container prices into a sourcing dashboard

### FAQ

**Does this cover every U.S. region Boxhub serves?**
Boxhub selects the depot region automatically based on the requester's location; the actor returns the full catalog for whichever region Boxhub resolves the request to (shown in `regionId`/`locationCity`/`locationState` on every record). Boxhub does not expose a public way to force a different region without a paid residential-proxy service, so region is informational rather than a filter in this version.

**Why do some listings have no price?**
Boxhub only shows a real price for in-stock units. Sold-out units are marked `isAvailable: false` and never carry a fabricated price — set `includeUnavailable: true` to see them alongside stocked listings.

**Why is there no `imageUrl` on some records?**
Boxhub only hosts a predictable product photo for Standard and High Cube containers. Side-door and Specialty variants don't have a matching photo at a reliable URL, so the field is omitted rather than guessed.

**How many listings should I expect?**
Boxhub's catalog per depot region typically has 15–30 distinct SKUs (across both sizes and all condition grades) — this is the genuine size of Boxhub's per-region catalog, not a scraping limitation.

**Is a proxy or login required?**
No. The actor reads Boxhub's publicly served catalog page directly; no cookies, no API key, no paid proxy tier.

**What does `totalEstimatedPrice` include?**
The container's list price plus its cheapest available delivery option (tilt-bed delivery or depot pickup, whichever is lower), giving you an all-in cost estimate.

**Can I filter by multiple sizes or conditions at once?**
Not in a single run — `size` and `condition` each accept one value (or `all`) per run. Run the actor multiple times with different filter values if you need several specific combinations.

# Actor input Schema

## `size` (type: `string`):

Filter by container length in feet.

## `containerType` (type: `string`):

Filter by structural type.

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

Filter by container condition grade.

## `deliveryMethod` (type: `string`):

Only keep containers that offer this delivery method (tilt-bed truck delivery or self pickup at the depot).

## `includeUnavailable` (type: `boolean`):

When true, also emit containers Boxhub currently lists as out of stock (no price shown for these).

## `minPrice` (type: `integer`):

Drop containers priced below this amount.

## `maxPrice` (type: `integer`):

Drop containers priced above this amount.

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

Hard cap on emitted records. Boxhub's catalog for a given depot region typically has 15-30 distinct container listings, so values above that reflect the full available catalog.

## Actor input object example

```json
{
  "size": "all",
  "containerType": "all",
  "condition": "all",
  "deliveryMethod": "all",
  "includeUnavailable": false,
  "maxItems": 50
}
```

# Actor output Schema

## `containers` (type: `string`):

Dataset containing all scraped Boxhub container listings.

# 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 = {
    "size": "all",
    "containerType": "all",
    "condition": "all",
    "deliveryMethod": "all",
    "includeUnavailable": false,
    "maxItems": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/boxhub-shipping-container-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 = {
    "size": "all",
    "containerType": "all",
    "condition": "all",
    "deliveryMethod": "all",
    "includeUnavailable": False,
    "maxItems": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/boxhub-shipping-container-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 '{
  "size": "all",
  "containerType": "all",
  "condition": "all",
  "deliveryMethod": "all",
  "includeUnavailable": false,
  "maxItems": 50
}' |
apify call crawlerbros/boxhub-shipping-container-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Boxhub Shipping Container Scraper",
        "description": "Scrape live shipping-container listings from Boxhub.com - sizes, conditions, container types, delivery pricing, and availability for B2B sourcing (storage, retail pop-ups, construction offices, container-home builds).",
        "version": "1.0",
        "x-build-id": "60pq3r1rLyOMcJdKF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~boxhub-shipping-container-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-boxhub-shipping-container-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/crawlerbros~boxhub-shipping-container-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-boxhub-shipping-container-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/crawlerbros~boxhub-shipping-container-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-boxhub-shipping-container-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",
                "properties": {
                    "size": {
                        "title": "Container size",
                        "enum": [
                            "all",
                            "20",
                            "40"
                        ],
                        "type": "string",
                        "description": "Filter by container length in feet.",
                        "default": "all"
                    },
                    "containerType": {
                        "title": "Container type",
                        "enum": [
                            "all",
                            "ST",
                            "HC",
                            "HS",
                            "SS",
                            "SP"
                        ],
                        "type": "string",
                        "description": "Filter by structural type.",
                        "default": "all"
                    },
                    "condition": {
                        "title": "Condition / grade",
                        "enum": [
                            "all",
                            "NEW",
                            "WWT",
                            "CWO",
                            "ICL",
                            "CIL"
                        ],
                        "type": "string",
                        "description": "Filter by container condition grade.",
                        "default": "all"
                    },
                    "deliveryMethod": {
                        "title": "Delivery method",
                        "enum": [
                            "all",
                            "tiltbed",
                            "pickup"
                        ],
                        "type": "string",
                        "description": "Only keep containers that offer this delivery method (tilt-bed truck delivery or self pickup at the depot).",
                        "default": "all"
                    },
                    "includeUnavailable": {
                        "title": "Include sold-out / unavailable containers",
                        "type": "boolean",
                        "description": "When true, also emit containers Boxhub currently lists as out of stock (no price shown for these).",
                        "default": false
                    },
                    "minPrice": {
                        "title": "Min price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop containers priced below this amount."
                    },
                    "maxPrice": {
                        "title": "Max price (USD)",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop containers priced above this amount."
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on emitted records. Boxhub's catalog for a given depot region typically has 15-30 distinct container listings, so values above that reflect the full available catalog.",
                        "default": 50
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
