Datasets:

danielrosehill
/

storage-container-dimensions

license: cc-by-4.0
language:
  - en
pretty_name: Industrial Storage Container Dimensions
size_categories:
  - n<1K
tags:
  - logistics
  - supply-chain
  - warehousing
  - packaging
  - reference
  - tabular
configs:
  - config_name: default
    data_files: containers.csv
  - config_name: listings
    data_files: listings.csv
dataset_info:
  - config_name: default
    features:
      - name: id
        dtype: string
      - name: type
        dtype: string
      - name: type_label
        dtype: string
      - name: common_names
        dtype: string
      - name: external_length_cm
        dtype: float64
      - name: external_width_cm
        dtype: float64
      - name: external_height_cm
        dtype: float64
      - name: external_length_in
        dtype: float64
      - name: external_width_in
        dtype: float64
      - name: external_height_in
        dtype: float64
      - name: external_volume_l
        dtype: float64
      - name: external_volume_gal
        dtype: float64
      - name: internal_length_cm
        dtype: float64
      - name: internal_width_cm
        dtype: float64
      - name: internal_height_cm
        dtype: float64
      - name: internal_length_in
        dtype: float64
      - name: internal_width_in
        dtype: float64
      - name: internal_height_in
        dtype: float64
      - name: internal_dims_basis
        dtype: string
      - name: internal_dims_vendors
        dtype: int64
      - name: typical_capacity_l
        dtype: float64
      - name: typical_capacity_gal
        dtype: float64
      - name: vendor_capacity_low_l
        dtype: float64
      - name: vendor_capacity_high_l
        dtype: float64
      - name: usable_ratio
        dtype: float64
      - name: capacity_basis
        dtype: string
      - name: lidded
        dtype: bool
      - name: lid_available_separately
        dtype: bool
      - name: nestable_when_empty
        dtype: bool
      - name: typical_nesting_ratio
        dtype: float64
      - name: standard_conformant
        dtype: bool
      - name: standard
        dtype: string
      - name: vda_4500_height
        dtype: bool
      - name: eur1_pallet_per_layer
        dtype: int64
      - name: listings_observed
        dtype: int64
      - name: notes
        dtype: string
    splits:
      - name: train
        num_examples: 48
  - config_name: listings
    features:
      - name: listing_id
        dtype: string
      - name: vendor
        dtype: string
      - name: vendor_country
        dtype: string
      - name: product_name
        dtype: string
      - name: sku
        dtype: string
      - name: url
        dtype: string
      - name: type
        dtype: string
      - name: native_unit
        dtype: string
      - name: external_length_cm
        dtype: float64
      - name: external_width_cm
        dtype: float64
      - name: external_height_cm
        dtype: float64
      - name: external_length_in
        dtype: float64
      - name: external_width_in
        dtype: float64
      - name: external_height_in
        dtype: float64
      - name: internal_length_cm
        dtype: float64
      - name: internal_width_cm
        dtype: float64
      - name: internal_height_cm
        dtype: float64
      - name: internal_length_in
        dtype: float64
      - name: internal_width_in
        dtype: float64
      - name: internal_height_in
        dtype: float64
      - name: stated_capacity_l
        dtype: float64
      - name: stated_capacity_gal
        dtype: float64
      - name: external_volume_l
        dtype: float64
      - name: external_volume_gal
        dtype: float64
      - name: usable_ratio
        dtype: float64
      - name: price
        dtype: float64
      - name: currency
        dtype: string
      - name: price_includes_vat
        dtype: bool
      - name: pack_quantity
        dtype: int64
      - name: unit_price
        dtype: float64
      - name: captured_date
        dtype: string
      - name: notes
        dtype: string
    splits:
      - name: train
        num_examples: 121

Industrial Storage Container Dimensions

Planning-grade volumetric reference for the plastic containers that European and North American warehouses actually run on: Euroboxes (Euro stacking containers), attached-lid containers (ALCs), and VDA 4500 KLTs.

Two tables:

