Grayscale vs Monochrome PDFs for Court Filing

When preparing pleadings and evidentiary appendices for court e-filing portals—such as federal CM/ECF, state e-filing systems, or the USPTO Patent Center, each of which sets its own per-file size limits (check the court’s local rules or ECF manual)—scanner operators and paralegals frequently treat “grayscale” and “monochrome” (black-and-white) as interchangeable settings. Understanding the structural difference in a grayscale vs monochrome PDF prevents three common filing disasters: highlighted contract clauses turning into solid black redaction bars, light-blue wet signatures and notary seals vanishing into white paper, and born-digital briefs losing their searchable text layer.

Under the PDF specification (ISO 32000-1, Section 8.6.4), both formats use the /DeviceGray color space, but they differ fundamentally in bit depth (/BitsPerComponent) and stream compression (/Filter).

Bit Depth: 8-Bit Grayscale vs. 1-Bit Monochrome

When a scanner or PDF processor converts a 24-bit /DeviceRGB page (3 channels × 8 bits = 24 bits per pixel) to black and white, it produces one of two internal /Image XObject structures:

In a 1-bit monochrome XObject created by libtiff (tiff2pdf) or img2pdf, the raw PDF object dictionary explicitly declares /BitsPerComponent 1 and two-dimensional CCITT Group 4 facsimile compression (/Filter /CCITTFaxDecode with /K -1 per ISO 32000-1 Table 11):

<<
  /Type /XObject
  /Subtype /Image
  /Width 2550
  /Height 3300
  /BitsPerComponent 1
  /ColorSpace /DeviceGray
  /Filter /CCITTFaxDecode
  /DecodeParms <<
    /K -1
    /Columns 2550
    /Rows 3300
    /BlackIs1 true
  >>
>>

Because CCITT Group 4 encodes only the horizontal run-length positions where pixels flip between 0 and 1 relative to the scanline above, a 300 DPI US Letter (2550 x 3300 px) page of clean black text compresses very efficiently—in our test below, a densely typed page dropped from 458,741 bytes (lossless color scan) to 80,832 bytes. However, because every pixel is forced into a binary choice, any document feature that relies on intermediate luminance is at risk.

Benchmarking 4 Real Legal Page Types Across Grayscale and Monochrome

To measure how both formats behave on mixed legal filings, we generate a synthetic 4-page US Letter (612 x 792 pt) filing packet (legal_packet_color.pdf) representing the four page archetypes found in court submissions:

1. Page 1 (Born-Digital Vector Brief): Native text pleading (586 selectable characters, 0 raster images) with a navy header banner, crimson rule, and blue case citations.
2. Page 2 (300 DPI Scanned Contract Exhibit): A losslessly stored scan of clean black type (RGB(22, 24, 28)) on off-white paper (RGB(247, 245, 240)).
3. Page 3 (300 DPI Executed Signature & Notary Page): Contains three critical evidentiary features:
   • Section 4.2 Indemnity Clause marked with a dark blue highlighter (RGB(35, 95, 190), ITU-R BT.601 luminance Y = 87.9) over black text (RGB(15, 15, 20), Y = 15.6).
   • Wet-Ink Signature signed in light-blue ballpoint pen (RGB(115, 165, 225), Y = 156.9).
   • Notary Public Seal stamped in faint gray ink (RGB(175, 175, 182), Y = 175.8).
4. Page 4 (300 DPI Photographic Evidence Exhibit): Continuous-tone site inspection photograph (2250 x 1500 px, placed at 7.5 x 5 in) with shadow gradients.

On both macOS (Homebrew Python) and Ubuntu/Debian Linux, PEP 668 blocks system-wide pip installs by default, so create a local virtual environment to run the benchmark and inspection scripts:

python3 -m venv .venv
.venv/bin/pip install pymupdf pillow img2pdf

[!NOTE] If you also use command-line TIFF tools (tiffcp, tiff2pdf, tiffinfo), install them with brew install libtiff on macOS or sudo apt install libtiff-tools on Debian/Ubuntu Linux. In Python scripts, Pillow + img2pdf embeds CCITT Group 4 streams directly into PDF without external binaries.

