Components · 10 min read

Jumper Wires for Arduino: Types, AWG, Current and Testing

Jumper wires for Arduino: male-male, male-female and female-female types, AWG gauge and current, loose contacts, multimeter testing and crimping Dupont wires.

Jumper wires for Arduino are thin wires with 2.54 mm pitch Dupont connectors on both ends, used to connect a breadboard, an Arduino and sensor modules in seconds without soldering. In short, a jumper wire is a plug-in wire bridge for trying out, changing and taking apart a circuit. Depending on whether the ends are male (with a pin) or female (with a socket), there are three basic types, male-male, male-female and female-female, and each is designed for a different kind of connection.

They look like the cheapest part of the kit, yet a surprising share of beginner problems comes from them: a sensor that sometimes doesn't respond, an I2C display that appears and disappears, or a board that resets when you touch a wire. In this article you'll learn the types of jumper wires and which one to use for each connection, how much current each wire gauge (AWG) can carry, how to catch a loose contact or a broken wire with a multimeter and a small Arduino sketch, how to make your own Dupont wires, and how to lay out a breadboard for the Arduino Uno, ESP32 and Raspberry Pi Pico.

Male-male, male-female and female-female jumper wires
Jumper wires sold as ribbons: 2.54 mm Dupont connectors at the ends and colored wires you can peel off one by one.

What is a jumper wire and what is it used for?

A jumper wire has three parts: a thin, flexible copper wire, a metal terminal crimped onto the end of the wire and a plastic housing around it. The terminal can be male, a pin about 0.6 mm thick that goes into a breadboard hole, or female, a spring socket that slides over a header pin. This connector system is commonly called Dupont. Because the pitch is 2.54 mm (0.1 inch), it fits all standard pin headers, breadboards, the Arduino's female headers and the male pins of modules. Jumper wires are usually sold as 40-wire colored ribbons in 10, 20 and 30 cm lengths, and you peel off as many as you need. Note that "jumper" means something else in electronics too: the small plastic cap that shorts two pins on boards like the L298N is also called a jumper (shunt). In this article, the jumper is the wire.

Types of jumper wires: male-male, male-female, female-female

TypeEndsWhere is it used?Example connection
Male-male (M-M)Pins on both endsInside the breadboard and between the breadboard and the Arduino Uno's female headersUno 5V → breadboard + rail
Male-female (M-F)A pin on one end, a socket on the otherConnecting a module with pins to the breadboard or the UnoHC-SR04 male pins → Uno D9 and D10
Female-female (F-F)Sockets on both endsJoining two male headers directly, without a breadboardESP32 pins → L298N IN1–IN4
Solid-core breadboard wireStiff wire cut and bent into a U shapeShort, flat and tidy connections on the breadboardJoining rails, connecting an LED to its resistor
Alligator clip leadSpring clipsTemporary connections to batteries, multimeters and screw terminalsTrying a battery pack on the circuit

For a first set we recommend one ribbon of each type (40 wires, 20 cm); male-male and male-female are the ones you run out of first. 20 cm is ideal for most desktop circuits. 30 cm wires are handy for reaching a distant sensor but make the circuit messy, and for connections inside the breadboard a solid-core jumper kit looks much tidier. We compare starter kit contents in Arduino starter kit.

Solid core or stranded? Copper or CCA?

Dupont jumper wires usually have a stranded conductor made of 7 or more fine strands: it's flexible and survives bending, but if the end is left bare the strands splay. Breadboard jumper wires, on the other hand, have a single thick solid-core wire: it goes straight into the hole and stays put, but it breaks if bent many times at the same point. Some cheap wires aren't pure copper but aluminum with a thin copper coating (CCA). CCA has about 50–60% more resistance than copper of the same gauge and breaks more easily. It's easy to spot: cut the end and scrape the wire; if it's silver inside, it's CCA. It's fine for signal lines, but on motor and servo power lines it increases the voltage drop.

Wire gauge (AWG) and current capacity

