ESP32 Data Logging to Firebase Realtime Database

In this guide, you’ll learn how to log data with the ESP32 to the Firebase Realtime Database with timestamps (data logging) so that you have a record of your data history. As an example, we’ll log temperature, humidity, and pressure from a BME280 sensor and we’ll get timestamps from an NTP server. Then, you can access the data using the Firebase console, or build a web app to display the results (check this tutorial).

Updated 12 May 2025

Part 2: ESP32/ESP8266: Firebase Data Logging Web App (Gauges, Charts, and Table)

Other Firebase Tutorials with the ESP32/ESP8266 that you might be interested in:

• ESP32: Getting Started with Firebase (Realtime Database)
• ESP8266 NodeMCU: Getting Started with Firebase (Realtime Database)
• ESP32 with Firebase – Creating a Web App
• ESP8266 NodeMCU with Firebase – Creating a Web App
• ESP32/ESP8266 Firebase Authentication (Email and Password)
• ESP32/ESP8266 Firebase: Send BME280 Sensor Readings to the Realtime Database
• ESP32/ESP8266: Firebase Web App to Display Sensor Readings (with Authentication)

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 like authentication, realtime database, hosting, etc.

Project Overview

The following diagram shows a high-level overview of the project we’ll build.

1. The ESP32 authenticates as a user with email and password (that user must be set on the Firebase authentication methods);
2. After authentication, the ESP gets the user UID;
3. The database is protected with security rules. The user can only access the database nodes under the node with its user UID. After getting the user UID, the ESP can publish data to the database;
4. The ESP32 gets temperatrure, humidity and pressure from the BME280 sensor.
5. It gets epoch time right after gettings the readings (timestamp).
6. The ESP32 sends temperature, humidity, pressure and timestamp to the database.
7. New readings are added to the database periodically. You’ll have a record of all readings on the Firebase realtime database.

These are the main steps to complete this project:

1. Create Firebase Project
2. Set Authentication Methods
3. Get Project API Key
4. Set up Realtime Database
5. Set up Database Security Rules
6. ESP32 Datalogging (Firebase Realtime Database)

You can continue with the Firebase project from this previous tutorial or create a new project. If you use the Firebase project from that previous tutorial, you can skip to section 4) Set up Realtime Database because the authentication methods are already set up.

Preparing Arduino IDE

For this tutorial, we’ll program the ESP32 board using the Arduino core. So, make sure you have the ESP32 add-on installed in your Arduino IDE:

• Installing the ESP32 Board in Arduino IDE (Windows, Mac OS X, Linux)

If you want to program the ESP32/ESP8266 boards using VS Code with the pioarduino or PlatformIO extensions, follow these tutorials instead:

• VS Code and pioarduino IDE: Programming the ESP32 (Windows, Mac OS X, Linux)
• Getting Started with VS Code and PlatformIO IDE for ESP32 and ESP8266

1) Create a Firebase 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

To allow authentication with email and password, first, 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 and provide the same personalized experience across all of the user’s devices.” 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.

   

Firebase creates a unique UID for each registered user. The user UID allows us to identify the user and keep track of the user to provide or deny access to the project or the database. There’s also a column that registers the date of the last sign-in. At the moment, it is empty because we haven’t signed in with that user yet.

3) Get Project API Key

To interface with your Firebase project using the ESP32 or ESP8266 boards, you need to get your project API key. Follow the next steps to get your 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.
   

   

4) Set up the Realtime Database

Now, let’s create a realtime database and set up database rules for our project.

1) On the left sidebar, click on 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. You can select Start in test mode. We’ll change the database rules in just a moment.

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/ESP8266 code.

5) Set up Database Security Rules

Now, let’s set up the database rules. On the Realtime Database tab, select the Rules tab at the top. Then, click on Edit rules, copy the following rules and then click Publish.

// These rules grant access to a node matching the authenticated
// user's ID from the Firebase auth token
{
  "rules": {
    "UsersData": {
      "$uid": {
        ".read": "$uid === auth.uid",
        ".write": "$uid === auth.uid"
      }
    }
  }
}

These rules allow access only to the node that matches the authenticated user’s UID. This ensures that each user can access only their own data. In other words, a user can only read or write to the parts of the database located under their specific UID. Any data stored outside of their UID node will not be accessible to them.

