Powering your Arduino seems simple—just plug it in, right? Well, yes… but also no. While USB works for quick prototyping, your project will eventually need something more reliable, more portable, or just plain more powerful. Should you use a battery pack? A wall adapter? The Vin pin? A secret arcane ritual? (Okay, maybe not that last one.)
In this guide, I’ll break down just about every way to power your Arduino—from USB to batteries, barrel jacks to buck converters—so you can keep your projects running smoothly without overheating, resetting, or turning your board into an expensive smoke machine.
- Power Supply Options
- Understanding Arduino’s Power Requirements
- Option 1: Powering Arduino via USB
- Option 2: Powering Arduino via the Barrel Jack
- Option 3: Powering Arduino via Vin Pin
- Option 4: Powering Arduino via the Onboard Battery Connector
- Powering External Components in Arduino Projects
- What’s a Buck Converter? (And Why You Might Need One)
- What’s Next? Go Build, Test, and Troubleshoot!
Understanding Arduino’s Power Requirements
Before we start plugging in power sources like mad scientists, let’s take a step back and talk about what your Arduino actually needs to stay alive—without frying it.
Common Arduino Operating Voltage Ranges
Different Arduino boards have different appetites when it comes to power. Some are fine dining with a well-regulated 5V, while others can handle a broader range. Here’s a quick summary for the most common boards:
| ARDUINO FAMILIES | VOLTAGE |
|---|---|
| CLASSIC: Uno R3, Uno R4 Wifi, Minima, Leonardo, Micro Zero, etc. | Operating Voltage: 5V Input Voltage: 7-12V (recommended) |
| NANO: Nano, Nano ESP21, 33 Series, Every, etc. | Operating Voltage: 5V (Classic Nano) or 3.3V (Nano 33 series) Input Voltage: 7-12V (recommended) |
| MEGA: Mega 2560, Due, GIGA | Operating Voltage: 5V (Mega) or 3.3V (Due & GIGA) Input Voltage: 7–12V (recommended) |
| MKR: WiFi 1010, WAN 1310, Zero, etc. | Operating Voltage: 3.3V Input Voltage (via battery connector): 3.7V Li-Po Input Voltage (via USB or VIN): 5V (regulated down internally) |
Double check your board’s datasheet to know its voltage limits before you plug anything in. Feeding 12V into a board that wants 5V is like watering a cactus with a fire hose—it won’t end well.
Option 1: Powering Arduino via USB
Using USB from a Computer or Wall Adapter
This is the classic “plug it in and go” method.
How It Works: You power your Arduino via the onboard USB port (Type-B, Micro-USB, or USB-C depending on the board). This gives your board a regulated 5V supply, straight from your computer or wall charger.
Pros of Using a USB Wall Adapter (or from Computer):
- Super easy- just plug and play
- Provides power and serial communication (great for programming and debugging)
- Safe current limits from your computer’s USB port
- Ideal for prototyping and short-term projects
Cons of Using a USB Wall Adapter (or from Computer):
- Limited current (usually 500mA on USB 2.0, 900mA on USB 3.0)
- Tethered to a computer or wall outlet
- Not ideal for permanent or portable projects
Using a USB Power Bank for Mobile Projects
Want to take your project on the go? A USB power bank (the same kind you use to charge your phone) makes it easy to run your Arduino portably while still using the USB port.
How It Works: Plug a USB cable into the power bank and the Arduino—done! You get 5V power without needing a PC.
Pros of Using a USB Power Bank:
- Portable and rechargeable—great for mobile or remote projects
- No wiring or soldering required
- Many modern power banks can supply 2A or more, plenty for Arduino + accessories
- Some include low-power sleep modes for energy-efficient projects
Cons of Using a USB Power Bank:
- Some power banks shut off if your Arduino draws too little current (like <50mA)
- You don’t get serial communication like you do with a computer
- May not last long with high-power accessories
- You’ll need to recharge it—eventually the power runs out
Arduino boards that operate at 5V draw power directly from the USB’s regulated 5V line, while 3.3V boards step down the USB’s 5V supply using an onboard voltage regulator. The available output current from the 5V pin depends on the source supplying the 5V power.
Option 2: Powering Arduino via the Barrel Jack
If you’re ready to cut the USB cord and give your Arduino some independence, the barrel jack is your next best option. In fact, this is the method I use the most to power my own Arduino projects.
This little round plug on your board is your gateway to external power, letting you run your projects without needing a computer. But before you start plugging in random adapters from your junk drawer, let’s talk about how to do it right—because this is one of the easiest ways to fry your Arduino if you’re not careful.
How the Barrel Jack Works
The barrel jack (a.k.a. DC power jack) is that cylindrical power port you’ll find on boards like the Arduino Uno, Mega, and similar models. It’s designed for an external DC power supply and connects to the Vin pin, feeding power through the onboard voltage regulator.
You can use either a wall adapter (plugged into the wall) or a battery pack (for portable power) to supply 7–12V through this jack.
Bonus: The barrel jack includes built-in polarity protection, so if you accidentally grab an adapter with reversed wiring, your Arduino won’t immediately go up in smoke. (Still—double-check your polarity. Let’s not test fate.)
Key Specs:
- Voltage Range: 7V – 12V (ideal), up to 20V (not recommended)
- Polarity: 2.1mm center-positive pin with negative 5.5mm sleeve (always double-check this!)
- Current: At least 1A recommended for stable operation
What happens if you give it the wrong voltage?
- Too low (<7V): The regulator may not provide a stable 5V output, leading to glitches, brownouts, or unexpected reboots.
- Too high (>12V): The onboard regulator has to burn off the excess voltage as heat, which can overheat and shut down your board—or worse.
- Above 20V: Congratulations, you’ve just turned your Arduino into an expensive paperweight.
TIP: A good choice for most Arduino projects is a 9V 1-2A power supply when using the barrel jack.
Using a Wall Adapter with the Barrel Jack
A wall adapter is your go-to option for stationary projects that need reliable, consistent power—without the hassle of recharging or swapping batteries. Just plug it in and let the onboard voltage regulator handle the rest.
How It Works: Plug a regulated DC power adapter (typically 7–12V) directly into the Arduino’s barrel jack. The onboard linear regulator steps it down to the required 5V.
Pros of Using a Wall Adapter with the Barrel Jack:
- Easy and clean—just plug it in
- Great for permanent installations
- Provides more current than USB (typically 1A or more, depending on your adapter)
- Stable voltage if you’re using a quality, regulated adapter
Cons of Using a Wall Adapter with the Barrel Jack:
- Wall-dependent—not portable
- Unregulated or cheap adapters can damage your board
- Going above 12V causes the onboard regulator to overheat
- Limited to boards that have a barrel jack (Uno, Mega, etc.—not Nano or MKR series)
Using a Battery Pack with the Barrel Jack
Need your project to hit the road—or the backyard, the garage, or a haunted house prop? A battery pack plugged into the barrel jack is a simple and portable way to keep your Arduino running wherever you go. It’s perfect for mobile builds, robots, and anything that needs to break free from the wall.
How It Works: Connect a battery pack to a male DC plug and insert it into the barrel jack. The Arduino gets its voltage through the same onboard regulator as with a wall adapter.
Pros of Using a Battery Pack with the Barrel Jack:
- Makes your project portable and untethered
- Still uses onboard voltage regulation—no extra circuitry needed
- Easy to swap batteries or switch packs on the fly
- Great for robotics and field projects
Cons of Using a Battery Pack with the Barrel Jack:
- Batteries deplete over time—you’ll need to monitor voltage
- Using the wrong battery (like a weak 9V) can lead to power drops
- High voltage (12V+) = heat, and heat = sad Arduino
- More wiring involved if you’re assembling your own battery packs
Choosing the Right Battery Pack
- 4x AA Battery Pack (6V) – Not recommended. While it might work on the Vin pin, it’s too low for the barrel jack, and the onboard regulator may not provide a steady 5V output.
- 6x AA Battery Pack (9V) – A good option. Six 1.5V alkaline batteries (or six 1.2V rechargeable NiMH batteries) provide a stable 7.2V-9V—perfect for the barrel jack without overheating the onboard regulator.
- 9V Battery (Single Battery) – Not ideal. While a single 9V battery can power your Arduino, it won’t last long, especially if your project draws more than 100mA. 9V batteries have low capacity and will die quickly under load.
- Lithium Battery Pack (7.4V or 11.1V Li-ion/LiPo) – Great for portable projects. A 7.4V Li-ion pack is perfect for the barrel jack, while an 11.1V pack works but can get warm. If using Li-ion or LiPo, make sure to include a battery management circuit (BMS) or voltage protection module for safe operation.
- 18650 Battery Pack (Two or Three in Series) – Highly efficient. My favorite! Two 18650 Li-ion cells (3.7V each) in series provide 7.4V, which is ideal for the barrel jack. Three cells in series (11.1V) work too but generate a little extra heat in the regulator.
Option 3: Powering Arduino via Vin Pin
If the barrel jack is like the front door of your Arduino’s power system, then the Vin pin is the backdoor—less obvious, but just as effective. The Vin pin (short for Voltage In) gives you another way to power your Arduino with an external 7-12V source, bypassing the USB connection and still making use of the onboard voltage regulator. But just like sneaking in through the backdoor, you need to be careful—use the wrong voltage, and your Arduino might not make it.
The Vin pin can also act as a voltage output when an external power supply is connected to the barrel jack on the Arduino boards that have them. In this case, Vin simply passes through the input voltage from the barrel jack, allowing you to tap into that same power source for other components or circuits—just keep in mind that it’s not regulated, so the output voltage will match whatever you’re supplying through the barrel jack.
How It Works: Connect the positive wire of your wall adapter or battery pack to the Vin pin. Then, connect the negative wire of that power supply to an Arduino ground (GND) pin. The onboard linear voltage regulator will step the voltage down to 5V.
One important difference: The barrel jack has a built-in diode for polarity protection, meaning if you accidentally reverse your power connection, your Arduino will likely survive. Vin has no such protection. If you wire it backwards, you might fry your board instantly—so double-check your connections!
Pros of Using the Vin Pin:
- Great for custom wiring and embedded builds—no bulky plugs needed
- Same voltage range as the barrel jack (7–12V recommended)
- Allows you to power the Arduino from a shared power supply alongside other components
- Ideal when building inside enclosures where jacks aren’t accessible
Cons of Using the Vin Pin:
- No polarity protection—if you mix up + and −, you could damage the board
- Slightly more hands-on—requires wiring, not plug-and-play
- Just like the barrel jack, voltages above 12V will cause the regulator to overheat
- Doesn’t work on boards that don’t expose a Vin pin (some smaller or 3.3V-only models)
Option 4: Powering Arduino via the Onboard Battery Connector
Did you know that some Arduino boards come with a built-in battery connector?
That’s right—no extra wiring, no splicing, no messing with barrel jacks or Vin pins. Just plug in a battery, and boom—your Arduino is up and running like a self-sufficient little machine.
This is a fantastic option for portable projects, robotics, or anything that needs to be untethered from a power outlet. But, as always, there are a few things you need to keep in mind to avoid unexpected shutdowns, overheating, or battery-related mishaps.
What is the Onboard Battery Connector?
Some Arduino boards, such as the Arduino MKR series and Portenta H7, come with a built-in Li-Po (Lithium-Polymer) battery connector. This lets you directly plug in a rechargeable battery, making it a super convenient way to power your board.
How It Works:
- The connector is designed for a single-cell Li-Po battery (3.7V nominal, 4.2V fully charged).
- The board automatically switches between USB power and battery power, ensuring smooth operation.
- Many boards with a battery connector also include a built-in charging circuit, meaning you can recharge the battery simply by plugging the Arduino into a USB power source.
Key Specs:
- Voltage: 3.7V – 4.2V (depends on charge level).
- Battery Type: Typically supports Li-Po (Lithium-Polymer) batteries.
- Charging Support: Many boards will recharge the battery automatically when connected to USB.
Powering External Components in Arduino Projects
So you’ve got your Arduino powered up as well as a few low-powered components—awesome!
But what about everything else in your project? LED strips, motors, sensors, servos—these hungry components all need power too, and (spoiler alert) your Arduino isn’t built to handle all of them directly. If you try, you’ll either end up with weird glitches, random resets, or worst-case scenario—a very sad, overheated Arduino.
Let’s break down how to properly power external components and when to bring in backup power so your project runs smoothly.
How Powering the Arduino is Different from Powering Motors, LED strips, and Servos
Your Arduino board itself doesn’t actually consume much power—it happily sips around 30-50mA, maybe a little more if you’re running a bunch of I/O. The problem starts when you connect components that draw serious current, like:
- LED strips – A single LED might only use 20mA, but an RGB strip can demand several amps!
- Motors & Servos – Can easily spike at hundreds of milliamps or even several amps when starting up.
- Relays, Buzzers, and Displays – Some relays need 100-200mA just to switch on.
- Heaters, Pumps, and High-Power Sensors – Anything that gets warm or moves usually wants more current than your Arduino can provide.
What Happens If You Overload the Arduino’s Power Supply?
Best-case Scenario: Your Arduino resets randomly, or things don’t work as expected.
Worst-case scenario: You overheat the onboard voltage regulator and damage your board.
The golden rule? Use the Arduino to control beefier components, not to power them.
How to Share a Power Source Between Arduino and External Components
If you’re using a wall power adapter or a battery pack, you’ll need to split the power:
- One set of wires to power the Arduino (through the barrel jack or Vin).
- Another set to power your external components.
Here’s the same circuit you see above as a wiring diagram showing only the power connections:
If you Arduino doesn’t have a barrel jack, here’s how to power your board using the Vin pin:
How to Split Power Between the Arduino and External Components:
- Splice the Power Wires – Take the positive (+) and ground (-) from your power adapter or battery pack and split them into two paths:
One pair goes to the Arduino (via the barrel jack or Vin pin).
One pair goes to the external components. - Connect All Grounds Together – The Arduino and external components must share a common ground to ensure a stable circuit.
- Use Buck Converters for Different Voltage Requirements – If some components need 5V, others need 12V, and some need 3.3V, you’ll need buck converters (step-down regulators) to drop the voltage where necessary.
What’s a Buck Converter? (And Why You Might Need One)
Imagine you have a 12V DC motor, but your Arduino is most comfortable with 9V or your servo only need 6V. That’s where the buck converter comes in.
A buck converter is a tiny power circuit that steps down a higher voltage to a lower one—efficiently. Instead of wasting energy as heat, it uses clever switching and inductors to drop the voltage while keeping most of the power intact.
How to Use a Buck Converter:
In order to incorporate a buck converter into your circuit, connect your power source to the converter’s input terminals, then use a multimeter and the built-in adjustment screw to set the output voltage to your desired level before connecting any components. Once set, you can safely power your Arduino or external devices from the output. Just remember to connect all grounds together and avoid exceeding the converter’s voltage or current limits.
In the circuit below, I’m powering a 12V motor with a 12V power supply. This will also work for the Arduino which can accept 7-12V. But sending 12V to the servo will certainly fry it so I added a buck converter to the power lines to step down the 12V to 6V which is safe for the servo.
And here is the same circuit as a breadboard wiring diagram showing only the power connections:
Powering an Arduino and external components from the same power source is totally doable—you just need to split the power correctly, use common ground, and step down voltages where necessary with buck converters. Whether you’re using a power adapter or a battery pack, don’t overload the Arduino’s power pins—let it control the action, while a dedicated power source carries the load.
What’s Next? Go Build, Test, and Troubleshoot!
By now, you’re basically an Arduino power guru. You know when to use USB for quick tests, barrel jacks for steady external power, Vin for direct wiring, and batteries for ultimate portability. You’ve even learned how to separate power for high-current components so your Arduino doesn’t turn into a tiny meltdown machine.
Just remember: give your Arduino the right power source for the job, and don’t expect it to do all the heavy lifting. Whether you’re running LEDs, motors, or sensors, a well-planned power setup means fewer resets, less heat, and way more reliable projects.
Now go forth, power up, and build something awesome!
