📡ESP32 vs ESP8266: Which One Should You Choose?

ESP32 vs ESP8266: which one should you choose for your next Wi-Fi project? Both are Espressif chips, both run Arduino code and MicroPython, and both sit on cheap development boards that Indian students and makers use for smart switches, weather stations and phone-controlled robots. But the ESP32 is a much bigger chip, and the differences show up the moment you add a second sensor, need Bluetooth or try to run on batteries.

This guide compares them precisely: CPU, RAM, pins, analog inputs, Bluetooth, deep sleep and libraries, with a decision table, migration tips for moving code from ESP8266 to ESP32, and a sketch that runs on both.

Short answer: for new projects, choose the ESP32. It has two cores at up to 240 MHz, 520 KB of SRAM, Bluetooth Classic and BLE, up to 18 analog channels and far more usable pins, usually for only a small price difference. The ESP8266 is still fine for simple Wi-Fi-only jobs, such as one relay or one sensor, especially if you already own the boards and code.

ESP32 vs ESP8266: full specification comparison

Sources: Espressif's ESP8266EX datasheet and ESP32 datasheet. Board-level figures (flash size, usable pins) vary between sellers.

The ESP32 wins on every number. The question is whether your project needs any of it.

Which should you choose: ESP32 or ESP8266?

Choose the ESP32 unless your project is a simple Wi-Fi job and you already have ESP8266 boards. The table below covers the common cases.

Answer from the top. Most new projects end at the ESP32.

If you are choosing between several ESP32 boards (DevKit V1, ESP32-CAM, S3, C3), our best ESP32 board for beginners guide compares them.

Analog inputs: the biggest practical difference

The ESP8266 has one 10-bit analog input that reads 0–1.0 V at the chip pin. NodeMCU-style boards add a resistor divider in front of A0, typically 220 kΩ and 100 kΩ, so the A0 pin accepts roughly 0–3.2 V.

On the ESP32, use ADC1 pins (GPIO 32–36 and 39) with Wi-Fi, and read calibrated millivolts with analogReadMilliVolts(). Convert raw readings with our ADC voltage calculator and design dividers with the voltage divider calculator.

Deep sleep and battery projects

Both chips can sleep at microamp levels, but the ESP32 is far easier to wake up. The ESP8266 wakes from a timed sleep only by resetting itself through a wire from GPIO16 (D0) to RST.

ESP8266 timed sleep needs the D0-to-RST wire. The ESP32's wake sources are inside the chip.

// ESP32: wake every 60 s and count how many times it has woken
RTC_DATA_ATTR int bootCount = 0;   // kept in RTC memory during deep sleep

void setup() {
  Serial.begin(115200);
  delay(200);
  bootCount++;
  Serial.print("Wake-up number ");
  Serial.println(bootCount);
  // ... read your sensor and send data here ...
  esp_sleep_enable_timer_wakeup(60ULL * 1000000ULL);  // 60 s in microseconds
  esp_deep_sleep_start();
}

void loop() {
  // never reached: the chip restarts from setup() after each sleep
}

Libraries and code: what changes

Most sketches move between the two with a handful of changes, because both Arduino cores follow the same style.

This sketch compiles for both boards and serves a small web page showing which chip you are on and its free memory:

// One sketch for both: select a NodeMCU or an ESP32 board and upload
#if defined(ESP8266)
  #include <ESP8266WiFi.h>
  #include <ESP8266WebServer.h>
  ESP8266WebServer server(80);
  const char* BOARD = "ESP8266";
#elif defined(ESP32)
  #include <WiFi.h>
  #include <WebServer.h>
  WebServer server(80);
  const char* BOARD = "ESP32";
#endif

const char* WIFI_SSID = "YourWiFi";       // must be a 2.4 GHz network
const char* WIFI_PASS = "YourPassword";

void handleRoot() {
  String page = "<h1>Hello from ";
  page += BOARD;
  page += "</h1><p>Free heap: ";
  page += String(ESP.getFreeHeap());
  page += " bytes</p>";
  server.send(200, "text/html", page);
}