For example, imagine our user UID is RjO3taAzMMXBB2Xmir2LQ. With our security rules, it can read and write data to the database under the node UsersData/RjO3taAzMMXBB2Xmir2LQ.

6) ESP32 Datalogging (Firebase Realtime Database)

In this section, we’ll program the ESP32 board to do the following tasks:

1. Authenticate as a user with email and password (the user you set up in this section);
2. Get BME280 readings: temperature, humidity, and pressure;
3. Get epoch time (timestamp) from an NTP server;
4. Send sensor readings and timestamp to the realtime database as an authorized user.

Parts Required

For this project, you need the following parts*:

• ESP32 board (read best ESP32 development boards);
• BME280 or any other sensor you’re familiar with;
• Breadboard;         
• Jumper wires.

* you can also test the project with random values instead of sensor readings, or you can use any other sensor you’re familiar with.

You can use the preceding links or go directly to MakerAdvisor.com/tools to find all the parts for your projects at the best price!

Schematic Diagram

In this tutorial, we’ll send BME280 sensor readings to the Firebase Realtime Database. So, you need to wire the BME280 sensor to your board.

We’re going to use I2C communication with the BME280 sensor module. For that, wire the sensor to the default ESP32 SCL (GPIO 22) and SDA (GPIO 21) pins, as shown in the following schematic diagram.

Learn more about I2C with the ESP32: ESP32 I2C Communication: Set Pins, Multiple Bus Interfaces and Peripherals (Arduino IDE).

Not familiar with the BME280 with the ESP32? Read this tutorial: ESP32 with BME280 Sensor using Arduino IDE (Pressure, Temperature, Humidity).

Installing Libraries

For this project, you need to install the following libraries:

• FirebaseClient Library
• Adafruit BME280 Library
• Adafruit Unified Sensor Library

Installing Libraries – VS Code

Follow the next instructions if you’re using VS Code with the PlatformIO or pioarduino extension.

Install the FirebaseClient Library

Click on the PIO Home icon and select the Libraries tab. Search for “FirebaseClient“. Select the Firebase Client Library by Mobitz.

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.

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

Install the BME280 Library

In the Libraries tab, search for BME280. Select the Adafruit BME280 library.

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

Follow this section if you’re using Arduino IDE.

You need to install the following libraries:

• FirebaseClient Library
• Adafruit BME280 Library
• Adafruit Unified Sensor Library

Go to Sketch > Include Library > Manage Libraries, search for the libraries’ names, and install the libraries.

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

Datalogging—Firebase Realtime Database Code

Copy the following code to your Arduino IDE or to the main.cpp file if you’re using VS Code.

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

/*
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete project details at our blog: https://RandomNerdTutorials.com/esp32-data-logging-firebase-realtime-database/
  Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files.
  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
*/

#include <Arduino.h>
#include <WiFi.h>
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include "time.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 functions
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

// Variable to save USER UID
String uid;

// Database main path (to be updated in setup with the user UID)
String databasePath;
// Database child nodes
String tempPath = "/temperature";
String humPath = "/humidity";
String presPath = "/pressure";
String timePath = "/timestamp";

// Parent Node (to be updated in every loop)
String parentPath;

int timestamp;

const char* ntpServer = "pool.ntp.org";

// BME280 sensor
Adafruit_BME280 bme; // I2C
float temperature;
float humidity;
float pressure;

// Create JSON objects for storing data
object_t jsonData, obj1, obj2, obj3, obj4;
JsonWriter writer;

// Initialize BME280
void initBME(){
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
}

// Initialize WiFi
void initWiFi() {
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
}

// Function that gets current epoch time
unsigned long getTime() {
  time_t now;
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    //Serial.println("Failed to obtain time");
    return(0);
  }
  time(&now);
  return now;
}

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

  initBME();
  initWiFi();
  configTime(0, 0, ntpServer);

  // 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;

      uid = app.getUid().c_str();

      // Update database path
      databasePath = "/UsersData/" + uid ;

      //Get current timestamp
      timestamp = getTime();
      Serial.print ("time: ");
      Serial.println (timestamp);

      parentPath= databasePath + "/" + String(timestamp);

      // Get sensor readings
      temperature = bme.readTemperature();
      humidity = bme.readHumidity();
      pressure = bme.readPressure()/100.0;

      // Create a JSON object with the data
      writer.create(obj1, tempPath, temperature);
      writer.create(obj2, humPath, humidity);
      writer.create(obj3, presPath, pressure);
      writer.create(obj4, timePath, timestamp);
      writer.join(jsonData, 4, obj1, obj2, obj3, obj4);

      Database.set<object_t>(aClient, parentPath, jsonData, processData, "RTDB_Send_Data");
    }
  }
}

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

