Skip to content

Spawn Actor from Class

At a glance

Lives in: Blueprint API / Game - Returns: a reference to the spawned Actor instance, or None if the spawn failed - Fails by: returning None while execution continues; invalid setup can also produce Output Log warnings - Main hidden inputs: current world, spawn parameters, collision handling, Owner, and Instigator - Official docs: Spawn Actor from Class

The one-minute version

  • Spawn Actor from Class creates a new actor instance in the current world at the transform you pass in. It does not fetch an existing actor.
  • The Return Value is the actor that was just created. Store it if you need to talk to that actor later.
  • The node can return None. The usual beginner causes are "no class was provided," "the class is not spawnable," or collision handling refused the spawn location.
  • Owner is not attachment. It sets the spawned actor's actor-owner relationship, mostly for replication ownership, owner-only relevancy, and owner visibility flags.
  • Instigator is usually a Pawn. It means "the pawn responsible for this actor's gameplay consequences," especially damage.
  • In multiplayer, a replicated gameplay actor should normally be spawned by the server. A client-spawned actor is just a local actor unless your server also creates the authoritative one.

What it actually does

The Blueprint node starts from the graph's hidden world context, the class you picked, and the transform you supplied. Then it asks the world to create one actor of that class.

pseudocode of the engine behavior - not engine source

function SpawnActorFromClass(WorldContext, Class, Transform, Options):
    World = find the world from WorldContext
    if World is missing or Class is not a spawnable Actor class:
        return None

    SpawnParameters.Owner = Options.Owner
    SpawnParameters.Instigator = Options.Instigator
    SpawnParameters.SpawnCollisionHandlingOverride =
        Options.CollisionHandlingOverride

    Actor = World.SpawnActor(Class, Transform, SpawnParameters)
    return Actor        // new actor instance, or None if spawn failed

That sounds simple, but the Blueprint node has one important compile-time trick: if the actor class has variables marked Expose on Spawn, those variables become pins on the spawn node. Unreal's Blueprint compiler expands the node into a deferred-spawn sequence so it can:

  1. create a valid but unfinished actor,
  2. assign the exposed spawn values,
  3. finish the spawn, which runs the actor's Construction Script.

That is why an exposed variable can affect component setup in the spawned actor's Construction Script. A normal variable you set after the Return Value comes back is too late for that first construction pass.

When it fails (and what failure does)

The node has no Failed execution pin. Failure looks like this:

Spawn Actor from Class
-> execution continues
-> Return Value is None

Common causes:

  1. The Class pin is empty or invalid. The world cannot spawn "nothing."
  2. The class is not an Actor class that can be spawned. Use actor-derived Blueprint classes for this node, not widgets, data assets, components, or abstract/native-only classes that are not spawnable.
  3. Collision handling says not to spawn there. With a "do not spawn if colliding" mode, a blocked spawn point can make the Return Value None. With "always spawn," collision will not veto the creation.
  4. You are doing it from the wrong phase. Spawning arbitrary actors while another actor is running its Construction Script is unsafe and usually the wrong design. Use exposed variables, components, or spawn later in gameplay.
  5. You spawned on the wrong machine. This is not a local error, so the Return Value may be valid on that machine. The failure is multiplayer authority: the server and other clients do not automatically know about a purely client-spawned gameplay actor.

Failure does not retry, wait for space to clear, choose a different class, or call your own cleanup branch. If you care whether the actor exists, put Is Valid after the Return Value and handle the empty case yourself.

Owner and Instigator are not decoration

These two pins are advanced for a reason, but they matter the moment a spawned actor interacts with damage, visibility, or networking.

Pin Type Means Does not mean
Owner Actor The spawned actor's actor-owner relationship. Used mostly by networking ownership/relevancy and by owner-only visibility flags. "Attach this actor to me," "destroy it with me," or "I caused its damage."
Instigator Pawn The pawn responsible for this actor's gameplay consequences. Projectiles commonly use the firing pawn. "The controller," "the weapon actor," or "the actor that owns it for replication."

For a single-player projectile, beginners often get away with leaving both empty. For a real projectile, set Instigator to the firing pawn so damage code can later ask who was responsible. Set Owner only when you have a reason: owner-only visibility, owner relevancy, or remote procedure call (RPC) permission through the owning player chain.

If you meant "make the spawned actor follow my hand socket," use an attach node after spawning. The Owner pin will not move or parent the actor in the world.

The pattern everyone actually uses

For a first projectile, the Blueprint shape is:

Input Fire
-> get a muzzle SceneComponent transform
-> Spawn Actor from Class (Class = BP_Projectile, Spawn Transform = muzzle)
-> Is Valid (Return Value)
-> optionally set extra runtime state on the projectile

For a multiplayer projectile, the shape changes:

Client input
-> Run on Server event
-> server validates the request
-> server calls Spawn Actor from Class
-> spawned projectile has Replicates enabled

The important rule is: the server creates the authoritative gameplay actor. The client can predict visuals if your game needs that, but the server copy is the one other machines should trust.

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

void AHeroCharacter::Fire()
{
    if (!ProjectileClass)
    {
        return;
    }

    FActorSpawnParameters Params;
    Params.Owner = this;
    Params.Instigator = this;
    Params.SpawnCollisionHandlingOverride =
        ESpawnActorCollisionHandlingMethod::AdjustIfPossibleButDontSpawnIfColliding;

    AHeroProjectile* Projectile = GetWorld()->SpawnActor<AHeroProjectile>(
        ProjectileClass,
        MuzzleComponent->GetComponentTransform(),
        Params);

    if (!IsValid(Projectile))
    {
        return;
    }

    Projectile->LaunchForward();
}

Lookalikes - which one do I want?

Node or tool Creates Use when
Spawn Actor from Class A new Actor in the world You need a projectile, pickup, enemy, effect actor, or any runtime actor instance.
Begin Deferred Actor Spawn from Class + Finish Spawning Actor A new Actor with a manual pause before construction finishes You need to set setup data before Construction Script runs, especially from C++ or advanced Blueprint flows.
Expose on Spawn variables Pins on the normal spawn node You want beginner-friendly setup values that the spawned actor can read during its Construction Script.
Spawn AI From Class A Pawn plus AI-controller setup You are spawning an AI pawn and want controller/behavior-tree setup handled with it.
Add Component by Class A component on an existing actor You are adding behavior or geometry to an actor you already have, not creating a separate actor.
Child Actor Component A child actor owned by a component You want a designed sub-actor as part of another actor's component setup.
Construct Object from Class A non-Actor UObject You need a plain object, not something that lives independently in the world.

Rule of thumb: if it needs a transform, can exist in a level, and can be placed or destroyed as its own thing, it is probably an Actor. If it is just a part of an existing actor, it is probably a Component.

Going deeper