CCNA 200-301

CCNP Enterprise

CCNP Security

CCIE Enterprise Lab

CCIE Security Lab

CCNP Service Provider

CCNP Data Center

CCNP Collaboration

CCIE DC Lab

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.


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, or Port-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 (where 255/255 indicates 100% reliability over the sampling window).
  • txload / rxload: Transmit and receive interface load represented as a fraction of 255 (where 1/255 indicates near-zero traffic and 255/255 represents 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
  1. Establish Physical Speed in bps:
    A 1000 Mb/s (Gigabit) port provides $1{,}000{,}000{,}000\text{ bps}$.
  2. Calculate Receive (Rx) Utilization:
    $$\text{Rx Utilization} = \left( \frac{750{,}000{,}000}{1{,}000{,}000{,}000} \right) \times 100 = 75\%$$
  3. Calculate Transmit (Tx) Utilization:
    $$\text{Tx Utilization} = \left( \frac{125{,}000{,}000}{1{,}000{,}000{,}000} \right) \times 100 = 12.5\%$$
  4. 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 internal rxload arrive 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.

PlatformPrimary ProtocolsArchitecture & DeploymentLicensing ModelKey StrengthsIdeal Use Case
SolarWinds Network Performance Monitor (NPM)SNMPv2c/v3, NetFlow, IPFIX, sFlowOn-premises (Windows Server, SQL backend)Commercial per-element licensingComprehensive Cisco out-of-the-box support, automated mapping, threshold alertsMedium to large enterprise networks seeking an all-in-one vendor solution
PRTG Network MonitorSNMP, NetFlow v5/v9, IPFIX, Packet SniffingOn-premises (Windows, embedded DB)Commercial tiered by sensor countFast setup, pre-configured sensor libraries, built-in mobile notificationsSmall to mid-sized IT environments wanting quick, low-maintenance deployment
ZabbixSNMPv2c/v3, Polling Agents, Telnet/SSHSelf-hosted Linux (PostgreSQL/MySQL)Free, open-source (GPLv2)Scalable polling engine, robust templating, granular trigger expressionsBudget-conscious teams requiring a scalable, non-commercial monitoring system
LibreNMSSNMPv2c/v3, Streaming Telemetry, Fast PingSelf-hosted Linux (PHP/MySQL)Free, open-source (GPLv3)Automated Cisco port discovery, built-in billing modules, simple UIService providers and campus networks needing automated interface inventory
Prometheus + GrafanaSNMP (via snmp_exporter), gNMI / OpenConfigContainerized or VM (Linux)Free, open-source (Apache 2.0)High-performance time-series data, flexible dashboarding, PromQL analyticsEngineering 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.

Please follow and like us:
Last modified: November 16, 2026

Author

Comments

Write a Reply or Comment

Your email address will not be published.