Inserters and belts: speed ratios, throughput and design

The six inserter types and their speed values

The game data stores two speeds for every inserter: rotation_speed, which controls how quickly the arm sweeps between pickup and drop-off, and extension_speed, which controls how quickly the hand reaches out and retracts. Both are measured in prototype units per tick. A full swing combines a rotation and an extension, and the time that swing takes depends on both numbers — plus the arm length, the pickup and drop-off positions, and whether the inserter benefits from stack size bonus research.

Inserter	Rotation speed	Extension speed	Energy / swing	Health
burner inserter	0.013	0.035	50kJ	100
inserter	0.014	0.035	5kJ	150
long handed inserter	0.02	0.05	5kJ	160
fast inserter	0.04	0.1	7kJ	150
bulk inserter	0.04	0.1	20kJ	160
stack inserter	0.04	0.1	40kJ	160

Three things stand out. First, the burner inserter is the slowest on rotation at 0.013, which is why early-game smelting columns feel sluggish. Second, the fast, bulk and stack inserters all share identical rotation and extension speeds (0.04 and 0.1 respectively). They are not different speeds — they are different item capacities per swing. Third, the long-handed inserter sits between the basic and fast tiers, which matches its role as a reach tool rather than a throughput tool.

Why absolute items/second cannot be computed from these numbers

It is tempting to divide one by a speed and get an items-per-second figure. That would be wrong. An inserter's cycle time depends on more than rotation_speed and extension_speed:

• Arm length. The distance the arm extends changes the extension distance, and a long-handed inserter reaches two tiles while a standard inserter reaches one. The prototype data stores the speed, not the distance, and the distance varies by placement.
• Pickup and drop-off position. An inserter grabbing from the near side of a belt and dropping directly into an adjacent machine has a shorter arc than one reaching across a tile gap.
• Stack size bonus. Stack inserters can move multiple items per swing once stack size bonus research is completed. The research levels and per-swing bonuses are not in the extracted data.
• Belt compression and timing. An inserter can only grab an item when one is present at the pickup point. A belt that is not fully compressed makes the inserter wait, reducing its effective rate regardless of its mechanical speed.

None of those factors are in data/2.1/logistics.json. What the data does support is relative comparison: if two inserters have the same arm geometry and pickup conditions, the one with a higher speed completes swings proportionally faster.

Relative speed ratios

The ratios below use the burner inserter's rotation speed (0.013) as the baseline of 1.00. The rotation column compares rotation against rotation; the extension column compares extension speed against that same baseline so that the two dimensions can be read against a single reference. The third column compares extension speed against the burner inserter's own extension speed (0.035), which is the dimensionally consistent ratio.

Inserter	Rotation (vs burner rot)	Extension (vs burner rot)	Extension (vs burner ext)
burner inserter	1.00x	2.69x	1.00x
inserter	1.08x	2.69x	1.00x
long handed inserter	1.54x	3.85x	1.43x
fast inserter	3.08x	7.69x	2.86x
bulk inserter	3.08x	7.69x	2.86x
stack inserter	3.08x	7.69x	2.86x

The fast inserter rotates 3.08 times as fast as the burner inserter, and its extension speed is 7.69 times the burner inserter's rotation speed. Because extension is the slower phase of a burner inserter's cycle, that extension gap is the more noticeable one in practice: a fast inserter does not merely rotate faster, it spends far less time reaching for the item. The basic inserter (yellow) is 1.08x the burner on rotation, a modest but real upgrade that costs only electronic circuits and iron plates rather than fuel.

The long-handed inserter's ratio of 1.54x on rotation and 3.85x on extension (versus burner rotation) places it above the basic inserter on extension but below the fast tier. That reflects its design purpose: it exists to cross a gap, not to maximise throughput. Using a long-handed inserter where a standard fast inserter would fit sacrifices speed for reach.

The stack and bulk inserters share the fast inserter's speeds. Their advantage is not mechanical speed but per-swing capacity, which depends on stack size bonus research not present in the data. The distinction between them is covered in detail later in this page.

Belt throughput across all four tiers

Belt throughput is computable from the data because it follows a fixed formula: speed × 8 × 60, where speed is tiles per tick, 8 is the number of items a tile of belt holds across both lanes, and 60 is ticks per second.

