Use WhatCable to figure out what your USB cable can do

WhatCable is a free, open source Mac app that tells you what a USB-C cable can actually do. Plug a cable in and it shows how fast it moves data, how many watts it can carry and who made it. When something is slow, it tells you which part is holding things back: the cable, the charger, the device on the other end, or the Mac itself.

It helped me find out why my Fujifilm X-M5 didn’t have the right resolution as a webcam: it wasn’t connected with the right cable. The camera has a 10 Gbps USB-C port, and the connection was running at USB 2.0 speed, 480 Mbps.

You want it because USB-C cables all look the same. The cable that came with your phone, the one that came with your monitor and the one you grabbed at the supermarket have the same plug. One of them might carry 240W, and another might not even be able to drive a display.

WhatCable is made by Darryl Morley and released under the MIT license. It runs on Apple Silicon Macs with macOS Sonoma or later. You can keep it in the menu bar or open it as a normal app with a window, and it also ships a whatcable command for the terminal.

Why USB-C cables that look the same are different

USB-C is the shape of the plug. It doesn’t say anything about the wires inside the cable.

A basic USB-C cable carries USB 2.0 data, which tops out at 480 Mbps. Copying a 10 GB folder of videos at that speed takes several minutes. Some cheap cables don’t carry data at all, they only charge.

Faster cables add more pairs of wires. With those you get anything from 5 Gbps for USB 3 up to 40 Gbps for USB4 and Thunderbolt 4, or 80 Gbps for Thunderbolt 5. An external display over USB-C uses the same fast wires, so a USB 2.0 cable can charge your Mac but it can’t drive a monitor.

Power works in a different way. Any USB-C cable can carry 3 amps, which at 20 volts means 60W.

To go above that, the cable needs a tiny chip in its plug called an e-marker. Before raising the current, the charger asks the chip what the cable can handle. If the chip says 5 amps, the charger can deliver 100W at 20 volts, or up to 240W at 48 volts on cables built for it. If there’s no chip, the charger stays at 3 amps to be safe.

The e-marker reports more than the current. It also says how fast the cable is and who made it, and that’s the information WhatCable reads.

Speed and power are two separate ratings. A cable can carry 240W and still be USB 2.0, and a 40 Gbps Thunderbolt cable can top out at 100W. Both cases show up in the example output later in this post.

How to install WhatCable

The simplest way is Homebrew:

brew install --cask whatcable

This puts WhatCable.app in your Applications folder and links the whatcable command into your PATH. That’s how I installed it.

You can also download WhatCable.zip from the releases page, unzip it and drag the app to Applications. The app is notarized by Apple, so Gatekeeper doesn’t block it. With this install, the command lives inside the app at /Applications/WhatCable.app/Contents/Helpers/whatcable, and you can run it from there or link it into your PATH yourself.

It’s not on the Mac App Store. The store’s sandbox blocks some of the power readings the Pro version uses, and there’s no place in a store app for the bundled command line tool.

WhatCable needs an Apple Silicon Mac. Intel Macs don’t publish the USB-C port controller data the app depends on, so there’s nothing for it to read.

One warning before the first launch if you use a KVM switch or an unusual USB hub. By default WhatCable asks the connected USB devices for extra details about what they support, and a few KVM switches and hubs react badly to that. One user reported that their wired mouse stopped working on first launch, and only a restart brought it back. If your setup includes one of those devices, run this before opening the app:

defaults write uk.whatcable.whatcable skipDeepUSBProbing -bool true

It turns on the “Skip deep USB probing” setting, which you’ll also find in the app’s Settings.

What WhatCable shows

The first time you open it, WhatCable asks how you want to use it. You can keep it in the menu bar and click the cable icon to check your ports, or open it as a Dock app with a regular window. I picked the Dock app. You can switch later in Settings, behind the gear icon.

The app shows one card per port, MagSafe included. At the top of each card there’s a plain English headline, like “Thunderbolt / USB4”, “Charging only”, “Slow USB / charge-only cable” or “Nothing connected”.

Below the headline you find the details:

• the cable’s speed and power rating, and its maker when the chip reports one
• every voltage the charger offers (5V, 9V, 15V, 20V…), with the one in use highlighted
• the device on the other end, with the USB devices behind it drawn as a tree, so a dock chained off a display reads as a chain
• for Thunderbolt and USB4 links, the link speed and what travels over it, like video for a display or PCIe for a drive

When something is plugged in, WhatCable compares what the Mac’s port, the cable, the charger and the device each support, and writes a verdict about where the limit is.

