ESP32: Getting Started with Firebase (Realtime Database)

This guide will get you started quickly with Firebase using the ESP32 board. Firebase is Google’s mobile application development platform that includes many services to manage data from IOS, Android, or web applications. You’ll create a Firebase project with a realtime database (RTDB), and you’ll learn how to store and read values from the database with your ESP32.

Updated April 21, 2025

In a later tutorial, you’ll learn how to create a Firebase web app that you can access from anywhere to monitor and control your ESP32 using firebase’s realtime database:

• ESP32 with Firebase – Creating a Web App

We have a similar tutorial for the ESP8266 board: Getting Started with Firebase (Realtime Database)

What is Firebase?

Firebase is Google’s mobile application development platform that helps you build, improve, and grow your app. It has many services used to manage data from any android, IOS, or web application.

The following paragraph clearly explains the advantages of using Firebase:

“Firebase is a toolset to “build, improve, and grow your app”, and the tools it gives you cover a large portion of the services that developers would normally have to build themselves but don’t really want to build because they’d rather be focusing on the app experience itself. This includes things like analytics, authentication, databases, configuration, file storage, push messaging, and the list goes on. The services are hosted in the cloud and scale with little to no effort on the part of the developer.”

This paragraph was taken from this article, and we recommend that you read it if you want to better understand what Firebase is and what it allows you to do.

You can use the ESP32 to connect and interact with your Firebase project, and you can create applications to control the ESP32 via Firebase from anywhere in the world.

In this tutorial, we’ll create a Firebase project with a Realtime Database and use the ESP32 to store and retrieve data. Once connected to the internet, the ESP32 can access the database from anywhere in the world.

You can have two ESP32 boards in different networks, with one board storing data and the other board reading the most recent data, for example.

In a later tutorial, we’ll create a web app using Firebase that will control the ESP32 to display sensor readings or control outputs from anywhere in the world.

Project Overview

In this tutorial, you’ll learn how to create a Firebase project with a realtime database and store and read data from the database using the ESP32.

To follow this project, first, you need to set up a Firebase project and create a realtime database for that project. Then, you’ll program the ESP32 to store and read data from the database. This tutorial is divided into three sections.

1. Create a Firebase Project
2. ESP32: Store data to the Firebase Realtime Database
3. ESP32: Read data from the Firebase Realtime Database

Let’s get started!

Set Up a Firebase Account and Create a New Project

1.Create a New Project

Follow the next instructions to create a new project on Firebase.

1. Go to Firebase and sign in using a Google Account.
2. Go to the Firebase Console and create a new project.
3. Give a name to your project, for example: ESP-Project, and click Continue.
   
4. Next, enable or disable AI assistance for your project. This is optional.
   
5. Disable the option Enable Google Analytics for this project, as it is not needed. Then, click Create project.
   
6. It will take a few seconds to set up your project. Click Continue when it’s ready.
   
   
7. You’ll be redirected to your Project console page.
   

2. Set Authentication Methods

You need to set authentication methods for your app.

“Most apps need to know the identity of a user. In other words, it takes care of logging in and identifying the users (in this case, the ESP32). Knowing a user’s identity allows an app to securely save user data in the cloud …” To learn more about the authentication methods, you can read the documentation.

1. On the left sidebar, click on Build > Authentication and then on Get started.
   
2. There are several authentication methods like email and password, Google Account, Facebook account, and others.
3. Select Email/Password and enable that authentication method. Then, click Save.
4. Then, at the top, click on the Users tab. Then, click on Add user.
5. Create a new user with an email and password. The email can be your personal email. Create a password for that user (you need to remember the password later). Finally, click on Add user.
6. The User will show up on the list of users. You can see information about the user, like when it was created, the last time it signed in, and its user UID.

3. Creating a Realtime Database

Next, you need to create a Realtime Database for your project. Follow the next steps to create the database.

1. On the left sidebar click on Build > Realtime Database and then, click on Create Database.
   
2. Select your database location. It should be the closest to your location.
   
3. Set up security rules for your database. For testing purposes, select Start in test mode. In later tutorials, you’ll learn how to secure your database using database rules.
   