Belt	Speed (tiles/tick)	Items/second	Relative to yellow
transport belt	0.03125	15.0	1.00x
fast transport belt	0.0625	30.0	2.00x
express transport belt	0.09375	45.0	3.00x
turbo transport belt	0.125	60.0	4.00x

The yellow belt carries 15 items per second, red doubles to 30, blue reaches 45, and the turbo belt — added in Space Age — runs at 60, four times the base tier. These are the hard ceilings an inserter must match or exceed when feeding or draining a belt. A single inserter that cannot swing fast enough to keep a yellow belt compressed will not keep a red or blue belt compressed either.

How inserters interact with belts

An inserter does not track the throughput of the belt it is loading or unloading. It picks up one item at a time (or more, with stack bonus) and places it on the belt at the drop-off point. Whether the belt ends up fully compressed depends on whether items are placed onto it faster than the belt carries them away.

Loading a belt from a chest or machine

When an inserter places items onto a belt, it drops them into the nearest available lane position. If the belt is moving faster than the inserter can swing, gaps appear between items and the belt runs below capacity. On a yellow belt, 15 items must arrive every second across both lanes to maintain full compression. If a single inserter is the only source, its swing rate must meet that demand. Because absolute swing throughput cannot be computed from the data, the practical question is whether a single inserter of a given type saturates a given belt tier — and that is something to verify in game rather than calculate from prototype values.

The common design pattern is to use multiple inserters in parallel. Three fast inserters feeding one belt have three times the swing capacity of one, and if each swings at rate R the combined rate is 3R. Whether 3R exceeds 15 (yellow), 30 (red), 45 (blue) or 60 (turbo) depends on R, which the data does not provide — but the scaling relationship holds regardless.

Unloading a belt into a chest or machine

When an inserter picks items off a belt, it can only grab when an item is at the pickup position. On a fully compressed belt, items arrive at that position at the belt's full rate — fast enough that any single inserter is the bottleneck, not the belt. On a partially compressed belt, items arrive less frequently and the inserter spends time waiting. This is why belt compression matters at unload points: a half-full belt makes even fast inserters look slow, because the hand is ready but no item has arrived yet.

Inserter-to-inserter transfer

When two inserters face each other across a gap — one dropping, one picking up — the second inserter can only grab after the first has placed the item. The combined throughput is limited by the slower of the two swing cycles, not the sum. This is why chaining inserters to move items over distance is a poor strategy: each handoff serialises the transfer, and the total rate approaches one swing per combined cycle rather than scaling with inserter count. Belts do not have this problem because items move continuously without handoff waits.

When to use the long-handed inserter

The long-handed inserter reaches two tiles instead of one, at a speed between the basic and fast tiers. It solves a geometric problem, not a throughput problem:

• Crossing a belt gap. When a machine must pull from or feed to a belt that is two tiles away — for example, when a row of assemblers is separated from its supply belt by a tile of underground belt — a long-handed inserter bridges the gap without rearranging the layout.
• Filtered side loading. A long-handed inserter can reach across one belt to grab from a second belt on the far side, which is useful for separating items on parallel lanes.
• Compact furnace columns. In tight smelting setups, long-handed inserters can reach across a belt to load furnaces on the far side, reducing the footprint of the column.

The cost is speed. The long-handed inserter's extension speed (0.05) is lower than the fast inserter's (0.1), and its longer reach means each extension phase covers more distance. If throughput matters and the geometry allows a standard inserter, use a fast inserter instead. Reserve the long-handed for the cases where nothing else reaches.

Stack inserter vs bulk inserter

The stack inserter and bulk inserter have identical rotation and extension speeds in the data (0.04 and 0.1). The difference is their behaviour with stack size bonus research and their intended use case.

The stack inserter is the general-purpose high-capacity inserter. It benefits from stack size bonus research and can move multiple items per swing between any combination of chests, belts and machines. It is the default choice for wagon unloading, large-scale smelting, and anywhere items need to move in volume.

The bulk inserter is tuned for chest-to-chest and chest-to-machine transfers where items are already in stacks. It shares the same mechanical speeds and benefits from the same research, but its energy cost per swing (20kJ) is half the stack inserter's (40kJ). In a large base with hundreds of inserters running continuously, that energy difference compounds. The bulk inserter is the economical choice for transfers that do not involve a belt — for example, moving items from a buffer chest into an assembler, or from a provider chest into a storage chest.

