Components · 13 min read

MT3608 Boost Converter Module: Get 5 V and 12 V from 3.7 V

How do you use the MT3608 boost converter? Get 5 V and 12 V from a 3.7 V Li-Ion cell, set the trimpot, work out current and efficiency, plus ESP32 and Pico examples.

A boost converter module is a small DC-DC converter that turns a low input voltage into a higher, adjustable one, and in hobby electronics the most common and cheapest solution is the module built around the MT3608 chip. If you want 5 V, 9 V or 12 V from a single 3.7 V Li-Ion or Li-Po cell, this is most likely the part you're looking for. The module measures about 36×17 mm and carries a blue multi-turn trimpot, which lets you set the output anywhere from just above the input up to 28 V.

In this post we'll look at what's inside the MT3608, how to set the trimpot correctly with a multimeter, how much current you can really draw from the module, and how much current the battery has to supply in the process, all with formulas. Then we'll explain how it differs from the LM2596 step-down module, measure the output voltage with an Arduino, and finish with real wiring and code examples that power an ESP32 and a Raspberry Pi Pico from a single 18650 cell.

What is the MT3608 boost converter and how does it work?

The MT3608 is a boost (step-up) switching regulator. Its internal MOSFET switches on and off about 1.2 million times per second. While the MOSFET is on, current flows through an inductor and the inductor stores energy in its magnetic field. When the MOSFET turns off, the inductor resists the interruption of current, adds its own voltage on top of the input voltage, and this energy is passed through a Schottky diode to the output capacitor. The chip constantly measures the output through a voltage divider and adjusts the on-time until the divider's midpoint equals the 0.6 V reference. So even as the battery drains and the input falls from 4.2 V to 3.0 V, the output stays constant.

FeatureValue
ChipMT3608 (SOT23-6 package)
Input voltage2–24 V
Output voltageHigher than the input, up to 28 V
Internal switch current limit4 A (peak, 80 mΩ internal MOSFET)
Switching frequency1.2 MHz
Feedback reference0.6 V
Efficiency85–93% in practice (up to 97% in the datasheet)
Parts on the board22 µH inductor, SS34 Schottky diode, input and output capacitors, 100 kΩ trimpot
ProtectionNo reverse-polarity or output short-circuit protection

The output voltage is set by this formula: Vout = 0.6 × (1 + R1 / R2). On most modules R1 is the 100 kΩ trimpot and R2 is a fixed 2.2 kΩ resistor. With the trimpot fully open you get 0.6 × (1 + 100 / 2.2) ≈ 27.9 V; that's where the module's 28 V upper limit comes from. For 5 V, R1 should be about 16 kΩ, and for 12 V about 41.8 kΩ. The lower limit comes not from the formula but from the structure: a boost converter can't produce a voltage lower than its input. However far you turn the trimpot down, the output stays at least a diode drop (about 0.3–0.4 V) below the input. To try your own divider values, use the voltage divider calculator.

MT3608 pins and wiring table

MT3608 pinArduino UnoESP32 DevKitRaspberry Pi Pico
VIN+Battery + (TP4056 OUT+)Battery + (TP4056 OUT+)Battery + (TP4056 OUT+)
VIN−Battery − (TP4056 OUT−)Battery − (TP4056 OUT−)Battery − (TP4056 OUT−)
VOUT+ (set to 5.0 V)5V pin5V (VIN) pinVSYS (pin 39) or 5 V peripherals only
VOUT+ (set to 9 V)VIN pin or DC jackNot connectedNot connected
VOUT−GNDGNDGND
The MT3608 module has neither reverse-polarity protection nor short-circuit protection. If you connect the battery the wrong way round, the chip can burn out instantly. If you short the output, current flows straight from the battery through the inductor and diode; even if the chip stops switching, this path stays open and the battery, wires or diode will heat up. Always use a protected cell or a protected TP4056 charger module, and measure the output of a module with unknown settings before connecting it to your board.

On the module, the VIN− and VOUT− terminals are connected to each other on the board, so input and output share the same ground. That means when you measure battery voltage with an Arduino, or use the module's output together with another board's supply, you don't need to set up a separate common ground, but make sure all the GNDs really meet at a single point. For loads that draw sudden current, such as servos, motors or Wi-Fi, adding a 470–1000 µF electrolytic capacitor to the output greatly reduces brief voltage dips.