Save and run build_legal_packet.py to generate the packet:

import io
import math
import os
import pymupdf
from PIL import Image, ImageDraw, ImageFilter, ImageFont

W, H = 2550, 3300  # US Letter at 300 DPI
PAPER, INK = (247, 245, 240), (22, 24, 28)
font = ImageFont.load_default(size=38)
clause = "The Indemnifying Party shall defend, indemnify, and hold harmless the Indemnified Party"

def jpeg_bytes(img: Image.Image, quality: int) -> bytes:
    buf = io.BytesIO()
    img.save(buf, format="JPEG", quality=quality)
    return buf.getvalue()

def png_bytes(img: Image.Image) -> bytes:
    buf = io.BytesIO()
    img.save(buf, format="PNG")
    return buf.getvalue()

def scanned_text_page(first_line: int) -> Image.Image:
    img = Image.new("RGB", (W, H), PAPER)
    d = ImageDraw.Draw(img)
    for i, y in enumerate(range(300, 3000, 62)):
        d.text((230, y), f"{first_line + i}. {clause} against all claims.", font=font, fill=INK)
    return img

doc = pymupdf.open()

# --- PAGE 1: Born-digital vector brief (no images) ---
p1 = doc.new_page(width=612, height=792)
shape = p1.new_shape()
shape.draw_rect(pymupdf.Rect(36, 36, 576, 84))
shape.finish(fill=(0.07, 0.16, 0.35), color=None)
shape.draw_line(pymupdf.Point(36, 104), pymupdf.Point(576, 104))
shape.finish(color=(0.75, 0.10, 0.15), width=2)
shape.commit()
p1.insert_text((50, 66), "PLAINTIFF'S MOTION FOR SUMMARY JUDGMENT", fontsize=15, fontname="helv", color=(1, 1, 1))
y = 130
for _ in range(6):
    p1.insert_text((36, y), "The undisputed record shows that Defendant breached Section 4.2 of the Agreement.", fontsize=10.5, fontname="tiro", color=(0, 0, 0))
    y += 18
p1.insert_text((36, y + 10), "See Smith v. Jones, 123 F.3d 456, 460 (9th Cir. 1997).", fontsize=10.5, fontname="tiro", color=(0.05, 0.25, 0.65))

# --- PAGE 2: 300 DPI scanned contract exhibit (clean black type on off-white, lossless scan) ---
p2 = doc.new_page(width=612, height=792)
p2.insert_image(p2.rect, stream=png_bytes(scanned_text_page(1)))

# --- PAGE 3: 300 DPI signature & notary page ---
img3 = scanned_text_page(101)
d3 = ImageDraw.Draw(img3)
d3.rectangle([200, 920, 2350, 1280], fill=(35, 95, 190))           # dark blue highlighter
for i, yy in enumerate(range(970, 1230, 62)):
    d3.text((240, yy), f"4.2.{i + 1} {clause}.", font=font, fill=(15, 15, 20))
