Skip to content

Get Overlapping Actors / Components / Is Overlapping Actor

At a glance

Lives in: Blueprint API / Collision - Targets: an Actor or a PrimitiveComponent, depending on the version you place - Returns: an array of overlapping Actor references, an array of overlapping PrimitiveComponent references, or one Boolean - Fails by: returning an empty array or false, silently - Reads: current overlap state already tracked by the target; it does not sweep a new shape through the world - Official docs: Get Overlapping Actors, Get Overlapping Components, and Is Overlapping Actor

The one-minute version

  • Use Get Overlapping Actors when you need who is inside/touching this overlap setup right now as actor references.
  • Use Get Overlapping Components when the exact colliders matter: a shield, weak-point mesh, pickup sphere, or one of several hitboxes on the same actor.
  • Use Is Overlapping Actor when you already have one actor reference and only need a yes/no answer.
  • Drag from an Actor reference to get the Actor version: it aggregates overlaps from that actor's primitive components. Drag from a collision component to ask only about that component.
  • These nodes read Unreal's maintained overlap records. They do not run a new sphere/box/capsule query at an arbitrary position.
  • Empty array or false is normal. It can mean nothing overlaps, the class filter removed every result, or the collision pair never established tracked overlap state.
  • Results are local to the world/machine running the query. The nodes do not replicate overlap state or make client-side results authoritative.

What they actually do

Primitive Components - capsules, boxes, spheres, Static Mesh Components, Skeletal Mesh Components, and other collision-capable scene components - can maintain records of the other components they currently overlap.

The component-level family reads that state directly:

pseudocode of the engine behavior - not engine source

function Component.GetOverlappingActors(OptionalClassFilter):
    Result = unique actors owning components in this component's overlap records
    if ClassFilter is set:
        Result = actors that are ClassFilter or a subclass
    return Result

function Component.GetOverlappingComponents():
    return unique primitive components in this component's overlap records

function Component.IsOverlappingActor(OtherActor):
    return any recorded overlapping component is owned by OtherActor

The Actor versions aggregate across the target actor's owned primitive components:

function Actor.GetOverlappingActors(OptionalClassFilter):
    Result = unique external actors found in overlaps of my primitive components
    remove self
    apply ClassFilter if set
    return Result

function Actor.GetOverlappingComponents():
    return unique external primitive components overlapping my components

function Actor.IsOverlappingActor(OtherActor):
    return any of my components overlaps any component owned by OtherActor

The Actor itself does not have a single collision shape. Its components do the collision work; the Actor functions provide an actor-wide view over those component relationships.

Actor target vs component target

Two nodes can have the same display name while asking at different scopes. Look at the Target pin.

Target Question Result shape
Actor -> Get Overlapping Actors Does any primitive component owned by this actor overlap components on other actors? Unique actor-level list; does not return self.
Primitive Component -> Get Overlapping Actors Which actors have a component overlapping this one component? Actor-level list for this collider only.
Actor -> Get Overlapping Components Which external primitive components overlap any of this actor's primitive components? Component references across the actor.
Primitive Component -> Get Overlapping Components Which primitive components overlap this exact collider? Unique component list for this collider only.
Actor -> Is Overlapping Actor Does any component pair connect these two actors? One Boolean.
Primitive Component -> Is Overlapping Actor Does this exact component overlap any component on that actor? One Boolean at component scope.

Use component scope for a named trigger or hitbox. Use actor scope when the actor-wide relationship is the gameplay question.

BP_Door has:
    DoorMesh (blocks movement)
    EntryTrigger (overlaps Pawns)

EntryTrigger -> Get Overlapping Actors

Querying EntryTrigger makes the intent obvious. Querying the whole Door actor also examines any overlap state maintained by its other primitive components.

What exactly comes back

Actor arrays

Get Overlapping Actors returns actor references. The output pin is declared as Actor (or as the selected Class Filter type on the Actor version), but each runtime object remains its real subclass: BP_PlayerCharacter, BP_Pickup, and so on.

One actor can overlap through several component pairs. The actor list is an actor-level answer, not one entry per pair. If the pair detail matters, query components or use the component overlap events.

