How to POST JSON to a REST API from Unreal Engine Blueprints

The problem: sending JSON to a backend without C++

Sooner or later every Unreal game needs to talk to a server. You want to submit a leaderboard score, push an analytics event, save a player profile, or POST a form to a web service - and the endpoint expects a JSON body with the right Content-Type header. Doing this with the raw engine HTTP module means writing a fair amount of C++ boilerplate: constructing an FHttpRequest, setting the verb, attaching headers, serialising the payload, binding a completion delegate, and handling the response. None of that is hard, but none of it is Blueprint either.

This tutorial shows the Unreal Engine Blueprint POST JSON to API workflow end to end using EasyHTTP, a Blueprint-friendly HTTP plugin that wraps the engine's HTTP module so you can call REST APIs from nodes (or C++) without that boilerplate. We will pick the right HTTP method, send a JSON body with the Async Quick POST JSON node, build the body string, and parse the reply back into a Blueprint struct. Everything here is grounded in what the plugin actually ships; no node names or behaviours are invented.

One thing to know up front: EasyHTTP is a single Runtime module and is Windows 64-bit only. It supports HTTPS through the engine's SSL/TLS, but does not do WebSockets or response streaming - the full response is buffered before you get it. For the request/response pattern most game backends use, that is exactly what you want.

When to use POST vs PUT vs PATCH

Before you wire anything up, pick the correct verb. EasyHTTP exposes all five common methods through the EEasyHTTPMethod enum - GET, POST, PUT, PATCH and DELETE - so the plugin will never be the thing that limits your choice. The decision is about what the API expects, not what the plugin can do.

Use POST when you are creating a new resource or submitting an action where the server decides the result, for example submitting a new leaderboard entry, registering a player, or firing an event. POST is the default for 'send this data and let the backend process it', and it is what the Async Quick POST JSON node performs.

Use PUT when you are replacing a resource wholesale at a known location - sending the complete, updated object so the server overwrites whatever was there. Use PATCH when you are sending only the fields that changed rather than the whole object, which keeps the payload small for partial updates such as bumping a single setting. If you need PUT, PATCH or DELETE with a JSON body, reach for the general-purpose Easy HTTP Request node and choose the method from its Method dropdown; the quick node in the next section is POST-specific by design.

Async Quick POST JSON node walkthrough

The fastest route to a working POST is the Async Quick POST JSON node. It is a latent async action with separate execution pins, so it does not block your game thread and you do not have to bind a delegate by hand. It takes a URL and a JSON Body string, sets the application/json content type automatically (and a matching Accept header), and defaults to a 30 second timeout.

1. Open the Blueprint where the request should fire - a UI button handler, a gameplay event, anything. Right-click in the graph and add the Async Quick POST JSON node.

2. Set the URL pin to your endpoint, for example https://api.yourgame.com/scores. During development you can point it at the plugin's built-in test server instead (covered below) so you do not need a live backend.

3. Feed the JSON Body pin a string containing your payload. We build that string in the next section.

4. The node exposes On Success and On Failure execution pins. Wire each to the branch of logic you want. On Success means the request completed; you still want to check the status code for application-level results.

5. From the result, add a Break node on the FEasyHTTPResponse struct. The fields you will use most are bSuccess, StatusCode and Content - the latter being the raw response body as a string. The struct also carries Headers, RequestStatus, ErrorMessage, ElapsedTimeSeconds and RequestedURL if you need them.

Because the response Content is returned as a raw string, the plugin deliberately leaves parsing to you - which is the right call, because your struct is yours to define. We handle that last.

Building the JSON body string

The JSON Body pin expects a string of valid JSON. For a small, fixed-shape payload the simplest approach is to assemble the string with the Blueprint string nodes you already know - Append and Format Text - making sure your keys and string values are wrapped in double quotes. A score submission body might read like this: an opening brace, then a playerId key with a quoted string value, then a score key with a numeric value, then a closing brace. Numbers go in unquoted; strings, booleans and nulls follow JSON rules.

Hand-assembling strings is fine for a handful of fields, but it gets fragile fast and it is easy to forget to escape a quote inside a value. For anything beyond a trivial body, define a USTRUCT that mirrors your payload and serialise it with the engine's built-in Struct to Json String node (the mirror image of the parsing node we use next). That way the field names and types come straight from your struct definition and you cannot typo a key.

If your endpoint takes parameters in the query string rather than the body, EasyHTTP also ships helper nodes: BuildURLWithParams auto-encodes query parameters onto a base URL, and URLEncode / URLDecode handle individual values. These keep you from hand-encoding spaces and special characters. For a JSON POST, though, the data belongs in the body, and the quick node handles the Content-Type for you.

Parsing the response into a struct with Json String to Struct

Once On Success fires and you have the Content string, convert it into typed Blueprint data. The plugin's documentation recommends the engine's built-in Json String to Struct node for exactly this, and it is the cleanest path to type-safe data.

1. Define a USTRUCT whose property names match the JSON keys the server returns. If the response is an object with rank and bestScore fields, your struct needs a Rank and a BestScore member with matching names and compatible types. Field-name matching is how the converter maps JSON onto your struct.

2. Add the Json String to Struct node, set its output struct type to the struct you just defined, and feed the Content string from the broken FEasyHTTPResponse into its input.

3. The node returns a boolean for whether parsing succeeded plus the populated struct. Branch on the boolean: if it failed, the body was not the shape you expected (a 4xx or 5xx error page, say), so fall back to your error path; if it succeeded, read the struct fields directly.

4. Always check StatusCode from the response before trusting the parsed data. A note on retries that catches people out: EasyHTTP's optional retry logic fires only on connection failures, never on 4xx or 5xx HTTP responses - the server answered, so the plugin does not retry. That means a 500 will surface as a completed request with an error status, which is your cue to handle it in Blueprint rather than expecting an automatic retry.

With the response in a struct, the loop is closed: you POSTed JSON, the server replied, and you now have typed data to drive your UI or gameplay - all without leaving Blueprint.

Test it without a backend, then go to production

You do not need a live server to build and debug this flow. EasyHTTP bundles a local test server (UEasyHTTPServerLibrary) that runs on port 8080 by default. Call Start Local Test Server, point your request URL at http://localhost:8080/, and use Set Server Response to control what it sends back and Get Last Server Request to inspect exactly what your POST transmitted. Call Stop All Test Servers on End Play to tidy up. The test server is HTTP-only and meant for development, not production traffic.

When you are ready for a real backend that needs authentication, switch from the quick node to the general-purpose Easy HTTP Request node, which accepts an FEasyHTTPRequestOptions struct. Build it with one of the auth helper builders - MakeOptionsWithBearerToken for a JWT or OAuth token, MakeOptionsWithApiKey for an API key, or MakeOptionsWithBasicAuth for basic auth - and chain Add Header To Options for any custom headers. The Options pin is on Advanced Display, so expand the node to see it. From there you can also set TimeoutSeconds (0 to 300), enable bRetryOnConnectionError with a RetryCount, and pick from the eight supported content types if you are not sending JSON.

A useful next step once your data is flowing: once you have parsed server data in hand, you can visualise it. If you are pulling back time-series or summary numbers - scores over time, economy figures, live stats - Fast Chart Widgets can render that data into UMG charts without per-project drawing code, which pairs naturally with the JSON you just fetched.

Choosing the right node for a JSON request

All nodes are async latent actions with separate execution pins. The quick nodes set application/json for you.

FAQ