Config	Rows	What it is
`default` → `containers.csv`	48	One typical row per nominal size. External and internal dimensions, usable capacity, the spread of what vendors publish, lid and nesting behaviour, standards conformance
`listings` → `listings.csv`	121	The individual vendor listings the typical figures were generalised from. Real SKUs, real prices, the date each was captured

from datasets import load_dataset

typical  = load_dataset("danielrosehill/storage-container-dimensions", split="train")
listings = load_dataset("danielrosehill/storage-container-dimensions", "listings", split="train")

Two documents come with it, both generated from the CSVs so neither can drift:


`datasheet/storage-container-dimensions-datasheet-v1.0.pdf`	The datasheet, v1.0 — scope, composition, how every number was derived, known limitations, provenance, and the full data dictionary. Read this before using the data in anything that matters.
`docs/data-dictionary.md` · `data-dictionary.csv`	Every column in both tables with its type, unit and meaning — as a document and machine-readable.

Prefer the sizes themselves on paper? The same data is rendered as an 8-page printable reference — every size, its typical internal dimensions, its usable capacity and the vendor spread, divided by family: reference/storage-container-reference.pdf.

The second table is there so you can audit the first. Every typical capacity is a judgement call about a spread of real products; listings.csv is that spread, with URLs and capture dates, so you can disagree with a number and see exactly what it was averaged from.

Every dimension appears in both centimetres and inches, and every capacity in litres and US gallons — the comparison this dataset exists for is cross-market, and one of the four vendors here designs in inches. Which side is the vendor's own figure and which is derived is recorded per listing in native_unit.

Scope

This dataset stops at the unit. It describes the smallest standardised unit of industrial storage — the tote — and nothing above it.

In scope	Out of scope
External and internal dimensions, both unit systems	Pallet builds and load patterns
External volume and usable capacity	Container loads, TEU utilisation, stowage
Nesting and stacking behaviour	Shelving and racking layouts
Lid arrangement, standards conformance	Live pricing, availability, lead times
What the trade calls each family, per geography	Any one manufacturer's exact spec

The one deliberate exception is eur1_pallet_per_layer, a convenience column giving the footprint count on a 1200 × 800 deck. It is the last thing that is purely a property of the box; anything past it depends on build height, pallet standard and container choice, which are decisions rather than dimensions.

Prices in listings.csv are captured observations with a date on them, kept so a capacity figure can be audited against what was really on sale. They are not a price feed and will rot.

What it is for

The point of a dimensional dataset is that the calculations downstream of it are somebody else's. In practice these are:

Pallet load calculation — how many units per layer and per pallet, and the build height that follows. The footprints tile a 1200 × 800 and a 1200 × 1000 deck exactly, which is the whole reason the module exists.
Shelving and racking calculation — industrial racking, business storeroom or domestic shelf: how many boxes per bay, and which height variant uses a given shelf pitch without wasting the gap above it.
Consolidation and move planning — how much of a shelf, room or shipment a given box count becomes, and how much less it becomes if the boxes nest.
Purchase comparison — ranking products on cost per usable litre rather than on the nominal size printed on the listing.

The point of it

If you are costing out a purchase or sizing a shipment, you need to know that a 60 × 40 × 23 cm Eurobox gives you about 42 litres, not the 55.2 litres that 60 × 40 × 23 implies. Multiply external dimensions and you will overstate what you are buying by roughly a quarter — and you will overstate a tapered ALC by more than a straight-walled Eurobox, which quietly corrupts any comparison between the two.

That gap is the whole reason this dataset exists.

Read this before using the numbers

The footprint is standardised. The heights mostly are not. The insides are not at all.

ISO 3394 fixes the 600 × 400 mm module and its submultiples, which is why the metric range tiles a Euro pallet exactly. Heights are a different matter: of the 18 distinct 600 × 400 heights in containers.csv, exactly one — 280 mm — is fixed by a standard (VDA 4500). The rest are convention, and manufacturers ship one-off variants inside it. Attached-lid heights are vendor convention throughout, to the point where the same 80 L box is listed at both 400 and 420 mm.