The exact number of items per swing depends on the stack size bonus research level, which is not in the extracted data. The base value is one item per swing for both types; research increases this. Without the research data, this page cannot state the per-swing capacity at any given technology level.

Property	Stack inserter	Bulk inserter
Rotation speed	0.04	0.04
Extension speed	0.1	0.1
Energy per swing	40kJ	20kJ
Best for	Belt loading/unloading, wagons, general high-volume transfer	Chest-to-chest, chest-to-machine, energy-sensitive large bases

Chest capacities and buffer sizing

A chest at an inserter transfer point acts as a buffer. Its capacity determines how many items it can hold before the inserter must stop loading or the downstream machine must catch up. The capacities below are read from data/2.1/machines.json.

Chest	Inventory slots	Max health
Wooden chest	16	100
Iron chest	32	200
Steel chest	48	350
Passive provider chest	48	350
Active provider chest	48	350
Storage chest	48	350
Buffer chest	48	350
Requester chest	48	350

The wooden chest holds 16 stacks, the iron chest holds 32, and every tier from steel chest upward holds 48. All five logistic chest variants share that 48-slot capacity. The actual item count a chest holds is its slot count multiplied by the item's stack size: a steel chest full of iron ore (stack size 50) holds 2400 ore, while the same chest full of electronic circuits (stack size 200) holds 9600.

At one item per inserter swing, filling a wooden chest takes 16 swings and a steel chest takes 48. With stack bonus research, those swing counts divide by the per-swing capacity. The buffer matters when production and consumption rates are uneven: a larger chest absorbs a burst from a fast producer and doles it out to a slower consumer without stalling the producer.

Belt compression and why it matters

A belt is fully compressed when items are packed at the maximum density of 8 items per tile across both lanes. On a yellow belt, that density produces the stated 15 items per second. Gaps between items reduce throughput proportionally: a belt that is 80% compressed carries 80% of its rated throughput.

Compression is lost in several common situations:

• Splitter priority and side loading. When a splitter merges two belts and one input is empty, the output has gaps where the empty input would have contributed items.
• Inserter loading that cannot keep up. A single inserter feeding a belt may leave gaps between the items it places, especially on faster belt tiers.
• Underground belt exits. Items emerging from an underground belt can have gaps if the input side was not fully compressed.
• Belt corners and turns. A properly designed corner preserves compression, but certain configurations — particularly splitter-fed turns — can introduce gaps.

Compression is restored by feeding a compressed belt into the under-compressed one, typically via a splitter that gives priority to the compressed input. Once items are packed, they stay packed through straight sections, corners and underground segments as long as nothing removes or inserts items at a different rate.

Belt corners and lane behaviour

A belt turn does not reduce throughput on its own. Items on the inside lane travel a shorter path, but the belt's movement speed is constant and items maintain their spacing. A compressed belt entering a corner exits still compressed. The throughput loss at corners comes from the junctions that often accompany them, not the curve itself.

What does change at a corner is which side of the belt items end up on. When two belts join at a turn, items from one input may end up on a specific lane depending on the turn direction. This is the basis of lane filtering and lane balancing. A left-turning belt tends to keep left-lane items on the left and shift right-lane items; a right turn is the mirror image. This behaviour is deterministic but fiddly to reason about in the abstract. In practice, the reliable way to control lane assignment is to use splitters with priority and filter settings, or to use underground belts to route one lane past another.

Lane balancing

A single belt has two lanes, and each lane carries half the belt's total throughput. On a yellow belt, each lane carries 7.5 items per second. When both lanes carry the same item, the distinction does not matter. When they carry different items — for example, iron plates on one lane and copper plates on the other — each lane is an independent half-belt.

A lane balancer is a specific arrangement of splitters and underground belts that redistributes items evenly between the two lanes of a single belt. This is distinct from a belt balancer, which redistributes across multiple belts. A lane balancer is useful when:

• Items are being loaded onto one lane only (by a single inserter, for example) and both lanes need to be filled for full throughput.
• A splitter or turn has pushed most items onto one lane, starving the other.
• A machine pulls from both sides of a belt and needs a steady supply on each lane.

