Python 3.14's Built-in Zstandard (compression.zstd), Tested

The module-level API mirrors gzip: two functions for whole-buffer work. compress takes bytes and returns a compressed frame; decompress reverses it. There's nothing to install on 3.14 — it's in the standard library:

from compression import zstd

data = b"pyobfuscate.com " * 1000   # 16,000 bytes, very repetitive
blob = zstd.compress(data)
back = zstd.decompress(blob)

print(len(data), "->", len(blob))   # 16000 -> 34
print(back == data)                 # True

The public surface of the module is small and predictable: compress, decompress, the ZstdCompressor / ZstdDecompressor streaming classes, ZstdFile and open for files, a ZstdDict for trained dictionaries, plus CompressionParameter / DecompressionParameter enums for advanced tuning and COMPRESSION_LEVEL_DEFAULT (which is 3).

I built a ~1.6 MB corpus of realistic JSON log lines (the kind of repetitive, structured data compression actually gets pointed at) and ran each codec on the identical bytes. These are measured results on Python 3.14.2 — sizes are deterministic; the timings are indicative of relative speed:

The honest read: zstd's headline is speed, not maximum ratio. At its default level it compressed this data in 2.9 ms — about 3.6× faster than gzip — for a comparable ratio, and it decompresses fast too. On *this* highly compressible data, bz2 and lzma actually squeezed smaller, but they paid 60–110× the compression time to do it. That trade-off is exactly zstd's pitch: near-instant compression you can afford to run on every request, log flush, or cache write.

What makes zstd different from picking between gzip and xz is that a single codec spans the whole range. Levels run from −5 (fastest) through the default 3 up to 22 (maximum). Same corpus, four levels:

At level 19 zstd reaches ~20× — matching xz's ratio on this data — but the time cost climbs steeply, so the high levels are for write-once/read-many data (release artifacts, backups) rather than hot paths. (Note the levels aren't perfectly monotonic on every input — low levels use a different internal strategy, which is why level 1 can edge level 3 here; the meaningful movement is at the top end.)

from compression import zstd

fast   = zstd.compress(data, 1)    # prioritise speed
small  = zstd.compress(data, 19)   # prioritise ratio
default = zstd.compress(data)      # level 3

For files, compression.zstd gives you the same shape as gzip: an open() helper and a ZstdFile class. For data that arrives in chunks, ZstdCompressor lets you feed pieces and flush() at the end:

from compression import zstd

# whole-file helper, like gzip.open()
with zstd.open("logs.zst", "wt") as f:
    f.write("hello\n")

# streaming: feed chunks, then flush
c = zstd.ZstdCompressor(level=9)
blob = c.compress(b"hello ") + c.compress(b"world") + c.flush()
print(zstd.decompress(blob) == b"hello world")   # True

Python 3.14 also teaches tarfile the zstd modes, so you can create and read .tar.zst archives directly — no external tool required:

import tarfile

with tarfile.open("bundle.tar.zst", "w:zst") as tar:
    tar.add("logs.zst")

with tarfile.open("bundle.tar.zst", "r:zst") as tar:
    print(tar.getnames())

• Reach for zstd when you compress often and latency matters: HTTP responses, log shipping, cache and session blobs, RPC payloads, or anything on a hot path. Default-level zstd is fast enough to run everywhere.
• Turn the level up (15–22) for write-once/read-many data — release bundles, backups, model files — where you can spend CPU once to ship fewer bytes forever.
• Stay with gzip when you need the most universal, zero-thought interop — every language and tool reads gzip, and for small payloads the difference is negligible.
• Consider bz2 or lzma when maximum ratio is the only goal and compression time is irrelevant, as on the repetitive data above they still edged zstd on size.

compression.zstd ships in Python 3.14 (PEP 784), released October 2025. On 3.13 and earlier it doesn't exist — importing it raises ModuleNotFoundError — so there you install a third-party package such as zstandard or pyzstd, which wrap the same underlying libzstd with a different API.

try:
    from compression import zstd            # Python 3.14+
except ModuleNotFoundError:
    import zstandard as zstd                  # pip install zstandard (3.13 and older)

You can confirm what your interpreter has with our online Python compiler, which defaults to Python 3.14 — paste from compression import zstd; print(zstd.COMPRESSION_LEVEL_DEFAULT) and it prints 3.