Trimpot adjustment: 5 V and 12 V step by step

  1. Don't connect anything to the module's output; just hold the multimeter probes on VOUT+ and VOUT− and set the multimeter to the DC voltage range.
  2. Connect the battery or a bench power supply to the input. If you're using a battery, measure and note its voltage first, so you know the input voltage at the time of adjustment.
  3. Turn the trimpot slowly with a small flat screwdriver. On a multi-turn trimpot the full range takes 15–25 turns; if you see no change in the first few turns, keep going in the same direction.
  4. If the voltage falls, reverse direction. On most modules counter-clockwise raises the voltage, but this varies by manufacturer; always trust the multimeter.
  5. For 5 V, stop at around 5.05–5.10 V; the output drops a few tens of millivolts under load. For 12 V, aim for 12.0–12.2 V.
  6. Connect your real load (for example a resistor or the board itself), measure the voltage once more and fine-tune by a quarter turn if needed.
  7. After adjusting, put a drop of nail polish or hot glue on the trimpot to stop it drifting with vibration.
If you're new to using a multimeter, first read the multimeter guide. A boost converter's output has a small but fast ripple (usually a few tens of mV); cheap multimeters won't show it, but it can appear as noise in analog sensor readings. In that case, adding a 100 nF ceramic and a 10 µF capacitor to the sensor's supply pin is enough.

Current limit and efficiency: how much current can you draw?

In a boost converter energy doesn't appear from nowhere; the battery pays for the power you take at the output, plus the losses. The current drawn from the battery is given by: Iin = (Vout × Iout) / (Vin × η), where η is the efficiency. For example, if you draw 1 A at 5 V from a 3.7 V battery and the efficiency is 88%: 5 × 1 / (3.7 × 0.88) ≈ 1.54 A. When the battery falls to 3.0 V, the current for the same load rises to about 2 A. In other words, the input current grows in proportion to how much you boost the voltage; asking for 1 A at 12 V means more than 4 A from the battery, which is far beyond the module's limit.

Output (from a 3.7 V battery)Recommended continuous currentBattery current (3.7 V)Battery current (3.0 V)
5 V0.5 A≈ 0.75 A≈ 0.95 A
5 V1 A≈ 1.54 A≈ 1.96 A
9 V0.5 A≈ 1.40 A≈ 1.76 A
12 V0.35 A≈ 1.34 A≈ 1.69 A

The 4 A in the datasheet is the peak current limit of the switch inside the chip; it isn't the current your load can draw. Because the inductor current ripples around an average value, the peak is higher than the average, and the small SOT23-6 package can't shed heat well. So when running from a single cell, a good rule is not to exceed about 2 A continuously on the battery side; the table above is built around that limit. The module also has no adjustable output current limit: it tries to deliver whatever the load asks for, so you have to limit loads like LED strips or motors yourself. Use the same logic to estimate battery life: a 2600 mAh 18650 holds about 3.7 × 2.6 ≈ 9.6 Wh. An ESP32 project averaging 150 mA at 5 V draws about 0.85 W from the battery at 88% efficiency, which is roughly 11 hours of running time. For your own numbers, use the battery life calculator and the mAh guide.

MT3608 vs LM2596: what's the difference?

Both modules are switching DC-DC converters and both have a multi-turn trimpot, so they're often confused. The basic difference is direction: the MT3608 only steps up voltage, while the LM2596 only steps down. If you want 5 V from a 12 V adapter or a car battery, you use the LM2596; if you want 5 V or 12 V from a single Li-Ion cell, you use the MT3608. The LM2596 needs the input to be at least 1.5–2 V above the output to work; with the MT3608 the output must always be higher than the input.

FeatureMT3608 (boost)LM2596 (buck)
TopologyBoost (step-up)Buck (step-down)
Input range2–24 V4.5–40 V
Output rangeAbove the input, up to 28 V1.23–37 V, at least 1.5 V below the input
Switching frequency1.2 MHz150 kHz
Current4 A switch limit, about 1 A output at 5 V in practice3 A rated, about 2 A in practice without a heatsink
Module sizeAbout 36×17 mmAbout 43×21 mm
Typical use5 V, 9 V, 12 V from a single Li-Ion cell5 V or 3.3 V from a 12–24 V adapter