The optional Class Filter accepts a class and includes that class and its subclasses. A Pawn filter includes Characters because Character inherits from Pawn. No filter means any overlapping actor class can be returned.

Component arrays

Get Overlapping Components returns PrimitiveComponent references. The declared pin is broad; each value can really be a Box Component, Capsule Component, Static Mesh Component, Skeletal Mesh Component, or another Primitive Component subclass.

The component array is the right level for logic such as:

  • count exact hitboxes;
  • distinguish ShieldMesh from BodyCapsule;
  • inspect Component Tags;
  • identify which trigger remains occupied when another pair ends.

Boolean result

Is Overlapping Actor returns true when at least one component pair at the target scope currently connects to Other. It returns false when no such record exists. Passing None as Other does not find a match.

The Boolean does not tell you how many pairs overlap or which components are involved.

Ordering and lifetime

Treat both arrays as unordered current-state results. Do not make "index 0 is the closest" or "the first actor is the player" part of gameplay. Filter, sort, or choose deliberately when order matters.

The array is a snapshot of references produced for this call. Overlap state can change immediately afterward, and an actor/component can be destroyed. Validate stored references before later use.

What makes tracked overlap state exist

These nodes do not ignore collision setup. The relevant component pair needs to participate in overlap tracking:

  1. Both sides need collision enabled for queries where appropriate.
  2. The pair's channel responses need to resolve to Overlap, not Ignore or a blocking-only relationship.
  3. Components that should report and track overlap notifications normally need Generate Overlap Events enabled on both sides.
  4. The components need registered collision geometry in the same world and actually need to intersect.
  5. The overlap state must have been updated. These functions are marked unsafe during Actor construction; use runtime setup such as BeginPlay or later, not a Construction Script query that assumes the world is settled.

Level streaming and unusual manual movement can also affect when overlap state is initialized or refreshed. If a level appears around a stationary actor, streaming overlap-update settings decide whether the initial relationship is known immediately.

Debug the exact component pair, not only the Actor names:

Trigger.Get Collision Enabled
Trigger.Get Generate Overlap Events
PlayerCapsule.Get Generate Overlap Events
Trigger.Get Collision Response to Channel (Pawn)
PlayerCapsule.Get Collision Object Type

Visible meshes and collision shapes are separate. A mesh can visibly intersect the trigger while its collision is disabled or its responses resolve to Ignore.

When they return empty or false

Failure is ordinary data, not an exception or a Failed execution pin.

Cause What you see
Nothing currently overlaps at the target scope. Empty array / false.
The Actor query used the wrong actor, or the component query used the wrong collider. Empty array / false even though another component visibly overlaps.
Class Filter excludes the actors present. Empty actor array.
Collision is disabled for queries on one side. No tracked overlap.
Pair responses do not resolve to Overlap. No tracked overlap; a Block may produce hit behavior instead.
Generate Overlap Events/tracking setup is missing. Begin/End events and maintained overlap records are absent or not useful.
Construction/streaming has not initialized the state yet. Empty now; state may appear after runtime overlap updates.
The other actor/component was destroyed or unregistered. It leaves current overlap state; a previously stored reference may be invalid.
Other is None for Is Overlapping Actor. false.

The functions do not print a warning, retry collision, turn on Generate Overlap Events, or run a fresh world query. Calling the node on a None Target is a different Blueprint error: the call is skipped and PIE reports Accessed None.

Component pairs and the early End Overlap trap

Overlap events are component-pair events. Two actors can still overlap after one pair ends:

Player actor:
    Capsule
    WeaponMesh

Door actor:
    EntryTrigger

EntryTrigger overlaps Capsule       -> Begin pair A
EntryTrigger overlaps WeaponMesh    -> Begin pair B
WeaponMesh leaves EntryTrigger      -> End pair B
Capsule still overlaps EntryTrigger -> actors still overlap

If the door closes on every End Overlap event, pair B can close it while the player capsule is still inside. Re-check actor-level state:

On EntryTrigger End Overlap (Other Actor)
-> EntryTrigger.Is Overlapping Actor (Other Actor)
-> Branch
    true  -> another component pair remains; keep occupied
    false -> actor fully left this trigger; clear occupancy

For multiple actors, maintain a set of occupants or query the current actor array. A single Boolean such as PlayerInside cannot represent two players or two component-pair lifetimes honestly.