For charging you get banners like “Cable is limiting charging speed”, “Charging at 30W (charger can do up to 96W)” when the Mac asks for less because the battery is nearly full, or “Charging well at 96W”. For data you get “Cable is limiting data speed”, or “Device runs at 10 Gbps, this is the fastest it supports, not a cable problem”, which saves you from buying a new cable for nothing.

The app also looks for values in the chip that don’t make sense according to the USB spec, like a zero vendor ID or bits the spec marks as reserved, and points them out in an orange card. A flag only means “this looks unusual”, and the app is careful never to call a cable fake. Cables that carry a USB-IF certification ID get a “USB-IF certified” line with the manufacturer’s name, matched against a list bundled with the app, so nothing is looked up online.

In Settings you can hide empty ports, launch the app at login, show the live charging wattage next to the menu bar icon, and turn on notifications when cables are connected or disconnected. There are desktop widgets in three sizes too. To see the raw IOKit properties behind every card, Option-click the menu bar icon or turn on “Show technical details” in Settings.

Using the whatcable command

The same engine runs in the terminal. Type the command with no options to get a summary of every port:

whatcable

This is the output on my MacBook Pro, with a Studio Display on one port and a second cable plugged into another. I removed the two empty ports, which only say “Nothing connected”:

=== Port-USB-C@1 (USB-C) ===
Connected
No data link or charger detected on this port.

  • Cable has an e-marker chip (advertises its capabilities)
  • Cable speed: USB 2.0 (480 Mbps)
  • Cable rated to 50V / 5 A, delivers up to 240W (USB-PD caps at 48V)

Cable note:
  • E-marker reports no vendor identity
    This cable's e-marker doesn't report a vendor ID, which is common on genuine cables. It's only worth a closer look if the cable's other capability data is also inconsistent.

=== Port-USB-C@3 (USB-C) ===
Thunderbolt / USB4 · 94W charger
Supports high-speed data, smart cable.

  • Linked at up to 20 Gb/s × 2
  • Connected to Apple Inc. Studio Display
  • Connected device: Alternate Mode Adapter, Apple (0x05AC) (PD 3.0)
  • Cable has an e-marker chip (advertises its capabilities)
  • Cable speed: USB4 Gen 3 (40 Gbps, Thunderbolt 4 class)
  • Cable rated for 5 A at up to 20V (~100W)
  • Active copper cable, re-timer
  • Cable made by Apple (0x05AC)
  • System reports charger at 94W

Charging: System reports charger at 94W
  Per-port negotiation data is not available. Wattage is from the system-wide adapter reading.

Data: Device runs at 40 Gbps
  This is the fastest the connected device supports. It is not a cable problem.

Display: Display running at full quality
  Your StudioDisplay is connected and the link has the bandwidth for its top mode. Nothing is holding the picture back.

Thunderbolt fabric:
  • Apple Inc. Studio Display - Up to 20 Gb/s × 2

Active tunnels:
  • Video → Apple Inc. Studio Display · adapter 10
  • PCIe data → Apple Inc. Studio Display · adapter 8

Connected devices:
  • Apple Inc. Studio Display - Thunderbolt link active at 40 Gbps
    ↳ Display: StudioDisplay · video output 10
    ↳ USB2 Hub (Apple) - High Speed (480 Mbps)
      ↳ Shure MV7+ - High Speed (480 Mbps)
    ↳ USB3 Gen2 Hub (Apple) - Super Speed+ (10 Gbps)

Let’s read it port by port.

The cable on port 1 has an e-marker, and the chip says it can handle 5 amps at up to 50 volts. USB Power Delivery stops at 48 volts, so that’s a 240W cable. Its data speed is USB 2.0, which makes it a great charging cable that’s too slow for an external SSD and can’t drive a monitor. WhatCable sees the cable but no device or charger behind it, which is why the port says there’s no data link or charger. The note about the missing vendor ID is only informational, since lots of genuine cables don’t report one.

Port 3 is the Studio Display. The cable is an Apple Thunderbolt cable: 40 Gbps, 5 amps at 20 volts (about 100W), and active, which means it has a chip (here a re-timer) that regenerates the fast signal so it stays clean over the whole length. The display also charges the Mac. WhatCable couldn’t read the per-port power negotiation on this connection, so it tells you the 94W figure comes from the Mac’s system-wide charger reading.

According to the data verdict, 40 Gbps is the fastest the Studio Display supports, so the cable isn’t the bottleneck. This MacBook Pro’s ports could go faster, but the display is a Thunderbolt 3 device. Under “Active tunnels” you see what travels over that link: video for the screen and PCIe for the display’s built-in USB hubs, where my microphone is connected.