So what if you want 3.3 V from a single Li-Ion cell? Because the battery varies between 4.2 V and 3.0 V, the output is sometimes below the input and sometimes above it; neither a pure boost nor a pure buck converter suits this job. The right solution is either a buck-boost converter or a low-dropout (LDO) regulator. Classic regulators like the AMS1117 need about 1.1 V of dropout, so they struggle to give 3.3 V straight from a battery; see the AMS1117 post for details. In practice the easiest way is to boost the battery to 5 V with the MT3608 and feed that to the board's own regulator; the ESP32 example below does exactly this.

Measuring battery and output voltage with an Arduino

While adjusting the trimpot, or when you want to watch how much charge the battery has left, you can use the Arduino Uno as a simple two-channel voltmeter. In this example the Uno is powered from USB. Since the battery voltage is at most 4.2 V, it can connect straight to A1. The module's output can reach 28 V, so it goes to A0 through a voltage divider of 100 kΩ (top) and 15 kΩ (bottom); the highest voltage this divider can measure is 5 × 115 / 15 ≈ 38 V, so it safely covers the module's whole range. The battery's negative terminal, the module's VIN− and the Uno's GND must be connected together.

C++ (Arduino IDE)
1// MT3608 ayar yardımcısı: pil ve çıkış gerilimini ölçer / MT3608 helper: measures battery and output voltage
2const int PIN_OUT = A0;        // MT3608 çıkışı, 100k/15k bölücü üzerinden / MT3608 output via 100k/15k divider
3const int PIN_BAT = A1;        // pil gerilimi, doğrudan (en fazla 4,2 V) / battery voltage, direct (max 4.2 V)
4const int PIN_LED = 13;        // düşük pil uyarısı / low battery warning
5const float VREF = 5.0;        // Uno ADC referansı / Uno ADC reference
6const float R_TOP = 100000.0;  // üst direnç / top resistor
7const float R_BOT = 15000.0;   // alt direnç / bottom resistor
8const float BAT_LOW = 3.3;     // uyarı eşiği / warning threshold
9
10float readPinVoltage(int pin) {
11  long sum = 0;
12  for (int i = 0; i < 32; i++) {   // 32 örnek ortalaması / average of 32 samples
13    sum += analogRead(pin);
14    delay(1);
15  }
16  return (sum / 32.0) * VREF / 1023.0;
17}
18
19void setup() {
20  Serial.begin(9600);
21  pinMode(PIN_LED, OUTPUT);
22}
23
24void loop() {
25  float vOut = readPinVoltage(PIN_OUT) * (R_TOP + R_BOT) / R_BOT;  // bölücüyü geri hesapla / undo the divider
26  float vBat = readPinVoltage(PIN_BAT);
27
28  Serial.print(F("Pil / Battery: "));
29  Serial.print(vBat, 2);
30  Serial.print(F(" V   Cikis / Output: "));
31  Serial.print(vOut, 2);
32  Serial.println(F(" V"));
33
34  digitalWrite(PIN_LED, vBat < BAT_LOW ? HIGH : LOW);   // pil zayıfsa LED yanar / LED on when battery is low
35  delay(500);
36}

The code averages 32 readings on each channel, which largely suppresses the converter's switching noise. The value on A0 is first converted to the 0–5 V range, then multiplied by (R_TOP + R_BOT) / R_BOT, that is 7.67, to get the real output voltage. The Uno's 5 V reference can vary between 4.8 and 5.1 V on USB; for a more accurate result, measure the 5V pin with a multimeter and put that number in VREF. Open the Serial Monitor and turn the trimpot, and you'll see the output voltage change live. If you want to turn this idea into a full device with an LCD, the building an Arduino voltmeter post is waiting for you.

Powering the ESP32 from a single 18650 cell

ESP32 DevKit boards run at 3.3 V, but the board's 5V (VIN) pin goes to a linear regulator similar to the AMS1117, and to give a stable 3.3 V this regulator wants about 4.3 V at its input. A full 18650 battery starts at 4.2 V and quickly falls to 3.7 V, so connecting it straight to VIN makes the voltage collapse during Wi-Fi's short 300–500 mA current peaks and the board keeps restarting. A reliable chain is: 18650 → protected TP4056 → MT3608 (5.05 V) → 470 µF capacitor → ESP32 5V pin. The capacitor covers the short dips caused by the boost converter not keeping up with Wi-Fi peaks; for the resets these dips cause, see the brownout post. To monitor the battery voltage, we go from the battery's positive terminal to GPIO 34 through a 100 kΩ + 100 kΩ divider; 4.2 V becomes 2.1 V after the divider, which stays in the range the ESP32 ADC measures comfortably.