The pattern everyone actually uses

Events maintain state; queries answer current-state questions

For a door or hazard that reacts to changes, Begin/End events are the main path. A query is useful for verification, initialization, or an explicit pulse:

On EntryTrigger Begin Overlap
-> validate/filter Other Actor
-> add Other Actor to Occupants set
-> open door

On EntryTrigger End Overlap
-> if not EntryTrigger.Is Overlapping Actor(Other Actor)
       remove Other Actor from Occupants
-> if Occupants is empty
       close door

One-shot area action

ExplosionTrigger.Get Overlapping Actors
    Class Filter = Pawn
-> For Each
-> Does Implement Interface (BPI_Damageable)
-> apply one validated effect

This reads current tracked occupants. If the explosion exists only for this instant and has no maintained overlap component, use a Sphere Overlap Actors world query instead.

Component-specific filtering

DamageVolume.Get Overlapping Components
-> For Each
-> Component Has Tag "DamageReceiver"
-> Get Owner
-> de-duplicate owner actors
-> apply gameplay once per actor

The C++ twin, for the curious (our own example code):

void ADoorTrigger::RefreshOccupancy()
{
    TArray<AActor*> OverlappingPawns;
    EntryTrigger->GetOverlappingActors(OverlappingPawns, APawn::StaticClass());

    for (AActor* Actor : OverlappingPawns)
    {
        if (IsValid(Actor))
        {
            Occupants.Add(Actor);
        }
    }
}

Polling, arrays, and cost

These are local queries over maintained overlap records, not full-world actor searches. That makes them useful, but not free:

  • Actor versions inspect/aggregate overlap state across owned primitive components.
  • Array versions create/populate an output list on every evaluation.
  • A large overlap volume containing many actors/components produces more work and more references to filter.
  • A pure component node can be evaluated more than once if its output feeds several disconnected Blueprint paths.

Prefer events to react when occupancy changes. Poll when the gameplay genuinely asks a repeated current-state question, and store a local result within one execution path instead of rebuilding the same array several times.

Multiplayer

Overlap tracking exists in each machine's local world. These nodes do not send results across the network.

  • Run damage, pickup grants, objective capture, and other authoritative rules on the server.
  • A client can query local overlaps for presentation, but its set can differ because of replication timing, prediction, relevancy, or client-only collision.
  • Replicate the resulting gameplay state - door open, item collected, capture progress - rather than trying to replicate a raw overlap array every frame.

Get Overlapping Actors does not prove a client is allowed to affect those actors. Authority and validation remain separate.

What these nodes do not do

  • They do not perform a new world overlap at a supplied location.
  • They do not return impact points, normals, penetration depth, or hit results.
  • They do not turn collision or Generate Overlap Events on.
  • They do not recursively include attached actors or Child Actor instances as if their components were owned by the parent actor. Those are separate actors with their own overlap state.
  • They do not sort by distance, priority, class, or player index.
  • They do not keep returned actors/components alive forever.
  • They do not apply gameplay, suppress duplicate component-pair events, or replicate the result.

Lookalikes - which one do I want?

Node Use when Watch out
Get Overlapping Actors You need the actor-level occupants currently tracked by an Actor/component. Actor scope collapses component-pair detail.
Get Overlapping Components Exact colliders or component tags matter. De-duplicate owners if gameplay is once per actor.
Is Overlapping Actor You already know the other actor and need one yes/no check. It does not say which pair or how many pairs remain.
On Component Begin / End Overlap Gameplay should react when one component pair enters or leaves. Several pairs can fire for the same actor.
Actor Begin / End Overlap Actor-wide enter/leave notification is enough. Component events expose more precise collider context.
Sphere / Box / Capsule Overlap Actors You need a fresh world query at a supplied position and size. This is a separate query, not maintained component state.
Sphere / Capsule / Box Trace You need a shape swept from Start to End with hit results. A trace answers along a path, not current occupancy.
Get All Actors Of Class You need every loaded actor of a class, regardless of overlap. A world search is broader and should not replace collision filtering.

Rule of thumb: events for changes, Get Overlapping for maintained current state, Overlap Actors for a fresh volume query, and traces for a swept path.

Going deeper