Sooner or later your game needs to read data it didn't ship with: a config file a designer edits, a mod a player drops in, a response from a server. That data almost always arrives as JSON or CSV. The good news: UE5 can parse JSON in Blueprints natively now. The catch: almost nobody knows the nodes exist, and CSV is only half-supported. Let's draw the line clearly.

The native JSON nodes nobody enables

UE5 ships a plugin called JSON Blueprint Utilities. It's off by default. Edit → Plugins, search "JSON Blueprint Utilities", enable, restart. Now you have Blueprint nodes to turn a JSON string into a structured object and read its fields.

The core flow:

CB0

You pull values out by key with typed getters (string, number, bool, array, nested object). It's official, in-engine, no marketplace download.

Where the native JSON path gets clunky

It works — but it's field-by-field. There's no automatic mapping from JSON to a Blueprint Struct; you read each key by hand and assemble the struct yourself. Nested objects mean chaining getter after getter. For a three-field config, that's fine. For a forty-field payload or a nested mod manifest, it's a wall of nodes. And error handling is manual: ask for a key that isn't there and you get a default value, not a warning — so a typo fails silently.

CSV: there are no native runtime nodes

Here's the part that surprises people. Unreal loves CSV — but only at edit time, as a DataTable import. There is no built-in Blueprint node to parse an arbitrary CSV string at runtime. If your game downloads a CSV or reads a user-supplied one, the engine hands you nothing out of the box.

Your realistic options:

  • Import as a DataTable (edit-time only) — perfect for fixed data that ships with the game, useless for anything runtime.
  • Roll your own — read the file as a string, split on newlines, split on commas. Fine for clean ASCII; it breaks the instant a field contains a comma or a quote.
  • A plugin — see below.

Encoding will bite you

Both formats: mind the encoding. A UTF-8 file saved with a BOM (byte-order mark) makes the very first key parse wrong, and you'll stare at it for an hour. Non-ASCII characters (ä, é, —) break naive CSV splitters and some parsers entirely. Save your data files as UTF-8 without BOM, and test with real names and accents, not test123.


Plugin tip
The native JSON nodes are field-by-field, and runtime CSV simply isn't there. The moment you're doing more than reading three keys, that gap gets old. FoxData covers exactly it — JSON and CSV parsing at runtime, plus config and DataTable helpers — as clean Blueprint nodes, no C++. Optional, but for a data-driven game it removes a whole category of boilerplate.

When to even reach for this

  • Config / balance files a designer can edit without a rebuild.
  • Mod support — let players drop in JSON.
  • Server-driven content — fetch JSON from an API (pairs with the HTTP nodes).
  • Save data interchange — though for real saves, use the SaveGame system (next week).

If the data ships with the game and never changes at runtime, you don't need any of this — a DataTable or DataAsset is simpler. That's the topic after next.

Common pitfalls

  • Not enabling the plugin. The JSON nodes don't exist until you turn on JSON Blueprint Utilities and restart the editor.
  • Expecting runtime CSV import. DataTable CSV import is editor-only. No native runtime CSV node exists — don't go looking for one.
  • Naive comma-splitting. A single quoted field with a comma in it destroys a hand-rolled parser. Use a real parser for anything beyond trivial data.
  • BOM and encoding. UTF-8 without BOM. Test with accented characters before you ship.
  • Parsing huge files on the game thread. A 5 MB JSON parsed in one frame is a visible hitch. Big payloads belong off the main thread or split into chunks.
  • No validation. Always confirm a field exists / a parse succeeded before using the value, or you ship a crash that triggers on the first malformed file.

The 30-second recap

  • JSON: enable JSON Blueprint Utilities (engine plugin, off by default) → parse strings to objects, read by key.
  • Native JSON is field-by-field; there's no automatic Struct mapping.
  • CSV has no native runtime Blueprint parser — only edit-time DataTable import.
  • Encoding matters: UTF-8 without BOM, and test with non-ASCII characters.
  • Validate before you read, and keep big parses off the game thread.

Next Sunday, votes permitting: Save/Load done right — why the default SaveGame runs out of room fast, and how to do slots, versioning and async saves without the hitch.

— Marco