C++ (Arduino IDE)
1#include "esp_sleep.h"
2
3// ESP32 pil izleme: düşük pilde derin uyku / ESP32 battery monitor: deep sleep on low battery
4const int PIN_BAT = 34;          // pil, 100k/100k bölücü üzerinden / battery via 100k/100k divider
5const int PIN_LED = 2;           // kart üzerindeki LED / onboard LED
6const float DIV_RATIO = 2.0;     // (100k + 100k) / 100k
7const float BAT_CUTOFF = 3.30;   // bu değerin altında uyu / sleep below this value
8const uint64_t SLEEP_US = 10ULL * 60ULL * 1000000ULL;  // 10 dakika / 10 minutes
9
10bool ledState = false;
11
12float readBattery() {
13  uint32_t sum = 0;
14  for (int i = 0; i < 16; i++) {
15    sum += analogReadMilliVolts(PIN_BAT);   // kalibre edilmiş mV / calibrated millivolts
16    delay(2);
17  }
18  return (sum / 16.0) / 1000.0 * DIV_RATIO;
19}
20
21void setup() {
22  Serial.begin(115200);
23  pinMode(PIN_LED, OUTPUT);
24  delay(200);
25}
26
27void loop() {
28  float vBat = readBattery();
29  Serial.printf("Pil / Battery: %.2f V\n", vBat);
30
31  if (vBat < BAT_CUTOFF) {
32    Serial.println("Pil zayif, derin uyku / Battery low, deep sleep");
33    digitalWrite(PIN_LED, LOW);
34    esp_sleep_enable_timer_wakeup(SLEEP_US);   // 10 dakika sonra tekrar kontrol / check again in 10 minutes
35    esp_deep_sleep_start();
36  }
37
38  ledState = !ledState;                      // çalışıyorum işareti / heartbeat
39  digitalWrite(PIN_LED, ledState ? HIGH : LOW);
40  delay(2000);
41}

The analogReadMilliVolts() function returns millivolts directly using the ESP32's factory calibration and works the same way on Arduino core 2.x and 3.x; GPIO 34 is on an ADC1 channel, so you can measure even while Wi-Fi is on. When the battery drops below 3.3 V the board goes into a 10-minute deep sleep. To be honest here: in deep sleep the ESP32 chip drops to microamps, but the MT3608, the on-board regulator and the USB chip keep running, so total consumption can stay at a few milliamps. Deep sleep slows the drain; what really protects the battery from over-discharge is the protection circuit on the TP4056 module or inside the cell. If you're aiming for long battery life, check the bare-module and low-current regulator suggestions in the ESP32 deep sleep guide.

Powering the Raspberry Pi Pico from a single cell

The Pico is lucky here: the VSYS pin (pin 39) accepts 1.8–5.5 V, and the RT6150 buck-boost converter on the board makes a stable 3.3 V from it. So the Pico itself doesn't need an MT3608; you can connect the Li-Ion cell straight to VSYS. If both USB and the battery will stay connected, put a Schottky diode (for example a 1N5817) between the battery and VSYS to stop USB from feeding the battery backwards. The MT3608 comes into play here for peripherals that need 5 V: servo motors, WS2812B LEDs or modules like the HC-SR04 are powered from the module's 5 V output, with their grounds joined to the Pico's GND. Thanks to the 1/3 divider on the board, the Pico can read VSYS voltage from ADC channel 3 (GP29); the code below is for the standard Pico, because on the Pico W this pin is shared with the wireless chip, so the measurement is done differently.