AWGDiameterCross-sectionCopper resistanceResistance of 20 cmPractical limit as a jumper
300.25 mm0.05 mm²0.34 Ω/m0.068 Ω0.3 A
280.32 mm0.08 mm²0.21 Ω/m0.043 Ω0.5 A
260.40 mm0.13 mm²0.13 Ω/m0.027 Ω1 A
240.51 mm0.21 mm²0.084 Ω/m0.017 Ω2 A
220.64 mm0.33 mm²0.053 Ω/m0.011 Ω2–3 A in the wire; breadboard contacts limit it to about 1 A

The bigger the AWG (American Wire Gauge) number, the thinner the wire; every 6 gauges the diameter halves. Most jumper wires on the market are 26 or 28 AWG, and the cheapest go down to 30 AWG. The last column of the table is more about the Dupont contacts than the wire itself: a cheap contact heats up above 1 A and its resistance rises. The real problem, though, shows up before the heat: voltage drop, which is easy to work out with Ohm's law (V = I × R). If you power a servo through two 20 cm jumpers (out and back), CCA wire plus four contacts can add up to 0.3–0.5 Ω. For an MG996R drawing 1.5 A at start-up, that's 0.45–0.75 V lost: the 5 V supply reaches the servo as about 4.3 V, and an Arduino on the same line may reset. Run the numbers with your own values in the Ohm's law calculator.

Use jumper wires and the breadboard only for low voltage and low current (up to 1 A). For a motor driver supply, an LED strip or a battery pack, use screw terminals and at least 20–22 AWG wire. And never carry mains voltage (110–230 V) through jumper wires or a breadboard.

Breadboard layout: Arduino Uno, ESP32 and Raspberry Pi Pico

BoardDoes it fit the breadboard?Recommended wireTip
Arduino UnoNo, it sits next to itMale-maleBring 5V and GND to the breadboard rails first and power the modules from the rails
Arduino NanoYes, across the center channelMale-male or solid-core wire2–3 open holes remain on each side; point the USB end toward the edge of the breadboard
ESP32 DevKit (30-pin)Yes, but tightMale-male, male-female if neededOnly one row of holes stays open on each side; joining two breadboards side by side is the easiest fix
ESP32 DevKitC (38-pin)Covers one side completelyFemale-female or male-femaleKeep the board off the breadboard and connect its pins directly with female ends
Raspberry Pi PicoYes, a perfect fitMale-maleWith the pins in rows c and h, two holes stay open on each side; its 8 GND pins make reaching the rails easy

Whatever the board, the layout follows the same logic: power first. Run the board's 5V or 3V3 pin to the breadboard's + rail with a red wire and GND to the − rail with a black wire, and power sensors and modules from those rails. On some long 830-point breadboards the rails are split in the middle; don't forget a short bridge between the two halves, or check them end to end with a multimeter. The ESP32 and Pico run at 3.3 V, so keep 5 V on a separate rail and never plug a jumper carrying 5 V into a GPIO. We explain the inside of a breadboard in detail in How to use a breadboard.

  • Red: 5 V or 3.3 V supply; if you have both, use orange for 3.3 V.
  • Black or brown: GND.
  • Yellow and white: digital signals, such as button and sensor outputs.
  • Green and blue: communication lines such as I2C (SDA, SCL) or UART (TX, RX).
  • Purple and gray: PWM outputs and analog inputs.

Loose contacts and broken wires: symptoms and causes

A bad jumper wire is rarely completely broken; most of the time it works "sometimes", which is why it's the fault that wastes the most time. Typical symptoms: a sensor gives meaningless or jumpy values, the I2C scanner sees the display one moment and not the next, an LED flickers when you touch the wire, or the board resets when you bump the table. The causes are few. The spring inside female ends opens up after being pushed onto thick pins many times and no longer grips. Cheap male pins are thin and sit loosely in the breadboard or the Uno's headers. The sneakiest one is strands breaking inside the insulation right where the wire is crimped into the terminal: the wire looks fine from the outside but loses the connection when bent. On wires kept in a damp place for a long time, the terminals also oxidize and the contact resistance goes up.