JSON output

Add --json to get the same data as JSON. It’s handy with jq. This prints the speed and power rating of the cable on each port:

whatcable --json | jq '.ports[] | {name, speed: .cable.speed, watts: .cable.maxWatts}'

Here are the two ports with a cable:

{
  "name": "Port-USB-C@1",
  "speed": "USB 2.0 (480 Mbps)",
  "watts": 240
}
{
  "name": "Port-USB-C@3",
  "speed": "USB4 Gen 3 (40 Gbps, Thunderbolt 4 class)",
  "watts": 100
}

The empty ports print null for both values.

Watching for changes

--watch keeps running and redraws the summary whenever you plug or unplug something. Press Ctrl+C to stop it.

Combined with --json, it prints one JSON object per change, which is easy to feed into a script:

whatcable --watch --json

Other options

--raw adds the raw IOKit properties for each port to the output.

--report prints a report for every cable with an e-marker, plus a link to a pre-filled GitHub issue. Nothing is sent until you submit that issue yourself. Those reports build the cable database WhatCable uses to name known cables by brand and model.

--no-usb-probe skips the deep USB probing for a single run, the same thing the setting does for the app.

What WhatCable Pro adds

Everything I described so far is free. The developer also sells WhatCable Pro, a one-time purchase that works on two Macs (it cost £9.99 in October 2026). It adds:

• a live power monitor with a graph of the power going into your Mac
• a side by side view of what the port, the cable and the device each support compared with what they agreed on, with the weak link highlighted
• display diagnostics that explain why a monitor runs below its best resolution or refresh rate
• a history for the cables you save, so you can see how each one performed over time
• a full-screen terminal dashboard you start with whatcable --dashboard

The Pro code isn’t in the public repository. The free app is MIT licensed, while the Pro module is proprietary.

How WhatCable works

macOS already knows everything WhatCable shows. When you plug in a cable, the Mac’s USB-C port controller talks to the cable’s e-marker, the charger and the device using USB Power Delivery messages. macOS stores the answers in the IOKit registry, the tree of hardware objects you can browse with the ioreg command.

WhatCable reads a few kinds of objects from that tree:

• AppleHPMInterfaceType10 and its siblings describe each port, like whether something is connected and which kinds of data are flowing (the class name changes between Apple chip generations)
• IOPortFeaturePowerSource lists the voltages the charger offers and which one is in use
• IOPortTransportComponentCCUSBPDSOP holds the identity of the device at the other end, while the SOPp and SOPpp variants hold the e-marker at the near and the far plug of the cable
• the USB controller’s tree, to match each USB device to the physical port it’s plugged into

You can look at the cable data yourself:

ioreg -r -w0 -c IOPortTransportComponentCCUSBPDSOPp

Here are a few lines from the entry for the 240W cable on port 1:

+-o SOP'  <class IOPortTransportComponentCCUSBPDSOPp, id 0x100eda5ca, registered, matched, active, busy 0 (3 ms), retain 8>
      "Metadata" = {"VDOs"=(<00000018>,<00000000>,<00000000>,<40460a00>),"Product Type Description"="Passive Cable","Vendor ID"=0,"Product ID"=0,"VDO Count"=4,"bcdDevice"=0,"Product Type"=3}
      "Description" = "Port-USB-C@1/CC/SOP'"

The last value in VDOs, <40460a00>, is the cable’s capability record. It’s a 32-bit number, and the USB Power Delivery spec defines what each bit means. The bytes are stored in reverse order, so the number is 0x000A4640.

Written out in binary, these are the fields that matter for this cable:

That’s where “USB 2.0” and “240W” in the summary come from.

WhatCable decodes those fields following the spec, and looks up vendor IDs in an SQLite database it ships with. The database merges USB-IF’s official vendor list, the community usb.ids list and cable fingerprints reported by users.

Plug and unplug events reach the app through IOKit notifications. On top of that it re-reads the values every second while its window is visible, and every 30 seconds while it’s hidden, to catch changes like the charging wattage going up or down.

The app, the widgets and the command share the same Swift code. Reading all this needs no background helper and no extra permissions, it runs as a normal app.

Everything is read locally. The app checks GitHub’s releases API about every six hours to see if there’s an update, and sharing diagnostic data with the developer is opt-in, behind a button in Settings.

Limits