4. Your database is now created. You need to copy and save the database URL—highlighted in the following image—because you’ll need it later in your ESP32 code.
   

The Realtime Database is all set. Now, you also need to get your project API key.

4. Get Project API Key

1. To get your project’s API key, on the left sidebar click on Project Settings.
   
2. Copy the API Key to a safe place because you’ll need it later.
   

Now, you have everything ready to interface the ESP32 with the database.

Program the ESP32 to Interface with Firebase

Now that the Firebase Realtime Database is created, you’ll learn how to interface the ESP32 with the database.

To program the ESP32, you can use Arduino IDE, VS Code with the PlatformIO extension or pioarduino, or other suitable software.

Note: For Firebase projects, we recommend using VS Code with the PlatformIO or pioarduino extension. If you plan to develop a web application to connect the ESP32 with Firebase, VS Code offers all the tools you need. However, since we won’t be building a web application in this tutorial, you can simply use the Arduino IDE, if you prefer.

Installing the FirebaseClient Library

There is a library with lots of examples to use Firebase with the ESP32: the FirebaseClient library. This library is compatible with the ESP32, ESP8266, and many other boards.

In this tutorial, we’ll look at simple examples to store and read data from the database. The library provides many other examples that you can check here. It also provides detailed documentation explaining how to use the library.

Installation – VS Code + PlatformIO

If you’re using VS Code with the PlatformIO extension, click on the PIO Home icon and then select the Libraries tab. Search for “FirebaseClient“. Select the Firebase Client Library by Mobitz.

Then, click Add to Project and select the project you’re working on.

Also, change the monitor speed to 115200 by adding the following line to the platformio.ini file of your project:

monitor_speed = 115200

Installation – Arduino IDE

If you’re using Arduino IDE, follow the next steps to install the library.

1. Go to Sketch > Include Library > Manage Libraries
2. Search for FirebaseClient and install the FirebaseClient by Mobitz. We’re using version 2.0.3.

Now, you’re all set to start programming the ESP32 board to interact with the database.

ESP32 Store Data to Firebase Database

Copy the following code to your Arduino IDE. This sketch inserts an int, a float number, and a string into the database every 10 seconds. This is a simple example that shows how to connect the ESP32 to the database to store data.

/*********
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete instructions at https://RandomNerdTutorials.com/esp32-firebase-realtime-database/
*********/
#define ENABLE_USER_AUTH
#define ENABLE_DATABASE

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>

// Network and Firebase credentials
#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

#define Web_API_KEY "REPLACE_WITH_YOUR_FIREBASE_PROJECT_API_KEY"
#define DATABASE_URL "REPLACE_WITH_YOUR_FIREBASE_DATABASE_URL"
#define USER_EMAIL "REPLACE_WITH_FIREBASE_PROJECT_EMAIL_USER"
#define USER_PASS "REPLACE_WITH_FIREBASE_PROJECT_USER_PASS"

// User function
void processData(AsyncResult &aResult);

// Authentication
UserAuth user_auth(Web_API_KEY, USER_EMAIL, USER_PASS);

// Firebase components
FirebaseApp app;
WiFiClientSecure ssl_client;
using AsyncClient = AsyncClientClass;
AsyncClient aClient(ssl_client);
RealtimeDatabase Database;

// Timer variables for sending data every 10 seconds
unsigned long lastSendTime = 0;
const unsigned long sendInterval = 10000; // 10 seconds in milliseconds

// Variables to send to the database
int intValue = 0;
float floatValue = 0.01;
String stringValue = "";

void setup(){
  Serial.begin(115200);

  // Connect to Wi-Fi
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(300);
  }
  Serial.println();
  
  // Configure SSL client
  ssl_client.setInsecure();
  ssl_client.setConnectionTimeout(1000);
  ssl_client.setHandshakeTimeout(5);
  
  // Initialize Firebase
  initializeApp(aClient, app, getAuth(user_auth), processData, "🔐 authTask");
  app.getApp<RealtimeDatabase>(Database);
  Database.url(DATABASE_URL);
}

