When network performance slows down or users report intermittent connectivity, determining whether a switch port is saturated is an essential first troubleshooting step. Cisco Catalyst and Nexus switches continuously track ingress and egress traffic counters across all physical and logical interfaces. By leveraging the Cisco IOS/IOS XE command-line interface (CLI), network administrators can inspect point-in-time throughput, evaluate calculated average load rates, and pinpoint which devices are exhausting available capacity.
Table of Contents
Cisco IOS show interfaces Syntax and Parameter Reference
To inspect interface statistics accurately, you must first understand the primary command structure and the specific data fields Cisco IOS generates.
Command Syntax
show interfaces [interface-id] [accounting | counters | description | stats | status | summary]
Parameter Descriptions
interface-id: The specific physical port or logical interface (for example,GigabitEthernet1/0/1,TenGigabitEthernet1/0/24, orPort-channel1). Omitting this parameter displays statistics for all interfaces on the switch.counters: Displays hardware-level packet counts, octet counts, and operational error counters.description: Lists configured interface descriptions alongside interface administrative and line protocol states.stats: Displays quantum metrics, including fast-switching packet counts, burst rates, and input/output packet distribution.status: Summarizes port status, VLAN assignment, duplex settings, speed negotiation, and media type.summary: Produces a tabular overview of transmit and receive data rates for all interfaces.
Counter and Field Definitions
BW(Bandwidth): The configured administrative bandwidth of the port expressed in kilobits per second (e.g.,BW 1000000 Kbit/sec). This is a static value used by routing protocols (such as OSPF and EIGRP) to compute path metrics; it does not reflect real-time traffic volume.reliability: The ratio of error-free frames to total frames, represented as a fraction of 255 (where255/255indicates 100% reliability over the sampling window).txload/rxload: Transmit and receive interface load represented as a fraction of 255 (where1/255indicates near-zero traffic and255/255represents total saturation).5 minute input/output rate: The exponentially decayed average traffic volume passing through the port, displayed in both bits per second (bps) and packets per second (pps).runts: Packets that fail to meet the minimum Ethernet frame size of 64 bytes and contain an invalid Cyclic Redundancy Check (CRC).giants: Packets that exceed the maximum Ethernet transmission unit (1518 bytes, or configured MTU/jumbo frame size) and contain an invalid CRC.CRC errors: Frames received with an invalid checksum, usually indicative of a physical cable fault, dirty optical fiber, or duplex mismatch.input errors: The aggregate total of runts, giants, CRC, no buffer, frame, overrun, and ignored frames.output errors: Frames the interface was unable to transmit due to excessive collisions, buffer exhaust, or interface resets.
Checking Real-Time and Average Traffic Rates via the CLI
Now that you are familiar with the output parameters, you can use targeted CLI commands to locate active bandwidth bottlenecks.
Step 1: Query a Specific Switch Port
To view detailed operational metrics for a single interface, execute:
Switch# show interfaces GigabitEthernet1/0/1
Locate the input and output rate lines in the output:
Queueing strategy: fifo
5 minute input rate 34520000 bits/sec, 4120 packets/sec
5 minute output rate 812400000 bits/sec, 72340 packets/sec
These values reflect the average throughput over the default 300-second (5-minute) sampling window.
Step 2: Shorten the Sampling Window for Troubleshooting
A 5-minute average can smooth out short bursts that cause dropped packets. You can reduce this sampling period to as low as 30 seconds to capture brief spikes:
Switch(config)# interface GigabitEthernet1/0/1
Switch(config-if)# load-interval 30
Switch(config-if)# end
Re-running show interfaces GigabitEthernet1/0/1 will now display a 30 second input rate and 30 second output rate.
Step 3: Filter Across All Interfaces
To quickly scan all interfaces on a switch for high traffic without wading through screen pages of diagnostic text, use an output filter:
Switch# show interfaces | include (is up|input rate|output rate)
Example filtered output:
GigabitEthernet1/0/1 is up, line protocol is up (connected)
5 minute input rate 124000 bits/sec, 42 packets/sec
5 minute output rate 4521000 bits/sec, 612 packets/sec
GigabitEthernet1/0/2 is up, line protocol is up (connected)
5 minute input rate 912450000 bits/sec, 82140 packets/sec
5 minute output rate 11200000 bits/sec, 1204 packets/sec
Step 4: Review Port Bandwidth Using Summary Mode
To view all switch ports in a clean, tabular format that highlights current rates:
Switch# show interfaces summary
*: interface is looped
$: interface is isdn quiet
Total Incoming Total Outgoing
Interface IHQ IQD Bytes/sec OHQ OQD Bytes/sec
---------------------------------------------------------------------------------------------
* GigabitEthernet1/0/1 0 0 15500 0 0 565125
GigabitEthernet1/0/2 0 0 114056250 0 0 1400000
Note: The show interfaces summary command reports traffic in Bytes/sec. Multiply these numbers by 8 to convert them to bits per second (bps).
Calculating Bandwidth Utilization Percentage
Cisco switches display traffic as absolute bit rates and fractional loads (rxload/txload). To determine whether a link is near capacity, you must calculate its percentage utilization.
The Conversion Formula
Because Ethernet is full-duplex, transmit (Tx) and receive (Rx) channels operate independently. You should compute utilization percentages separately for both directions against the full physical port speed:
$$\text{Utilization (\%)} = \left( \frac{\text{Current Traffic Rate (bps)}}{\text{Physical Interface Speed (bps)}} \right) \times 100$$
Step-by-Step Calculation Example
Suppose show interfaces GigabitEthernet1/0/2 displays:
Full-duplex, 1000Mb/s, media type is 10/100/1000BaseTX
5 minute input rate 750000000 bits/sec, 68420 packets/sec
5 minute output rate 125000000 bits/sec, 14210 packets/sec
rxload 191/255, txload 31/255
- Establish Physical Speed in bps:
A 1000 Mb/s (Gigabit) port provides $1{,}000{,}000{,}000\text{ bps}$. - Calculate Receive (Rx) Utilization:
$$\text{Rx Utilization} = \left( \frac{750{,}000{,}000}{1{,}000{,}000{,}000} \right) \times 100 = 75\%$$ - Calculate Transmit (Tx) Utilization:
$$\text{Tx Utilization} = \left( \frac{125{,}000{,}000}{1{,}000{,}000{,}000} \right) \times 100 = 12.5\%$$ - Verify Against Cisco Hardware Load:
Cisco’s reported load fraction is based on 255:
$$\text{Reported Rx Load} = \frac{191}{255} \approx 0.749 \implies 74.9\%$$
The manual formula and the switch’s internalrxloadarrive at the same figure: the ingress path is running at approximately 75% capacity.
Identifying High-Bandwidth Top Talkers with NetFlow
Knowing that an interface is running at 80% or 90% utilization confirms congestion, but it does not reveal what is causing it. Using Flexible NetFlow (FNF) on supported switches (such as Cisco Catalyst 3650, 3850, 9000 series) allows you to break down traffic by source IP, destination IP, and application port directly from the CLI.
Step 1: Create the Flow Record
Define the parameters you want to capture:
Switch(config)# flow record TOP-TALKERS-RECORD
Switch(config-flow-record)# match ipv4 source address
Switch(config-flow-record)# match ipv4 destination address
Switch(config-flow-record)# match ipv4 protocol
Switch(config-flow-record)# match transport source-port
Switch(config-flow-record)# match transport destination-port
Switch(config-flow-record)# collect counter bytes long
Switch(config-flow-record)# collect counter packets long
Switch(config-flow-record)# exit
Step 2: Configure the Flow Monitor
Create a flow monitor to store the captured telemetry in cache memory:
Switch(config)# flow monitor TOP-TALKERS-MONITOR
Switch(config-flow-monitor)# record TOP-TALKERS-RECORD
Switch(config-flow-monitor)# cache timeout active 60
Switch(config-flow-monitor)# exit
Step 3: Apply the Flow Monitor to the Saturated Interface
Attach the monitor to track inbound packets on the busy port:
Switch(config)# interface GigabitEthernet1/0/2
Switch(config-if)# ip flow monitor TOP-TALKERS-MONITOR input
Switch(config-if)# exit
Step 4: Query the Top Bandwidth Consumers
Inspect the active cache, sorted by total bytes transferred, to identify the heaviest talkers:
Switch# show flow monitor TOP-TALKERS-MONITOR cache sort counter bytes top 5
IPV4 SRC ADDR IPV4 DST ADDR TRNS SRC PORT TRNS DST PORT IP PROT bytes long pkts long
=============== =============== ============= ============= ======= ========== =========
10.10.20.150 192.168.100.25 44321 8443 6 4581290312 3121400
10.10.20.88 172.16.50.12 51234 445 6 892140000 610210
10.10.20.12 10.200.1.10 61200 80 6 412000000 281000
In this output, host 10.10.20.150 transferring data to 192.168.100.25 over TCP port 8443 is responsible for the vast majority of the consumed bandwidth.
Automated Bandwidth Monitoring Templates: Prometheus and Python
While CLI inspection is ideal for immediate incident triage, day-to-day operations benefit from automated polling. You can collect interface metrics programmatically using SNMP via Prometheus or lightweight automation scripts.
Prometheus SNMP Exporter and PromQL Query
Standard SNMP monitoring targets IF-MIB 64-bit high-capacity counters: ifHCInOctets (.1.3.6.1.2.1.31.1.1.1.6) and ifHCOutOctets (.1.3.6.1.2.1.31.1.1.1.10).
To calculate the ingress interface utilization percentage across a 5-minute rolling window in Prometheus, run the following PromQL query:
(
rate(ifHCInOctets{ifDescr="GigabitEthernet1/0/2"}[5m]) * 8
)
/
(
ifHighSpeed{ifDescr="GigabitEthernet1/0/2"} * 1000000
) * 100
rate(...[5m]) * 8: Calculates the incoming bytes per second over 5 minutes and converts them to bits per second.ifHighSpeed * 1000000: Retrieves the port speed in megabits per second and scales it to bits per second.
Python Automation Script Using Netmiko
This executable script connects to a switch, fetches interface data, parses rates via regex, and calculates utilization:
import re
from netmiko import ConnectHandler
device = {
"device_type": "cisco_ios",
"host": "10.10.10.1",
"username": "admin",
"password": "SecretPassword123",
}
interface_target = "GigabitEthernet1/0/2"
interface_speed_bps = 1_000_000_000 # 1 Gbps
connection = ConnectHandler(**device)
output = connection.send_command(f"show interfaces {interface_target}")
connection.disconnect()
in_rate_match = re.search(r"(\d+)\s+bits/sec.*input rate", output)
out_rate_match = re.search(r"(\d+)\s+bits/sec.*output rate", output)
if in_rate_match and out_rate_match:
in_bps = int(in_rate_match.group(1))
out_bps = int(out_rate_match.group(1))
rx_util = (in_bps / interface_speed_bps) * 100
tx_util = (out_bps / interface_speed_bps) * 100
print(f"Interface: {interface_target}")
print(f" Ingress: {in_bps:,} bps ({rx_util:.2f}%)")
print(f" Egress: {out_bps:,} bps ({tx_util:.2f}%)")
else:
print("Could not parse rate information from interface output.")
Comparing Interface Bandwidth Monitoring Tools
For long-term capacity planning, historical trend analysis, and proactive alerting, dedicated network management software is essential. The table below compares the leading platforms used to monitor Cisco switch interfaces.
| Platform | Primary Protocols | Architecture & Deployment | Licensing Model | Key Strengths | Ideal Use Case |
|---|---|---|---|---|---|
| SolarWinds Network Performance Monitor (NPM) | SNMPv2c/v3, NetFlow, IPFIX, sFlow | On-premises (Windows Server, SQL backend) | Commercial per-element licensing | Comprehensive Cisco out-of-the-box support, automated mapping, threshold alerts | Medium to large enterprise networks seeking an all-in-one vendor solution |
| PRTG Network Monitor | SNMP, NetFlow v5/v9, IPFIX, Packet Sniffing | On-premises (Windows, embedded DB) | Commercial tiered by sensor count | Fast setup, pre-configured sensor libraries, built-in mobile notifications | Small to mid-sized IT environments wanting quick, low-maintenance deployment |
| Zabbix | SNMPv2c/v3, Polling Agents, Telnet/SSH | Self-hosted Linux (PostgreSQL/MySQL) | Free, open-source (GPLv2) | Scalable polling engine, robust templating, granular trigger expressions | Budget-conscious teams requiring a scalable, non-commercial monitoring system |
| LibreNMS | SNMPv2c/v3, Streaming Telemetry, Fast Ping | Self-hosted Linux (PHP/MySQL) | Free, open-source (GPLv3) | Automated Cisco port discovery, built-in billing modules, simple UI | Service providers and campus networks needing automated interface inventory |
| Prometheus + Grafana | SNMP (via snmp_exporter), gNMI / OpenConfig | Containerized or VM (Linux) | Free, open-source (Apache 2.0) | High-performance time-series data, flexible dashboarding, PromQL analytics | Engineering teams and DevOps environments managing automated monitoring pipelines |
If your environment already uses containers and time-series infrastructure, deploying Prometheus with Grafana offers the most flexible dashboarding engine. For traditional on-premises infrastructure requiring turnkey alerting and minimal configuration, platforms like SolarWinds or PRTG provide the fastest time-to-insight.
Conclusion
Checking bandwidth usage on a Cisco switch interface ranges from quick command-line checks to comprehensive time-series telemetry. For immediate troubleshooting, use show interfaces combined with a shortened load-interval to capture active traffic rates, and apply the bandwidth formula to verify port saturation against physical link speeds. When persistent congestion appears, enable Flexible NetFlow to trace top talkers directly to specific hosts and applications. Finally, integrate SNMP or streaming collectors into centralized platforms like Grafana, LibreNMS, or PRTG to ensure long-term visibility and capacity planning across your switching fabric.











Comments