US vendors design in inches, and some of their totes land near the 600 × 400 module without hitting it. Hudson Exchange's 24 × 15 in "straight wall stacking tote" is 61.0 × 38.1 cm — one centimetre too long to put four on a Euro pallet, so the pattern collapses to two. Full table of the near misses, and what native_unit is for: guidance/units-and-us-vendors.md.

The standards fix external dimensions. They do not fix internal ones.

ISO 3394 defines the 600 × 400 mm packaging module. EN 13199 caps a small load carrier at that footprint. VDA 4500 additionally fixes three external heights (147.5, 213, 280 mm). None of them specifies wall thickness, draft angle, rib design or base construction — those are the manufacturer's choice, and they are what determine internal volume.

So every internal dimension and capacity here is a typical figure averaged across vendor catalogues, not a specification. Ten vendors will give you ten different numbers for the same nominal size, and the spread is not small: across the four catalogues captured here, a 60 × 40 × 32 cm Eurobox is quoted internally at anything from 60.4 to 66.4 litres. That is an 11 % range on a box every one of them calls 600 × 400 × 320. vendor_capacity_low_l and vendor_capacity_high_l give you the range on every row rather than hiding it behind a single figure.

That is a limitation of the product category, not of this dataset. Chasing manufacturer-exact figures is not achievable in a general reference, and would be obsolete the moment a mould changed. Use these for calculation, comparison and planning. Check the specific supplier's own internal dimensions before committing to a large order.

Fields

Field	Type	Notes
`id`	string	Stable slug, e.g. `euro-600x400x230`, `alc-600x400x310`, `vda-rklt-6429`
`type`	string	`euro_stacking_container` · `attached_lid_container` · `vda_klt_container`
`type_label`	string	Human-readable form of `type`
`common_names`	string	Semicolon-separated search terms, ordered most standard to most colloquial, including regional ones (`Eurobehälter`, `bac gerbable`) and genericised vendor names (`Hudson box`). Search terms only — never discriminate families on them, see `guidance/naming.md`
`external_length_cm`	float64 (cm)	External length
`external_width_cm`	float64 (cm)	External width
`external_height_cm`	float64 (cm)	External height
`external_length_in`	float64 (in)	External length in inches. Always the derived side on this table — these nominal sizes are fixed in millimetres by the standards
`external_width_in`	float64 (in)	External width in inches, derived
`external_height_in`	float64 (in)	External height in inches, derived
`external_volume_l`	float64 (L)	L × W × H. Not what the box holds
`external_volume_gal`	float64 (US gal)	External volume in US liquid gallons
`internal_length_cm`	float64 (cm)	Typical internal length. Populated for every Euro row and for the two KLT sizes a vendor publishes; empty for ALCs, whose taper makes a single internal dimension meaningless
`internal_width_cm`	float64 (cm)	Typical internal width, same basis
`internal_height_cm`	float64 (cm)	Typical internal height, same basis
`internal_length_in`	float64 (in)	Typical internal length in inches, derived
`internal_width_in`	float64 (in)	Typical internal width in inches, derived
`internal_height_in`	float64 (in)	Typical internal height in inches, derived
`internal_dims_basis`	string	Where those internal figures came from: `vendor_average_rule`, `vendor_published`, `not_published`, `not_published_tapered_walls`
`internal_dims_vendors`	int64	How many vendors publish internal dimensions for this footprint. Vendors, not listings — one mould in five colours is one opinion
`typical_capacity_l`	float64 (L)	The usable number. Always populated
`typical_capacity_gal`	float64 (US gal)	Usable capacity in US liquid gallons
`vendor_capacity_low_l`	float64 (L)	Capacity implied by the least generous vendor's own published internal dimensions for this footprint. Empty where no vendor publishes any
`vendor_capacity_high_l`	float64 (L)	As above, most generous vendor. See `guidance/internal-dimensions.md`
`usable_ratio`	float64	`typical_capacity_l / external_volume_l`
`capacity_basis`	string	How the capacity was arrived at: `derived_from_internal_dims`, `vendor_nominal`, `published`, `derived_from_klt_ratio`
`lidded`	bool	True where a lid is integral to the product (ALCs)
`lid_available_separately`	bool	True where a lid exists but is a separate purchase
`nestable_when_empty`	bool	True for ALCs; straight-walled boxes stack but do not nest
`typical_nesting_ratio`	float64	Fraction of its own height a nested empty box saves. 0.75 for ALCs, 0 for everything else — that is a fact about a straight-walled box, not missing data
`standard_conformant`	bool	Whether the footprint conforms to a recognised module
`standard`	string	Which one, stated precisely
`vda_4500_height`	bool	Whether the external height is on the VDA KLT grid (147.5 / 213 / 280 mm)
`eur1_pallet_per_layer`	int64	Boxes per layer on a 1200 × 800 Euro pallet, no overhang. The one column that reaches past the box itself — see Scope
`listings_observed`	int64	How many rows in the `listings` table back this size — 0 means the row is a plausible interpolation, not something seen for sale
`notes`	string	Per-row caveats. Read these

