Minecraft Mob Cap and Entity Limits Explained (Reduce Lag Guide 2026)

Entity limits control how many mobs, items, projectiles, and other live objects your Minecraft server is willing to spawn and tick each second and getting them wrong is one of the most common reasons servers lag. The fastest fix on most servers is to lower spawn-limits in bukkit.yml, reduce entity-activation-range in spigot.yml, and enable per-player-mob-spawns in paper-world-defaults.yml. Those three changes alone usually claw back enough tick budget to stabilise TPS on a busy SMP.

This guide walks through what entities actually are, how the mob cap works, where every relevant setting lives, and what values to use on different server types. If you've ever seen your server stutter the moment a big farm kicks in or a few hundred items pile up at a player's feet, you're in the right place.

What Is an Entity in Minecraft?

An entity is any object in the world that isn't a block. That's a wider category than most people expect. It includes:

• Mobs: zombies, cows, villagers, wardens, endermen, every living creature in the game.
• Dropped items: every stack that a player or mob has tossed on the floor.
• Experience orbs: the green XP blobs from kills, smelting, and mining.
• Projectiles: arrows, tridents, snowballs, eggs, ender pearls, fireballs.
• Vehicles: minecarts, boats, rideable horses, pigs with saddles.
• Decorations: armor stands, paintings, item frames, glow item frames.
• Primed TNT, falling blocks, fireworks, fishing bobbers, area effect clouds.

Every one of those objects occupies memory, runs some form of logic each tick, and sends updates to nearby players. A chest full of blocks costs your server almost nothing once loaded. A chest's worth of dropped items lying on the floor costs a lot more, because the server has to physics-simulate each stack and merge them on a timer.

When server owners talk about "too many entities," they usually mean too many ticking entities inside loaded chunks, which is the workload that actually eats tick budget.

What Is the Mob Cap?

The mob cap is Minecraft's built-in limit on how many mobs can spawn naturally in the world at one time. The vanilla game checks the cap before every spawn attempt. If the current population of a category is already at the cap, the spawn is skipped.

Vanilla splits mobs into separate categories, each with its own cap. On a standard server the defaults look like this:

These numbers are per-chunk-loaded scale in vanilla. In other words, the cap multiplies by how many chunks are currently loaded around players. Add a second player loading a fresh area and your effective monster cap goes up too. That's why a single-player test feels fine and the same settings on a 30-slot SMP feel swarmed.

On Paper and Purpur, the cap model changes slightly when you turn on per-player-mob-spawns, which moves the limit from "shared across all loaded chunks" to "each player gets their own budget." That setting is one of the single most important flags for busy servers; we'll get to it in the config section below.

Mob Cap vs Entity Limits

These terms get used interchangeably, but they control different parts of the engine:

• The mob cap governs spawning. It decides whether a new mob is allowed to enter the world. Once the cap is hit, spawning pauses until something dies or despawns.
• Entity limits govern existence and ticking. They cap how many entities can live in a chunk, how far away an entity has to be before the server stops updating its AI, and how many can pile up before the game crushes them together.

A server can hit its mob cap without ever hitting an entity limit, and vice versa. A skyblock server with aggressive spawners might have four million items on the ground and almost no natural mobs — the mob cap is fine but the per-chunk entity limit is blown out. A vanilla-feeling SMP with big open biomes can have the opposite problem: no item piles, but hundreds of passive mobs everywhere, pinning the monster cap high and hammering the CPU.

Understanding which one you're fighting tells you which config keys to touch. Item piles mean max-entity-cramming, merge-radius, and entity-per-chunk-save-limit. Mob-packed biomes mean spawn-limits, per-player-mob-spawns, and despawn-ranges.

There's also a third bucket worth naming: chunk entity save limits. These don't stop entities from spawning and don't stop them from ticking — they simply refuse to save more than a fixed number of a given entity type into a chunk file on disk. When a chunk unloads, the overflow is silently discarded. That's a destructive guarantee that a misconfigured farm can't permanently corrupt your world with a million stacked items.

Why Entity Limits Matter for Server Performance

Every entity that exists in a loaded chunk gets processed every tick. The server has a 50-millisecond budget per tick to run AI, pathfinding, physics, block updates, redstone, chunk streaming, and network traffic. Push past that window and TPS drops.

Entities are one of the biggest variable costs in that budget. A few observations that come up over and over when you profile a lagging server:

