{"id":22929,"date":"2026-07-07T18:36:28","date_gmt":"2026-07-07T18:36:28","guid":{"rendered":"https:\/\/xgamingserver.com\/blog\/minecraft-target-selectors\/"},"modified":"2026-07-07T18:36:28","modified_gmt":"2026-07-07T18:36:28","slug":"minecraft-target-selectors","status":"publish","type":"post","link":"https:\/\/xgamingserver.com\/blog\/minecraft-target-selectors\/","title":{"rendered":"Minecraft Target Selectors Explained (@a @p @e @r @s)"},"content":{"rendered":"\n

Target selectors are the shorthand that lets a Minecraft command pick who<\/em> or what<\/em> it acts on without typing player names. Instead of \/tp Steve 100 64 100<\/code>, you can write \/tp @p 100 64 100<\/code> and the game resolves the nearest player automatically. This reference covers all six Java Edition selector variables (@p<\/code>, @r<\/code>, @a<\/code>, @e<\/code>, @s<\/code>, @n<\/code>) and every filter argument you can add in square brackets, current for Minecraft Java 26.2.<\/p>\n\n\n\n

To run any of these, open the chat window by pressing T<\/strong> (or \/<\/strong>, which pre-types the slash) and enter a command. On a multiplayer server you can also type commands into the server console without the leading slash. Cheat commands generally require operator\/permission level 2, so make sure cheats are enabled or you are opped. Want to build selectors visually and copy the exact string? Use our free Minecraft Target Selector tool<\/a>.<\/p>\n\n\n\n

The Six Selector Variables at a Glance<\/h2>\n\n\n\n
\n
Selector<\/th>Targets<\/th>Default sort \/ limit<\/th>Example<\/th><\/tr><\/thead>
@p<\/code><\/td>Nearest player. If tied, the most recently joined player wins.<\/td>sort=nearest, limit=1<\/td>tp @p 100 64 100<\/code><\/td><\/tr>\n
@r<\/code><\/td>A random online player (Java can target a random entity with type=<\/code>).<\/td>sort=random, limit=1<\/td>give @r diamond 1<\/code><\/td><\/tr>\n
@a<\/code><\/td>All online players, including dead\/respawning<\/strong> players.<\/td>sort=arbitrary, no limit<\/td>gamemode adventure @a<\/code><\/td><\/tr>\n
@e<\/code><\/td>All alive entities in loaded chunks (players, mobs, items, etc.).<\/td>sort=arbitrary, no limit<\/td>kill @e[type=zombie]<\/code><\/td><\/tr>\n
@s<\/code><\/td>The entity that executed the command. Selects nothing if the executor is not an entity.<\/td>self only<\/td>tag @s add marked<\/code><\/td><\/tr>\n
@n<\/code><\/td>Nearest alive entity of any<\/em> type, not just players.<\/td>sort=nearest, limit=1<\/td>data get entity @n<\/code><\/td><\/tr>\n<\/tbody><\/table><\/figure>\n\n\n\n

Players vs Entities: @a @p @r vs @e @n @s<\/h2>\n\n\n\n

@a<\/code>, @p<\/code> and @r<\/code> always resolve to players<\/strong>. In Java you cannot use type=<\/code> to make them target a mob \u2014 that argument only re-types @e<\/code>, @n<\/code> and @s<\/code>. A key gotcha: @a<\/code> includes dead players who are still respawning, whereas @e<\/code> only matches alive<\/em> entities in loaded chunks. So gamemode adventure @a<\/code> catches everyone, but @e[type=player]<\/code> may miss a player mid-respawn.<\/p>\n\n\n\n

@e<\/code> is the broadest selector and almost always needs narrowing. kill @e[type=zombie]<\/code> removes every zombie, and @e[type=!player]<\/code> targets every non-player entity. @n<\/code> is the entity-aware cousin of @p<\/code> \u2014 @n[type=cow]<\/code> is the nearest cow. @s<\/code> refers only to the command’s executor and is the backbone of \/execute<\/code> chains: it selects nothing from a command block or the bare server console because neither is an entity, but it can<\/em> select a dead entity.<\/p>\n\n\n\n

Selector Arguments (Filters)<\/h2>\n\n\n\n

Arguments go inside square brackets and are combined with logical AND<\/strong>: @e[type=zombie,distance=..10]<\/code> means zombies and<\/em> within 10 blocks. Java is case-sensitive. Many arguments can be negated with !<\/code> and repeated for multiple exclusions.<\/p>\n\n\n\n

\n
Argument<\/th>Syntax<\/th>What it filters<\/th>Example<\/th><\/tr><\/thead>
type<\/td>type=<\/code> \/ type=!<\/code> \/ type=#<\/code><\/td>Entity type; #<\/code> for entity-type tag, !<\/code> to exclude (one positive value only).<\/td>@e[type=creeper]<\/code><\/td><\/tr>\n
distance<\/td>distance=<\/code><\/td>Euclidean distance in blocks. Java ranged floats; cannot be negative.<\/td>@e[distance=5..15]<\/code><\/td><\/tr>\n
limit<\/td>limit=<\/code><\/td>Max targets returned, applied after sort.<\/td>@e[type=item,limit=5]<\/code><\/td><\/tr>\n
sort<\/td>sort=nearest|furthest|random|arbitrary<\/code><\/td>Order targets are chosen before limit.<\/td>@a[limit=3,sort=furthest]<\/code><\/td><\/tr>\n
x, y, z<\/td>x=,y=,z=<\/code><\/td>Override the search origin (Java: not center-corrected).<\/td>@e[x=100,y=64,z=200,distance=..10]<\/code><\/td><\/tr>\n
dx, dy, dz<\/td>dx=,dy=,dz=<\/code><\/td>Cuboid volume by hitbox intersection from the origin.<\/td>@e[x=0,y=64,z=0,dx=5,dy=3,dz=5]<\/code><\/td><\/tr>\n
tag<\/td>tag=<\/code> \/ tag=!<\/code> \/ tag=<\/code><\/td>Custom \/tag<\/code> tags; empty matches no tags, !<\/code> matches any tag.<\/td>@e[tag=marked,tag=!done]<\/code><\/td><\/tr>\n
scores<\/td>scores={=}<\/code><\/td>Scoreboard objective values (integer or range), ANDed.<\/td>@a[scores={kills=10..}]<\/code><\/td><\/tr>\n
nbt (Java only)<\/em><\/td>nbt=<\/code> \/ nbt=!<\/code><\/td>Entity NBT match via stringified NBT.<\/td>@e[type=sheep,nbt={Color:0b}]<\/code><\/td><\/tr>\n
gamemode<\/td>gamemode=survival|creative|adventure|spectator<\/code><\/td>Player game mode, negatable.<\/td>@a[gamemode=!spectator]<\/code><\/td><\/tr>\n
name<\/td>name=<\/code> \/ name=!<\/code><\/td>Exact name (case-sensitive; quote spaces).<\/td>@e[name=\"My Dog\"]<\/code><\/td><\/tr>\n
level<\/td>level=<\/code><\/td>Player experience level.<\/td>@a[level=30..]<\/code><\/td><\/tr>\n
x_rotation<\/td>x_rotation=<\/code><\/td>Head pitch: -90 up, 0 horizon, +90 down.<\/td>@e[x_rotation=..0]<\/code><\/td><\/tr>\n
y_rotation<\/td>y_rotation=<\/code><\/td>Yaw: -180 north, -90 east, 0 south, +90 west.<\/td>@e[y_rotation=-45..45]<\/code><\/td><\/tr>\n
team (Java only)<\/em><\/td>team=<\/code> \/ team=!<\/code> \/ team=<\/code><\/td>Scoreboard team; empty = no team.<\/td>@a[team=red]<\/code><\/td><\/tr>\n
advancements (Java only)<\/em><\/td>advancements={=}<\/code><\/td>Advancement or criterion completion.<\/td>@a[advancements={story\/smelt_iron=true}]<\/code><\/td><\/tr>\n
predicate (Java only)<\/em><\/td>predicate=<\/code> \/ predicate=!<\/code><\/td>Data-pack predicate match.<\/td>@e[predicate=mypack:is_underwater]<\/code><\/td><\/tr>\n<\/tbody><\/table><\/figure>\n\n\n\n

Sort and Limit: Order Matters<\/h2>\n\n\n\n

Sort always runs before limit.<\/strong> That is why default limits pair with default sorts: @p<\/code> and @n<\/code> use sort=nearest, limit=1<\/code>; @r<\/code> uses sort=random, limit=1<\/code>; @a<\/code> and @e<\/code> use sort=arbitrary<\/code> with no limit (arbitrary is the fastest ordering). Override them together \u2014 @e[type=item,limit=5,sort=nearest]<\/code> returns the five closest dropped items, while @a[limit=3,sort=furthest]<\/code> returns the three players farthest from the execution point. You cannot raise @s<\/code> beyond one target.<\/p>\n\n\n\n

Position, Distance and Volume<\/h2>\n\n\n\n

By default a selector searches from the command’s execution position. Override the origin with x<\/code>, y<\/code>, z<\/code> \u2014 in Java these are not center-corrected<\/strong>, so x=0<\/code> means exactly 0.0<\/code>. Combine with distance<\/code> for a sphere (@e[distance=..10]<\/code> = within 10 blocks) or with dx<\/code>\/dy<\/code>\/dz<\/code> for a box. The cuboid spans from (x,y,z)<\/code> to (x+dx, y+dy, z+dz)<\/code> plus one block, and selection is by hitbox intersection<\/strong>, not entity center. Unspecified d-axes default to 0. For rotation-aware effects, x_rotation<\/code> filters pitch and y_rotation<\/code> filters yaw.<\/p>\n\n\n\n

Tags, Scores and Data-Driven Filters<\/h2>\n\n\n\n

For map-making, the most powerful filters are data-driven. tag<\/code> reads custom tags set with \/tag<\/code>: @e[tag=marked]<\/code> matches tagged entities, tag=<\/code> matches entities with no<\/em> tags, and multiple tag=<\/code> arguments are ANDed. scores<\/code> reads scoreboard objectives as ranges \u2014 @a[scores={hp=1..5,mana=10}]<\/code>. Java-only filters include nbt<\/code> (matches a subset of the entity’s NBT, e.g. @a[nbt={OnGround:true}]<\/code>), team<\/code>, advancements<\/code>, and predicate<\/code>. Note the nbt<\/code> selector still reads entity<\/em> NBT and was unaffected by the 1.20.5 move to item components \u2014 that change only altered item syntax like \/give<\/code>, not selector arguments.<\/p>\n\n\n\n

How to Run These<\/h2>\n\n\n\n