MicroPython
1from machine import ADC, Pin
2import time
3
4vsys = ADC(29)                  # VSYS / 3, yalnız standart Pico / VSYS / 3, standard Pico only
5led = Pin(25, Pin.OUT)          # dahili LED / onboard LED
6CONV = 3 * 3.3 / 65535          # ham değeri volta çevir / raw value to volts
7BAT_LOW = 3.4                   # uyarı eşiği / warning threshold
8
9while True:
10    total = 0
11    for _ in range(16):         # 16 örnek ortalaması / average of 16 samples
12        total += vsys.read_u16()
13        time.sleep_ms(2)
14    v = total / 16 * CONV
15    print("VSYS: {:.2f} V".format(v))
16    if v < BAT_LOW:
17        led.toggle()            # pil zayıf: LED yanıp söner / battery low: LED blinks
18    else:
19        led.value(1)            # pil iyi: LED sürekli yanar / battery ok: LED steady
20    time.sleep(1)

Project ideas with a boost converter module

  • Portable ESP32 sensor station: With a single 18650, a TP4056 and an MT3608, send temperature and humidity data over Wi-Fi and add the battery voltage to the same packet.
  • Battery-powered robot car: Instead of a two-cell pack, set up a 5 V logic supply from a single cell and an MT3608; power the motors from a separate driver. To get started, see the robot car post.
  • 12 V mini fan or small LED strip: Boost from 3.7 V to 12 V to run loads that don't exceed 300 mA.
  • Pocket plant watering: In a battery-powered system, run a 5 V mini water pump in short bursts and add a large capacitor to the output.
  • Running an Arduino Uno from a battery: Set the MT3608 to 9 V and feed the DC jack or VIN pin; the board's regulator handles the rest. For other options, see the Arduino power supply guide.
  • Mini power bank with USB output: Set the MT3608 output to 5.1 V and charge small devices through a female USB-A socket.

Common mistakes and how to fix them

SymptomLikely causeFix
Output is almost the same as the inputTrimpot is at its lowest position or being turned the wrong wayWith the multimeter connected, turn the trimpot 10–20 turns the other way
Board burned out as soon as it was connectedModule was set to 12–28 V and connected straight to the 5V pinMeasure every new module unloaded and connect it only after adjusting
ESP32 resets when Wi-Fi turns onVoltage collapses on current peaks; wires are thin or longAdd 470–1000 µF to the output, shorten and thicken the wires
Module gets very hotOutput current is too high or the boost ratio is highCalculate the input current, reduce the load or choose a stronger module
There's still voltage at the output even when the battery is emptyWhen the converter turns off, the battery feeds the output through the inductor and diodeFor a true shutoff, put a switch or MOSFET on the input
Battery won't charge at all, swollenAn unprotected cell was over-dischargedUse a protected TP4056 or a protected cell, and replace the cell
Analog readings jitterSwitching ripple is reaching the ADCTake an average, add 100 nF and 10 µF to the sensor supply
On most boards the module's EN (enable) pin is permanently tied to VIN, so you can't switch the MT3608 off in software. If your project will sit on a battery for a long time, the cleanest solution is a switch on the input or a P-channel MOSFET controlled by the Arduino; even with no load, the boost converter draws a small but non-zero current because of the feedback divider and the chip's own consumption.

When set correctly and used within its limits, the MT3608 is an extremely handy module that turns a single Li-Ion cell into a 5 V or 12 V power supply. There are three rules to remember: measure the output before connecting, calculate the current on the battery side with the formula, and use a protected cell. In the BlueGrays app you can explore battery-friendly projects such as ESP32 deep sleep, a digital voltmeter, a robot car and WS2812B, each with a step-by-step circuit diagram and ready code, and build the power supply yourself with the chain in this post.

Frequently asked questions

How many amps can the MT3608 deliver?

The MT3608's 4 A figure is the peak current limit of the switch inside the chip, not the current you can take from the output. From a single 3.7 V Li-Ion cell, realistic continuous limits are about 1 A at 5 V, 0.5 A at 9 V and 0.3–0.35 A at 12 V. Beyond that the chip overheats and the battery current exceeds 2 A.

Can you get 12 V from a 3.7 V battery with the MT3608?

Yes, you can set the output to 12 V by turning the trimpot with a multimeter connected. But drawing 0.35 A at 12 V means about 1.34 A from the battery at 3.7 V, and around 1.7 A when the battery falls to 3.0 V. It suits small fans, short LED strips and low-current modules, not motors or long strips.

What's the difference between the MT3608 and the LM2596?