Height coverage

The Euro series carries the heights actually observed for sale across the captured vendors, near-duplicates merged to the round figure (315 → 310 mm, 365/370 → 365 mm, 415/420 → 420 mm):

Footprint	Heights (cm)
60 × 40	12, 15, 17, 17.5, 20, 22, 23, 24, 27, 28, 30, 31, 32, 34, 36.5, 40, 42, 46.5
40 × 30	12, 15, 17, 20, 22, 23, 24, 27, 32
30 × 20	12, 15, 17, 22
80 × 60	22, 32, 42

Unlike the VDA grid, no standard defines the consumer Euro height series — it is whatever manufacturers converged on, which is why it is irregular and why "common" here means "seen on sale" rather than "specified". Check listings_observed before treating any single row as a size you can definitely buy; a handful (60 × 40 × 30 and × 46.5, 40 × 30 × 20 and × 24, most of the 30 × 20 range) are interpolations into gaps in the captured evidence.

`capacity_basis` values

derived_from_internal_dims — computed from the typical internal footprint for that module (600 × 400 boxes are internally ~550 × 355 mm, 400 × 300 are ~350 × 250 mm, 300 × 200 are ~260 × 160 mm, 800 × 600 are ~750 × 550 mm, with internal height 10–20 mm under external). These are the conservative end of what vendors publish, not the middle of it; vendor_capacity_low_l and vendor_capacity_high_l on the same row show what the market quotes.
vendor_nominal — the manufacturer's published capacity. Used for all ALCs.
published — a directly published internal figure (VDA R-KLT 6429).
derived_from_klt_ratio — scaled from the 6429 anchor at its 71.4 % usable ratio. VDA KLTs are thicker-walled than consumer euroboxes, so the euro rule does not apply to them.

Vendors disagree about the inside of the same box

By 11 % in litres, at 600 × 400. Salesbridges publishes 570 × 370 mm internal where Plastic Box Shop publishes 555 × 355 and Yosibox 550 × 360 — the first is the top opening, the others are close to the base, and a euro crate is slightly tapered, so all three are honest. vendor_capacity_low_l and vendor_capacity_high_l carry that spread on every row; typical_capacity_l sits at or just below the conservative end on purpose, because a planning figure that overstates capacity fails silently.

The full evidence, per vendor and per footprint, is in guidance/internal-dimensions.md.

Why ALC rows still have no internal dimensions

ALCs taper. The walls slope inward towards the base so the containers nest when empty. A single internal L × W × H would be wrong wherever you chose to measure it — right at the top opening, badly overstated at the base. Rather than invent a number, those rows carry the vendor's nominal capacity, which already accounts for the taper and is the figure you should actually plan against.