Cable details need an e-marker. Most USB-C cables rated for 60W or less don’t have one. For those, WhatCable can still show what the charger and the device negotiated, but it has no chip to read the cable’s speed or rating from.

Some cables only answer once something is plugged into the other end. If a cable shows up as basic, connect a charger or a device to its far end and check again.

WhatCable reports what the chip claims. Software can’t see the copper inside the jacket, so if a cheap cable’s chip says 240W and 40 Gbps but the wiring can’t deliver, the chip is lying to WhatCable too. The app cross-checks the claim against what was actually negotiated, so a mismatch shows up, and it flags odd values in the chip, but it can’t measure the wires.

The front USB-C ports on a Mac mini or Mac Studio are plain USB ports behind an internal hub. Devices plugged into them show up in a “Built-in USB ports” section, but the Mac exposes no cable or power data for them. The rear Thunderbolt ports work fully.

It’s Apple Silicon only, on macOS Sonoma or later.

WhatCable is a young project and it moves fast. The issue tracker has open bugs, like Thunderbolt 5 links reported as 40 Gbps in some views, or a cable’s e-marker that can’t be read with some chargers, so when a verdict surprises you, look at the details before you trust it.

Alternatives

System Information and system_profiler

macOS has its own view of this. Hold the Option key, click the Apple menu and choose System Information. The USB and Thunderbolt/USB4 sections list the connected devices and the speed each link runs at.

You get the same data in the terminal:

system_profiler SPUSBDataType
system_profiler SPThunderboltDataType

If a data type name doesn’t work on your version of macOS, system_profiler -listDataTypes lists the available ones.

What you don’t get is the cable. Those sections describe devices, so the 240W cable on my port 1, with no device behind it, doesn’t appear anywhere. When a device is connected, you see the link speed but not whether the cable or the device decided it.

For charging, system_profiler SPPowerDataType includes the charger’s wattage:

    AC Charger Information:

      Connected: Yes
      ID: 0x0000
      Wattage (W): 94
      Family: 0xe000400a
      Charging: No

ioreg

Everything WhatCable reads is in the IOKit registry, and you saw above how to print the cable entries with ioreg. The data is all there, but you decode the bits yourself.

Hardware testers

A hardware tester checks the cable itself, which no app can do.

The Treedix USB cable tester shows which pins of the plug are connected, so you see which wires actually exist inside the cable. It also measures the cable’s resistance and reads the e-marker.

A USB-C power meter like the ChargerLAB POWER-Z KM003C sits between the charger and the device. It shows the real voltage and current flowing through, and it can read e-markers too.

On Linux

WhatCable is macOS only. On Linux there’s usbeehive, an independent Rust port that reads the USB-C information the Linux kernel exposes in sysfs instead of IOKit.

How I use WhatCable

I installed WhatCable with Homebrew and picked the Dock app, so it opens as a window when I need it instead of living in the menu bar.

I use a Fujifilm X-M5 as my webcam, and it had been giving me trouble. Sometimes I had to restart the camera to get the video input back, and once Fujifilm’s X Webcam app froze every camera on my Mac until its extension was stopped.

Part of the fix was the camera’s mode. X Webcam grabs the camera’s live view in photo-transfer mode and hands it to macOS through its own extension, and macOS listed that virtual camera at 1024×768 only. The X-M5 also has a USB WEBCAM connection mode, where it shows up as a regular webcam that macOS drives itself. I switched to it in the camera’s Network/USB settings and updated the firmware. The camera then appeared as FUJIFILM X-M5, with 1920×1080 and 3840×2160 formats, and I removed X Webcam.

WhatCable helped me with the other part, the cable. The X-M5 has a 10 Gbps USB-C port, but it was connected at USB 2.0 speed, 480 Mbps, in the old mode and in the new one. The cable was the wrong one, and it was holding the camera back as a webcam.

Fujifilm’s own speed table puts USB 2.0 at 480 Mbps (about 60 MB/s) and the X-M5’s port at 10 Gbps, around twenty times more. Uncompressed 4K video at 30 frames per second is about 3 Gbps of data, which fits easily in 10 Gbps. Over 480 Mbps, the camera has to squeeze the video much harder or send fewer pixels.

Fujifilm’s manual asks for a USB cable no longer than 1 m that’s suitable for data transfer, and its support pages recommend USB-IF certified cables. So the fix is a USB-C cable rated for at least 10 Gbps, 1 m or shorter. WhatCable lists every USB device with the speed it’s actually running at, so a camera stuck at USB 2.0 behind a 10 Gbps port stands out.

Want me to talk about your product? You can sponsor this site.