The simplest lane balancer uses one splitter to split the belt, routes one output underground to cross under, and merges both back onto a single belt. The exact splitter count depends on the layout, but the principle is the same as a belt balancer applied to two lanes rather than two belts. The belt balancer designs page covers the multi-belt case in detail.

Throughput limits: where the bottleneck actually is

When a production line is not getting enough items, the bottleneck is rarely "the belt is too slow" considered alone. It is usually one of:

1. The inserter feeding the belt. If one inserter is the only source and it cannot swing fast enough, the belt runs under-compressed. The fix is to add more inserters or upgrade to a faster type.
2. The inserter unloading the belt. If one inserter is pulling from the belt into a machine, it can only grab one item per swing. On a compressed belt, items arrive faster than one hand can take them. The fix is to add more inserters or use stack inserters.
3. The belt tier. If a yellow belt carrying 15 items/s is feeding a line that needs 30, no amount of inserter tuning helps. The fix is to upgrade the belt or add parallel belts.
4. The machine craft speed. If the assembler or furnace cannot consume items as fast as the belt delivers them, items back up on the belt and the inserter stops loading. This is not a belt or inserter problem — it is a ratio problem. The production ratios page covers how to size machines correctly.

Belt tier	Items/s	Per lane	Inserter implication
transport belt	15.0	7.50	One fast inserter may keep up; verify in-game
fast transport belt	30.0	15.0	Likely needs multiple inserters or stack bonus
express transport belt	45.0	22.5	Requires multiple stack inserters for full compression
turbo transport belt	60.0	30.0	Requires multiple stack inserters for full compression

The inserter implication column is a qualitative assessment, not a computed figure. Because absolute inserter throughput depends on geometry, stack bonus and belt compression as described above, the exact number of inserters needed to saturate each belt tier should be verified in-game. The table exists to flag that faster belts demand more loading hardware, not to provide a false-precision number.

Burner inserters: the early-game exception

The burner inserter is the only inserter that burns fuel instead of consuming electrical energy. Its energy per swing is 50kJ, ten times the electric inserter's 5kJ. That energy comes from burning coal or other fuel items in its internal fuel inventory, which means it needs a fuel supply — typically a piece of coal manually inserted or delivered by another burner inserter.

Despite its slowness and inefficiency, the burner inserter has one critical advantage: it works without power. In the early game, before boilers and steam engines are running, burner inserters are the only way to automate item transfer. They also remain useful as a failsafe: if the power grid collapses, burner inserters fed by a coal belt can keep boilers fueled while the rest of the factory stops.

The burner inserter's rotation speed of 0.013 makes it the slowest of the six types by that measure, but its extension speed of 0.035 equals the basic electric inserter's. Rotation is the bottleneck: a burner inserter spends more time sweeping its arm than reaching, which is why replacing burner inserters with electric ones produces a visible speedup even before fast inserters are researched.

Practical design patterns

Furnace columns

A standard smelting column places furnaces in a row with a belt of ore on one side and a belt of plates on the other. Each furnace has one inserter loading ore and one unloading plates. Using fast inserters provides 3.08x the burner's rotation speed and 7.69x its rotation speed in extension performance, which is usually sufficient to keep pace with a yellow or red belt of ore. Stack inserters are overkill for single-item furnace loading unless the column is fed by a blue belt or higher. The smelting ratios page covers how many furnaces a given belt of ore can sustain.

Assembler rows

Assemblers often need multiple ingredient types, which means multiple inserters pulling from different belts. Long-handed inserters are useful when ingredient belts are two tiles away, but fast inserters should be used wherever they fit. If an assembler has three ingredients and three belts, each belt should be compressed and each inserter upgraded to the fastest type that the geometry allows. A buffer chest between the belt and the assembler can smooth out bursty supply, especially when a belt is shared between multiple machines.

Wagon loading and unloading

A cargo wagon is six tiles long per side, allowing up to six inserters per side (twelve total) to load or unload simultaneously. Stack inserters are the standard choice here because the wagon holds a large volume and the goal is to minimise the time the train spends at the station. The exact unload time depends on inserter swing rate and stack bonus, neither of which is computable from the data — but using twelve stack inserters rather than six fast inserters is always faster, and the energy cost of the stack inserter is justified by the reduction in train idle time. The train throughput page covers how wagon capacity and station timing interact.

Buffer chests between belt and machine