d3.rectangle([200, 1500, 2350, 2200], fill=PAPER)
pts = [(300 + x, 1710 + int(60 * math.sin(x / 55.0)) - x // 20) for x in range(0, 800, 4)]
d3.line(pts, fill=(115, 165, 225), width=7)                        # light-blue ballpoint signature
d3.ellipse([1550, 1600, 2050, 2100], outline=(175, 175, 182), width=14)  # faint notary seal
d3.ellipse([1640, 1690, 1960, 2010], outline=(175, 175, 182), width=8)
d3.text((1660, 1830), "NOTARY PUBLIC", font=font, fill=(175, 175, 182))
p3 = doc.new_page(width=612, height=792)
p3.insert_image(p3.rect, stream=jpeg_bytes(img3, 90))

# --- PAGE 4: 300 DPI photographic exhibit (2250 x 1500 px placed at 7.5 x 5 in) ---
photo = Image.merge("RGB", [
    Image.linear_gradient("L").resize((2250, 1500)).point(lambda v: 60 + v * 0.6),
    Image.linear_gradient("L").rotate(90).resize((2250, 1500)).point(lambda v: 70 + v * 0.5),
    Image.linear_gradient("L").resize((2250, 1500)).point(lambda v: 150 - v * 0.3),
])
noise = Image.effect_noise((2250, 1500), 40).filter(ImageFilter.GaussianBlur(2))
photo = Image.blend(photo, Image.merge("RGB", [noise] * 3), 0.25)
dp = ImageDraw.Draw(photo)
dp.polygon([(300, 1500), (900, 700), (1500, 1500)], fill=(40, 38, 35))  # shadowed structure
photo = photo.filter(ImageFilter.GaussianBlur(1.5))
p4 = doc.new_page(width=612, height=792)
p4.insert_text((36, 60), "EXHIBIT D: SITE INSPECTION PHOTOGRAPH", fontsize=13, fontname="helv", color=(0, 0, 0))
p4.insert_image(pymupdf.Rect(36, 90, 576, 450), stream=jpeg_bytes(photo, 85))

doc.save("legal_packet_color.pdf", garbage=4, deflate=True)
print(f"Saved legal_packet_color.pdf: {os.path.getsize('legal_packet_color.pdf'):,d} bytes, "
      f"page 1 chars: {len(doc[0].get_text().strip())}")

Output:

Saved legal_packet_color.pdf: 1,765,245 bytes, page 1 chars: 586

Trap 1: Highlighted Clauses Black Out & Signatures Vanish in 1-Bit Monochrome

When converting RGB pixels to grayscale luminance (Y = 0.299 * R + 0.587 * G + 0.114 * B), a naive 1-bit monochrome converter applies a single global threshold at T = 128: every pixel with Y <= 128 becomes pure black (0), and every pixel with Y > 128 becomes pure white (255).

We measured the pixel contrast span (max - min) and dark-ink survival ratio across all three evidentiary regions of Page 3 under 8-Bit Grayscale, 1-Bit Naive Global Threshold (T = 128), and 1-Bit Local Adaptive Thresholding (31 x 31 local mean filter with offset C = 12):

import io
import pymupdf
from PIL import Image, ImageFilter, ImageChops

doc = pymupdf.open("legal_packet_color.pdf")
d3 = doc.extract_image(doc[2].get_images(full=True)[0][0])
im3_gray = Image.open(io.BytesIO(d3["image"])).convert("L")

# 1. Global 1-bit monochrome threshold at T = 128
im3_mono_global = im3_gray.point(lambda p: 255 if p > 128 else 0, mode="L")

# 2. Local adaptive 1-bit threshold (31x31 BoxBlur neighborhood mean minus C = 12)
local_mean = im3_gray.filter(ImageFilter.BoxBlur(15))
diff = ImageChops.subtract(local_mean, im3_gray)
im3_mono_adaptive = diff.point(lambda d: 0 if d > 12 else 255, mode="L")

def region_stats(img_l: Image.Image, box: tuple[int, int, int, int]) -> str:
    px = list(img_l.crop(box).get_flattened_data())
    dark_ratio = sum(1 for p in px if p < 220) / len(px)
    return f"min={min(px):3d}, max={max(px):3d}, span={max(px)-min(px):3d}, dark_px={dark_ratio:.2%}"

regions = {
    "Highlighted Clause": (200, 920, 2350, 1280),
    "Blue Wet Signature": (250, 1600, 1150, 1820),
    "Faint Notary Seal ": (1500, 1550, 2100, 2150),
}

for label, box in regions.items():
    print(f"=== {label} ===")
    print("  8-Bit Grayscale  :", region_stats(im3_gray, box))
    print("  1-Bit Global T128:", region_stats(im3_mono_global, box))
    print("  1-Bit Adaptive   :", region_stats(im3_mono_adaptive, box))

Output:

=== Highlighted Clause ===
  8-Bit Grayscale  : min=  2, max=105, span=103, dark_px=100.00%
  1-Bit Global T128: min=  0, max=  0, span=  0, dark_px=100.00%
  1-Bit Adaptive   : min=  0, max=255, span=255, dark_px=17.02%
=== Blue Wet Signature ===
  8-Bit Grayscale  : min=141, max=255, span=114, dark_px=3.24%
  1-Bit Global T128: min=255, max=255, span=  0, dark_px=0.00%
  1-Bit Adaptive   : min=  0, max=255, span=255, dark_px=3.24%
=== Faint Notary Seal  ===
  8-Bit Grayscale  : min=160, max=255, span= 95, dark_px=8.78%
  1-Bit Global T128: min=255, max=255, span=  0, dark_px=0.00%
  1-Bit Adaptive   : min=  0, max=255, span=255, dark_px=8.78%

Look closely at what happens under 1-Bit Global T128 on a single page:

• The Highlighted Clause Blacks Out (span = 0, 100.00% black): Because both the dark blue marker (Y = 87.9) and the black contract text (Y = 15.6) sit below 128, every pixel in the highlighted box turns 0 (solid black), obscuring the text as if it had been redacted.
• The Signature and Notary Seal Disappear (span = 0, 0.00% dark pixels): Because the light-blue ballpoint ink (min = 141) and gray notary seal (min = 160) sit above 128, every stroke snaps to 255 (pure white), stripping both the signature and the notarization from the exhibit.
• 8-Bit Grayscale Preserves All Three Naturally: Without any threshold tuning, 8-bit grayscale keeps roughly a 100-level contrast span between the text (min = 2) and the highlight (max = 105), while keeping the signature (141) and notary seal (160) clearly visible against the paper (Y ≈ 245).

Trap 2: Dithering a Photo for 1-Bit CCITT Group 4 Bloats the File by 6.8x

When an exhibit contains a continuous-tone photograph (Page 4, a 24-bit RGB JPEG), some tools attempt to simulate gray shading in 1-bit monochrome using Floyd-Steinberg error-diffusion dithering (Image.Dither.FLOYDSTEINBERG) before compressing with CCITT Group 4:

import io
import os
import pymupdf
from PIL import Image

doc = pymupdf.open("legal_packet_color.pdf")
d4 = doc.extract_image(doc[3].get_images(full=True)[0][0])
im4_gray = Image.open(io.BytesIO(d4["image"])).convert("L")

buf_gray85 = io.BytesIO()
im4_gray.save(buf_gray85, format="JPEG", quality=85)

im4_thresh = im4_gray.point(lambda p: 255 if p > 128 else 0, mode="1")
im4_thresh.save("p4_thresh_g4.tiff", format="TIFF", compression="group4", dpi=(300, 300))

im4_dither = im4_gray.convert("1", dither=Image.Dither.FLOYDSTEINBERG)
im4_dither.save("p4_dither_g4.tiff", format="TIFF", compression="group4", dpi=(300, 300))

print(f"24-Bit RGB JPEG (original)          : {len(d4['image']):,d} bytes")
print(f"8-Bit Grayscale JPEG (q=85)         : {len(buf_gray85.getvalue()):,d} bytes")
print(f"1-Bit CCITT Group 4 (Global T=128)  : {os.path.getsize('p4_thresh_g4.tiff'):,d} bytes")
print(f"1-Bit CCITT Group 4 (Floyd-Steinberg): {os.path.getsize('p4_dither_g4.tiff'):,d} bytes")

Output:

24-Bit RGB JPEG (original)          : 153,517 bytes
8-Bit Grayscale JPEG (q=85)         : 135,122 bytes
1-Bit CCITT Group 4 (Global T=128)  : 6,998 bytes
1-Bit CCITT Group 4 (Floyd-Steinberg): 1,037,256 bytes

CCITT Group 4 is a run-length encoding algorithm optimized for long contiguous runs of white and black pixels in text and line drawings. Floyd-Steinberg dithering scatters alternating 0 and 1 pixels into a high-frequency checkerboard, creating millions of 1-pixel run transitions that defeat Group 4 Huffman tables and balloon a 153,517-byte photograph into 1,037,256 bytes (~1.04 MB)—6.8x larger than the original color image and 7.7x larger than the 8-bit grayscale JPEG (135,122 bytes).

Trap 3: Rasterizing Born-Digital Briefs Destroys Searchable Text

Many federal and state courts distinguish between scanned exhibits and born-digital pleadings (motions, briefs, and memoranda exported directly from Word or LaTeX), and their local rules or ECF procedures often require—or strongly prefer—that born-digital filings be converted directly to text-searchable PDF rather than printed and scanned. Check the specific court’s rules.

On Page 1 of our test packet (586 selectable characters, 0 images), any pipeline that renders every page to a bitmap (whether 8-bit grayscale JPEG or 1-bit TIFF) wipes out the /Contents text operators (extracted text drops from 586 characters to 0) and inflates the page size.

Method 1: Selective Per-Page Hybrid Pipeline in Python

For mixed court filings or large appendices, the cleanest engineering approach inspects each page and routes it based on its structure and pixel histogram:

flowchart TD
    A["Input PDF Page"] --> B{"Contains Embedded<br/>Raster Scan?"}
    B -->|"No (Born-Digital Brief)"| C["Rewrite RGB Operators (rg / RG)<br/>to /DeviceGray (g / G) In-Place<br/>(Keeps 100% Vector Searchable Text)"]
    B -->|"Yes (Scanned Exhibit)"| D{"Mid-Tone Pixels (50..210)<br/>below 5% of Page?"}
    D -->|"Yes (Clean Black-on-White Text)"| E["Convert to 1-Bit Monochrome<br/>/CCITTFaxDecode (CCITT Group 4)"]
    D -->|"No (Highlights, Faint Seals, Photos)"| F{"Filing Requires Black-and-White<br/>Line Art (e.g. USPTO Drawings)?"}
    F -->|"No (Typical Court Exhibit)"| G["Convert XObject In-Place to<br/>8-Bit 1-Channel Gray JPEG (/DCTDecode)"]
    F -->|"Yes (Patent Line Drawings)"| H["Apply Local Adaptive Threshold<br/>(31x31 BoxBlur Mean) + CCITT Group 4"]

Save and run prepare_legal_pdf.py to execute this selective hybrid conversion on legal_packet_color.pdf:

import io
import os
import re
import img2pdf
import pymupdf
from PIL import Image

doc = pymupdf.open("legal_packet_color.pdf")
rgb_op_re = re.compile(rb"([0-9.]+)\s+([0-9.]+)\s+([0-9.]+)\s+(rg|RG)\b")

def to_gray_op(m: re.Match) -> bytes:
    r, g, b = float(m.group(1)), float(m.group(2)), float(m.group(3))
    y = 0.299 * r + 0.587 * g + 0.114 * b
    op = b"g" if m.group(4) == b"rg" else b"G"
    return f"{y:.4f} ".encode("ascii") + op

for idx in range(len(doc)):
    page = doc[idx]
    imgs = page.get_images(full=True)
    if not imgs:
        # Page 1: Native vector page -> convert RGB fill/stroke operators to /DeviceGray
        for c_xref in page.get_contents():
            raw = doc.xref_stream(c_xref)
            doc.update_stream(c_xref, rgb_op_re.sub(to_gray_op, raw))
        print(f"Page {idx+1}: {len(page.get_text().strip())} chars kept, RGB operators -> /DeviceGray")
        continue

    xref = imgs[0][0]
    old_size = len(doc.xref_stream_raw(xref))
    ext = doc.extract_image(xref)
    im_l = Image.open(io.BytesIO(ext["image"])).convert("L")
    hist = im_l.histogram()
    total_px = im_l.width * im_l.height
    mid_tone_ratio = sum(hist[50:211]) / total_px

    if mid_tone_ratio < 0.05:
        # Page 2: Clean bimodal text scan -> 1-bit CCITT Group 4 (/CCITTFaxDecode)
        im_1 = im_l.point(lambda p: 255 if p > 128 else 0, mode="1")
        t_buf = io.BytesIO()
        im_1.save(t_buf, format="TIFF", compression="group4", dpi=(300, 300))
        g4_doc = pymupdf.open("pdf", img2pdf.convert([t_buf.getvalue()]))
        new_size = len(g4_doc.xref_stream_raw(g4_doc[0].get_images()[0][0]))
        doc.insert_pdf(g4_doc, from_page=0, to_page=0, start_at=idx)
        doc.delete_page(idx + 1)
        g4_doc.close()
        print(f"Page {idx+1}: mid_tone_ratio={mid_tone_ratio:.2%} -> 1-bit CCITT Group 4 "
              f"({old_size:,d} -> {new_size:,d} B)")
    else:
        # Pages 3 & 4: Highlights, faint stamps/signatures, or photos -> 8-bit 1-channel gray JPEG
        j_buf = io.BytesIO()
        im_l.save(j_buf, format="JPEG", quality=80)
        page.replace_image(xref, stream=j_buf.getvalue())
        print(f"Page {idx+1}: mid_tone_ratio={mid_tone_ratio:.2%} -> 8-bit gray /DCTDecode q=80 "
              f"({old_size:,d} -> {len(j_buf.getvalue()):,d} B)")

doc.save("packet_selective_legal.pdf", garbage=4, deflate=True)
doc.close()
print(f"Saved packet_selective_legal.pdf: {os.path.getsize('packet_selective_legal.pdf'):,d} bytes "
      f"(from {os.path.getsize('legal_packet_color.pdf'):,d} bytes)")

Output:

Page 1: 586 chars kept, RGB operators -> /DeviceGray
Page 2: mid_tone_ratio=2.99% -> 1-bit CCITT Group 4 (458,741 -> 80,832 B)
Page 3: mid_tone_ratio=10.71% -> 8-bit gray /DCTDecode q=80 (1,145,888 -> 826,239 B)
Page 4: mid_tone_ratio=85.88% -> 8-bit gray /DCTDecode q=80 (153,517 -> 131,710 B)
Saved packet_selective_legal.pdf: 1,046,076 bytes (from 1,765,245 bytes)

Look at what this selective pass achieves across the 4-page packet:

• Total File Size Drops by 40.7% (1,765,245 bytes down to 1,046,076 bytes): Page 2 shrinks by 82.4% (458,741 bytes to 80,832 bytes) via 1-bit /CCITTFaxDecode, while Pages 3 and 4 shrink to 826,239 bytes and 131,710 bytes as 1-channel gray JPEGs (PyMuPDF tags them /ICCBased with /N 1 and /Alternate /DeviceGray).
• No Evidentiary Features Lost in Our Test: Page 1 retains all 586 selectable vector characters, and Page 3 keeps its highlighted indemnity clause, blue wet signature, and faint notary seal as 256-level gray.
• Tune the 5% gate to your scans: Anti-aliased type edges alone produced 2.99% mid-tone pixels on our clean text page, so a much lower cutoff would route ordinary text scans to grayscale. Raise or lower it after checking a few of your own pages.
• Patent drawings are a special case: 37 CFR 1.84 generally requires black-and-white drawings (color only by granted petition), so for line art use the adaptive 1-bit threshold from Trap 1 with CCITT Group 4, and check the USPTO’s current Patent Center PDF guidelines for resolution requirements.

Method 2: Quick Browser Conversion for Scanned Exhibits

For a scanned color exhibit that only needs to look gray, Utiliome’s PDF to Grayscale tool converts it locally in your browser without uploading the file. Know its limits for filings: it re-renders every page at 144 DPI, so 300 DPI scans lose fine detail, and any selectable text or OCR layer is flattened away. Its page images look gray but are tagged /DeviceRGB, not 8-bit /DeviceGray or 1-bit CCITT Group 4, so keep born-digital briefs and filings that validate the color space on the Python route above. For how the converter works step by step and what grayscale does to ink and toner use, see how to print PDFs in grayscale to save ink and toner.

Comparing Legal PDF Conversion Workflows

The sizes below come from build_legal_packet.py and prepare_legal_pdf.py above; the other rows summarize the behavior shown in the Trap 1–3 tests rather than separately measured whole-packet runs:

If your grayscale exhibits still exceed a court portal’s attachment limit, you can further downsample oversized image streams with Compress PDF, split multi-hundred-page appendices into docket-sized volumes with Split PDF, or strip blank duplex back pages using our guide on detecting and deleting blank pages from scanned PDFs.