• Mob AI dominates on the main thread. Pathfinding is expensive. A villager re-planning a route in a dense building can cost a full millisecond on its own. Multiply that by a hundred villagers and you've burned through 20% of your tick budget on a single iron farm.
• Items aren't free. Every dropped item runs physics, checks for pickup collisions with nearby players and mobs, and tries to merge with other stacks in a small radius. Thousands of items stack that cost up fast.
• Entity collisions are a well-known CPU bottleneck. When mobs cram into a small space — the classic "200 chickens in a 1x1 hole" — each tick every mob checks every other mob for overlap. It's effectively O(n²) work.
• Chunk tracking scales with entity count. The server sends entity position updates to nearby clients every tick. Shorter entity-tracking-range means fewer updates sent.

Cutting entity counts and their activation range is the single highest-leverage change you can make on a laggy server, ahead of throwing more RAM at it and often ahead of upgrading plugins.

There's a knock-on effect on bandwidth too. Every tracked entity generates position, velocity, and metadata packets sent to nearby clients. A packed chunk with 200 mobs inside a crowded base is quietly pushing a lot of packets per second. Lowering entity-tracking-range doesn't just help the CPU — it reduces network load on the server uplink and on the players' downlinks, which matters for anyone on a marginal connection.

How to Check Entity Counts on Your Server

Before you tune anything, measure. "Too many entities" is meaningless without a number.

The /lagg or /minecraft count Approach

On Paper servers you can use:

/minecraft:kill @e[type=item]

Don't actually run this on a live server — the point is that the selector @e[type=item] counts them. Most owners get a count through plugins instead:

• LagAssist exposes /lagassist entity for a breakdown by type per world.
• ClearLagg has /lagg check which lists entity counts globally and per chunk.
• Spark (highly recommended) shows top entity types in its reports.

Spark Profiler

Spark is the standard profiling plugin. Two commands you'll use constantly:

/spark profiler start --timeout 300
/spark tickmonitor

The profiler runs for five minutes then drops a URL with a flame graph. Entity-heavy lag shows up as big blocks under ServerLevel.tick → entityTick, usually broken down by mob class. If you see Villager.customServerAiStep or Item.tick taking more than a few percent of your tick time, you've got an entity problem.

/spark tickmonitor is a real-time readout that flags ticks running long. Pair it with in-game actions — fire up that creeper farm and watch what happens.

Paper's Built-In Commands

Paper exposes a few useful commands out of the box:

/paper entity list
/paper chunkinfo
/paper dumpitem

/paper entity list shows a breakdown of all entities by type in the world you're standing in. It's quick, free, and doesn't need a plugin.

Where Entity Limits Are Configured

Every fork of Spigot, Paper, and Purpur splits these settings across several YAML files. Here's the map.

bukkit.yml — spawn-limits

bukkit.yml holds the raw mob cap values. Lowering these numbers reduces how many mobs will naturally spawn across the server.

spawn-limits:
  monsters: 70
  animals: 10
  water-animals: 5
  water-ambient: 20
  ambient: 15
  axolotls: 5
  water-underground-creature: 5
ticks-per:
  monster-spawns: 1
  animal-spawns: 400
  water-animal-spawns: 1
  water-ambient-spawns: 1
  ambient-spawns: 1

ticks-per controls how often the server even tries to spawn that category. Raising monster-spawns from 1 to 4 means the server attempts monster spawning four times less often — a small but real TPS saving on packed servers.

spigot.yml — entity-activation-range

This is the file that most often gets misconfigured. entity-activation-range tells the server how far away from a player an entity has to be before it stops running AI. Out-of-range entities still exist and can still despawn, but they don't path, attack, or make ambient noise.

world-settings:
  default:
    entity-activation-range:
      animals: 32
      monsters: 32
      raiders: 48
      misc: 16
      water: 16
      villagers: 32
      flying-monsters: 32
      wake-up-inactive:
        animals-max-per-tick: 4
        animals-for: 100
        monsters-max-per-tick: 8
        monsters-for: 100
        villagers-max-per-tick: 4
        villagers-for: 100
    entity-tracking-range:
      players: 48
      animals: 48
      monsters: 48
      misc: 32
      other: 64
    tick-inactive-villagers: false
    merge-radius:
      item: 2.5
      exp: 3.0

Key levers:

• entity-activation-range — lower is faster. 32 is vanilla-ish. Packed servers drop monsters and animals to 16–24.
• entity-tracking-range — how far the server sends entity packets to clients. Lower means players don't see mobs from as far away, which is usually fine.
• tick-inactive-villagers: false — flips off AI for villagers outside activation range. Big win on iron/trading hall servers.
• merge-radius.item — stacks dropped items that are within this block radius into one entity. Raising from the default 2.5 to 3.5 or 4.0 aggressively consolidates loot.

paper-world-defaults.yml — per-player-mob-spawns and friends

