Why Gmail Clips Emails at 102KB (and How to Fix It)

What triggers Gmail clipping?

Gmail clipping occurs whenever the raw HTML code of an email message exceeds 102,400 bytes (exactly 100 KiB / 102.4 KB). When this threshold is crossed, Gmail stops rendering the DOM tree at that exact byte offset and inserts a truncation link prompting the reader to view the full message in a separate window.

Crucially, Gmail measures this cutoff purely on the text payload of the HTML document itself. External assets like images, web fonts, or hosted assets loaded via HTTP URLs do not count toward the 102,400-byte cap. However, inline CSS declarations, HTML comments, embedded SVG strings, and base64 data URIs count directly toward the byte weight.

This is often confused with Google Workspace's 25MB total email transmission limit. While Gmail will happily transmit an email with attachments up to 25MB, its web and mobile rendering engine applies an independent 102KB display limit to the body text.

Why clipping damages email performance

Clipping is not just an aesthetic defect. It silently breaks tracking, deliverability, and legal compliance:

• Open-rate tracking pixel loss (up to 80% distortion). Most ESPs (Klaviyo, Mailchimp, Customer.io, Resend) place a 1x1 transparent tracking GIF at the very end of the message HTML. When Gmail clips the email, that image tag is never fetched unless the recipient clicks through, causing your analytics to report false non-opens and distorting your email deliverability metrics.
• Mandatory footer and unsubscribe links cut off. CAN-SPAM and GDPR require clear unsubscribe links and sender physical addresses. When Gmail cuts the footer, recipients cannot find the unsubscribe button and hit “Report Spam” instead, directly harming your domain reputation.
• Unclosed HTML tags distorting layouts. Because Gmail chops the byte stream mid-document, closing tags like </table>, </td>, or </div> are frequently missing, causing unexpected rendering glitches across Gmail's interface and compounding issues in strict table-based engines like Outlook.

What counts toward the 102KB limit (and what doesn't)

This is why many developers are surprised when their email is clipped even though “it only has 2 images.” It is never about image file sizes, it is strictly about the character count of the HTML markup itself.

How to fix it without cutting content

You rarely need to delete copy or remove sections to beat the 102KB limit. Here are the four most effective structural fixes:

1. Minify your compiled HTML. Stripping unnecessary whitespace, tabs, and build-tool comments reliably yields a 40% to 60% byte reduction without modifying rendered output.
2. Replace inline SVGs with hosted PNGs. Complex SVG coordinate paths consume thousands of bytes. Convert icons and decorative graphics to optimized hosted PNG or WebP assets.
3. Move the tracking pixel above the footer. If your ESP permits custom tracking placement, placing the 1x1 pixel earlier in the body ensures open rates record even if a long message is clipped.
4. Verify payload size before sending. Always measure the raw UTF-8 byte length of your final compiled HTML in your build step or CI check.

Automating minification

If you are using MJML, React Email, or Maizzle, add a post-compilation minification step to your export pipeline:

// Example: Automated HTML minification in your build pipeline
import { minify } from 'html-minifier-terser';

export async function optimizeEmailHtml(rawHtml: string): Promise<string> {
  const minified = await minify(rawHtml, {
    collapseWhitespace: true,
    removeComments: true,
    minifyCSS: true,
    removeAttributeQuotes: false, // Preserves quotes for Outlook MSO attributes
    keepClosingSlash: true,
  });

  // UTF-8 byte count verification against the 102,400 bytes threshold
  const byteLength = new TextEncoder().encode(minified).length;
  if (byteLength > 102400) {
    console.warn(`Warning: Email is ${byteLength} bytes. Gmail will clip this message.`);
  }
  
  return minified;
}

The reliable approach

Rather than sending test emails to personal Gmail accounts (where conversation threading often falsely aggregates multiple test sends into a clipped view), test your email against Gmail's sanitizer in your development loop.

Emailens inspects your exact UTF-8 byte weight in milliseconds and simulates Gmail's sanitizer alongside 20 other email clients, flagging potential clipping before your campaign goes out.