How to test jumper wires with a multimeter

  1. Set the multimeter to continuity (beep) mode; if it doesn't have one, use the 200 Ω resistance range.
  2. Touch the probe tips together and note the reading (usually 0.1–0.3 Ω); that's the resistance of the probes themselves.
  3. Touch the male end directly with a probe; for a female end, push a short male pin into it and touch that pin.
  4. A good 20 cm jumper beeps and adds at most a few tenths of an ohm on top of the probe resistance.
  5. While measuring, gently bend both ends of the wire, especially just behind the connector. If the beep cuts out or the value jumps, the wire is faulty.
  6. Cut or mark the faulty wire right away; if you put it back in the box, it will end up in your hands again one day.
A multimeter's beep is slow to catch short dropouts; you won't hear contact losses of a few milliseconds. A microcontroller, however, notices even a dropout that short, and I2C communication fails right at that moment. That's why it's worth also trying suspicious wires with the test code in the next section. For the other multimeter functions, see How to use a multimeter.

An Arduino jumper wire tester: catch the loose contact

This small sketch turns an Arduino into a wire tester that counts dropouts. Connect one end of the wire under test to D2 and the other to GND. Because D2's internal pull-up resistor is enabled, the pin reads LOW while the wire is good and HIGH the moment contact is lost. The real work is done by an interrupt: every time the pin goes from LOW to HIGH, even for just a few microseconds, the counter goes up by one. If the dropout count rises in the Serial Monitor while you bend the wire, that wire belongs in the trash. On an ESP32 the code automatically uses GPIO 4 and the on-board LED (GPIO 2).

C++ (Arduino IDE)
1// Jumper kablo test cihazı / jumper wire tester
2// Kablonun bir ucu TEST_PIN'e, diğer ucu GND'ye / one end of the wire to TEST_PIN, the other to GND
3#if defined(ESP32)
4const byte TEST_PIN = 4;             // ESP32: GPIO 4
5const byte LED_PIN = 2;              // DevKit kart LED'i / DevKit on-board LED
6#else
7const byte TEST_PIN = 2;             // Uno: kesme pini D2 (ya da D3) / interrupt pin D2 (or D3)
8const byte LED_PIN = LED_BUILTIN;    // Uno: D13
9#endif
10
11#ifndef IRAM_ATTR
12#define IRAM_ATTR                    // AVR'de boş; ESP32'de kesmeyi RAM'e alır / empty on AVR; keeps the ISR in RAM on ESP32
13#endif
14
15volatile unsigned long dropouts = 0; // temas kesilme sayısı / number of contact dropouts
16
17void IRAM_ATTR onDropout() {         // pin HIGH'a çıktı: temas koptu / pin went HIGH: contact lost
18  dropouts++;
19}
20
21void setup() {
22  pinMode(TEST_PIN, INPUT_PULLUP);   // kablo yokken HIGH, sağlam kabloda LOW / HIGH with no wire, LOW with a good wire
23  pinMode(LED_PIN, OUTPUT);
24  Serial.begin(9600);
25  attachInterrupt(digitalPinToInterrupt(TEST_PIN), onDropout, RISING);
26  Serial.println(F("Kabloyu bagla ve uclarini kipirdat / connect the wire and wiggle the ends"));
27}
28
29void loop() {
30  bool ok = (digitalRead(TEST_PIN) == LOW);   // LOW = kablo iletiyor / LOW = wire conducts
31  digitalWrite(LED_PIN, ok);
32
33  noInterrupts();                             // sayacı güvenle oku / read the counter safely
34  unsigned long n = dropouts;
35  interrupts();
36
37  Serial.print(ok ? F("SAGLAM / OK    ") : F("ACIK / OPEN    "));
38  Serial.print(F("kopma / dropouts: "));
39  Serial.println(n);
40  delay(250);
41}

