Which Arduino Board Has Bluetooth? A Guide to BLE on Every Arduino

You’ve got an Arduino sketch that reads a temperature sensor. It works. The number shows up in the Serial Monitor. But you want that number on your phone, without a cable, and suddenly you’re staring at 15+ Arduino boards wondering which ones can actually do that.

Here’s the annoying part: most of the classic boards everyone starts with (Uno R3, Mega 2560, Leonardo) don’t have any wireless built in. You could solder on an HC-05 module and deal with Classic Bluetooth wiring, but several newer official Arduino boards come with Bluetooth already on the chip. You just need to know which ones.

This article gives you the complete list, a comparison table, and a working BLE sketch you can flash in under 5 minutes.

BLE vs. Classic Bluetooth: The 30-Second Version

Every official Arduino board with built-in Bluetooth uses BLE (Bluetooth Low Energy), not Classic Bluetooth. This distinction matters.

BLE is designed for small, infrequent bursts of data: sensor readings, button presses, status flags. It sips power. It’s perfect for battery-powered projects.

But BLE can’t stream audio. It won’t act like a wireless serial cable out of the box. If you need those things, you’re looking at external Classic Bluetooth modules (HC-05, HC-06), which aren’t covered here.

Everything below is about onboard BLE on official Arduino boards, with no add-on modules or third-party knockoffs.

Every Official Arduino Board with Bluetooth

Here’s the full list. If a board isn’t in this table, it doesn’t have Bluetooth built in.

A few niche boards like the Nicla Sense ME and Nicla Vision also have BLE. They’re targeted at edge AI and embedded ML applications, so if you’re reading this article, you probably don’t need those yet.

Notice the pattern: only 2 boards (the Nano 33 BLE and the Nano 33 BLE Sense Rev2) are BLE-only. Every other board bundles Wi-Fi alongside BLE. Wi-Fi + BLE combos tend to cost a few dollars more and draw more current, so if you only need Bluetooth, you can save on both.

The Nano 33 BLE is probably the most popular beginner pick for Bluetooth-only projects. It’s small, cheap, and the nRF52840 chip is a workhorse for BLE. If you’re coming from a classic Uno and want the familiar form factor with wireless, the UNO R4 WiFi is the natural upgrade. Same pin layout, same shield compatibility, plus BLE and Wi-Fi bolted on.

How to Choose the Right Board

Four questions:

• “I just need BLE, nothing else.” Get the Nano 33 BLE. Lowest cost, lowest power draw, smallest footprint.
• “I need BLE and Wi-Fi.” UNO R4 WiFi if you want Uno-compatible shields. Nano 33 IoT or Nano ESP32 if you want something smaller.
• “I need BLE plus onboard sensors (accelerometer, gyroscope, temperature, etc.).” Nano 33 BLE Sense Rev2. It’s the Nano 33 BLE with 7 sensors packed onto the board.
• “I need serious horsepower and lots of pins.” GIGA R1 WiFi. Dual-core processor, 76 GPIO pins, camera and audio support.

One nice thing: all these boards use the same ArduinoBLE library. Code you write for the Nano 33 BLE will run on the UNO R4 WiFi with minimal changes. What you learn once applies everywhere.

Getting Started with the ArduinoBLE Library

ArduinoBLE is Arduino’s official library for Bluetooth Low Energy. It works on every board in the table above (the Nano ESP32 uses it slightly differently, but the API is the same).

Install it in 3 clicks:

1. Open the Arduino IDE.
2. Go to Library Manager (Sketch > Include Library > Manage Libraries).
3. Search “ArduinoBLE” and hit Install.

Here’s the mental model you need. When your Arduino runs BLE, it acts as a peripheral, like a beacon that advertises “hey, I exist.” Your phone is the central that scans for peripherals and connects.

Your Arduino exposes services, and each service contains characteristics. Think of a service as a folder and a characteristic as a file inside it. A phone app can read or write those files. That’s the whole concept.

You’ll see the terms GATT and UUID pop up in examples. GATT is just the name for this folder/file system. A UUID is a long ID string that labels each service and characteristic so devices can find them. Just know they’re addresses.

