What Is the Extra Claims Command in FTB Chunks (And How Does It Work)?

If you've spent time managing a Minecraft server running Feed The Beast (FTB) modpacks, you've likely run into FTB Chunks — the mod that handles chunk claiming and chunk loading. One of the lesser-understood features inside this system is the extra claims command, which lets server administrators and players extend claim limits beyond the defaults. Here's what it actually does, how it fits into the broader chunk management system, and why the right value depends heavily on your specific setup.

What Is FTB Chunks?

FTB Chunks is a mod included in many FTB modpacks that gives players the ability to claim chunks — specific 16×16 block columns in a Minecraft world — so that those areas are protected from other players building or griefing within them. It also allows force-loading of claimed chunks, meaning those chunks stay active in memory even when no player is nearby.

Every player and team starts with a default number of chunks they're allowed to claim. That limit is defined in the mod's configuration, and it applies globally to the server unless overridden.

What Does the Extra Claims Command Do?

The extra claims command in FTB Chunks allows server operators (or players with appropriate permissions) to grant additional chunk claims to a specific player or team on top of their base allocation.

The command syntax typically looks like this:

/ftbchunks extra_claim_chunks <player> <amount> 

Or for force-loaded chunks specifically:

/ftbchunks extra_force_load_chunks <player> <amount> 

These commands add to whatever the player's current maximum is — they don't replace it. So if a player's base limit is 100 claims and you grant them 50 extra, their new ceiling becomes 150.

This is particularly useful in scenarios like:

• Rewarding donators or VIP players on a public server
• Giving server staff expanded access for builds or testing areas
• Allowing large teams or factions to claim territory proportional to their size
• Compensating for performance-heavy modpacks where more loaded chunks are needed for automation

Extra Claims vs. Default Config Limits

It's worth separating two distinct ways claim limits get set in FTB Chunks:

The config file sets the floor for everyone. The extra claims command creates per-player exceptions above that floor. Changes made through the command persist in the mod's data storage and survive server restarts.

Permissions and Who Can Run It 🔧

By default, the extra claims command requires operator-level permissions (typically permission level 2 or higher on a vanilla-adjacent server). On servers using a permissions plugin or mod — like LuckPerms — the specific node can be granted more granularly.

The key permission nodes to know:

• ftbchunks.command.extra_claim_chunks — controls who can grant extra claim chunks
• ftbchunks.command.extra_force_load_chunks — controls who can grant extra force-load slots

If you're running a modded server with a dedicated permissions system, these nodes let you delegate the ability to grant extras to moderators without giving them full operator access.

How Force-Loading Interacts With Extra Claims

Force-loaded chunks are a separate but related concept. Claiming a chunk protects it — force-loading keeps it active in memory. These are two different counters, and the extra claims command addresses both independently.

Force-loaded chunks have a meaningful performance cost. Each force-loaded chunk requires the server to tick entities, tile entities, and game logic within it continuously. On servers with many players each running large automated farms or complex machinery, this compounds quickly.

This is why most server operators don't simply raise the defaults globally — they use the extra claims command surgically, granting larger allocations only where genuinely needed rather than inflating everyone's limits.

Variables That Determine the Right Values 🎮

There's no universal "correct" number of extra claims to grant. The factors that actually matter include:

• Server hardware — RAM, CPU thread count, and tick rate headroom determine how many loaded chunks the server can sustain
• Modpack complexity — tech-heavy packs with automation (like those featuring Create, Applied Energistics, or Mekanism) generate far more chunk activity than exploration-focused packs
• Player count — a 5-person private server behaves very differently from a 50-person public one
• Team vs. solo play — FTB Chunks supports team-shared claims, which changes how individual allocations translate to total server load
• Intended use — a player claiming land for aesthetic builds needs different limits than one running a fully automated resource network

Granting too many force-load slots to too many players is one of the more common causes of server TPS (ticks per second) degradation on modded Minecraft servers, so the ceiling you set through extra claims has real consequences beyond just storage space.

What Gets Stored and How to Check Current Allocations

FTB Chunks stores per-player data in the world's serverconfig or ftbchunks data folder, depending on the version. You can typically inspect a player's current claim counts through the in-game map (the FTB Chunks minimap interface) or via command output.

To check a player's current allocation:

/ftbchunks info <player> 

This returns their current claimed chunks, force-loaded chunks, and any extra allocations already granted — useful before deciding whether to extend limits further.

The right balance between generous player access and stable server performance isn't something a default config or a single command can determine on its own — it comes down to the specific combination of hardware, player behavior, and modpack demands you're actually working with.