Paper adds some of the most powerful knobs in the entire performance toolkit. In modern Paper builds these live in config/paper-world-defaults.yml (per-world overrides go in paper-world.yml inside each world folder).

entities:
  spawning:
    per-player-mob-spawns: true
    despawn-ranges:
      monster:
        hard: 96
        soft: 24
      creature:
        hard: 96
        soft: 24
      ambient:
        hard: 64
        soft: 24
      axolotls:
        hard: 64
        soft: 24
      underground_water_creature:
        hard: 64
        soft: 24
      water_creature:
        hard: 64
        soft: 24
      water_ambient:
        hard: 64
        soft: 24
      misc:
        hard: 96
        soft: 24
    count-all-mobs-for-spawning: false
  entities-target-with-follow-range: false
  behavior:
    disable-chest-cat-detection: true
chunks:
  entity-per-chunk-save-limit:
    experience_orb: 16
    snowball: 8
    llama_spit: 4
    arrow: 16
    trident: 16
    small_fireball: 8
    fireball: 8
    dragon_fireball: 8
    egg: 8
    area_effect_cloud: 8
    item: 32
    wither_skull: 8
    eye_of_ender: 8
collisions:
  max-entity-collisions: 8

The big ones to know:

• per-player-mob-spawns: true — switches spawning from "shared cap across loaded chunks" to "each player has their own budget based on spawn-limits." This single flag does more for crowded SMPs than almost anything else. Turn it on.
• despawn-ranges.soft / .hard — inside soft, mobs never despawn. Outside hard, they despawn immediately. Shrinking both reclaims tick budget from mobs nobody is interacting with. hard: 96 / soft: 24 is a solid starting point, down from vanilla's 128 / 32.
• entity-per-chunk-save-limit — a hard cap on how many entities of each type can be saved into a single chunk. Set item: 32 and you physically cannot have a chunk with more than 32 ground-item entities. The overflow is deleted on chunk save. This is the nuclear option against item-piling AFK farms.
• max-entity-collisions: 8 — each entity runs collision checks against at most this many neighbours per tick. Lowering it from 8 to 2 or 4 can dramatically cut cost in mob crushers and iron farms, at the price of some fidelity on crowd behaviour.
• count-all-mobs-for-spawning: false — excludes farm mobs (like those piled in a mob grinder) from the "is the mob cap full?" check, letting natural spawns continue around the rest of the world. Enable with care; leaving it on can let farm servers spawn more than you intend.

server.properties — simulation-distance

simulation-distance indirectly controls entity cost by defining how far out chunks are ticked. A chunk outside simulation range keeps its entities on disk but doesn't process them. Dropping from 10 to 6 or 8 is one of the easiest performance wins you can make. View distance and simulation distance are different — you can keep view distance high for visuals and push simulation distance low for performance.

See our chunk loading lag guide for how these two values interact with world streaming.

Recommended Entity Limit Settings by Server Type

There is no single "best" set of values. The right numbers depend on what players are doing. Three starting profiles that work well in practice:

Survival / SMP (Balanced)

For a vanilla-feel SMP with 10–40 players, iron farms, and the usual mix of building and exploring:

# bukkit.yml
spawn-limits:
  monsters: 35
  animals: 8
  water-animals: 3
  ambient: 8

# spigot.yml
entity-activation-range:
  animals: 24
  monsters: 24
  raiders: 48
  misc: 12
  villagers: 24
tick-inactive-villagers: false
merge-radius:
  item: 3.5
  exp: 4.0

# paper-world-defaults.yml
entities:
  spawning:
    per-player-mob-spawns: true
    despawn-ranges:
      monster: { soft: 24, hard: 72 }
      creature: { soft: 24, hard: 72 }
collisions:
  max-entity-collisions: 4
chunks:
  entity-per-chunk-save-limit:
    item: 32
    arrow: 16
    experience_orb: 16

Keeps farms working, keeps natural spawning visible, but cuts AI cost roughly in half compared to vanilla defaults.

Skyblock / Minigames (Aggressive)

For minigame networks and skyblock servers where most of the map doesn't need natural mobs:

# bukkit.yml
spawn-limits:
  monsters: 10
  animals: 3
  water-animals: 1
  ambient: 1

# spigot.yml
entity-activation-range:
  animals: 12
  monsters: 16
  raiders: 32
  misc: 8
  villagers: 16
merge-radius:
  item: 4.0
  exp: 6.0

# paper-world-defaults.yml
collisions:
  max-entity-collisions: 2
chunks:
  entity-per-chunk-save-limit:
    item: 16
    arrow: 8
    experience_orb: 8