On the Raspberry Pi Pico, the same test is done in MicroPython. Connect the wire between GP15 (physical pin 20) and the nearby GND (physical pin 18); with current MicroPython versions, Pin("LED") drives the on-board LED on both the Pico and the Pico W. Before trying suspicious wires, connect GP15 to GND with a wire you know is good and check that it prints SAGLAM / OK, so you know the setup itself works.

MicroPython
1from machine import Pin
2import time
3
4test = Pin(15, Pin.IN, Pin.PULL_UP)     # kablo GP15 (pin 20) ile GND (pin 18) arasında / wire between GP15 (pin 20) and GND (pin 18)
5led = Pin("LED", Pin.OUT)               # kart üzerindeki LED / on-board LED
6dropouts = 0
7
8def on_dropout(pin):                    # pin 1'e çıktı: temas koptu / pin went to 1: contact lost
9    global dropouts
10    dropouts += 1
11
12test.irq(trigger=Pin.IRQ_RISING, handler=on_dropout)
13
14while True:
15    ok = test.value() == 0              # 0 = kablo iletiyor / 0 = wire conducts
16    led.value(ok)
17    print("SAGLAM / OK" if ok else "ACIK / OPEN", "kopma / dropouts:", dropouts)
18    time.sleep(0.25)

Making your own Dupont wires

MaterialDescription
Crimping toolSN-28B or PA-09 type for Dupont terminals; ordinary pliers aren't suitable for this
Dupont terminals (male and female)2.54 mm; usually sold in packs of 100
Plastic housings1, 2, 3… positions (1×N or 2×N); a multi-pin housing turns the connector into a single piece
Stranded wire26–28 AWG, preferably pure copper with silicone or PVC insulation
Wire stripperAn adjustable or automatic stripper for thin wires
  1. Cut the wire to the length you want and strip 2–3 mm of insulation from the ends; twist the strands slightly so they don't splay.
  2. Look at the terminal: the small front wings grip the bare wire and the larger rear wings grip the insulation.
  3. Place the terminal in the matching slot of the crimper with the wings facing up and push the wire in until the bare copper sits under the front wings.
  4. Squeeze the crimper all the way; in a good crimp the wings wrap the wire and the insulation in a round shape.
  5. Pull the wire gently: the terminal must not move. If it does, cut it off and redo it.
  6. Push the terminal into the housing with its small latch facing the housing window; it should snap into place with a click.

Making your own wires is cheap and lets you use exact lengths and multi-pin connectors; for example, you can connect all four pins of a sensor module with a single 1×4 housing, which makes plugging it in backwards less likely. A loose female end can usually be saved too: lift the small plastic latch on the housing with a needle, pull the terminal out, squeeze the spring part very slightly with tweezers and push it back in. For permanent circuits, though, a soldered connection is more reliable than a jumper; see Permanent circuits on perfboard.

Common mistakes and fixes

  • Plugging into the wrong row: it's very easy to slip one row on a breadboard; read the letters and numbers as you plug in and compare the circuit with the diagram once more when you're done.
  • Forcing a female end onto a thick pin: screw terminal legs or 1 mm pins open the female spring for good; don't use female ends on pins like that.
  • Long I2C and SPI wires: jumpers longer than 30 cm pick up noise and break fast communication; use short wires for I2C displays and sensors and lower the I2C speed if needed.
  • Forgetting the common GND: if you use two separate power supplies and don't join their GNDs with a jumper, the signals become meaningless; details in Common ground.
  • Pulling a jumper out by the wire: hold the plastic housing, not the wire, when unplugging; pulling on the wire is the number one cause of broken crimps.
  • Putting a bad wire back in the box: cut the wire you suspect right away; fighting the same fault again costs you hours.

Jumper wires are the veins of a circuit: when you pick the right type, keep them short and tidy, and now and then test them and throw out the tired ones, the time you spend hunting for faults drops dramatically. With a solid set of wires on your desk, you're ready for your first circuits. In the BlueGrays app you'll find breadboard starter projects such as the traffic light, the LED with a button, the distance meter and first steps with the Raspberry Pi Pico, with circuit diagrams that show where every wire goes and step-by-step code.

