ESP8266: Parsing JSON

The objective of this post is to explain how to parse JSON data using the ArduinoJson library.


In this post, we will create a simple program to parse a JSON string simulating data from a sensor and print it to the serial port. We assume that the ESP8266 libraries for the Arduino IDE were previously installed. You can check how to do it here.

In order to avoid having to manually decode the string into usable values, we will use the ArduinoJson library, which provides easy to use classes and methods to parse JSON. The GitHub page of the library can be consulted here.

This very useful library allows both encoding and decoding of JSON, is very efficient and works on the ESP8266.

It can be obtained via library manager of the Arduino IDE, as shown in figure 1.

ArduinoJSON library

Figure 1 – Installation via Arduino IDE library manager.


First of all, we will include the library that implements the parsing functionality.

#include "ArduinoJson.h"

Since this library has some tricks to avoid problems while using it, this post will just show how to parse a locally created string, and thus we will not use WiFi functions. So, we will just start a Serial connection in the setup function.

void setup() {

  Serial.println();  //Clear some garbage that may be printed to the serial console


Main loop

On our main loop function, we will declare our JSON message, that will be parsed. The \ characters are used to escape the double quotes on the string, since JSON names require double quotes [1].

char JSONMessage[] ="{\"SensorType\":\"Temperature\", \"Value\": 10}";

This simple structure consists on 2 name/value pairs, corresponding to a sensor type and a value for that sensor. For the sake of readability, the structure is shown bellow without escaping characters.

"SensorType" : "Temperature",
"Value" : 10

Important: The JSON parser modifies the string [2] and thus its content can’t be reused. That’s the reason why we declare the string inside the main loop and not as a global variable, even though its content is always the same in this program. This way, the variable is local and when the main loop function returns, it is freed and a new variable is allocated again in the next call to the loop function. Check here some definitions about variable scopes.

Then, we need to declare an object of class StaticJsonBuffer. It will correspond to a pre-allocated memory pool to store the object tree and its size is specified in a template parameter (the value between <> bellow), in bytes [3].

StaticJsonBuffer&lt;300&gt; JSONBuffer;

In this case, we declared a size of 300 bytes, which is more than enough for the string we want to parse. The author of the library specifies here two approaches on how to determine the buffer size. Personally, I prefer to declare a buffer that has enough size for the expected message payload and check for errors in the parsing step.

The library also supports dynamic memory allocation but that approach is discouraged [4]. Here we can check the differences between static and dynamic JsonBuffer.

Next, we call the parseObject method on the StaticJsonBuffer object, passing the JSON string as argument. This method will return a reference to an object of class JsonObject [5]. You can check here the difference between a pointer and a reference.

JsonObject&amp;  parsed= JSONBuffer.parseObject(JSONMessage);

To check if the JSON was successfully parsed, we can call the success method on the JsonObject instance [6].

if (!parser.success()) {

  Serial.println("Parsing failed");


After that, we can use the subscript operator to obtain the parsed values by their names [7]. Check here some information about the subscript operator. In other words, this means that we use square brackets and the the names of the parameters to obtain their values, as shown bellow.

const char * sensorType = parsed["SensorType"];
int value = parsed["Value"];

The whole main function is shown bellow. We included some extra prints to separate each iteration of the loop function and to show how the original string is modified when parsed. We need to print it char by char because the parser introduces \0 characters and thus, if we used Serial.println(JSONMessage), we would just see the content until the first \0 character.

void loop() {


  char JSONMessage[] = " {\"SensorType\": \"Temperature\", \"Value\": 10}"; //Original message
  Serial.print("Initial string value: ");

  StaticJsonBuffer&lt;300&gt; JSONBuffer;   //Memory pool
  JsonObject&amp; parsed = JSONBuffer.parseObject(JSONMessage); //Parse message

  if (!parsed.success()) {   //Check for errors in parsing

    Serial.println("Parsing failed");


  const char * sensorType = parsed["SensorType"]; //Get sensor type value
  int value = parsed["Value"];                                         //Get value of sensor measurement


  Serial.print("Final string value: ");

  for (int i = 0; i &lt; 31; i++) { //Print the modified string, after parsing





Testing the code

To test the code, simply compile it and upload it to your ESP8266. After that, open the Arduino IDE serial monitor. Figure 2 illustrates the result printed to the serial monitor.

ESP8266 JSON Parsing

Figure 2 – Output of the program in the Arduino IDE serial console.

As seen by the previous explanation, this library has some particularities that we need to take in consideration when using it, to avoid unexpected problems. Fortunately, the GitHub page of this library is very well documented, and thus here is a section describing how to avoid pitfalls.

Also, I strongly encourage you to check the example programs that come with the installation of the library, which are very good for understanding how it works.

Final notes

This post shows how easily is to parse JSON in the ESP8266. Naturally, this allows to change data in a well known structured format that can be easily interpreted by other applications, without the need for implementing a specific protocol.

Since microcontrollers and IoT devices have many resource constraints, JSON poses much less overhead than, for example, XML, and thus is a very good choice.

Nevertheless, we need to keep in mind that for some intensive applications, even JSON can pose an overhead that is not acceptable, and thus we may need to go to byte oriented protocols. But, for simple applications, such as reading data from a sensor and sending it to a remote server or receiving a set of configurations, JSON is a very good alternative.









Technical details

  • ESP8266 libraries: v2.3.0.
  • ArduinoJson library: v5.1.1.

18 Replies to “ESP8266: Parsing JSON”

    1. Basically, you need to make your ESP8266 listen to incoming HTTP requests. To do so, check the ESP8266WebServer implementation in the github page of the libraries:

      You can then parse the content of the http request received in the ESP and use its values to control the RGB LED.

      From the ESP8266 perspective, it won’t matter if the request was sent from Android or a web browser.

  1. Hi! Thank you very much for the feedback, I’m glad you are finding these tutorials easy to understand 🙂

    Let me see if I can help. So, if you have followed the tutorial, you should already be able to get the response from the website in the format you mention, right? It should be being stored as a string named payload.

    I think that something like shown bellow should suffice for you to get the parsed values. That excerpt of code lacks initializations and error checking, but it has the parsing part from the received response taking in consideration the code from the HTTP GET tutorial.

    I haven’t been able to test it but I think it shoud work fine.
    Just as a note, your ID is being sent as a string rather than an integer in the JSON structure, and that’s why I’m obtaining it as a string rather than as an integer.

    if (httpCode > 0) { //Check the returning code
          String payload = http.getString();   //Get the request response payload
         StaticJsonBuffer<300> JSONBuffer;   //Memory pool
         JsonObject& parsed = JSONBuffer.parseObject(payload); 
        const char * error_code = parsed["error_code"];
        const char * id = parsed["id"]; 

    Let me know if it helps.

    Best regards,
    Nuno Santos

  2. Hi, Great Post I must say!!
    I am actually facing some problem using ArduinoJson.h
    I am unable to run the predefined examples or any other custom examples.
    I am actually getting the same error every time
    collect2.exe : error ld returned 1 exit status
    and something undefined reference to ‘__cxa_guard_release’ on FloatTraits.hpp file
    Can you please help ???

    1. Hi! Thank you very much for the feedback 🙂

      I never ran into that issue during my tests with the library, so unfortunately I cannot give much help with it.

      My suggestion is that you create an issue on the library GitHub page, since it is more likely that the author can give an help with your problem:

      Let us know if you found a solution, so it may help other readers.

      Best regards,
      Nuno Santos

  3. First, thank you so much for this tutorial, but i got this problem..
    I’m using nodemcu v3 and connect to my sites, and i used this command :
    client.print(String(“GET “) + url + ” HTTP/1.1\r\n” +
    “Host: ” + host + “\r\n” +
    “Connection: close\r\n\r\n”);

    And got data from my serial like this :

    HTTP/1.1 200 OK
    Date: Fri, 06 Oct 2017 08:18:41 GMT
    Content-Type: application/json
    Content-Length: 47
    Connection: close
    Last-Modified: Sun, 24 Sep 2017 05:35:32 GMT
    Accept-Ranges: bytes
    Server: awex
    X-Xss-Protection: 1; mode=block
    X-Content-Type-Options: nosniff
    X-Request-ID: 134dcf4b10038706b4dbc3ccdcfea12e

    closing connection
    how i just parsing my json only? i succeed parsing using subString, but those header always changes and i must changed subString every i don’t get any data…. how to parsing just JSON data for easier?

    1. Hi! Thanks 🙂 Well it seems like you are using sockets to build your HTTP request. If doing so, it will be difficult to parse the result because, as you mentioned, the header changes.

      My recommendation is that you use the ESP8266 HTTP Client API to make the GET requests:

      It gives you access to the payload by calling a simple function, which you can then parse if it is JSON.

      Hope it helps.

      Best regards,
      Nuno Santos

  4. Hi, First of all. Thanks for this very good description.

    One thing. Isn’t there a typo? pleas correct me if I understand something wrong.

    if (!parser.success()) { // <– should be parsed with d

    Serial.println("Parsing failed");


    1. Hi!

      You’re welcome, thanks for the feedback 🙂

      Where did you find the typo? There it is just handling the case when the parsing procedure fails 🙂

      Best regards,
      Nuno Santos

Leave a Reply