JLRestful – Blueprint & C++ HTTP Client for Unreal Engine
JLRestful – Blueprint & C++ HTTP Client for Unreal Engine
Tagline / Short Description
A Blueprint-first, high-concurrency HTTP client with isolated requests, JSON, typed multipart, streaming, retries, progress, cancellation, and structured failures.
Long Description
JLRestful turns Unreal Engine’s native HTTP stack into a clear, practical API for both Blueprint and C++. Make ordinary REST calls, submit forms, send typed multipart data, upload large files, and stream downloads directly to disk without bringing in a third-party networking library.
Five focused asynchronous Blueprint nodes cover the common workflows: JL HTTP Request, JL Form Request, JL Multipart Request, JL Upload File, and JL Download File. Each call owns an independent request object, so multiple operations can run concurrently, report progress, be queried, and be cancelled separately.
The isolated per-request design is well suited to high-concurrency workloads such as parallel API queries, telemetry batches, content metadata retrieval, and multi-file operations. JLRestful does not serialize requests through a plugin-level global queue: every request keeps its own payload, delegates, timeout, progress, retry state, and cancellation lifecycle.
The response model deliberately separates transport success from application success. HTTP 4xx and 5xx responses remain available through On Response, including their status code, headers, body, and downloaded error file. On Failure is reserved for invalid input, connection failures, timeouts, cancellation, startup failures, and local file errors. This prevents useful server error bodies from disappearing behind a generic failure branch.
Request setup stays explicit without becoming repetitive. Choose GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, or a custom verb; add encoded query parameters and headers; set per-attempt and activity timeouts; then select JSON, text, XML, HTML, form, binary, MessagePack, CBOR, or a custom MIME type directly on the request node. JSON bodies are validated locally before any network request starts.
Multipart is built for real API schemas rather than file-only forms. A single part type supports file, string, number, integer, boolean, object, array, and null. Numbers use locale-independent web formatting, int64 values keep their precision, and object/array fields validate their JSON and receive an appropriate per-part content type. The dedicated Make JLRestful Multipart Part (Smart) editor node changes its visible inputs based on the selected type, while the standard struct Make node remains available for compatibility.
File transfers use Unreal’s streaming HTTP interfaces. Raw uploads send a file as the complete request body, downloads write the response directly to disk, and multipart reads file bytes on demand while retaining only small boundaries and text fields in memory. Failed downloads remove their partial destination file. If a platform backend does not provide Unreal’s streaming interface, JLRestful reports a structured StartFailed result instead of silently buffering an unbounded file.
Optional retries are disabled by default and can be enabled for connection errors, timeouts, HTTP 408, HTTP 429, and HTTP 5xx responses. Retry delay uses exponential backoff, while a numeric Retry-After response header takes precedence. The final response exposes the actual retry count and total duration. Cancellation also works while a request is waiting for its next retry.
Blueprint JSON helpers validate JSON and read top-level string, number, integer, boolean, object, and array fields. The wildcard array helper adapts to the connected Blueprint array type, while a raw JSON fallback preserves mixed or nested arrays. Repeated headers such as multiple Set-Cookie lines are preserved and can be queried case-insensitively.
JLRestful is a compact native-code plugin built on Unreal Engine modules only. It is suitable for login flows, account services, cloud saves, telemetry endpoints, content services, admin tools, API-driven UI, file delivery, and any project that needs a focused HTTP layer without adopting an external networking SDK.
Key Features:
Five focused async nodes — general HTTP, form, multipart, raw upload, and download.
Blueprint-first and C++ ready — async Blueprint nodes plus native delegates and C++ factories.
High-concurrency request architecture — run many independent requests without a plugin-level global request queue.
Isolated request state — each call owns its payload, delegates, timeout, progress, cancellation, and retry lifecycle.
Clear response semantics — HTTP 4xx/5xx remain readable responses; transport and local failures are structured separately.
Common and custom methods — GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS, and custom verbs.
Flexible content types — JSON, plain text, XML, HTML, form-urlencoded, octet stream, MessagePack, CBOR, or custom MIME.
Preflight JSON validation — malformed JSON fails locally before sending network traffic.
Typed multipart values — file, string, number, integer, boolean, object, array, and null.
Smart Multipart Part node — context-sensitive Blueprint pins for a cleaner graph.
MIME assistance — extension-based auto detection, common MIME presets, and custom MIME support.
Streamed file transfers — raw uploads, multipart file parts, and downloads avoid full-file buffering.
Progress and cancellation — cumulative sent/received byte events and per-request cancellation.
Configurable retries — connection errors, timeouts/408, 429, and 5xx with exponential backoff and Retry-After support.
Structured diagnostics — invalid request, connection error, cancelled, timed out, file error, start failure, and other.
Complete response data — status, headers, repeated header list, text body, binary body, saved path, duration, and retry count.
Blueprint JSON helpers — typed field extraction, wildcard typed arrays, and raw mixed-array JSON.
Repeated header support — preserves and queries multiple headers such as Set-Cookie.
No third-party networking library — built on Unreal Engine’s native HTTP and JSON modules.
Typical Use Cases
Authentication and account APIs
Player profiles, inventories, and cloud saves
REST-driven game or editor tools
Telemetry and analytics endpoints
High-concurrency API aggregation, batched queries, and parallel metadata retrieval
Multiple simultaneous uploads, downloads, or background content requests
Multipart image, log, or save-file submission
Patch, media, document, and generated-content downloads
API-driven menus and live service interfaces
Custom WebDAV-style methods through Custom Verb
Technical details:
High-concurrency independent async requests; isolated per-request state; JSON/text/XML/HTML/binary/custom bodies; URL-encoded forms; typed multipart; streamed raw upload/download; progress; cancellation; per-attempt and activity timeouts; configurable retries; structured response/failure data; JSON and repeated-header Blueprint helpers.
Code Modules:
JLRestful (Runtime), JLRestfulEditor (UncookedOnly).
Number of Blueprints: 0
Number of C++ Classes: 6
Network Replicated: No
Supported Development Platforms:
Windows: Yes
Mac: No
Supported Target Build Platforms: Win64
Supported Unreal Engine Versions: 5.3 – 5.8
Important/Additional Notes:
JLRestful does not impose a plugin-level concurrency limit or global serialization queue. Actual throughput and simultaneous connection limits depend on Unreal Engine’s HTTP manager, the platform backend, system resources, and the remote server.
HTTP 4xx and 5xx responses trigger On Response, not On Failure, so their headers and body remain available. Check StatusCode for application success.
Retries are disabled by default. Retrying a non-idempotent request may duplicate server-side work; use server-supported idempotency safeguards.
Object and Array multipart values must contain valid JSON of the matching top-level type.
Failed streamed downloads remove partial files; HTTP error response files are preserved because they are valid server responses.
DOWNLOAD FROM HOT4SHARE.COM
DOWNLOAD FROM SYNCS.ONLINE