Natural mobs become effectively background decoration; the server focuses on whatever gameplay loop is actually happening.

Modded / Tech / Farming Servers (Loose Where Intended)

Modded packs like All the Mods, FTB, or heavily automated tech servers need room for machinery and intended entity volume:

# bukkit.yml (or equivalent for Forge via plugins)
spawn-limits:
  monsters: 50
  animals: 12
  ambient: 10

# spigot.yml / Mohist equivalent
entity-activation-range:
  animals: 32
  monsters: 32
  villagers: 32
  misc: 16

# paper-world-defaults.yml
entities:
  spawning:
    per-player-mob-spawns: true
collisions:
  max-entity-collisions: 8
chunks:
  entity-per-chunk-save-limit:
    item: 64

The item save limit is deliberately higher because automated sorting and item pipelines legitimately drop a lot of entities at once. Pair this with optimised farm design rather than trying to cap items out of existence.

Adjusting Entity Limits to Your Hardware and Player Count

Hardware matters. A dedicated server with a modern Ryzen CPU and NVMe storage can chew through entity workloads that would crush a cheap shared host. Don't copy another server's config blindly.

A rough decision tree:

• Low single-thread CPU (under ~2,000 PassMark single-thread score) — cut entity-activation-range hard (16–24), lower spawn-limits to 30–40% of vanilla, turn per-player-mob-spawns on, and drop max-entity-collisions to 2.
• Mid-tier shared host — start from the SMP profile above. Monitor MSPT via /mspt. If it creeps past 30ms during peak, tighten activation range by 4 blocks at a time.
• Dedicated CPU with strong single-thread — you can keep closer to vanilla numbers, but still enable per-player-mob-spawns and set sane entity-per-chunk-save-limit values. The limits are still cheap insurance against a broken farm.

Player count scales the problem. With per-player-mob-spawns on, every extra player effectively multiplies the monster budget. A server that runs 20 players fine at monsters: 70 might choke the moment you hit 40. Shrink spawn-limits proportionally as your headcount grows.

RAM is the other axis. If your server is already tight on memory — see how much RAM a Minecraft server needs — higher entity counts directly pressure the heap and can trigger GC pauses that look like TPS drops. Fewer entities is both a CPU win and a GC win.

One final rule of thumb: change one category of settings at a time, then let the server run for a day before you decide whether it helped. Entity workloads are spiky. A config change that feels neutral at 2am can be the difference between 20 TPS and 14 TPS at peak when 40 players log on and start mining simultaneously.

Plugins That Help Manage Entities

Plugins layer extra entity management on top of the config values. The useful ones are:

• Spark — profiling and live tick monitoring. Not strictly an entity plugin but the first tool you should install to find out what's actually eating tick time. Covered in our performance plugin roundup.
• LagAssist — a suite of tools including per-chunk entity scans, automatic chunk entity purges, and TPS-based throttling that slows spawning automatically when TPS drops below a threshold. One of the more complete packages.
• ClearLagg / ClearLag — the original. Periodically clears dropped items, arrows, and optionally mobs based on configurable rules. Good for servers where an inactive auto-farm is the main problem.
• EntityTrackerFixer — patches a Minecraft behaviour where entities are tracked further than they need to be. Low impact alone but worth stacking.
• MobFarmManager or StackMob — stack mobs into single entities for the visuals while keeping the drop-and-XP behaviour. Can cut mob entity counts in farms by 90%+ without changing player experience.

A good baseline stack on a performance-minded SMP: Paper or Purpur + Spark + LagAssist + StackMob, with entity limits tuned in the YAML files rather than relying on plugins alone. Plugin-level clearing is a backstop, not a substitute for sensible caps. See best Paper settings for performance for the broader config picture these entity values sit inside.

Troubleshooting High Entity Counts

When /paper entity list shows an alarming number, the culprit is almost always one of a small set of common causes. Work through them in order.

Dropped Items from AFK Farms

By far the most common cause. A mob grinder running 24/7 while its owner is offline pushes thousands of items into a single chunk. Even with a hopper chain, the buffer between drop and pickup can be huge.

Fixes:

• Lower entity-per-chunk-save-limit.item to 32 or lower.
• Raise merge-radius.item to 3.5–4.0.
• Install StackMob-style plugins to cap how many mobs can live in the farm at all.
• In extreme cases, use LagAssist's chunk entity cap to forcibly clear when a chunk exceeds a threshold.

Villager Breeders

Villagers are expensive entities. They run complex AI, re-plan their schedules, search for beds and job sites, and pathfind constantly. A trading hall with 200 villagers will visibly lag a whole server.