KLTs now carry vendor-published internals at the two sizes a captured vendor publishes them for (vda-rklt-6429, vda-rklt-4329). The other five heights are still empty: nobody in listings.csv sells them with a spec sheet attached.

The `listings` table

121 individual vendor listings across four markets, each with the date it was captured. Same dimensional columns as the main table — in both unit systems — plus vendor, vendor_country, url, sku, native_unit, price, currency, price_includes_vat, pack_quantity, unit_price and captured_date.

native_unit is imperial or metric: which unit the vendor's own catalogue publishes in, and therefore which column is the figure and which is the conversion. Hudson Exchange is the imperial one. It matters because inch-designed totes land near the 600 × 400 module without hitting it — their 24 × 15 in tote is 61.0 × 38.1 cm, one centimetre too long to put four on a Euro pallet. See guidance/units-and-us-vendors.md.

Vendor	Market	Listings	Publishes internals	Captured
Salesbridges	Netherlands	69	almost all	2026-07-27
Plastic Box Shop	UK	31	most	2026-07-27
Yosibox	Israel	12	3	2026-07-23
Hudson Exchange	US	9	none	2026-07-27

usable_ratio on this table is computed from each listing's own stated capacity and external dimensions — so it shows what each vendor claims, not what the typical table concluded. The spread is the useful part:

	n	min	median	max
Attached-lid containers	16	52 %	71 %	81 %
Euro stacking containers	101	56 %	78 %	99 %
VDA KLTs	3	66 %	70 %	70 %

Three things fall out of that, all of which shaped the main table:

The ~6-point gap between tapered and straight-walled is real and consistent across three independent markets. It is the single most important number here.
Vendor nominal litres run optimistic. Several UK Euro listings claim 83 % of external volume, which the published internal dimensions on the same page do not support. This is why containers.csv derives Euro capacities from internal dimensions rather than trusting the marketed litre figure.
The extremes are shape, method, and occasionally a typo. The 52 % is a small tote where walls are a large fraction of the volume. The Euro maximum of 99 % is a single Salesbridges listing whose stated litres contradict the internal dimensions printed beside them; the rest of their high ratios are real but computed geometrically from the top opening rather than measured. All are kept in — the point of this table is to show what vendors say, not to launder it.

Note that the Hudson Exchange sizes are US-market footprints (21.9 × 15.2 in ≈ 55.6 × 38.6 cm), not 600 × 400 Euro modules. They are included because they are the same product class and corroborate the ALC ratio independently of the European supply chain — not because they are interchangeable with a Eurobox.

Raw captures are in raw/, trimmed to the fields used. Re-fetching those is the only way to refresh the table; the build script never touches the network, so a rebuild always reproduces the same rows.

Quick start

from datasets import load_dataset

ds = load_dataset("danielrosehill/storage-container-dimensions", split="train")

# What does a 60x40x23 Eurobox actually hold?
box = next(r for r in ds if r["id"] == "euro-600x400x230")
print(box["typical_capacity_l"], "L usable vs", box["external_volume_l"], "L external")
# 42.0 L usable vs 55.2 L external

# Straight-walled vs tapered, same footprint
for r in ds:
    if r["external_length_cm"] == 60 and r["external_width_cm"] == 40:
        print(f'{r["id"]:22} {r["usable_ratio"]:.0%} usable')

# What did the 42 L figure get generalised from?
obs = load_dataset("danielrosehill/storage-container-dimensions", "listings", split="train")
for r in obs:
    if r["external_length_cm"] == 60 and r["external_height_cm"] == 23:
        print(r["vendor"], r["stated_capacity_l"], "L", r["captured_date"], r["url"])

Or just pandas.read_csv the files — 48 and 121 rows.

Sources

Assembled from vendor catalogues and standards documentation, verified 27 July 2026:

