Why Your USB-C Cable Won't Do What You Think (and How to Debug It on macOS)

Every developer with a USB-C hub, an external monitor, and a drawer full of identical-looking cables has been here. You plug in a cable expecting Thunderbolt speeds or 4K output, and you get... USB 2.0. Or no video at all. The cable looks fine. The port looks fine. You start questioning reality.

The problem isn't your Mac. It's that USB-C is a connector shape, not a capability promise. And macOS actually knows what your cables can do — it just buries that information where you'd never think to look.

The Root Cause: USB-C Is a Mess (By Design)

USB-C the physical connector can carry wildly different protocols depending on the cable:

• USB 2.0 — 480 Mbps, the bare minimum
• USB 3.0/3.1/3.2 — various speeds up to 20 Gbps
• Thunderbolt 3/4 — up to 40 Gbps, can carry DisplayPort
• USB4 — up to 40 Gbps (or 80 Gbps with USB4 v2)

A cheap charging cable and a $50 Thunderbolt 4 cable use the same connector. There's no visual difference. USB-IF tried to fix this with logos on the cables, but good luck reading a 2mm icon on a black cable in a dark office.

The real kicker for developers: when you plug in a cable that doesn't support the bandwidth you need, macOS silently downgrades. No warning. Your external display just... doesn't show up, or runs at a lower resolution. Your NVMe enclosure crawls at USB 2.0 speeds. You waste 30 minutes before suspecting the cable.

Step 1: What macOS Already Knows

macOS actually queries USB-C cables for their capabilities through the USB Power Delivery specification. Every USB-C cable has an electronically marked chip (e-marker) that reports what it supports — or in the case of cheap cables, no e-marker at all (which limits it to USB 2.0).

You can see this data right now. Open Terminal and run:

# Dump all USB device info including cable capabilities
system_profiler SPUSBDataType

This gives you a tree of every USB device connected to your Mac. You'll see entries like:

USB31Bus:
  Host Controller Driver: AppleT8122USBXHCI
    USB3.1 Hub:
      Product ID: 0x1234
      Vendor ID: 0x5678
      Speed: Up to 10 Gb/s
      ...

The Speed field tells you what the cable actually negotiated — not what you hoped it would do. If you plugged in a Thunderbolt dock but see Up to 480 Mb/s, your cable is the bottleneck.

For Thunderbolt specifically, there's a separate command:

# Check Thunderbolt connections and negotiated link speed
system_profiler SPThunderboltDataType

This will show you the Thunderbolt bus topology, including Link Speed for each connection. If your Thunderbolt cable only negotiated a 20 Gbps link when you expected 40 Gbps, you've got a cable that doesn't fully support the spec.

Step 2: Digging Deeper with IORegistry

If system_profiler doesn't give you enough detail, macOS has a lower-level tool that exposes the raw IOKit device tree:

# Search for USB-C port and cable property details
ioreg -r -c AppleUSBDevice -l | grep -A 20 "USB Speed\|Current Available\|Link Speed"

This digs into the IORegistry, which is where macOS stores the hardware negotiation results. You can find properties like:

• Current Available — how much power the port is providing
• USB Speed — the negotiated data rate
• Port Connector Type — confirms it's a USB-C connection

The problem? This output is a wall of text. You need to already know what you're looking for, cross-reference device IDs, and mentally map port numbers to physical locations on your Mac. It's not exactly developer-friendly.

Step 3: Making This Actually Usable

This is where open-source tooling steps in. The project whatcable takes a practical approach to this problem: it's a macOS menu bar app that reads the cable capability data and translates it into plain English. Instead of parsing system_profiler output, you get a quick summary of what each plugged-in cable actually supports.

It sits in your menu bar, so you can check cable capabilities without opening Terminal at all. If you're the kind of developer who cycles through cables and docks regularly (and let's be honest, who isn't), that saves real time.

Writing Your Own Cable Checker Script

If you prefer a lightweight script over installing an app, here's a quick approach using system_profiler output:

#!/bin/bash
# quick-cable-check.sh — summarize USB-C connection speeds

echo "=== USB Connections ==="
system_profiler SPUSBDataType 2>/dev/null | \
  grep -B 5 "Speed:" | \
  grep -E "^\s+(.*):$|Speed:" | \
  sed 's/^[ ]*//' 
# Pairs each device name with its negotiated speed

echo ""
echo "=== Thunderbolt Connections ==="
system_profiler SPThunderboltDataType 2>/dev/null | \
  grep -E "Device Name|Link Speed|Current Link Width" | \
  sed 's/^[ ]*//' 
# Shows Thunderbolt device names and their active link speeds

This isn't pretty, but it'll immediately tell you if something is running slower than expected. I keep a version of this in my dotfiles and run it whenever an external display acts up.

The Quick Diagnostic Checklist

When a USB-C connection isn't behaving right, here's the order I debug it:

1. Check the negotiated speed — run system_profiler SPUSBDataType and find your device. If the speed is lower than expected, it's the cable.
2. Try the cable in a different port — Apple Silicon Macs sometimes have different capabilities per port (especially the front vs. back ports on Mac Studios).
3. Check power delivery — some cables support data but not sufficient power. system_profiler SPPowerDataType shows charging info.
4. Look for Thunderbolt vs. USB — a Thunderbolt device plugged in with a USB-only cable will fall back to USB mode silently. Check SPThunderboltDataType to see if the device even shows up on the Thunderbolt bus.
5. Label your cables — seriously. I use colored cable ties now. Red for Thunderbolt 4, blue for USB 3.2, no tie for charging-only. It's low-tech and it works.

Prevention: Stop Buying Mystery Cables

The real fix is upstream. A few rules I follow now:

• Only buy cables with clearly stated specs — if the listing doesn't say the exact USB or Thunderbolt version, skip it
• Thunderbolt 4 cables are the safest bet for everything — they support the highest speeds and are backward compatible with USB4, USB 3.x, and Thunderbolt 3
• Short cables are more reliable at high speeds — passive Thunderbolt cables max out at around 0.8m for 40 Gbps; if you need longer, you need an active cable
• Mark cables when you verify them — once you confirm a cable works at the expected speed, label it immediately

Wrapping Up

USB-C cable debugging shouldn't be this hard, but here we are. The good news is macOS has all the information — it's just not surfaced well. Between system_profiler, ioreg, tools like whatcable, and a little cable management discipline, you can stop losing time to mystery bandwidth issues.

The next time your external monitor doesn't work or your SSD enclosure is suspiciously slow, check the cable first. It's almost always the cable.