How the Code Works

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

Include Libraries

First, include the required libraries.

#include <Arduino.h>
#if defined(ESP32)
    #include <WiFi.h>
#elif defined(ESP8266)
    #include <ESP8266WiFi.h>
#endif
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>
#include <Wire.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.h>
#include "time.h"

Network Credentials

Include your network credentials in the following lines so that your boards can connect to the internet using your local network.

// Insert your network credentials
#define WIFI_SSID "REPLACE_WITH_YOUR_SSID"
#define WIFI_PASSWORD "REPLACE_WITH_YOUR_PASSWORD"

Firebase Project API Key, Firebase User, and Database URL

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

#define Web_API_KEY "REPLACE_WITH_YOUR_PROJECT_API_KEY"

Insert the authorized email and the corresponding password—these are the details of the user you’ve added in this section.

// Insert Authorized Email and Corresponding Password
#define USER_EMAIL "REPLACE_WITH_THE_USER_EMAIL"
#define USER_PASSWORD "REPLACE_WITH_THE_USER_PASSWORD"

Insert your database URL in the following line:

// Insert RTDB URLefine the RTDB URL
#define DATABASE_URL "REPLACE_WITH_YOUR_DATABASE_URL"

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, which represents the Firebase Realtime Database.

RealtimeDatabase Database;

Timer and Data Variables

Then create variables to track the time. We’ll send sensor readings to the database every 10 seconds.

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

Create a variable to save the user UID. The uid variable will be used to save the user’s UID. We can get the user’s UID after the authentication.

// Variable to save USER UID
String uid;

Create variables to save the database path and specific database nodes. We’ll update these variables later in the code when we get the user UID.

// Database main path (to be updated in setup with the user UID)
String databasePath;
// Database child nodes
String tempPath = "/temperature";
String humPath = "/humidity";
String presPath = "/pressure";
String timePath = "/timestamp";

// Parent Node (to be updated in every loop)
String parentPath;

We create a variable to save the timestamp and another to save the NTP server.

int timestamp;

const char* ntpServer = "pool.ntp.org";

BME280 Variables

Then, create an Adafruit_BME280 object called bme. This automatically creates a sensor object on the ESP32 or ESP8266 default I2C pins.

Adafruit_BME280 bme; // I2C

The following variables will hold the temperature, humidity, and pressure readings from the sensor.

float temperature;
float humidity;
float pressure;

JSON Variables

We’ll send all data to the database in a JSON object. The FirebaseClient library has its own JSON methods. You should use them instead of other JSON libraries. To do that, we need to create four jsonData objects called obj1, obj2, obj3, and obj4.

object_t jsonData, obj1, obj2, obj3, obj4;

Then, we need to create an instance of the JsonWriter class, in this case called writer, that provides methods to create and combine JSON objects for Firebase.

JsonWriter writer;

To learn more, we recommend reading this section of the documentation about the JsonWriter object.

initBME()

The initBME() function will initialize the BME280 sensor. We’ll call it later in the setup().

// Initialize BME280
void initBME(){
  if (!bme.begin(0x76)) {
    Serial.println("Could not find a valid BME280 sensor, check wiring!");
    while (1);
  }
  Serial.print("BME280 Initialized with success");
}

initWiFi()

The initWiFi() function will connect the ESP32 to your local network using the SSID and password defined earlier.

// Initialize WiFi
void initWiFi() {
  WiFi.begin(WIFI_SSID, WIFI_PASSWORD);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
}

getTime()

The getTime() function returns the current epoch time.

// Function that gets current epoch time
unsigned long getTime() {
  time_t now;
  struct tm timeinfo;
  if (!getLocalTime(&timeinfo)) {
    //Serial.println("Failed to obtain time");
    return(0);
  }
  time(&now);
  return now;
}

To learn more about getting epoch time with the ESP32 board, you can check the following tutorial:

• Get Epoch/Unix Time with the ESP32 (Arduino IDE)

setup()

In the setup(), initialize the Serial Monitor, the BME280 sensor, WiFi, and configure the NTP server.

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

    initBME();
    initWiFi();
    configTime(0, 0, ntpServer);

