ESP32/ESP8266 MAC Address Complete Guide: Read, Change, and Apply (Arduino IDE)

Controlling your smart home devices, managing a fleet of sensors, or troubleshooting network conflicts often starts with one crucial piece of information: the MAC Address. This unique identifier is the key to advanced network management for your ESP32 and ESP8266 boards.

This definitive guide will not only show you how to read and change the MAC Address of your ESP boards using the Arduino IDE but, more importantly, will explain the critical “why” and “when” behind doing so. You’ll learn practical applications, essential security and legal considerations, and gain expert insights to manage your IoT projects like a pro.

1. Understanding the MAC Address: Your Device’s Network ID

A MAC Address (Media Access Control Address) is a globally unique identifier assigned to the network interface controller (NIC) of your device. Think of it as a permanent serial number for network communication, hardcoded by the manufacturer onto the device’s hardware.

• Format: It consists of six groups of two hexadecimal digits, separated by colons (e.g., 30:AE:A4:07:0D:64).

• Structure: The first three bytes (OUI – Organizationally Unique Identifier) identify the manufacturer (e.g., Espressif systems). The last three bytes are assigned uniquely by the manufacturer to that specific device.

• Function: At the most fundamental level of your local network (Ethernet, Wi-Fi), devices use MAC addresses, not IP addresses, to find and communicate with each other. Your router uses it to assign IPs via DHCP and for network access control lists.

2. Why Read or Change a MAC Address?

Understanding the purpose is crucial before implementation.

Reasons to READ the MAC Address:

• Network Administration: Identify specific ESP boards on your router’s client list for monitoring or troubleshooting.

• Security: Create a whitelist on your router, allowing only devices with known MAC addresses to connect.

• Device Identification: In projects with multiple ESP units, use the MAC address as a unique ID in your code or data logs.

• Obtaining Initial Network Info: It’s the first step in network-related programming.

Reasons to CHANGE the MAC Address (Spoofing/Cloning):

• Testing & Development: Simulate multiple devices with a single board when testing server or network applications.

• Privacy Concerns: On public Wi-Fi, using a random MAC can reduce persistent tracking (note: ESP boards can do this programmatically for networks).

• Bypassing Network Restrictions: Some networks restrict access based on MAC. Cloning an approved address can be a workaround (use responsibly and ethically).

• Replacing Hardware: If a device fails, you can program its replacement with the same MAC address to seamlessly take its place in the network without reconfiguring routers or servers.

⚠️ Critical Legal & Ethical Warning: Changing a MAC address (“spoofing”) can violate the terms of service of some internet providers or be used for unauthorized network access. Always ensure you have explicit permission to modify network settings on any network you do not own. This guide is for educational and legitimate development purposes.

3. How to Get the ESP32 MAC Address

The following Arduino sketch uses the esp_wifi.h library to reliably fetch the MAC address. This method is preferred for its direct access to the ESP32‘s WiFi functions.

/*
 * ESP32 - Read Default MAC Address
 * Complete Project: https://RandomNerdTutorials.com/
 */

#include <WiFi.h>
#include <esp_wifi.h> // Required for direct MAC access

void setup() {
  Serial.begin(115200);
  delay(1000); // Short startup delay

  WiFi.mode(WIFI_STA); // Set WiFi to Station mode
  WiFi.begin(); // Initiate WiFi (no connection needed for MAC)

  uint8_t macAddr[6]; // Array to hold the 6-byte MAC
  esp_err_t result = esp_wifi_get_mac(WIFI_IF_STA, macAddr);

  if (result == ESP_OK) {
    Serial.print("ESP32 MAC Address: ");
    // Print MAC in standard XX:XX:XX:XX:XX:XX format
    Serial.printf("%02X:%02X:%02X:%02X:%02X:%02X\n",
                  macAddr[0], macAddr[1], macAddr[2],
                  macAddr[3], macAddr[4], macAddr[5]);
  } else {
    Serial.println("Error: Could not read MAC Address.");
  }
}

void loop() {
  // Nothing here
}

Upload & Verify:

1. Upload the code to your ESP32.

2. Open the Serial Monitor (Tools > Serial Monitor) at a baud rate of 115200.

3. Press the EN/RST button on the board.

4. Your unique MAC address will be displayed.

4. How to Set a Custom MAC Address on ESP32

Important: Changing the MAC address this way is volatile. It will revert to the factory-default address after a hard reset or power cycle unless you reprogram it. You must include the MAC-setting code in every sketch where you need the custom address.

Key Technical Rule: The least significant bit (LSB) of the first byte of a custom MAC address must be 0. This bit indicates whether the address is unicast (0) or multicast (1). A simple rule: ensure the first hex digit is even (0, 2, 4, 6, 8, A, C, E). For example, 0x3A... is valid, 0x3B... is not.

Here is the complete code to read the default address, set a new one, and verify the change.

/*
 * ESP32 - Set a Custom MAC Address
 * Complete Project: https://RandomNerdTutorials.com/
 */

#include <WiFi.h>
#include <esp_wifi.h>