void loop(){
  // Maintain authentication and async tasks
  app.loop();
  // Check if authentication is ready
  if (app.ready()){ 
    // Periodic data sending every 10 seconds
    unsigned long currentTime = millis();
    if (currentTime - lastSendTime >= sendInterval){
      // Update the last send time
      lastSendTime = currentTime;
      
      // send a string
      stringValue = "value_" + String(currentTime);
      Database.set<String>(aClient, "/test/string", stringValue, processData, "RTDB_Send_String");
      // send an int
      Database.set<int>(aClient, "/test/int", intValue, processData, "RTDB_Send_Int");
      intValue++; //increment intValue in every loop

      // send a string
      floatValue = 0.01 + random (0,100);
      Database.set<float>(aClient, "/test/float", floatValue, processData, "RTDB_Send_Float");
    }
  }
}

void processData(AsyncResult &aResult) {
  if (!aResult.isResult())
    return;

  if (aResult.isEvent())
    Firebase.printf("Event task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.eventLog().message().c_str(), aResult.eventLog().code());

  if (aResult.isDebug())
    Firebase.printf("Debug task: %s, msg: %s\n", aResult.uid().c_str(), aResult.debug().c_str());

  if (aResult.isError())
    Firebase.printf("Error task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.error().message().c_str(), aResult.error().code());

  if (aResult.available())
    Firebase.printf("task: %s, payload: %s\n", aResult.uid().c_str(), aResult.c_str());
}

View raw code

You need to insert your network credentials, URL database, project API key, firebase user email and password.

This sketch was based on this basic example provided by the library. You can find more examples here.

How the Code Works

Continue reading to learn how the code works, or skip to the demonstration section.

Including Libraries

First, include the required libraries. The WiFi.h library to connect the ESP32 to the internet, the WiFiClientSecure to create a wi-fi client, and the FirebaseClient.h library to interface the ESP32 with Firebase.

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>

Defining Credentials

Include your network credentials in the following lines.

#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

Insert your Firebase project API key—the one you’ve gotten in section 4.1.

#define Web_API_KEY "REPLACE_WITH_YOUR_FIREBASE_PROJECT_API_KEY"

Insert your database URL—see section 3.4.

#define DATABASE_URL "REPLACE_WITH_YOUR_FIREBASE_DATABASE_URL"

Set the Firebase email user and corresponding password. The ones you set up in section 2.

#define USER_EMAIL "REPLACE_WITH_FIREBASE_PROJECT_EMAIL_USER"
#define USER_PASS "REPLACE_WITH_FIREBASE_PROJECT_USER_PASS"

Declaring Firebase Authentication and Components

The following line creates an authentication object using the project API key, the project user email, and password.

UserAuth user_auth(Web_API_KEY, USER_EMAIL, USER_PASS);

This creates a FirebaseApp instance called app that refers to the Firebase application.

FirebaseApp app;

The following lines set up the asynchronous communication framework for interacting with Firebase’s Realtime Database. Basically, you create an SSL client using the WiFiClientSecure library. Then, you instantiate an Asynchronous client called aClient that enables secure HTTPS. This will allow you to handle network operations asynchronously.

WiFiClientSecure ssl_client;
using AsyncClient = AsyncClientClass;
AsyncClient aClient(ssl_client);

The following line creates a RealtimeDatabase object called Database, that represents the Firebase Realtime Database.

RealtimeDatabase Database;

Timer and Data Variables

Then create variables to track the time and save the data to be sent to the database.

unsigned long lastSendTime = 0;
const unsigned long sendInterval = 10000; // 10 seconds in milliseconds
int intValue = 0;
float floatValue = 0.01;
String stringValue = "";

setup()

In the setup(), initialize the Serial Monitor and connect the board to your Wi-Fi network.

void setup(){
  Serial.begin(115200);
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)    {
    Serial.print(".");
    delay(300);
  }
  Serial.println();

Configure the SSL Client.

ssl_client.setInsecure();
ssl_client.setConnectionTimeout(1000);
ssl_client.setHandshakeTimeout(5);

The following line initializes the Firebase app with authentication and sets the processData() as the callback function for async results (this means that any results from the initializeApp() function will be handled on the processData() callback function).

initializeApp(aClient, app, getAuth(user_auth), processData, "🔐 authTask");

Then, tell that you want to set the Database object defined earlier as a database for our Firebase app.

app.getApp<RealtimeDatabase>(Database);

Finally, set the database URL.

Database.url(DATABASE_URL);

loop()

The Firebase library we’re using works asynchronously and with callback functions. This means that when an event happens, the corresponding assigned callback functions will run. To keep the Firebase app running, handling authentication and asynchronous tasks, we need to add app.loop() at the start of our loop() function.

void loop(){
  app.loop();

The app.ready() command checks if Firebase authentication is complete and ready, so that we can proceed with other Firebase operations (like writing to the database).

if (app.ready()){

The following lines check if 10 seconds (sendInterval) have passed. We’ll use this to send data periodically every 10 seconds.

unsigned long currentTime = millis();
if (currentTime - lastSendTime >= sendInterval){
  lastSendTime = currentTime;

Send Data to the Database

Next in the loop(), we send our data. We’re sending three different variable types. Sending other types is the same. You just need to specify the type on the set() function as we’ll explain.

The FirebaseClient library supports different methods to send data to the Real Time Database. In this example, we’re using an asynchronous approach with a callback function.

To send data to the database we use Database.set(). This is templated to support different data types. Here’s the general syntax and the arguments:

Database.set<T>(AsyncClient &client, const String &path, T value, AsyncResultCallback callback, const String &uid);

Let’s break down how it works:

• <T> refers to the data type. In the code, it’s used as Database.set<String>, Database.set<int> and Database.set<float>. You can use other data types.

• AsyncClient &client: this is the asynchronous client object (aClient in the code) that manages the network connection to Firebase.

• const String &path: specifies the path in the Firebase Realtime Database where the data will be written. The path is relative to the database root (defined by DATABASE_URL). For example: “test/string”.

• T value: the value to be written to the specified path.

• AsyncResultCallback callback: a function pointer to the callback that handles the result of the asynchronous operation. In the code, this is the processData() function. It processes the AsyncResult object to log events, errors, debug messages, or successful payloads. The callback is called when the Firebase server responds or if an error occurs during the request.

• const String &uid: a unique identifier for the task, used to track the specific operation in the callback. This helps differentiate between multiple asynchronous tasks in the processData() function.

For example, the following lines send a string to the database.

stringValue = "value_" + String(currentTime);
Database.set<String>(aClient, "/test/string", stringValue, processData, "RTDB_Send_String");

• Client: aClient (manages the HTTPS connection).
• Path: “/test/string”.
• Value: stringValue variable that contains a String.
• Callback: processData (handles the result).
• UID: “RTDB_Send_String” (identifies this task in logs).

Sending an integer and a float is similar.

// send an int
Database.set<int>(aClient, "/test/int", intValue, processData, "RTDB_Send_Int");
intValue++; //increment intValue in every loop

// send a string
floatValue = 0.01 + random (0,100);
Database.set<float>(aClient, "/test/float", floatValue, processData, "RTDB_Send_Float");

Process the Async Results

Finally, the processData() function logs the results of the asynchronous Firebase operations.

void processData(AsyncResult &aResult) {
  if (!aResult.isResult())
    return;

  if (aResult.isEvent())
    Firebase.printf("Event task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.eventLog().message().c_str(), aResult.eventLog().code());

  if (aResult.isDebug())
    Firebase.printf("Debug task: %s, msg: %s\n", aResult.uid().c_str(), aResult.debug().c_str());

  if (aResult.isError())
    Firebase.printf("Error task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.error().message().c_str(), aResult.error().code());

  if (aResult.available())
    Firebase.printf("task: %s, payload: %s\n", aResult.uid().c_str(), aResult.c_str());
}

Demonstration

Upload the code to your ESP32 board. Don’t forget to insert your network credentials, database URL path, the project API key, and the Firebase project user email and password.

After uploading the code, open the Serial Monitor at a baud rate of 115200 and press the ESP32 on-board reset button so it starts running the code.

If everything works as expected, the values should be stored in the database, and you should get success messages.

Go to your project’s Firebase Realtime database, and you’ll see the values saved on the different node paths. Every 10 seconds, it saves a new value. The database blinks when new values are saved.

Congratulations! You’ve successfully stored data in Firebase’s Realtime Database using the ESP32. In the next section, you’ll learn to read values from the different database node paths.

ESP32 Read From Firebase Database

In this section, you’ll learn how to read data from the database. We’ll read the data stored in the previous section. Remember that we saved an int value in the test/int path, a float value in the test/float and a String value in the test/string path.

There are different ways to get values from the database. We’ll show you how to do that synchronously and asynchronously.

ESP32 – Read From Firebase RTDB (Async Mode)

The following example reads the values stored in the database using an asynchronous method. Upload the following code to your board. You can use the same ESP32 board or another board to get the data posted by the previous ESP32.

/*********
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete instructions at https://RandomNerdTutorials.com/esp32-firebase-realtime-database/
*********/
#define ENABLE_USER_AUTH
#define ENABLE_DATABASE

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>

// Network and Firebase credentials
#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

#define Web_API_KEY "REPLACE_WITH_YOUR_FIREBASE_PROJECT_API_KEY"
#define DATABASE_URL "REPLACE_WITH_YOUR_FIREBASE_DATABASE_URL"
#define USER_EMAIL "REPLACE_WITH_FIREBASE_PROJECT_EMAIL_USER"
#define USER_PASS "REPLACE_WITH_FIREBASE_PROJECT_USER_PASS"

// User function
void processData(AsyncResult &aResult);

// Authentication
UserAuth user_auth(Web_API_KEY, USER_EMAIL, USER_PASS);

// Firebase components
FirebaseApp app;
WiFiClientSecure ssl_client;
using AsyncClient = AsyncClientClass;
AsyncClient aClient(ssl_client);
RealtimeDatabase Database;

// Timer variables for reading data every 10 seconds
unsigned long lastSendTime = 0;
const unsigned long sendInterval = 10000; // 10 seconds in milliseconds

// Variables to save values from the database
int intValue;
float floatValue;
String stringValue;

void setup(){
  Serial.begin(115200);

  // Connect to Wi-Fi
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)    {
    Serial.print(".");
    delay(300);
  }
  Serial.println();
  Serial.print("Connected with IP: ");
  Serial.println(WiFi.localIP());
  Serial.println();

  // Configure SSL client
  ssl_client.setInsecure();
  ssl_client.setConnectionTimeout(1000);
  ssl_client.setHandshakeTimeout(5);

  // Initialize Firebase
  initializeApp(aClient, app, getAuth(user_auth), processData, "🔐 authTask");
  app.getApp<RealtimeDatabase>(Database);
  Database.url(DATABASE_URL);
}

void loop(){
  // Maintain authentication and async tasks
  app.loop();

  // Check if authentication is ready
  if (app.ready()){
    // Getting data every 10 seconds
    unsigned long currentTime = millis();
    if (currentTime - lastSendTime >= sendInterval){
      // Update the last send time
      lastSendTime = currentTime;

      // GET VALUES FROM DATABASE (using the callback async method method)
      // you can then get the values on the processData function as soon as the results are available
      Database.get(aClient, "/test/int", processData, false, "RTDB_GetInt");
      Database.get(aClient, "/test/float", processData, false, "RTDB_GetFloat");
      Database.get(aClient, "/test/string", processData, false, "RTDB_GetString");

      Serial.println("Requested data from /test/int, /test/float, and /test/string");
    }
  }
}

void processData(AsyncResult &aResult){
  if (!aResult.isResult())
    return;

  if (aResult.isEvent())
    Firebase.printf("Event task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.eventLog().message().c_str(), aResult.eventLog().code());

  if (aResult.isDebug())
    Firebase.printf("Debug task: %s, msg: %s\n", aResult.uid().c_str(), aResult.debug().c_str());

  if (aResult.isError())
    Firebase.printf("Error task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.error().message().c_str(), aResult.error().code());

  // here you get the values from the database and save them in variables if you need to use them later
  if (aResult.available())    {
    // Log the task and payload
    Firebase.printf("task: %s, payload: %s\n", aResult.uid().c_str(), aResult.c_str());

    // Extract the payload as a String
    String payload = aResult.c_str();

    /// Handle int from /test/int
    if (aResult.uid() == "RTDB_GetInt"){
      // Extract the value as an int
      intValue = payload.toInt();
      Firebase.printf("Stored intValue: %d\n", intValue);
    }
    // Handle float from /test/float
    else if (aResult.uid() == "RTDB_GetFloat"){
      // Extract the value as a float
      floatValue = payload.toFloat();
      Firebase.printf("Stored floatValue: %.2f\n", floatValue);
    }
        
    // Handle String from /test/string
    else if (aResult.uid() == "RTDB_GetString"){
      // Extract the value as a String
      stringValue = payload;
      Firebase.printf("Stored stringValue: %s\n", stringValue.c_str());
    }
  }
}

View raw code

You need to insert your network credentials, URL database, project API key, firebase user email and password.

How the Code Works

The first sections of the code are quite similar to the previous example. It connects and authenticates to Firebase and sets up the database connection. Then, it gets the data from the database in async mode. The results of the operation (the values of the variables) are then handled in the callback function.

Getting Data from the Database

To get data, we need to know the exact path where it is located and its type (for later processing). We can get it using the get() method on the Database object as follows.

Database.get(AsyncClient &client, const String &path, AsyncResultCallback callback, bool queue, const String &uid);

Here’s how it works:

• AsyncClient &client: this is the asynchronous client object (aClient in the code) that manages the network connection to Firebase.

• const String &path: specifies the path in the Firebase Realtime Database where we’ll get the data. The path is relative to the database root (defined by DATABASE_URL). For example: “test/string”.

• AsyncResultCallback callback: a function pointer to the callback that handles the result of the asynchronous operation. In the code, this is the processData() function. In this example, it is where we’ll get the actual data from the database and save it in variables.

• bool queue: a boolean flag indicating whether the operation should be queued if the client is busy with another task. Set false for immediate execution, or true to queue the request. In more complex examples, it is a good idea to set it to true.

• const String &uid: a unique identifier for the task, used to track the specific operation in the callback. This helps differentiate between multiple asynchronous tasks in the processData() function.

As you can see, the get() function is quite similar to the set() function we’ve seen previously.

For example, in the following line, we set the operation to read from the database node /test/int. This operation will be handled on the task with the identifier RTDB_GetInt.

Database.get(aClient, "/test/int", processData, false, "RTDB_GetInt");

We proceed similarly to get values from the other node paths.

Database.get(aClient, "/test/float", processData, false, "RTDB_GetFloat");
Database.get(aClient, "/test/string", processData, false, "RTDB_GetString");

Saving the Data Into Variables

The result of the get() operation is then handled in the processData() function.

The following statement if (aResult.available()) verifies if the AsyncResult contains a successful result with data available for processing. If available() returns true, it means we have data to process—we successfully got data from the database.

if (aResult.available())  {
  // Log the task and payload
  Firebase.printf("task: %s, payload: %s\n", aResult.uid().c_str(), aResult.c_str());

We can get the data as follows:

String payload = aResult.c_str();

Then, with aResult.uid() we can check which operation occurred based on the task name and then save the data in the appropriate variable type.

/// Handle int from /test/int
if (aResult.uid() == "RTDB_GetInt"){
  // Extract the value as an int
  intValue = payload.toInt();
  Firebase.printf("Stored intValue: %d\n", intValue);
}
// Handle float from /test/float
else if (aResult.uid() == "RTDB_GetFloat"){
  // Extract the value as a float
  floatValue = payload.toFloat();
  Firebase.printf("Stored floatValue: %.2f\n", floatValue);
}
        
// Handle String from /test/string
else if (aResult.uid() == "RTDB_GetString"){
  // Extract the value as a String
  stringValue = payload;
  Firebase.printf("Stored stringValue: %s\n", stringValue.c_str());
}

Demonstration

Upload the code to your board. Then, open the Serial Monitor at a baud rate of 115200. After a few seconds, it will print the values saved in the database.

ESP32 – Read From Firebase RTDB (No Async Mode)

For simpler applications where you don’t need to queue tasks and blocking code is not critical while waiting for a database operation, you can use the get() function in a simplified format. This allows you to directly retrieve a value from the Firebase Realtime Database and immediately store it in a variable.

For example:

int intValue =  Database.get<int>(aClient, "/test/int");

The Database.get(aClient, “/test/int”) synchronously fetches an integer from the Firebase RTDB path /test/int using aClient, assigns it to intValue, and blocks execution until complete. This is ideal for simple applications where you don’t need multiple tasks, but this may delay other operations.

Here’s an example code using this method. It works exactly like the previous example. But for more complex applications, you should opt for the asynchronous method.

/*********
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete instructions at https://RandomNerdTutorials.com/esp32-firebase-realtime-database/
*********/

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>

// Network and Firebase credentials
#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

#define Web_API_KEY "REPLACE_WITH_YOUR_FIREBASE_PROJECT_API_KEY"
#define DATABASE_URL "REPLACE_WITH_YOUR_FIREBASE_DATABASE_URL"
#define USER_EMAIL "REPLACE_WITH_FIREBASE_PROJECT_EMAIL_USER"
#define USER_PASS "REPLACE_WITH_FIREBASE_PROJECT_USER_PASS"

// User function
void processData(AsyncResult &aResult);

// Authentication
UserAuth user_auth(Web_API_KEY, USER_EMAIL, USER_PASS);

// Firebase components
FirebaseApp app;
WiFiClientSecure ssl_client;
using AsyncClient = AsyncClientClass;
AsyncClient aClient(ssl_client);
RealtimeDatabase Database;

// Timer variables for sending data every 10 seconds
unsigned long lastSendTime = 0;
const unsigned long sendInterval = 10000; // 10 seconds in milliseconds

// Variables to save values from the database
int intValue;
float floatValue;
String stringValue;

void setup(){
  Serial.begin(115200);

  // Connect to Wi-Fi
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to Wi-Fi");
  while (WiFi.status() != WL_CONNECTED)    {
    Serial.print(".");
    delay(300);
  }
  Serial.println();
  Serial.print("Connected with IP: ");
  Serial.println(WiFi.localIP());
  Serial.println();

  // Configure SSL client
  ssl_client.setInsecure();
  ssl_client.setConnectionTimeout(1000);
  ssl_client.setHandshakeTimeout(5);

  // Initialize Firebase
  initializeApp(aClient, app, getAuth(user_auth), processData, "🔐 authTask");
  app.getApp<RealtimeDatabase>(Database);
  Database.url(DATABASE_URL);
}

void loop(){
  // Maintain authentication and async tasks
  app.loop();

  // Check if authentication is ready
  if (app.ready()){
    // Periodic data sending every 10 seconds
    unsigned long currentTime = millis();
    if (currentTime - lastSendTime >= sendInterval){
      // Update the last send time
      lastSendTime = currentTime;

      // GET VALUES FROM DATABASE (and save the data in a variable)
      int intValue =  Database.get<int>(aClient, "/test/int");
      check_and_print_value (intValue);

      float floatValue = Database.get<float>(aClient, "/test/float");
      check_and_print_value(floatValue);

      String stringValue = Database.get<String>(aClient, "/test/string");
      check_and_print_value(stringValue);

      Serial.println("Requested data from /test/int, /test/float, and /test/string");
    }
  }
}

template <typename T>
void check_and_print_value(T value){
  // To make sure that we actually get the result or error.
  if (aClient.lastError().code() == 0){
    Serial.print("Success, Value: ");
    Serial.println(value);
  }
  else {
    Firebase.printf("Error, msg: %s, code: %d\n", aClient.lastError().message().c_str(), aClient.lastError().code());
  }
}

void processData(AsyncResult &aResult){
  if (!aResult.isResult())
    return;

  if (aResult.isEvent())
    Firebase.printf("Event task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.eventLog().message().c_str(), aResult.eventLog().code());

  if (aResult.isDebug())
    Firebase.printf("Debug task: %s, msg: %s\n", aResult.uid().c_str(), aResult.debug().c_str());

  if (aResult.isError())
    Firebase.printf("Error task: %s, msg: %s, code: %d\n", aResult.uid().c_str(), aResult.error().message().c_str(), aResult.error().code());

  if (aResult.available()){
    // Log the task and payload
    Firebase.printf("task: %s, payload: %s\n", aResult.uid().c_str(), aResult.c_str());
  }
}