Accessed None Trying to Read Property: Why Your Blueprint Is Crashing

Blueprint Runtime Error: "Accessed None trying to read property CallFunc_GetActorOfClass_ReturnValue".
Node: Set Health  Graph: EventGraph  Function: Execute Ubergraph  Blueprint: BP_PlayerCharacter

If you've seen this in the log, your engine isn't broken. This is the single most common Blueprint error, and it means exactly one thing: you referenced an object that doesn't exist.

Most explanations skip the part that actually saves time — how to read the error message itself, not just what to do about it. So let's go through the whole thing.

What happened

In Blueprint, a variable holding a reference to an object can be empty. An empty reference is called None — the equivalent of null.

When you drag a wire from a variable like that into something like Get Health or Set Location, the engine tries to read a property on an object that doesn't exist. The node's execution stops there, Accessed None shows up in the log, and everything downstream starts behaving strangely: values are wrong, events don't fire.

Important: the game usually doesn't crash. Blueprint survives an error like this and keeps going, which is exactly why it's easy to miss until you go looking for the cause of some unrelated weird behavior.

How to read the error text

This is the main skill, and it saves more time than any specific fix. The message is structured like this:

Accessed None trying to read property X — X is the name of the empty variable. If it looks like CallFunc_GetActorOfClass_ReturnValue, you don't have an empty variable of your own — a function call returned an empty result. In the example above, Get Actor Of Class didn't find anything. The CallFunc_ prefix always points to a node's return value, not a variable you declared. A similar prefix, K2Node_DynamicCast_AsBP_..., means a cast came back empty.

Node: — the specific node where things stopped. That's the one to look for in the graph.

Graph: and Function: — where that node lives. Execute Ubergraph means the EventGraph.

Blueprint: — which asset it's in. If the error comes from a Blueprint you didn't touch, while you're editing your own, the problem probably isn't yours.

Four common causes

A failed cast. You're casting to BP_MyCharacter, but the object is a different class. The cast returns None, and everything wired after it now works with nothing. Easy to spot: Cast To has a Cast Failed output, and if it's not handled, that's usually the culprit.

The object hasn't been created yet. A classic on BeginPlay. You're reaching for a widget, a controller, or some other actor before it exists yet. Initialization order in Unreal isn't as guaranteed as you'd like it to be.

A function found nothing. Get Actor Of Class, Get Player Pawn, Find Component all honestly return None when there's nothing there. That's not a bug in the function, that's the answer.

The object was destroyed. The reference was valid, but the actor died in the meantime — between an event firing and it being handled, for instance. Common with timers and delays.

How to fix it

There's really one correct approach: check the reference before using it.

The IsValid node takes an object reference and gives you two outputs: Is Valid and Is Not Valid. A useful detail — it also catches objects marked for destruction, not just empty references. A plain comparison against None misses that second case.

There's a shorter option too: right-click a reference variable and pick Convert to Validated Get. A regular Get turns into a node with two outputs, and the "empty" branch shows up right there, no separate node needed.

Which to use: Validated Get is more convenient when the check only happens in one place. IsValid reads more clearly when a whole branch of logic depends on the result.

And one more thing: don't suppress the error, understand why the object is empty. Wrapping everything in IsValid removes the message from the log, but if the object was supposed to exist, you've just hidden the real bug. The error disappears, the wrong behavior stays.

When the culprit isn't the one you're looking at

An unpleasant scenario: the error comes from a Blueprint you didn't touch, and the real cause is somewhere else — wherever the variable was supposed to get filled in and didn't.

The way through this is to work backward: find every place that variable gets assigned. Unreal has search across all Blueprints for this (Ctrl+Shift+F) — search for the variable's name and look at which Set nodes exist in the project and under what conditions they run.

On a large project this gets tedious: dozens of matches, some in dead branches. This is where an agent with access to the project's files helps — Blueprint assets themselves are binary, but logs, configs, and the C++ side are text, and going through them can narrow things down fast: when the error first appeared, what changed nearby, which subsystems it touches.

Doka works with the project and terminal directly and can go through entire folders of logs, and the model can be local — for a project under NDA, that matters. For UE 5.8 there's a second path too: connecting an agent to the editor through the built-in MCP server.

Quick checklist

Saw Accessed None? Don't go hunting through the graph at random.

1. Read the property name: CallFunc_ means a function, K2Node_DynamicCast_ means a cast.
2. Double-click the node from the log line.
3. Figure out why the object is empty: wrong class, not created yet, not found, already destroyed.
4. Add IsValid or Validated Get — and handle the "empty" branch meaningfully.
5. Confirm the error is gone not just from the log, but in practice.

If you're going through someone else's project and there are hundreds of these, download Doka and start with the logs: error frequency by type usually shows fast which three spots to fix first.