In this article series, we introduce the integration of Artificial Intelligence (AI) into trading systems using MetaQuotes Language 5 (MQL5), starting with this part, where we develop a robust JavaScript Object Notation (JSON) parsing framework to handle data exchange for AI Application Programming Interface (API) interactions, such as with ChatGPT. We focus on creating a foundation for processing JSON structures to enable seamless communication with AI services for future trading applications. We will cover the following topics:
By the end, you’ll have a solid foundation for handling JSON data, setting the stage for AI-driven trading systems — let’s dive in!
JSON (JavaScript Object Notation) is a lightweight, text-based data interchange format widely used for structuring and transmitting data between systems, particularly in web-based APIs, due to its simplicity, readability, and compatibility across programming languages. In the context of AI-powered trading systems, like we want to build, serves as the standard format for exchanging data with AI APIs, such as OpenAI’s ChatGPT, enabling MQL5 applications to send trading-related prompts and receive structured responses for decision-making. Our approach in this article focuses on building a JSON parsing framework to handle these API interactions, laying the groundwork for integrating AI-driven insights into automated trading strategies.
What is JSON and Why It Matters
JSON represents data as key-value pairs, arrays, and nested objects, making it ideal for encoding complex information like market data, trading signals, or AI responses in a format that is both human-readable and machine-parsable. For example, a JSON object might look like this:
This structure includes strings, numbers, arrays, and nested objects, which an MQL5 Expert Advisor (EA) must parse to extract relevant information, such as the AI’s response to a trading query. JSON’s role in AI integration is critical here because APIs return responses in JSON format, requiring the program to serialize inputs (convert data to JSON) and deserialize outputs (parse JSON into usable data) to enable dynamic trading decisions. If this sounds like a jargon to you, here is a quick visualization of what data serialization and deserialization means.
Our implementation plan involves creating a JSON handling class that supports the following functionalities:
We will test this framework to ensure it can parse typical AI API responses, such as those from OpenAI, and serialize trading-related prompts accurately as shown below.
By mastering JSON parsing in this article, we ensure that future AI-driven programs can process complex data structures, paving the way for sophisticated trading strategies that combine price action, chart patterns, and AI-generated insights. Let’s proceed to the implementation!
To implement the integration, we will first create a comprehensive parsing class that we will use for our first prompts and future applications. Here is how we achieve that.
We begin the implementation of the JSON parsing framework, focusing on the foundational “JsonValue” class to handle JSON data for AI API integration. First, we define a macro “DEBUG_PRINT” set to false to control debugging output, ensuring minimal logging during production. Then, we establish an enumeration “JsonValueType” with values (JsonUndefined, JsonNull, JsonBoolean, JsonInteger, JsonDouble, JsonString, JsonArray, JsonObject) to categorize JSON data types, enabling the class to handle diverse structures like those returned by APIs.
Next, we implement the “JsonValue” class with public members: an array “m_children” for nested JSON elements, strings “m_key” and “m_temporaryKey” for key storage during parsing, a pointer “m_parent” for hierarchical relationships, a “JsonValueType” variable “m_type” for the data type, and variables “m_booleanValue”, “m_integerValue”, “m_doubleValue”, and “m_stringValue” for storing respective data, plus a static “encodingCodePage” for character encoding. We provide multiple constructors to initialize “JsonValue” objects: a default constructor calling “Reset”, one with parent and type, one with type and string value, and others for integer, long, double, boolean, and copy construction, ensuring flexibility in creating JSON elements.
The “Reset” method clears all members to default values (e.g., null parent, empty strings, undefined type, zeroed values, and empty children array), while “CopyFrom”, “CopyDataFrom”, and “CopyChildrenFrom” methods facilitate deep copying of JSON structures, including children, with proper parent reassignment. This foundational implementation sets up the structure for parsing and manipulating JSON data, critical for future AI API interactions. We can then proceed to implement some pure virtual function of the class, still under a public access specifier for completeness. We use virtual to make the system flexible and polymorphic.
Still under the public access specifier, we implement the “IsNumericValue” method, which checks if the JSON value is a number by returning true if “m_type” is “JsonDouble” or “JsonInteger”, enabling type-specific handling for numeric data. Then, we develop the “FindChildByKey” method, which iterates backward through the “m_children” array to locate a child with a matching key, returning a pointer to it or NULL if not found, facilitating access to nested JSON objects.
Next, we define overloaded assignment operators (“operator=”) for “JsonValue”, integer, long, double, boolean, and string types, updating “m_type” and corresponding value fields (“m_integerValue”, “m_doubleValue”, “m_stringValue”, “m_booleanValue”) while ensuring type consistency, such as converting integers to doubles and strings for unified storage. We also implement comparison operators (“operator==” and “operator!=”) for integer, long, double, boolean, and string types, allowing direct value comparisons with the respective fields.
Additionally, we provide conversion methods “ToInteger”, “ToDouble”, “ToBoolean”, and “ToString” to retrieve values in their respective formats. The “SetFromString” method sets the JSON value based on the specified “JsonValueType”, handling boolean, integer, double, and string types by converting the input string and updating related fields, with string values unescaped via “UnescapeString”. The “GetSubstringFromArray” method extracts a substring from a character array, copying a specified portion and converting it to a string using “CharArrayToString” with the defined “encodingCodePage”.
Finally, we implement methods to manage child elements: “AddChild” (for “JsonValue”, integer, long, double, boolean, string) adds a new child to “m_children”, setting the parent and type as needed; “CreateNewChild” and “CreateNewChildInternal” create an empty child; and “SetValue” copies data from another “JsonValue”, ensuring the class can construct, manipulate, and access JSON structures. Finally, we can conclude the class by including methods to serialize, deserialize, and encode characters from responses and prompts.
Here, we implement the “SerializeToString” method with parameters for a string reference, “includeKey”, and “includeComma”, which converts the JSON structure into a string; it adds a comma if “includeComma” is true, includes the key if “includeKey” is true, and handles different types (“JsonNull” as “null”, “JsonBoolean” as “true” or “false”, “JsonInteger” and “JsonDouble” via string conversion, “JsonString” with escaped values, “JsonArray” with bracketed child elements, and “JsonObject” with keyed child elements), recursively serializing children for nested structures. A convenience overload of “SerializeToString” creates a string, calls the parameterized version, and returns the result.
Next, we implement “DeserializeFromString”, which takes a JSON string and encoding (default CP_ACP), resets the object, sets “encodingCodePage”, converts the string to a character array using StringToCharArray, and delegates to “DeserializeFromArray”. The “DeserializeFromArray” overload with encoding initializes the index, resets the object, sets “encodingCodePage”, and calls the main “DeserializeFromArray” method, which parses a character array by iterating through characters, handling whitespace, arrays (“[” to “]”), objects (“{” to “}”), booleans (“true” or “false”), null (“null”), numbers (detecting integers or doubles via valid characters), and strings (with escape handling), creating child elements as needed and managing hierarchy with “m_parent” and “m_temporaryKey”.
Finally, “ExtractStringFromArray” parses strings within the array, handling escaped characters (e.g., “n”, “t”, Unicode “uXXXX”) until a closing quote, just in case we decide to use Unicode characters like emojis, ensuring accurate string extraction. Here is how they look like.
We can now define this methods so they do their intended work accurately.
To define the class methods outside the body, we use the scope resolution operator. We could define them inside, but this way makes the code modular. We initialize the static member “encodingCodePage” to CP_ACP (Active Code Page) to define the default character encoding for string conversions, ensuring compatibility with JSON data from AI APIs. Then, we implement the “HasChildWithKey” method, which iterates forward through the “m_children” array to find a child with a matching key and, optionally, a specific “JsonValueType” (defaulting to “JsonUndefined” to ignore type), returning a pointer to the matching child or NULL if not found, improving efficiency over “FindChildByKey” by breaking early and allowing type-specific checks.
Next, we develop the overloaded “operator” method, which sets “m_type” to “JsonObject” if undefined, searches for a child with the given key using “FindChildByKey”, and, if not found, creates a new “JsonValue” with the key and adds it to “m_children” via “AddChild”, returning a pointer to the existing or new child for seamless object access. Similarly, the “operator” method sets “m_type” to “JsonArray” if undefined, expands the “m_children” array with undefined elements if the index exceeds its size using “AddChild”, and returns a pointer to the element at the specified index, ensuring safe array access.
Last, we implement “SetArrayValues”, which sets “m_type” to “JsonArray” if undefined, resizes “m_children” to match the input list size, copies each “JsonValue” from the list to “m_children”, and sets the parent of each child to the current object, enabling bulk assignment of array values. For the other methods, we will use a similar format. Let us start with methods to serialize and deserialize strings.
We continue the implementation of the parsing framework, focusing on the critical serialization and deserialization methods.
First, we define the “SerializeToString” method, which converts a JSON structure into a string; it skips undefined types, adds a comma if “includeComma” is true, appends the key if “includeKey” is true using StringFormat, and handles each “m_type” case: “JsonNull” appends “null”, “JsonBoolean” appends “true” or “false” based on “m_booleanValue”, “JsonInteger” uses IntegerToString for “m_integerValue”, “JsonDouble” uses DoubleToString for “m_doubleValue”, “JsonString” escapes “m_stringValue” with “EscapeString” and wraps it in quotes (or “null” if empty), “JsonArray” wraps children in brackets with recursive calls to “SerializeToString” (without keys, adding commas for non-first elements), and “JsonObject” wraps children in braces with keys included. A convenience overload of “SerializeToString” creates a string, calls the parameterized version with default arguments, and returns the result.
Next, we implement “DeserializeFromArray”, which parses a character array to construct a JSON structure, using a string of valid numeric characters (“0123456789+-.eE”) and iterating through the array; it skips whitespace, handles arrays (“[“) by setting “m_type” to “JsonArray” and recursively deserializing children until a closing bracket, validates array closure, processes key-value separators (“:”) by assigning “m_temporaryKey” to a new child, handles value separators (“,”), processes objects (“{“) by setting “m_type” to “JsonObject” and deserializing children until a closing brace, validates object closure, parses booleans (“true” or “false”) by setting “m_booleanValue”, parses null (“null”) by setting “m_type” to “JsonNull”, parses numbers by detecting decimal or exponential notation to set “m_type” to “JsonDouble” or “JsonInteger”, and parses strings (quoted) by using “ExtractStringFromArray” to handle escaped characters.
The “DeserializeFromArray” method ensures proper parent-child relationships and error handling via “DEBUG_PRINT” logs for invalid structures, making it robust for parsing responses. Finally, we can define the escape methods.
We finalize the implementation by focusing on the string handling methods. First, we implement the “ExtractStringFromArray” method, which parses a string from a character array by iterating until a closing quote or array end, handling escape sequences (e.g., “”, “””, “/”, “b”, “f”, “n”, “r”, “t”) and Unicode escapes (“uXXXX”) by validating four hexadecimal digits, returning false on invalid hex or bounds errors, and using “DEBUG_PRINT” for debugging invalid cases, ensuring accurate string extraction for JSON parsing.
Then, we develop the “EscapeString” method, which converts a string to its JSON-compliant form by transforming it into a short array with StringToShortArray, resizing an output array to twice the input length to accommodate escapes, and iterating through each character to handle special cases: backslash, quote, slash, backspace (8), form feed (12), newline, carriage return, and tab are escaped with a preceding backslash (e.g., “n” for newline), while other characters are copied directly, returning the escaped string via the ShortArrayToString function.
Last, we implement the “UnescapeString” method, which reverses the escaping process by converting the input string to a short array, resizing an output array to the input length, and iterating to process escape sequences: when a backslash is encountered, the next character is interpreted (e.g., “n” to newline, “t” to tab), copying the unescaped character to the output, while non-escaped characters are copied directly, returning the unescaped string via “ShortArrayToString” or NULL on resize failure. These methods ensure the “JsonValue” class can handle special characters in JSON strings, critical for correctly formatting API requests and parsing AI responses in a robust and reliable manner. Here is an example of the usage of special characters that will be interpreted correctly for easier communication and seamless understanding.
With the class implementation done, we are now all okay to start using the parsing logic. But let us first test the parser and make sure everything is okay. We will do that in the next section below.
To ensure the reliability of our JSON parsing framework, we rigorously test the “JsonValue” class in MQL5 to verify its ability to handle various JSON structures critical for AI API integration. Below, we outline the testing approach, including test cases, expected outcomes, and methods to validate the parser’s functionality in a trading environment. We will be defining a code function and calling it in the OnInit event handler, printing the contents. Here is the first code. We will use the same file. Let’s first print “Hello world”, as in the case of a start-up.
We create a “TestBasicSerialization” function and create a “JsonValue” object named “root” and assign values using “operator[]”: “string” to “hello world”, “number” to 42, “double” to 3.14159, “boolean” to true, and “empty” to an empty string, covering key JSON data types (JsonString, JsonInteger, JsonDouble, JsonBoolean). Then, we call “SerializeToString” on “root” to generate a JSON string, store it in “json”, and print it to the MetaTrader 5 terminal with Print for verification.
Next, we create a new “JsonValue” object named “parsed” and call “DeserializeFromString” with the “json” string to reconstruct the JSON structure, checking if it returns true to confirm success; if successful, we print “Deserialization successful” and use “ToString”, “ToInteger” (cast to int), “ToDouble”, and “ToBoolean” to retrieve and print the values of “string”, “number”, “double”, “boolean”, and “empty” via “operator[]”; if it fails, we print “Deserialization failed!”. Last, in OnInit, we call “TestBasicSerialization” to execute the test upon program initialization and return “INIT_SUCCEEDED” to indicate successful setup. Here is the output we get.
From the image, we can see basic serialization is successful. Let us now test basic deserialization and see.
That was a success too. Let us now increase the complexity gauge and see.
Let us now test performance, nested structures, and data types.
That was a success. Let us test the escape characters now.
That was a success. Since we have confirmed that our JSON implementation is usable, we can now use it to create AI integrations in future programs that we will be creating.
In conclusion, we’ve developed a JSON (JavaScript Object Notation) parsing framework in MQL5, implementing a “JsonValue” class to handle serialization and deserialization of JSON data critical for API (Application Programming Interface) interactions. Through methods like “SerializeToString”, “DeserializeFromArray”, and “EscapeString”, and testing via functions like “TestBasicSerialization”, we ensure reliable processing of diverse JSON structures, laying a solid foundation for future AI-driven trading systems. In the subsequent parts, we will be integrating and interacting with the AIs in our trading applications. Keep tuned.
