Ownership and lifetime

Unreal uses the word "owner" for at least four different relationships. The official docs never tell you which one a node means. This page is the decoder.

The four ownerships

#	Relationship	Query	What it's for
1	A component belongs to an actor	GetOwner() on a component	Structure: a mesh belongs to a character
2	An actor has an optional Owner actor	GetOwner() on an actor	Networking: whose client may call server functions; relevancy
3	A Controller possesses a Pawn	GetController() / GetPawn()	Control: which brain drives which body
4	Every UObject has an Outer	(C++ only: GetOuter())	Memory: what contains what, for loading and garbage collection

The trap: GetOwner exists on both components and actors and means a different relationship on each. On a component it's #1 (structural, always set). On an actor it's #2 (networking, often None). Same name, different question.

1. Components belong to an actor

Every component lives inside exactly one actor. GetOwner on the component returns that actor — always, from the moment the component exists. When the actor is destroyed, its components are destroyed with it.

This is the "owner" in Try Get Pawn Owner: the skeletal mesh component being animated belongs to some actor; the node asks "is that actor a Pawn?"

2. The actor Owner chain (networking)

Separately, an actor can point at another actor as its Owner — set via the Owner pin on Spawn Actor from Class, or Set Owner later. Unlike

1 this is optional and often None.

Why it exists — multiplayer:

• A client is only allowed to call Run on Server events on actors it owns — meaning the actor's Owner chain reaches that client's PlayerController. Forgot to set Owner when the server spawned the weapon? That's the classic "my Run on Server event silently does nothing" bug.
• Some actors are only network-relevant to their owner (bOnlyRelevantToOwner — e.g. an inventory that only its player needs).

Single-player rule of thumb: you can ignore #2 entirely. Multiplayer rule of thumb: every interactable a player "holds" should have its Owner set.

3. Possession: Controller ↔ Pawn

A Controller (the brain — player or AI) possesses one Pawn (the body). This is a two-way link: GetController from the pawn, GetPawn from the controller. The dedicated concept page is Possession.

• Possession is dynamic: on death you typically destroy the pawn and the controller survives to possess the next one. Controller = the persistent will; pawn = the disposable body.
• Possessing also sets the pawn's actor Owner (#2) to the controller — which is exactly why a player's own pawn may call server functions.
• A pawn can be unpossessed (no controller): an NPC before its AI starts, a body mid-respawn. Nodes returning a Controller can therefore return None — guard them.

flowchart LR
    HP[Human player] --> PC[PlayerController]
    PC -- possesses --> CH[Your Character]
    CH -- contains #1 --> MESH[SkeletalMeshComponent]
    MESH -- animated by --> ABP[Anim Instance / Anim Blueprint]
    SW[Sword actor] -- attached to --> CH
    SW -. actor Owner #2 .-> CH

One character, three "ownerships" at once — and a node called "get owner" could plausibly mean any arrow in that diagram. Hence this page.

4. Outer and garbage collection (C++ mostly)

Every UObject lives inside another object — its Outer: components inside their actor, actors inside their level. This chain is about memory and loading, not gameplay; Blueprint never shows it.

What you will meet is its consequence, garbage collection:

• An object with no referencing UPROPERTY/Blueprint variable anywhere gets destroyed and collected.
• Destruction isn't instant. Between Destroy and actual deletion, the object is "pending kill": your saved references now point at a zombie.
• Is Valid exists precisely for this: it checks both "not None" and "not pending kill". This is why Is Valid is the right guard, not == None.
• In C++, only UPROPERTY() pointers are seen by the GC (and get nulled on destruction); raw pointers silently dangle. Blueprint variables are all effectively UPROPERTY, so Blueprint users get this for free.

Cheat sheet

You want	Ask
The actor my component is part of	Component → GetOwner (#1)
The pawn my anim blueprint animates	Try Get Pawn Owner (#1 + pawn check)
Whether a client may call Run-on-Server on this actor	Actor → GetOwner chain to their PlayerController (#2)
The brain driving this pawn	Pawn → Get Controller (#3, may be None)
The body this brain drives	Controller → Get Pawn / Get Controlled Pawn (#3, may be None)
"Is this reference still safe to use?"	Is Valid (#4)