Configure the SSL Client.

ssl_client.setInsecure();
#if defined(ESP32)
  ssl_client.setConnectionTimeout(1000);
  ssl_client.setHandshakeTimeout(5);
#elif defined(ESP8266)
  ssl_client.setTimeout(1000); // Set connection timeout
  ssl_client.setBufferSizes(4096, 1024); // Set buffer sizes
#endif

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.

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

After a successful authentication, we’ll get the user UID and save it in the uid variable. Then, we’ll update the database path to UsersData/<USER_UID>.

uid = app.getUid().c_str();

The databasePath variable saves the database main path, which can now be updated with the user UID.

// Update database path
databasePath = "/UsersData/" + uid;

After this, we can get the current timestamp and update the path where the readings will be saved.

//Get current timestamp
timestamp = getTime();
Serial.print ("time: ");
Serial.println (timestamp);

parentPath= databasePath + "/" + String(timestamp);

To better understand how we’ll organize our data, here’s a diagram.

It might seem redundant to save the timestamp twice (in the parent node and the child node), however, having all the data at the same level of the hierarchy will make things simpler in the future, if we want to build a web app to display the data.

After getting the timestamp and updating all database nodes with the user UID and corresponding timestamp, we can get readings from the BME280 sensor.

// Get sensor readings
temperature = bme.readTemperature();
humidity = bme.readHumidity();
pressure = bme.readPressure()/100.0;

Creating the JSON Objects

We’ll send all the readings and corresponding timestamps to the realtime database at the same time by creating a JSON object that contains the values of those variables. The FirebaseClient library has its own JSON methods. We’ll use them to send data in JSON format to the database.

We use the create() method on the writer object to create a JSON object with a key (node) and corresponding value (sensor readings).

For example, the following line creates a JSON object with tempPath as the key and temperature as the value. It stores the result in obj1.

writer.create(obj1, tempPath, temperature);

An example of output would be in this case:

obj1 = {"UserData/<user_udi>/timestamp/temperature": 23.5}

We proceed similarly for the other readings and timestamp.

writer.create(obj2, humPath, humidity);
writer.create(obj3, presPath, pressure);
writer.create(obj4, timePath, timestamp);

Then, we use the join() method on the writer object to merge the four JSON objects (obj1, obj2, obj3, obj4) into a single JSON structure, stored in jsonData. The 4 indicates the number of objects to combine.

writer.join(jsonData, 4, obj1, obj2, obj3, obj4);

Sending the JSON Object

Finally, we can send the JSON object to the database using the set() method on the database object. We already explained how this works in this previous tutorial.

Database.set<object_t>(aClient, parentPath, jsonData, processData, "RTDB_Send_Data");

This uses the SSL client aClient and sends the jsonData variable to the parentPath path in the database. The results of this operation will be handled on the processData function. The last parameter RTDB_Send_Data identifies this task.

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 previous code to your ESP32 board. Don’t forget to insert your network credentials, project API key, database URL, user email, and the corresponding password.

After uploading the code, press the board RST button so that it starts running the code. It should authenticate to Firebase, get the user UID, and immediately send new readings to the database.

Open the Serial Monitor at a baud rate of 115200 and check that everything is working as expected.

Aditionally, go to the Realtime Database on your Firebase project interface and check that new readings are saved. Notice that it saves the data under a node with the own user UID—this is a way to restrict access to the database.

Wait some time until you get some readings on the database. Expand the nodes to check the data.

Wrapping Up

In this tutorial, you learned how to log your sensor readings with timestamps to the Firebase Realtime Database using the ESP32. This was just a simple example for you to understand how it works.

You can use other methods provided by the FirebaseClient library to log your data, and you can organize your database in different ways. We organized the database in a way that is convenient for another project that we’ll publish soon.

In PART 2, we’ll create a Firebase Web App to display all saved data in a table and the latest readings on charts.

• ESP32/ESP8266: Firebase Data Logging Web App (Gauges, Charts, and Table)

We hope you’ve found this tutorial useful.

If you like Firebase projects, please take a look at our new eBook. We’re sure you’ll like it:

• Firebase Web App with ESP32 and ESP8266

Learn more about the ESP32 with our resources:

• Free ESP32 Projects and Tutorials
• Learn ESP32 with Arduino IDE

Thanks for reading.