Sizing Caster Wheels with a Tiny Python Helper (and Why "Weight 4" Breaks Carts)

Every time someone builds a cart, a machine base or a mobile workbench, the same question comes up: which casters can actually carry this? The usual answer is "divide the weight by four", and that answer is wrong often enough to break wheels in the field. Here is a tiny, dependency-free Python helper that does the sizing properly, plus the reasoning behind each number.

Why "weight ÷ 4" fails

1. Floors are not flat. On any real floor, one wheel of a four-wheel cart is often barely touching the ground for a moment. That means at any instant, roughly three wheels carry the whole load.
2. Loads are dynamic. Rolling over a door threshold, an expansion joint or a cable protector creates a shock load well above the static weight.
3. Speed and duty matter. A cart pushed by hand at walking pace is very different from a trolley towed all shift by a tugger.

So the professional rule of thumb is: divide by (number of wheels − 1), then multiply by a safety factor that reflects floor and usage.

The helper

from dataclasses import dataclass

# Safety factors are conservative rules of thumb, not a standard.
FLOOR_FACTOR = {"smooth": 1.0, "average": 1.2, "rough": 1.5}
DUTY_FACTOR = {"light": 1.0, "daily": 1.15, "continuous": 1.3}

@dataclass
class CasterSpec:
    min_capacity_kg: float
    note: str

def required_caster_capacity(load_kg: float, cart_kg: float, wheels: int = 4,
                             floor: str = "average", duty: str = "daily") -> CasterSpec:
    if wheels < 3:
        raise ValueError("Use at least 3 casters")
    total = load_kg + cart_kg
    bearing_wheels = wheels - 1 if wheels <= 4 else wheels - 2
    per_wheel = total / bearing_wheels
    capacity = per_wheel * FLOOR_FACTOR[floor] * DUTY_FACTOR[duty]
    note = (f"{total:.0f} kg over {bearing_wheels} load-bearing wheels, "
            f"floor={floor}, duty={duty}")
    return CasterSpec(round(capacity, 1), note)

if __name__ == "__main__":
    spec = required_caster_capacity(load_kg=600, cart_kg=60, wheels=4,
                                    floor="rough", duty="continuous")
    print(spec)  # CasterSpec(min_capacity_kg=429.0, note='660 kg over 3 ...')

For a 600 kg load on a 60 kg cart, "÷ 4" gives 165 kg per wheel. The helper says you want casters rated around 430 kg each on a rough floor with continuous use. That gap is exactly where cracked wheels and bent forks come from.

Turning the number into a part

Capacity is only the first filter. Once you have it, check:

• Wheel material vs floor. Polyurethane is the default for most warehouse floors; rubber is quieter and kinder to delicate floors but carries less; nylon and cast iron suit very heavy, slow loads on hard floors.
• Wheel diameter. Larger wheels roll over joints and debris with much less push force. If your helper output is near the top of a series' rating, step up a diameter.
• Swivel vs fixed layout. Two fixed plus two swivel steers like a shopping cart and tracks straight on long runs; four swivel is maximally agile but harder to push in a line.
• Locking. Brakes stop the wheel from turning; for machines that must not move at all (work tables, packing stations, test rigs), a caster with a built-in leveling foot or jack stop lifts the load off the wheels entirely. Manufacturers such as Donyaie Charkh list heavy-duty casters with a jack stop for exactly this case, and comparing their rated loads against the helper's output is a quick sanity check.

Extending it

Some easy improvements if you want to drop this into an internal tool:

• Add a speed_kmh parameter and bump the factor above 4 km/h (towed trains).
• Return a recommended wheel diameter band based on floor roughness.
• Read a CSV of your caster catalog and return the cheapest model that clears min_capacity_kg.

Small tool, but it has saved more than one project from a recall of broken wheels. If you size casters differently, I'd love to hear your rules of thumb in the comments.