Fixes:

• Set tick-inactive-villagers: false in spigot.yml.
• Set entity-activation-range.villagers to 16 or 24.
• Cap villagers per chunk via plugins; Paper doesn't have a native villager cap.
• Encourage players to demolish idle breeders instead of leaving them running.

Abandoned Minecarts

A surprising percentage of laggy servers have 3,000+ minecarts floating in Nether rail systems or half-built transport networks. Minecarts are cheap individually but accumulate.

Fixes:

• Search with /paper entity list and physically clean up hotspots.
• Use ClearLagg rules to purge minecarts with no passenger older than N minutes.

Projectiles Stuck in Walls

Arrows, tridents, and fireballs stuck in blocks persist for a long time. A skeleton farm can spew tens of thousands of arrows into the surrounding walls.

Fixes:

• entity-per-chunk-save-limit.arrow: 16 (or lower).
• Paper's arrow-despawn-rate — lower than vanilla's 1200 ticks. Bumping it down to 300 ticks kills arrows in 15 seconds.
• Add creative-arrow-despawn-rate and non-player-arrow-despawn-rate as well; skeleton-shot arrows obey the latter, not the former.

Raids and Pillager Patrols

A single active raid can put 60+ raiders into a chunk. Multiple simultaneous raids (on big servers, this happens constantly) are a sneaky source of spikes.

Fixes:

• entity-activation-range.raiders: 48 is vanilla; 32 is usually fine.
• per-player-mob-spawns: true helps here too because raids contribute to the cap.

Check Before Blaming Entities

Worth noting: a spike that looks like an entity problem sometimes isn't. Chunk generation, a rogue redstone contraption, or a single plugin running an expensive sync task can look identical to "too many mobs." A Spark profile tells you definitively. See our TPS guide for how to read one.

Looking for a Minecraft host where entity limits, Paper tuning, and memory allocation are dialled in from day one? Take a look at Wabbanode Minecraft hosting — every plan ships with Paper pre-installed and performance defaults that already cover most of what this guide recommends.

Frequently Asked Questions

What is the mob cap in Minecraft?

The mob cap is the ceiling on how many mobs of each category (monsters, animals, water creatures, ambient, axolotls) can exist in loaded chunks before natural spawning pauses. The default monster cap is 70; animals is 10. On Paper with per-player-mob-spawns: true, that number applies per player instead of being shared across the whole server.

How do I increase or decrease the mob cap?

Edit spawn-limits in bukkit.yml. Lower numbers mean fewer mobs spawn; higher numbers mean more. Restart the server to apply. On busy servers it's almost always a good idea to lower these from vanilla defaults rather than raise them.

What's a safe entity-activation-range?

For most SMPs, 24 is a safe starting value for monsters and animals, down from the vanilla 32. Minigame servers can run as low as 12–16. Values under 12 start producing visibly frozen mobs in normal gameplay, which players will notice.

Does lowering entity limits actually reduce lag?

Yes, consistently. Entity tick cost is one of the single biggest variable expenses on a Minecraft server. Cutting spawn-limits by half and entity-activation-range by a third often translates into a measurable TPS and MSPT improvement, especially on servers with active farms or dense player bases.

Does the mob cap apply per player or per server?

Vanilla and Spigot: per server, scaled by loaded chunk count. Paper with per-player-mob-spawns: true: per player. The Paper option is strongly recommended on any server with more than a handful of active players.

How many entities is too many?

There's no hard number, it depends on hardware. As a rule of thumb, if a single loaded chunk has more than 200 entities or a single player area has more than 2,000, you're in "expect lag" territory. Use Spark to confirm whether entity tick is actually the problem before assuming.

Do entity limits affect mob farms?

They can, if set aggressively. spawn-limits affects natural spawns, so farms relying on natural spawning (like general mob grinders) will produce less. Spawner-based farms (from cave spawners or spawn eggs in a grinder) aren't affected by spawn-limits. entity-per-chunk-save-limit and max-entity-cramming do affect both. Farm servers should tune limits thoughtfully rather than crank them down blindly.

What's the default mob cap on Paper?

Paper uses the same vanilla defaults out of the box — 70 monsters, 10 animals — unless you've enabled per-player-mob-spawns, in which case that number becomes a per-player budget. Paper does not lower these defaults for you; you have to do it in bukkit.yml.

Will lowering simulation-distance hurt entity behaviour?

Entities outside simulation distance don't tick. That means frozen mobs and stalled redstone beyond that radius. For most servers simulation-distance: 6 or 8 is a fine balance. Players inside their own base area will always be at the centre of the sim distance and won't see frozen mobs where they are.