Your First BLE Sketch: LED Control from a Phone

This sketch creates one service with one writable characteristic. When a phone app writes 1, the onboard LED turns on. When it writes 0, the LED turns off.

#include <ArduinoBLE.h>

// Create a BLE service and a writable characteristic
BLEService ledService("19B10000-E8F2-537E-4F6C-D104768A1214");
BLEByteCharacteristic ledChar("19B10001-E8F2-537E-4F6C-D104768A1214", BLERead | BLEWrite);

void setup() {
  Serial.begin(9600);
  pinMode(LED_BUILTIN, OUTPUT);

  if (!BLE.begin()) {                    // Start the BLE radio
    Serial.println("BLE failed to start!");
    while (1);
  }

  BLE.setLocalName("ArduinoLED");        // Name that shows up on your phone
  BLE.setAdvertisedService(ledService);   // Attach service to advertisement
  ledService.addCharacteristic(ledChar);  // Put the characteristic in the service
  BLE.addService(ledService);             // Register the service
  ledChar.writeValue(0);                  // Initial value: LED off

  BLE.advertise();                        // Start broadcasting
  Serial.println("BLE active. Waiting for connection...");
}

void loop() {
  BLEDevice central = BLE.central();      // Check for a connected phone

  if (central) {
    Serial.print("Connected to: ");
    Serial.println(central.address());

    while (central.connected()) {
      if (ledChar.written()) {            // Did the phone write a new value?
        if (ledChar.value()) {
          digitalWrite(LED_BUILTIN, HIGH);
          Serial.println("LED ON");
        } else {
          digitalWrite(LED_BUILTIN, LOW);
          Serial.println("LED OFF");
        }
      }
    }
    Serial.println("Disconnected.");
  }
}

Upload this to any board from the table. Then grab a free phone app to test it:

• LightBlue (iOS and Android): clean, beginner-friendly.
• nRF Connect (iOS and Android): more detailed, great for debugging.

Open the app, scan for devices, and look for “ArduinoLED.” Connect, find the characteristic, and write 01 to turn the LED on or 00 to turn it off.

Quick Troubleshooting

• Board not showing up in the phone app? Make sure you selected the correct board in the Arduino IDE (Tools > Board). A wrong board selection means the sketch compiles but the BLE radio never starts.
• Phone can’t find “ArduinoLED”? Check that Bluetooth is enabled on your phone and the scanning app has Bluetooth and Location permissions (Android requires both).
• Sketch won’t compile? Confirm ArduinoBLE is installed and your board’s core is up to date (Tools > Board > Boards Manager).

Where BLE Gets Interesting

You’ve got the LED toggling from your phone. That’s the “Hello World” of BLE, and it proves your radio works. The real payoff starts when you push sensor data over that link: a temperature reading every 5 seconds, an accelerometer spike on motion detection, a battery level percentage on demand.

The ArduinoBLE library ships with several example sketches in the IDE (File > Examples > ArduinoBLE). The “BatteryMonitor” and “ButtonLED” examples are good next steps.

If your project eventually needs to reach beyond phone range, keep in mind that BLE signals can also be picked up by network infrastructure, not just smartphones. Hubble’s network, for example, can receive BLE transmissions from standard BLE advertising packets without changing your hardware. That opens up interesting possibilities for projects that grow past the bench and into the field.

Pick a board from the table, install ArduinoBLE, flash the sketch, and get that LED blinking from your phone. Everything else builds on top of that.

Picking Your Board and Getting Started

Here’s what to do right now:

1. Pick a board. If you’re unsure, the Nano 33 BLE is the safest starting point. Under $30, great BLE support, huge community.
2. Install the ArduinoBLE library through the Library Manager.
3. Flash the LED sketch above and confirm your phone can connect.
4. Explore the built-in examples (File > Examples > ArduinoBLE) once the basics work.

You don’t need to understand GATT profiles, connection intervals, or MTU sizes right now. The only thing between you and a wireless Arduino project is choosing the right board and uploading 35 lines of code.

Hubble Network enables BLE devices to transmit data from anywhere on Earth via satellite—no gateway infrastructure required. See how it works →