Calculate the total frame size of network packets by adding protocol headers to your payload. See exact overhead percentages, MTU compliance, and per-layer breakdown — all calculated locally in your browser.

A network packet is a formatted unit of data carried across a network. Every packet consists of a payload (your actual data) wrapped in multiple layers of headers that tell network devices how to route, deliver, and verify the data. Understanding packet structure is fundamental to network troubleshooting and performance optimization.
Each layer of the TCP/IP model adds its own header, creating overhead that reduces the bandwidth available for actual data. This calculator helps you visualize exactly how much overhead your packets carry. For understanding how this impacts throughput, see our Network Throughput Calculator.
Each network protocol adds a fixed (or semi-fixed) header to every packet. Here's a comprehensive reference of header sizes at each layer:
| Protocol | OSI Layer | Header Size | Key Fields |
|---|---|---|---|
| Ethernet II | L2 (Data Link) | 14 bytes | Dst MAC, Src MAC, EtherType |
| 802.1Q VLAN | L2 (Data Link) | +4 bytes | VLAN ID, priority, DEI |
| Q-in-Q (802.1ad) | L2 (Data Link) | +8 bytes | Outer + inner VLAN tags |
| PPPoE | L2 (Data Link) | 8 bytes | Session ID, length, PPP protocol |
| IPv4 | L3 (Network) | 20 bytes | Src/Dst IP, TTL, protocol, checksum |
| IPv6 | L3 (Network) | 40 bytes | Src/Dst IP, hop limit, flow label |
| TCP | L4 (Transport) | 20 bytes | Src/Dst port, seq/ack, flags, window |
| UDP | L4 (Transport) | 8 bytes | Src/Dst port, length, checksum |
| GRE | Tunnel | 4-24 bytes | Protocol type, key, sequence |
| VXLAN | Tunnel | 50 bytes | VNI + outer UDP/IP/Ethernet |
| IPsec ESP | Tunnel | ~50 bytes | SPI, sequence, IV, padding, auth |
| MPLS | L2.5 | 4 bytes/label | Label, TC, S-bit, TTL |
Pro Tip: When running a VPN or tunnel, the encapsulation headers reduce your effective MTU. For example, IPsec with ESP adds about 50 bytes of overhead, reducing a standard 1500-byte MTU to approximately 1400 bytes of usable payload. This is why VPN connections sometimes cause fragmentation and slow performance. Adjust your MTU accordingly and test with our Ping Test using the "don't fragment" flag.
The Maximum Transmission Unit (MTU) is the largest IP datagram a network interface will transmit without fragmentation. The standard Ethernet MTU is 1500 bytes, which includes the IP header and everything above it but excludes the Ethernet header and FCS.
| Network Type | MTU (bytes) | Max TCP Payload | Notes |
|---|---|---|---|
| Standard Ethernet | 1500 | 1460 | Most common default |
| Jumbo Frames | 9000 | 8960 | Data center networks |
| PPPoE (DSL) | 1492 | 1452 | PPPoE header reduces MTU by 8 |
| VPN / IPsec | ~1400 | ~1360 | Varies by encryption and mode |
| GRE Tunnel | 1476 | 1436 | 24-byte GRE + outer IP header |
| VXLAN | 1450 | 1410 | 50-byte VXLAN encapsulation |
| IPv4 Minimum | 576 | 536 | All IPv4 hosts must support |
When a packet exceeds the MTU, it must be fragmented (split into smaller pieces) or dropped if the Don't Fragment (DF) bit is set. Fragmentation hurts performance because each fragment needs its own headers and reassembly adds latency. Use the Network Latency Test to detect if fragmentation is impacting your connection.
Packet size directly impacts network throughput, latency, and efficiency. Smaller packets have higher overhead percentages, while larger packets risk fragmentation:
For understanding how packet size impacts your effective bandwidth, use the Bandwidth Calculator alongside this tool. To measure actual vs theoretical throughput, check the Network Throughput Calculator.
Different applications generate characteristic packet sizes. Knowing these helps with traffic analysis and QoS configuration:
| Application | Typical Payload | Total Frame | Protocol |
|---|---|---|---|
| VoIP (G.711) | 160 bytes | 214 bytes | UDP + RTP |
| DNS Query | 40-60 bytes | ~100 bytes | UDP |
| TCP ACK (no data) | 0 bytes | 54 bytes | TCP |
| HTTP GET request | 200-500 bytes | 260-560 bytes | TCP |
| SSH / Interactive | 20-100 bytes | 74-154 bytes | TCP |
| File Transfer (bulk) | 1460 bytes | 1514 bytes | TCP (MSS) |
| Video Streaming | 1316 bytes | 1370 bytes | UDP (MPEG-TS) |
| Online Gaming | 40-200 bytes | 94-254 bytes | UDP |
Discovering the correct MTU for your path prevents fragmentation and optimizes performance:
ping -f -l 1472 8.8.8.8
Decrease the size (-l value) until pings succeed. Add 28 for IP+ICMP headers to get your path MTU.
ping -D -s 1472 8.8.8.8
The -D flag sets Don't Fragment. Reduce -s value until successful. Your path MTU = successful size + 28.
Most routers display MTU settings in the WAN configuration. Log in at your router's IP and check the internet/WAN settings. For DSL connections with PPPoE, the MTU should be set to 1492. See our ISP throttling test to check if MTU issues are causing performance problems.
When using VPNs, VXLAN, or other tunneling technologies, the encapsulation headers consume part of the MTU. This reduces the space available for your actual data:
For long-distance or high-latency links, this overhead compounds. Test your effective throughput with the Speed Test and compare to theoretical capacity from the Bandwidth Calculator. For wired connections, check maximum cable distances with the Cable Length Calculator.
ping -f to discover your path MTU and avoid fragmentation.The minimum Ethernet frame size is 64 bytes (excluding preamble and SFD). This includes 14 bytes for the Ethernet header, 46 bytes of payload (padded if necessary), and 4 bytes for the FCS. Frames smaller than 64 bytes are padded to meet this minimum. On the wire, with preamble and interframe gap, the minimum is 84 bytes.
The maximum standard Ethernet frame is 1518 bytes (14-byte header + 1500-byte payload + 4-byte FCS). With 802.1Q VLAN tagging, it increases to 1522 bytes. Jumbo frames extend this to 9022 bytes but require support from all devices in the path.
VPN overhead includes not just the extra headers but also encryption/decryption CPU time, potential fragmentation and reassembly, and increased packet processing. Each encrypted packet requires crypto operations that consume CPU cycles. This is especially noticeable on routers with limited processing power.
MSS clamping adjusts the Maximum Segment Size in TCP SYN packets to prevent fragmentation over tunnels. Use it when you have a reduced MTU (VPN, PPPoE, VXLAN) and see TCP performance issues. Most routers can clamp MSS automatically — look for the setting near your MTU configuration.
VoIP packets are intentionally small (typically 160-320 bytes payload) to minimize latency. Each packet carries 10-30ms of audio. Larger packets would add more delay. The tradeoff is higher overhead — a VoIP stream at 50 packets/second consumes more bandwidth per audio-second than bulk data. Configure QoS to prioritize these small, time-sensitive packets.
If the Don't Fragment (DF) bit is not set, the router fragments the packet into smaller pieces that fit the MTU. Each fragment gets its own IP header, increasing overhead. If DF is set, the router drops the packet and sends an ICMP "Fragmentation Needed" message back. Modern TCP uses Path MTU Discovery (PMTUD) with DF set to find the optimal packet size automatically.
Generally no. Jumbo frames (9000 bytes) require every device in the path to support them — switches, NICs, and endpoints. If any device doesn't support jumbo frames, you'll get fragmentation or dropped packets. Jumbo frames are primarily beneficial in data centers for storage traffic (iSCSI, NFS) and high-throughput server-to-server communication.
About Tommy N.
Tommy is the founder of RouterHax and a network engineer with 10+ years of experience in home and enterprise networking. He specializes in router configuration, WiFi optimization, and network security. When not writing guides, he's testing the latest mesh WiFi systems and helping readers troubleshoot their home networks.
![]() |
![]() |
![]() |
![]() |
Promotion for FREE Gifts. Moreover, Free Items here. Disable Ad Blocker to get them all.
Once done, hit any button as below
![]() |
![]() |
![]() |
![]() |