ESP32/ESP8266 Firebase: Send BME280 Sensor Readings to the Realtime Database

In this guide, you’ll learn how to send BME280 sensor readings to the Firebase Realtime Database using the ESP32 or ESP8266 NodeMCU boards. The ESP board will authenticate as a user with email and password, and you’ll add database security rules to secure your data. The boards will be programmed using the Arduino core.

Updated May 8, 2026

Here’s Part 2 of this project: ESP32/ESP8266: Firebase Web App to Display Sensor Readings (with Authentication)

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)

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/ESP8266 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 ESP sends temperature, humidity and pressure to the 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/ESP8266 Send Sensor Readings to the Realtime Database

You can continue with the Firebase project from this previous tutorial or create a new project. If you use the Firebase project of 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 and ESP8266 boards using the Arduino core. So, make sure you have the ESP32 or ESP8266 add-on installed in your Arduino IDE:

• Installing ESP32 Board in Arduino IDE 2 (Windows, Mac OS X, Linux)
• Installing ESP8266 NodeMCU Board in Arduino IDE 2 (Windows, Mac OS X, Linux)

If you want to program the ESP boards using VS Code with the PlatformIO extension, follow the following tutorial instead:

• Getting Started with VS Code and PlatformIO IDE for ESP32 and ESP8266

1) Create 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 or ESP8266). 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.

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 Web App for Your Project (and API key)

To interface with your Firebase project using the ESP8266 and ESP32, you need to get your project API key. To get an API key for your project, you need to create a web app first. Follow the next steps.

1. On the left sidebar, click on Settings.
   

   

2. Scroll down on that page to the Your apps section. Then, click on the web icon </> to create and add a web app to your Firebase project.
   

   

3. Give your app a name. Then, check the box next to √ Also set up Firebase Hosting for this App. Click Register app.
   

   

4. Then, in the firebaseConfig object, you can find your API key. Save it because you’ll need it later.
   

   

   After this, you can also access the firebaseConfig object if you go to your Project settings in your Firebase console and scroll down to the Your apps section.
5. Click Next on the preceding steps, and finally on Continue to console.

4) Set up 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.

You’ll better understand how this works when you start working with the ESP32/ESP8266.

6) ESP32/ESP8266 Send Sensor Readings to the Realtime Database

In this section, we’ll program the ESP32 or ESP8266 boards to do the following tasks:

1. Authenticate as a user with email and password (the user you set up in this section);
2. Send sensor readings to the Firebase Realtime Database as an authorized user to the node corresponding to its user UID.

Parts Required

For this project, you need the following parts*:

• ESP32 or ESP8266 board (read ESP32 vs ESP8266);
• 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. Follow one of the following schematic diagrams.

ESP32 with BME280

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.

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

ESP8266 with BME280

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

Not familiar with the BME280 with the ESP8266? Read this tutorial: ESP8266 with BME280 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.

Send Sensor Readings to the 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-esp8266-firebase-bme280-rtdb/
  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.
*/
#define ENABLE_USER_AUTH
#define ENABLE_DATABASE

#include <Arduino.h>
#if defined(ESP32)
  #include <WiFi.h>
#elif defined(ESP8266)
  #include <ESP8266WiFi.h>
#endif
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.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_PROJECT_API_KEY"
#define DATABASE_URL "REPLACE_WITH_YOUR_DATABASE_URL"
#define USER_EMAIL "REPLACE_WITH_THE_USER_EMAIL"
#define USER_PASSWORD "REPLACE_WITH_THE_USER_PASSWORD"

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

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

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

// Variable to save USER UID
String uid;

// Variables to save database paths
String databasePath;
String tempPath;
String humPath;
String presPath;

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

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

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

  initBME();

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

  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

  // 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 User UID
      Firebase.printf("User UID: %s\n", app.getUid().c_str());
      uid = app.getUid().c_str();
      databasePath = "UsersData/" + uid;

      // Update database path for sensor readings
      tempPath = databasePath + "/temperature"; // --> UsersData/<user_uid>/temperature
      humPath = databasePath + "/humidity"; // --> UsersData/<user_uid>/humidity
      presPath = databasePath + "/pressure"; // --> UsersData/<user_uid>/pressure

      // Get latest sensor readings
      temperature = bme.readTemperature();
      humidity = bme.readHumidity();
      pressure = bme.readPressure()/100.0F;
        
      Serial.println("Writing to: " + tempPath);

      Database.set<float>(aClient, tempPath, temperature, processData, "RTDB_Send_Temperature");
      Database.set<float>(aClient, humPath, humidity, processData, "RTDB_Send_Humidity");
      Database.set<float>(aClient, presPath, pressure, processData, "RTDB_Send_Pressure");

    }
  }
}

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. We’re including different WiFi libraries for the ESP32 and ESP8266.

#include <Arduino.h>
#if defined(ESP32)
    #include <WiFi.h>
#elif defined(ESP8266)
    #include <ESP8266WiFi.h>
#endif
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>
#include <Adafruit_Sensor.h>
#include <Adafruit_BME280.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 your database URL in the following line:

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

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

#define USER_EMAIL "REPLACE_WITH_THE_USER_EMAIL"
#define USER_PASSWORD "REPLACE_WITH_THE_USER_PASSWORD"

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.

// Variables to save database paths
String databasePath;
String tempPath;
String humPath;
String presPath;

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;

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");
}

setup()

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

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

    initBME();

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

  // Get User UID
 Firebase.printf("User UID: %s\n", app.getUid().c_str());
 uid = app.getUid().c_str();
 databasePath = "UsersData/" + uid;

Then, we’ll update the path for each node where the readings will be saved.

// Update database path for sensor readings
tempPath = databasePath + "/temperature"; // --> UsersData/<user_uid>/temperature
humPath = databasePath + "/humidity"; // --> UsersData/<user_uid>/humidity
presPath = databasePath + "/pressure"; // --> UsersData/<user_uid>/pressure

Get Sensor Readings

Then, we get new sensor readings and save them in the temperature, humidity, and pressure variables.

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

Send Data to the Database

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.

Learn more: ESP32: Getting Started with Firebase (Realtime Database)

In our example, we’ll send float variables. We use the set() function as follows to send the readings to their specific database node paths.

Database.set<float>(aClient, tempPath, temperature, processData,"RTDB_Send_Temperature");
Database.set<float>(aClient, humPath, humidity, processData, "RTDB_Send_Humidity");
Database.set<float>(aClient, presPath, pressure, processData, "RTDB_Send_Pressure");

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 previous code to your board. The code is compatible with both the ESP32 and ESP8266 boards. 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 user UID—this is a way to restrict access to the database.

And that’s it. You’ve successfully sent sensor readings to the Firebase Realtime Database, and you protected the data using database rules.

Wrapping Up

In this tutorial, you’ve learned how to authenticate the ESP32/ESP8266 as a user with email and password, send sensor readings to the database, and set up security rules to protect your database and restrict access.

In PART 2, we’ll create a Firebase Web App with authentication (login with email and password) that displays the sensor readings saved in the database. Only an authorized logged-in user can access the data. Later, you’ll be able to modify that project to display all sorts of data and restrict or allow access to the data to specific users.

We hope you’ve found this tutorial useful.

>> Continue to Part 2: ESP32/ESP8266: Firebase Web App to Display Sensor Readings (with Authentication)

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

• Firebase Web App with ESP32 and ESP8266

Learn more about the ESP32 and ESP8266 with our resources:

• Free ESP32 Projects and Tutorials
• Free ESP8266 Projects and Tutorials
• Learn ESP32 with Arduino IDE
• Home Automation using ESP8266

Thanks for reading.