// >>> DEFINE YOUR CUSTOM MAC ADDRESS HERE <<<
// Format: {0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX}
// First byte LSB must be 0 (first hex digit must be even).
uint8_t newMACAddress[] = {0x32, 0xAE, 0xA4, 0x07, 0x0D, 0x66};

// Optional: Your WiFi Credentials to test connection with new MAC
const char* ssid = "YOUR_NETWORK_SSID";
const char* password = "YOUR_NETWORK_PASSWORD";

void printMacAddress() {
  uint8_t currentMac[6];
  esp_wifi_get_mac(WIFI_IF_STA, currentMac);
  Serial.printf("%02X:%02X:%02X:%02X:%02X:%02X\n",
                currentMac[0], currentMac[1], currentMac[2],
                currentMac[3], currentMac[4], currentMac[5]);
}

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

  WiFi.mode(WIFI_STA);
  Serial.print("[1] Default MAC Address: ");
  printMacAddress();

  // --- CHANGE THE MAC ADDRESS ---
  esp_err_t setResult = esp_wifi_set_mac(WIFI_IF_STA, &newMACAddress[0]);
  if (setResult == ESP_OK) {
    Serial.println("[2] MAC Address change successful.");
  } else {
    Serial.println("[2] ERROR: Failed to set MAC Address.");
    while (1) delay(100); // Halt on critical error
  }

  Serial.print("[3] New MAC Address:      ");
  printMacAddress();
  Serial.println();

  // --- OPTIONAL: Connect to WiFi with the new MAC ---
  Serial.println("[4] Attempting to connect to WiFi...");
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\n[5] Connected! New IP Address: " + WiFi.localIP().toString());
}

void loop() {
  // Your main code here
}

5. ESP8266 NodeMCU: Get and Change MAC Address

The process for the ESP8266 is similar but uses different library functions. The ESP8266WiFi library has built-in methods.

Get ESP8266 MAC Address:

#include <ESP8266WiFi.h>
void setup() {
  Serial.begin(115200);
  Serial.print("ESP8266 MAC Address: ");
  Serial.println(WiFi.macAddress()); // Simple one-liner
}
void loop() {}

Change ESP8266 MAC Address:

#include <ESP8266WiFi.h>
// Define your custom MAC (same rules apply)
uint8_t newMAC[] = {0x32, 0xAE, 0xA4, 0x07, 0x0D, 0x66};

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  Serial.print("[OLD] MAC: ");
  Serial.println(WiFi.macAddress());

  // Use the low-level 'wifi_set_macaddr' function
  wifi_set_macaddr(STATION_IF, &newMAC[0]);

  Serial.print("[NEW] MAC: ");
  Serial.println(WiFi.macAddress());
}
void loop() {}

6. Advanced Applications & Expert Tips

Moving beyond basics, here’s how to leverage MAC addresses in real-world projects.

1. Generating “Legal” Random MACs:
For testing, you might need to generate valid, non-conflicting MAC addresses.

void generateRandomMAC(uint8_t* macArray) {
  randomSeed(analogRead(0)); // Seed with "noise"
  for (int i = 0; i < 6; i++) {
    macArray[i] = random(0, 256);
  }
  // Enforce Unicast (LSB of first byte = 0) and Locally Administered (second LSB = 1)
  macArray[0] = (macArray[0] & 0xFE) | 0x02; // Mask ensures 0x02, 0x06, 0x0A, etc.
}

2. Using MAC as a Unique Device ID in IoT Projects:
Instead of hard-coding identifiers, use the MAC.

String getDeviceID() {
  uint8_t mac[6];
  WiFi.macAddress(mac);
  char deviceId[13]; // 12 hex chars + null terminator
  sprintf(deviceId, "%02X%02X%02X%02X%02X%02X", mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
  return String(deviceId); // Returns a 12-character string like "30AEA4070D64"
}
// Use this ID in MQTT client names, HTTP headers, or database records.

3. Factory MAC vs. Active MAC (Crucial for Debugging):
Remember, the esp_wifi_get_mac() function returns the currently active address, which may be your custom one. The factory MAC is stored in the ESP’s EFUSE memory. If you need the permanent factory MAC even after a spoof, you must read it from EFUSE (advanced technique requiring specific ESP-IDF commands).

7. Troubleshooting Common Issues

Conclusion & Best Practices

You now have complete control over the network identity of your ESP32 and ESP8266 boards. To use this power effectively and responsibly, follow these final guidelines:

1. Document Everything: Keep a log of your ESP boards’ factory MAC addresses and any custom ones you assign. This is vital for inventory and debugging.

2. Test Thoroughly: Always test MAC address changes in a controlled, isolated network environment before deploying to a production setting.

3. Prioritize Security: Do not rely on MAC address filtering as a sole security measure. MAC addresses can be spoofed, as you’ve just learned. Use it in conjunction with WPA2/WPA3 encryption and strong passwords.

4. Understand Permanence: Accept that software-based MAC changes are temporary. For a permanent change, you would need to burn the address into EFUSE—a risky, irreversible process not covered here and generally not recommended.

By mastering your device’s MAC address, you unlock a deeper level of network integration and project flexibility. Whether for simplifying device management, enhancing privacy, or scaling your testing environment, this knowledge is a fundamental tool in the IoT developer’s toolkit.

Contact Us