Placing a chest between a belt and an assembler — belt feeds chest via inserter, chest feeds assembler via another inserter — decouples the belt's burst delivery from the assembler's steady consumption. The steel chest's 48 slots absorb short-term supply gaps. This pattern is especially useful when a belt is shared between multiple consumers: each consumer gets a buffer chest, and the belt feeds all of them without any one consumer's stall affecting the others. Logistic chests extend this pattern into a robot-fed network, which the logistic robots page covers.

Energy consumption across inserter types

Every electric inserter draws energy per swing, and the amount varies considerably by type. The basic and long-handed inserters cost 5kJ per swing, the fast inserter costs 7kJ, the bulk inserter costs 20kJ, and the stack inserter costs 40kJ. The burner inserter burns 50kJ worth of fuel energy per swing.

These numbers matter at scale. A smelting column with a hundred furnaces and two hundred fast inserters makes a noticeable but modest demand on the power grid. Replacing all of those with stack inserters multiplies the per-swing cost roughly six-fold, and the stack inserter's higher swing rate compounds it. The bulk inserter sits between the two: it has the speed of a fast inserter and the item-per-swing capacity of a stack inserter (with research), but at half the stack inserter's energy cost, making it the efficient choice for chest-to-chest transfers where its higher capacity is useful but the stack inserter's raw power is unnecessary.

The energy figures are read from data/2.1/logistics.json as energy_per_movement. They represent the energy consumed per swing cycle, not a continuous drain. An idle inserter consumes no energy. A fast inserter that swings more frequently because it is feeding a compressed belt consumes more total energy than the same inserter waiting beside a half-empty belt, even though the per-swing cost is identical.

Selecting the right inserter for each job

The six inserter types form a clear progression, and the choice at each stage of the game follows from what you are trying to move and how fast:

• Burner inserter — early game only, or as a coal-feeding failsafe for boilers. Slow, fuel-hungry, but works without electricity.
• Basic (yellow) inserter — the first electric inserter. Adequate for low-throughput early assembly and furnace loading. Upgrade when red belts or faster assemblers create a bottleneck.
• Long-handed inserter — reach tool, not a speed tool. Use it only when a standard inserter cannot span the gap. Its speed is between basic and fast, so do not use it where a fast inserter would fit.
• Fast inserter — the workhorse of the mid-game. Fast enough for most belt and machine transfers, cheap to build, and energy-efficient. Use it everywhere until stack bonus research makes higher capacity worthwhile.
• Stack inserter — high-capacity transfer for wagon unloading, high-throughput smelting, and anywhere items move in volume. Higher energy cost, justified by the reduced number of swings.
• Bulk inserter — the economical high-capacity option for chest-to-chest and chest-to-machine transfers. Same capacity as the stack inserter with research, at half the energy. Prefer it when belts are not involved.

The progression is not strictly linear — the long-handed inserter is unlocked before the fast inserter but occupies a niche that the fast inserter cannot fill — but in terms of throughput on standard geometry, each tier above the basic inserter is a strict upgrade. The smart factory uses the cheapest inserter that does the job without becoming the bottleneck, and reserves the most expensive types for the places where their capacity is actually needed.

Applies when…

• Inserter speed ratios are computed from rotation_speed and extension_speed in data/2.1/logistics.json. They compare mechanical speeds, not items-per-second throughput.
• Absolute inserter throughput in items/second is NOT FOUND in the prototype data. It depends on arm length, pickup/drop-off positions, stack size bonus research, and belt compression, none of which are in data/2.1/.
• Belt throughput uses speed × 8 × 60, where 8 is items per tile across both lanes and 60 is ticks per second.
• Chest capacities are read from data/2.1/machines.json. Item counts per chest require multiplying by the item's stack_size from data/2.1/items.json.
• Stack size bonus research levels are not in the extracted data. Per-swing capacities for stack and bulk inserters must be measured in-game at your current research level.
• All figures are for game version 2.1.12. Mods that change inserter speeds, belt tiers, or chest sizes will change these values.

Questions or corrections? Contact support@corecalx.com.

Related

• Belt balancer designs — splitter counts and throughput for multi-belt networks
• Main bus design — how to organise belts so inserters can tap them cleanly
• Train throughput — wagon capacity and how inserter unloading speed affects station timing
• Smelting ratios — how many furnaces a belt of ore can feed
• How production ratios work — the machine side of the throughput equation