In this guide, you’ll learn how to authenticate to Firebase using your ESP32 or ESP8266 board with an email and password, and get the user UID. This is useful for restricting or allowing access to certain users or creating multiple users that can access the same Firebase project. Additionally, this is helpful when setting up database rules to protect your project’s data.

Updated 30 April 2025.

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

• ESP32: Getting Started with Firebase (Realtime Database)
• ESP32 with Firebase – Creating a Web App

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. In this tutorial, we’ll focus on the authentication part.

Project Overview

1. Create Firebase Project
2. Set Authentication Methods
3. Get Project API Key
4. Authentication with ESP32/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.

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) Authentication with ESP32/ESP8266

Now that your Firebase Project is created and you’ve set up the authentication method, you’ll learn to log in with the ESP32 or ESP8266 using the authorized user email and password.

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

Note: for firebase projects, we recommend using VS Code with the PlatformIO or pioarduino extension because if you want to develop a web application to make the bridge between the ESP and Firebase, VS Code provides all the tools to do that. However, we won’t build the web application in this tutorial, so you can use Arduino IDE.

Installing the FirebaseClient Library

To use Firebase with the ESP32 and ESP8266, we’ll use the FirebaseClient library. This library is compatible with the ESP32, ESP8266, and many other boards.

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.

ESP32/ESP8266 Firebase Authentication Email/Password (Get User UID)

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

/*
  Rui Santos & Sara Santos - Random Nerd Tutorials
  Complete project details at our blog: https://RandomNerdTutorials.com/esp32-esp8266-firebase-authentication/
  Based on this example: https://github.com/mobizt/FirebaseClient/blob/main/examples/App/AppInitialization/UserAuth/UserAuth.ino
*/

#include <Arduino.h>
#if defined(ESP32)
  include <WiFi.h>
#elif defined(ESP8266)
  #include <ESP8266WiFi.h>
#endif
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>
#include "ExampleFunctions.h" // Provides the functions used in the examples.

// 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 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);
AsyncResult dbResult;

bool taskComplete = false;

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

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

  // Check if authentication is ready
  if (app.ready() && !taskComplete){
    taskComplete = true;
    // Print authentication info
    Serial.println("Authentication Information");
    Firebase.printf("User UID: %s\n", app.getUid().c_str());
    Firebase.printf("Auth Token: %s\n", app.getToken().c_str());
    Firebase.printf("Refresh Token: %s\n", app.getRefreshToken().c_str());
    print_token_type(app);
  }
}

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, and project API key for the project to work.

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. The WiFi.h library to connect the ESP32 to the internet (or the ESP8266WiFi.h library for the ESP8266 board), the FirebaseClient.h and WiFiClientSecure libraries to interface the boards with Firebase. We also include the ExampleFunctions.h file which is included in the library that comes with some additional functions for this example.

#include <Arduino.h>
#if defined(ESP32)
    #include <WiFi.h>
#elif defined(ESP8266)
    #include <ESP8266WiFi.h>
#endif
#include <WiFiClientSecure.h>
#include <FirebaseClient.h>
#include "ExampleFunctions.h" // Provides the functions used in the examples.

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.

#define Web_API_KEY "REPLACE_WITH_YOUR_FIREBASE_PROJECT_API_KEY"

Set the Firebase email user and corresponding password.

#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);

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 (different for ESP32 and ESP8266).

// Configure 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");

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 getting the User UID). We also have a control variable taskComplete so that is just runs once to print the user UID.

if (app.ready() && !taskComplete){
  taskComplete = true;

Then, we can get the user UID with app.getUid().

Firebase.printf("User UID: %sn", app.getUid().c_str());

We also print more information about the app auth token.

 Firebase.printf("Auth Token: %sn", app.getToken().c_str());
 Firebase.printf("Refresh Token: %sn", app.getRefreshToken().c_str());
 print_token_type(app);

Demonstration

After uploading the code, open the Serial Monitor at a baud rate of 115200.

Note: if you’re using VS Code, you need to add the following line to your platformio.ini file to change the baud rate. Then, save your file.

monitor_speed = 115200

Reset your board by pressing the on-board EN/RST button.

The ESP32/ESP8266 authenticates successfully and prints information about the user UID and the authentication token.

Then, go to your Firebase project console to check if it signed in as a user. Go to Authentication > Users. You should have the current date in the Signed In field. Additionally, you’ll see that the User UID matches the UID printed by your ESP board in the Serial Monitor.

Congratulations! You successfully signed in your ESP32/ESP8266 board as a user. You can combine this example with one of our previous tutorials to send sensor readings to the database as an authorized user: ESP32: Getting Started with Firebase (Realtime Database) or you can follow this project:

• ESP32/ESP8266: Firebase Web App to Display Sensor Readings (with Authentication)

Wrapping Up

In this tutorial, you learned how to set up the ESP32/ESP8266 board as a user that can access your Firebase project with email and password. This was just a simple example that you can apply to more advanced projects.

Setting up the ESP as a user allows you to identify the user to enable or restrict access to the Firebase Project or to the database or to specific database nodes—allows you to set up database rules.

We have a project that shows how to use this feature to create database rules and to build a web app with login/logout features to authorize and restrict access to the data. You can check it out on the following link:

• ESP32/ESP8266: Firebase Web App to Display Sensor Readings (with Authentication)

If you want to learn more about building a fully-featured Firebase Web App to control and monitor your ESP32 and ESP8266 boards from anywhere, take a look at our eBook:

• Firebase Web App with ESP32 and ESP8266

Other resources that you might find helpful:

• Build Web Servers with the ESP32/ESP8266
• Learn ESP32 with Arduino IDE
• Home Automation using ESP8266