Frequently asked questions

What are jumper wires used for?

Jumper wires are used to make temporary connections between a breadboard, an Arduino and modules without soldering. Thanks to their 2.54 mm Dupont connectors they plug onto and off pins, so you can build and change a circuit quickly.

When do you use male-to-female jumper wires?

Male-to-female wires connect a module with male pins to a breadboard or to the Arduino Uno's female headers. For example, you push the female end onto the pins of an HC-SR04 or DHT11 module and plug the male end into the Arduino or the breadboard.

How much current can a jumper wire carry?

For common 26 AWG jumper wires the practical limit is about 1 A, and about 0.5 A for 28 AWG; most of the time the limit is set by the Dupont contacts rather than the wire. For motors, LED strips and battery packs, use thicker wire and screw terminals.

How do I know if a jumper wire is bad?

Set your multimeter to continuity, measure end to end and bend the wire just behind the connectors while measuring. If the beep cuts out or the resistance jumps, the wire is faulty; to catch very short dropouts you can build a simple Arduino tester that uses an interrupt.

Are Dupont wires and jumper wires the same thing?

In everyday use, yes. Dupont is the name of the 2.54 mm pitch connector system on the ends, and ready-made wires with those connectors are called either jumper wires or Dupont wires.

Which jumper wires should I buy for a breadboard?

To start, one 20 cm ribbon each of male-male, male-female and female-female plus a box of solid-core breadboard wires is ideal. Solid-core wires keep connections inside the breadboard tidy, while flexible Dupont wires reach boards and modules.

See all projects
Traffic Light
AR-3Beginner

Traffic Light

A tiny copy of the traffic light you see on the road every day. Red stays on for two seconds, yellow flashes for a moment, green stays on for two seconds, then it goes back to red through yellow…

4.8(137)
440
LED Control with a Push Button (Push)
AR-9Beginner

LED Control with a Push Button (Push)

Just like a doorbell: the light stays on as long as you press, and goes off when you let go.

4.8(114)
253
Measuring Light Intensity with an LDR
AR-11Beginner

Measuring Light Intensity with an LDR

Want to see how bright your room is as a number? The LDR, a small part that reacts to light, measures the light around it, and the Arduino writes the value to your computer screen every half second.

4.6(83)
143
HC-SR04 Distance Measurement (Serial Display)
AR-27Beginner

HC-SR04 Distance Measurement (Serial Display)

The HC-SR04 sensor works just like a bat finding its way in the dark: it sends out a sound you cannot hear, listens for the echo and measures how far away the object in front of it is.

4.6(50)
82
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
ESP32 Traffic Light
ES-5Beginner

ESP32 Traffic Light

Real traffic light simulation with 3 LEDs red-yellow-green. Timings close to real traffic logic: red long, yellow short, green long. Classic example of sequential GPIO control.

4.4(22)
45
Raspberry Pi Pico: Controlling an External LED (Breadboard)
PI-2Beginner

Raspberry Pi Pico: Controlling an External LED (Breadboard)

The next step after the Pico's built-in LED: connect an external LED on a breadboard and control it through pin GP14. You'll learn how to use any of the Pico's GPIO pins as an output, the LED's polarity (long leg = anode/+, short leg = cathode/–) and why a current-limiting resistor (220Ω) is a must. Without the resistor, too much current flows through the LED and it can burn out.

4.5(2)
7
Raspberry Pi Pico Traffic Light Simulator (3 LEDs Sequential)
PI-4Beginner

Raspberry Pi Pico Traffic Light Simulator (3 LEDs Sequential)

We recreate real traffic light logic with red, yellow and green LEDs, the first Pico project to move up to 3 LEDs! Green says "go" for 4 seconds, yellow "get ready" for 1.5 seconds, red "stop" for 3 seconds, and red+yellow "set off" for 1 second (the European traffic light pattern). You'll learn to define functions (def all_off()), state machine logic and multi-GPIO synchronization.

4.0(1)
12