void setup() {
  Serial.begin(115200);
  WiFi.mode(WIFI_STA);
  WiFi.begin(WIFI_SSID, WIFI_PASS);
  while (WiFi.status() != WL_CONNECTED) {
    delay(250);
    Serial.print('.');
  }
  Serial.println();
  Serial.printf("%s connected, open http://%s\n", BOARD, WiFi.localIP().toString().c_str());
  Serial.printf("CPU %u MHz, free heap %u bytes\n",
                (unsigned)ESP.getCpuFreqMHz(), (unsigned)ESP.getFreeHeap());
  server.on("/", handleRoot);
  server.begin();
}

void loop() {
  server.handleClient();
}

Migrating a project from ESP8266 to ESP32

1. Install the ESP32 core in the Arduino IDE by following Espressif's Arduino-ESP32 installation guide.
2. Swap the includes and class names using the table above.
3. Replace D-labels with GPIO numbers. Use the pin map below; for I²C, the ESP32 defaults are SDA = GPIO21 and SCL = GPIO22.
4. Move analog sensors to ADC1 pins and rescale: 0–1023 becomes 0–4095.
5. Check PWM ranges. Older ESP8266 code may assume 0–1023; set the range you want explicitly (analogWriteRange() on the ESP8266, analogWriteResolution() on the ESP32).
6. Rewrite deep sleep with the ESP32 calls shown earlier, and remove the D0–RST wire.
7. Check the power supply. Wi-Fi transmit bursts can reset an ESP32 on a weak USB port or thin cable; see our ESP32 brownout fix.

A practical pin map for moving a NodeMCU project to an ESP32 DevKit V1. Red rows are pins with boot or special behaviour.

Experiment: run the same sketch on both boards

1. Upload the two-board sketch above to a NodeMCU, then to an ESP32 DevKit, with your 2.4 GHz Wi-Fi name and password.
2. Open the Serial Monitor at 115200 baud and note the CPU speed and free heap each board prints.
3. Open the printed IP address in a phone browser on the same Wi-Fi and refresh a few times.
4. Fill in the table.

What you learn: both boards do the job for a small page, but the ESP32 reports several times more free heap. That headroom is what lets it run a display, a bigger web page and Bluetooth at the same time.

If your board does not show a COM port, see ESP32 not detected: COM port fix. For project ideas that use the ESP32's extra features, see ESP32 project ideas for students. Get boards from our ESP32 products page, pick up from our Pune store, or learn hands-on at a workshop.

Frequently asked questions

Is the ESP32 better than the ESP8266?

For most projects, yes. It has two cores, far more RAM, Bluetooth, many more analog inputs and pins, and better sleep and wake options. The ESP8266 is still adequate for simple Wi-Fi-only devices.

Can ESP8266 code run on an ESP32?

Mostly, after small changes: replace ESP8266WiFi.h with WiFi.h, ESP8266WebServer with WebServer, NodeMCU D-labels with GPIO numbers, and the deep-sleep calls. Libraries that use ESP8266-only features need ESP32 versions.

Does the ESP8266 have Bluetooth?

No. The ESP8266 has Wi-Fi only. For Bluetooth, use an ESP32, which supports Bluetooth Classic and BLE, or an ESP32-C3 or ESP32-S3 for BLE only.

Which is better for battery-powered projects?

The ESP32, mainly because it wakes from deep sleep on a timer, touch or pin without extra wiring and has a ULP coprocessor. In both cases, choose a board without a power-hungry LED and USB chip, or the board will drain the battery long before the chip does.

Are ESP8266 and ESP32 pins 5 V tolerant?

Treat both as 3.3 V only. Power the boards with 5 V through USB or the 5V/VIN pin, but use a voltage divider or level shifter for any 5 V signal going into a GPIO pin. Our Arduino vs ESP32 vs Raspberry Pi Pico guide explains logic levels in detail.