salesbridges.eu (NL/EU retail) — the widest published set of internal dimensions of any vendor here: 70 of 98 listings in their plastic-crates category, measured at the top opening. Prices in EUR ex-VAT. Their storefront runs on Lightspeed eCom, which serves any category or product page as JSON if you append ?format=json — see scripts/capture_salesbridges.py.
plasticboxshop.co.uk (UK retail) — Euro and ALC ranges with published internal dimensions and nominal capacities. Their Shopify storefront exposes the full catalogue at /collections/{handle}/products.json.
hudsonex.com (US retail, Hudson Exchange) — attached-lid totes on US-market footprints, dimensions in inches and capacity in US gallons. Also Shopify. The product copy confirms the tapered-wall / nesting behaviour but publishes no internal dimensions.
yosibox.com (Israeli retail) — G- and T-series industrial boxes with published internal dimensions; the primary cross-check on the 600 × 400 internal rule.
IPL Schoeller (iplschoeller.com) — the Kaiman ALC height grid. Their product pages publish external dimensions only.
VDA 4500 v3.1 (December 2025) — KLT footprints, the three system heights, the 15 mm insertion depth, and the R-KLT 6429 figures.
ISO 3394 / EN 13199 — the packaging module and the small-load-carrier cap, via secondary summaries; both are paid publications.

eurobox-calculator — the calculator this data was built for: usable capacity, pallet and 20 ft container loads, and cost per usable litre across both families.
storage-box-3d-models — true-scale GLB models of several of these units, CC BY 4.0.
eurobox-standard — VDA 4500 itself plus a human-readable digest.

Longer notes that did not fit the card:

guidance/internal-dimensions.md — why vendors disagree about the inside of the same box, with the per-vendor evidence.
guidance/naming.md — what these boxes are called in each market, which of those names are evidenced here, and the two that mislead.
guidance/eurobox-vs-alc-same-size.md — what the ALC taper actually costs you, worked through.
guidance/units-and-us-vendors.md — both unit systems, what native_unit is for, the US near-miss footprints, and precisely what is standardised and what is only convention.

Versioning

The data dictionary carries a version — currently 1.0 — set in dictionary.py and stamped into the datasheet filename and its footer. It describes the schema: bump the minor version when a column is added or a description changes materially, the major when a column is removed or its meaning changes under an unchanged name. Row additions and capacity revisions do not move it; those are visible in the git history and in captured_date.

Regenerating

containers.csv, containers.jsonl and this card's YAML frontmatter are all produced by build.py, which holds the internal-dimension rules in one place so a rule change cannot leave them disagreeing. Edit the rules there, not the CSV.

python3 build.py                         # listings.csv, containers.*, dictionary, frontmatter
./datasheet/build.sh                     # datasheet/...-datasheet-v1.0.pdf  (needs typst)
python3 scripts/build_reference_pdf.py   # reference/storage-container-reference.pdf
python3 scripts/capture_salesbridges.py  # only if you want to re-fetch raw/

build.py runs build_listings.py first, so the typical rows can count the vendors and listings behind them. Only scripts/capture_salesbridges.py touches the network. The PDF needs reportlab (pip install -r scripts/requirements.txt); rerun it after build.py, since it renders the CSVs rather than recomputing anything.

The data dictionary lives in dictionary.py and is rendered four ways — data-dictionary.csv, docs/data-dictionary.md, this card's Fields table and the frontmatter dtypes. build.py fails if a builder emits a column the dictionary does not document, or documents one it does not emit, so the schema and its documentation cannot drift apart. Add a column in both places or the build stops.

Two PDF toolchains, deliberately: the reference is reportlab (it lays out long generated tables of sizes), the datasheet is Typst (it is a document that happens to read data). Both take their numbers from the CSVs at build time.

container_stats.py holds the per-vendor internal-dimension statistics that both build.py and the PDF report as fact, so the two cannot disagree about what a vendor publishes.

The frontmatter declares the column schema explicitly. Left to infer types from the CSV, the Hub reads a mostly-blank column such as notes as all-null, which breaks load_dataset for anyone reading that field — so the schema is written by the same run that writes the data.

Licence

CC BY 4.0. Dimensional facts are not themselves copyrightable; the licence covers the compilation, the derived figures and the documentation.