The MT3608 is a boost converter that steps voltage up, and its output is always higher than its input. The LM2596 is a buck converter that steps voltage down and needs the input to be at least 1.5–2 V above the output. Use the MT3608 for 5 V from a single-cell battery, and the LM2596 for 5 V from a 12 V adapter.

Which way do you turn the MT3608 trimpot to increase the voltage?

On most modules, turning the trimpot counter-clockwise raises the output voltage, but this can vary by manufacturer. The trimpot is multi-turn, so the full range takes 15–25 turns and you may see no change in the first few turns. Always adjust with a multimeter connected to the output and with no load.

Why does a boost converter module get hot?

As the boost ratio increases, the current drawn from the input grows, and that current turns into heat in the chip, inductor and diode. For example, taking 1 A at 5 V from 3.7 V means more than 1.5 A from the battery. Slight warmth is normal; if it's too hot to touch, reduce the load or move to a more powerful converter.

Does the ESP32 run directly from an 18650 battery?

The ESP32 chip runs at 3.0–3.6 V, but the regulator on a DevKit board's 5V pin wants about 4.3 V for a stable 3.3 V. So connecting the battery straight to the 5V pin causes resets once the battery falls below 3.7 V. A practical solution is to boost the battery to 5 V with the MT3608, or to connect it to the 3V3 pin through a low-dropout LDO.

See all projects
LED Blink with ESP32
ES-1Beginner

LED Blink with ESP32

Teaches basic GPIO output usage with ESP32. We achieve a blinking effect by turning an LED on and off from a digital pin. ESP32 version of the classic blink project on Arduino UNO; the basic blink commands in the Arduino environment are the same, but the ESP32's pin layout and 3.3 V GPIO levels differ from those of the Arduino UNO.

4.7(37)
108
Raspberry Pi Pico Onboard LED Blink (Pico and Pico W)
PI-1Beginner

Raspberry Pi Pico Onboard LED Blink (Pico and Pico W)

The opening project of the Raspberry Pi Pico series! We blink the Pico's green built-in LED to confirm the board works, the classic "Hello World" first experiment. No external parts needed, just the Pico and a USB cable. The code is written in MicroPython, the language officially supported by the Raspberry Pi Foundation.

5.0(1)
10
ESP32 Deep Sleep — Battery Saving (OLED + RTC RAM Counter)
ES-33Advanced
Premium

ESP32 Deep Sleep — Battery Saving (OLED + RTC RAM Counter)

The ESP32's Deep Sleep mode shuts down the CPU and most peripherals, cutting current draw to about 10µA, which is vital for battery-powered IoT devices. This project uses three wake-up sources: a timer (15 s), an external pin (EXT0, the button on GPIO 33) and a touch pin (T0/GPIO 4). Counters marked with RTC_DATA_ATTR survive deep sleep.

4.3(10)
16
Digital Voltmeter with LCD Display
AR-56Intermediate
Premium

Digital Voltmeter with LCD Display

Find out how much voltage a battery or power adapter gives with a meter you built yourself.

4.5(27)
36
Bluetooth Controlled Car with L298N
AR-80Advanced
Premium

Bluetooth Controlled Car with L298N

Turn your phone into a remote and drive your own robot car. The Arduino receives commands from a remote-control app on your phone through a Bluetooth module and spins the wheels with a motor driver…

5.0(39)
66
Obstacle Avoidance Robot
AR-81Advanced
Premium

Obstacle Avoidance Robot

How about building a smart vehicle that finds its own way? The Obstacle Avoidance Robot constantly scans its surroundings thanks to the ultrasonic sensor in front of it.

5.0(38)
49
ESP32 WS2812B NeoPixel Strip Control
ES-24Intermediate
Premium

ESP32 WS2812B NeoPixel Strip Control

WS2812B (NeoPixel) addressable LEDs are smart RGB LEDs that can be chained and controlled from a single data pin. In this project we drive an 8-LED WS2812B strip with the Adafruit_NeoPixel library and create a smooth rainbow animation. The ESP32's 3.3V logic works with most WS2812B batches; if it gets unstable, we show the fix with a 470Ω series resistor and a 1000µF capacitor. The animation shifts the hue in HSV color space.

4.9(19)
30
Smart Irrigation Station
AR-83Advanced
Premium

Smart Irrigation Station

A gardener that waters your plants on its own, so they don't dry out while you're on vacation.

5.0(42)
57