What Is VMAF? How Netflix’s Video Quality Metric Works and How to Use It

VMAF is how streaming engineers answer a deceptively hard question: does this encode actually look good? Netflix open-sourced the metric in June 2016, and it now predicts human viewer ratings on a 0-100 scale with a correlation of roughly 0.90-0.95.

That’s far better than the pixel-difference math the industry relied on for decades.

In June 2026, Netflix shipped VMAF v1, the first major model overhaul since v0.6.1. It changes which artifacts the metric can see, which defaults you get, and which model files you should be pointing at. If your pipeline still references vmaf_v0.6.1, some of what follows will be news.

What Is VMAF?

VMAF (Video Multimethod Assessment Fusion) is a full-reference video quality metric that predicts subjective viewer ratings by fusing several image-quality features through a trained machine learning model, producing a score from 0 to 100 for every frame.

“Full-reference” is the part that trips people up. VMAF needs both files: the pristine source and the compressed output.

It can’t look at a single video and tell you how good it is. It tells you how much quality the encode lost relative to what went in, which is exactly the question you’re asking when you tune a video codec or build a bitrate ladder.

The metric came out of a collaboration between Netflix, the University of Southern California, Nantes Université’s IPI/LS2N lab, and the LIVE lab at the University of Texas at Austin. Netflix released it under a BSD+Patent license, so anyone can run it, retrain it, or ship it inside a product. The work earned a Technology and Engineering Emmy in 2021.

VMAF exists because the old metrics lied. Two encodes could post identical PSNR numbers while one looked visibly worse to a person watching it. Netflix needed a number it could trust across thousands of titles and dozens of encoding decisions, so it built one from features that track how human vision actually fails.

Here’s what the scale means in practice:

VMAF vs PSNR vs SSIM

Three full-reference metrics dominate video engineering, and they measure genuinely different things. Picking the wrong one is how teams end up shipping encodes that score well and look bad.

PSNR (peak signal-to-noise ratio) measures pixel-level error between two frames and reports it in decibels. It’s cheap to compute and it’s been the codec-comparison standard since the 1990s.

It’s also close to blind to how people perceive video. A blurry frame and a blocky frame can post the same PSNR while looking nothing alike to a viewer.

SSIM (structural similarity index) improved on that by comparing luminance, contrast, and structure across local neighborhoods instead of individual pixels. MS-SSIM, the multi-scale variant, tracks perception better still. Both remain frame-by-frame measurements with no sense of motion.

VMAF fuses multiple features, including a temporal one, through a model trained on actual human ratings. That training step is the difference. PSNR and SSIM are formulas someone derived; VMAF is a prediction fitted to what viewers said.

The linear scale matters more than it sounds. Moving PSNR from 38 dB to 40 dB tells you almost nothing about how much better the video looks. Moving VMAF from 85 to 93 maps to something a viewer would actually notice, which makes it usable as a target in automated encoding decisions and in quality of experience reporting.

None of this makes PSNR useless. It’s fast, it’s deterministic, and it’s a decent smoke test for “did this encode break.” Most production pipelines compute all three and use VMAF for the decisions that matter.

How Does VMAF Work?

VMAF doesn’t compute one thing. It computes several elementary features per frame, then feeds them into a trained regressor that outputs a single number.

1. Align the two videos. Reference and distorted clips have to match in resolution, frame rate, and frame count. Mismatch here is the single most common source of nonsense scores.
2. Extract elementary features per frame. The v0 models use Visual Information Fidelity (VIF) at multiple spatial scales, the Detail Loss Metric (DLM), and Mean Co-Located Pixel Difference (MCPD) for motion. VMAF v1 drops VIF, keeps DLM and MCPD, and adds a banding detector and chroma features.
3. Feed the features into the fusion model. A support vector machine regressor, trained on subjective scores from human viewing sessions, maps the feature vector to a predicted opinion score.
4. Clamp to the score range. Each frame gets a value from 0 to 100, where 100 means indistinguishable from the reference.
5. Pool the per-frame scores. By default VMAF takes the arithmetic mean across every frame to produce the clip-level score you see reported.

The motion feature is what separates VMAF from its predecessors. MCPD measures how much the luminance channel changes between consecutive frames, which lets the model account for temporal masking: viewers tolerate far more compression artifacts in fast-moving content than in a slow pan across a gradient sky.

A frame-by-frame metric can’t make that distinction. That’s why per-frame metrics penalize action sequences that look fine and wave through static scenes that look terrible.

The per-frame output is also the part most teams ignore, and the clip average hides everything. A file averaging VMAF 92 with a 30-frame dip to 60 produces a visible glitch the headline number never reveals.

That kind of dip is a common cause of complaints about video encoding quality that “tests fine.”

VMAF Models Explained: v0.6.1 vs VMAF v1

VMAF isn’t one model. It’s a family, and the one you pick encodes an assumption about how your viewers watch. Point at the wrong file and your scores will be internally consistent and externally meaningless.

The v0.6.1 family (2016-2026)

vmaf_v0.6.1 is the default model almost every tutorial and blog post references. It assumes a 1080p display viewed from three times the screen height, which is roughly a TV across a living room. Netflix added a phone model in 2017 that applies a polynomial adjustment for small screens held close, and a 4K model in 2018 trained for 4K TVs at 1.5x display height.

There’s also vmaf_v0.6.1neg, the no-enhancement-gain variant. Netflix published it after researchers showed that sharpening a video before encoding could inflate its VMAF score without improving how it looked. NEG caps the reward for enhancement, which makes it the honest choice for comparing encoders.

The VMAF v1 family (June 2026)

VMAF v1 is the first structural rewrite in a decade, and it changes four things:

• NEG behavior is on by default. You no longer opt into the anti-gaming variant; it’s the baseline.
• Banding detection is built in. VMAF v1 folds in CAMBI, the Contrast Aware Multiscale Banding Index, so the model finally sees the staircase edges that appear in smooth gradients. The v0 models were blind to banding entirely.
• Chroma artifacts count. VMAF v0 extracted luma-only features, which meant color quantization and chroma subsampling damage went unscored. VMAF v1 applies a modified SpEED-QA to the chroma channels.
• Viewing distance replaced the phone hack. Instead of a phone-specific polynomial, v1 uses a contrast-sensitivity model parameterized by viewing distance, and ships a model file per distance.

Netflix also removed VIF, which was the most expensive feature to compute and stopped contributing accuracy once the other features improved. The net result is a model that sees more artifacts and runs faster than the one it replaces. The VMAF v1 announcement documents the accuracy gains in detail.

Which model file to use

Each v1 model also ships an _hfr variant under model/vmaf_v1.0.16_hfr/ for high-frame-rate content around 50-60 fps. One more thing worth knowing: Netflix recommends running VMAF v1 at 10-bit precision for SDR content, because 8-bit processing masks the banding the new model is specifically trained to catch.

If you have historical VMAF data, don’t mix generations. A v1 score and a v0.6.1 score on the same file are different numbers answering slightly different questions. Rebaseline before you migrate.

What Is a Good VMAF Score?

Target 93 or higher for premium delivery, 85-93 for the top rung of a normal ladder, and treat anything below 60 as a complaint waiting to happen. The exact number depends on your delivery tier, but the industry has converged on defensible bands.

VMAF 93-95 is the transparency threshold. At 95, most viewers can’t distinguish the encode from the source in a side-by-side test. This is the target for mezzanine files and premium tiers where storage and bandwidth aren’t the binding constraint.

VMAF 85-93 is the sweet spot for top ladder rungs. You’re spending far fewer bits than transparency requires, and the difference is invisible during normal viewing. Large UGC platforms typically land in the 84-92 range for their highest rungs.

VMAF 70-85 covers the middle of an adaptive bitrate streaming ladder. Viewers on constrained connections get something that looks fine on a phone and merely acceptable on a TV.

Below VMAF 60, you’re in complaint territory for paid services. Research on acceptance rates puts the 50% acceptability line around VMAF 55 for free services and around 70 for paid ones.

The 6-point rule

A widely used rule of thumb holds that roughly 6 VMAF points equal one Just Noticeable Difference. If encode A scores 88 and encode B scores 90, stop arguing about it and pick whichever is cheaper. If A scores 88 and B scores 96, that’s a gap your viewers will see.

Pooling changes the answer

The default arithmetic mean rewards content that’s easy to encode and hides localized failures. Human opinion doesn’t work that way. Viewers weight the worst moments far more heavily than the average, which is why a single bad scene sinks a session that was otherwise clean.

libvmaf supports alternative pooling methods for exactly this reason: mean, harmonic_mean, median, min, perc5, perc10, and perc20. The harmonic mean and the 5th-percentile score both punish dips the arithmetic mean smooths over.

A practical setup reports three numbers per file:

• Arithmetic mean for the headline score
• 5th percentile for the worst stretches
• Frame count below your floor for localized failures

Tune your video bitrate against all three, not just the first.

Advantages of VMAF

It predicts human opinion, not pixel math

VMAF is trained on subjective scores from real viewing sessions, so it’s fitted to perception rather than derived from an equation someone hoped would match perception. That’s why it correlates with mean opinion scores at 0.90-0.95 while PSNR sits far below.

It works across codecs

Because it scores output rather than bitstream internals, VMAF compares encodes from different codecs on the same scale. Benchmark testing has shown it outperforming other metrics across H.265, VP9, AV1, and VVC. That’s what makes it usable for the “is AV1 worth the encode cost versus H.264” question that every streaming team eventually faces.

The scale is readable

A 0-100 linear range means anyone on the team can interpret it. Product managers understand “we’re shipping at 91.” Nobody outside video engineering has an intuition for 41.3 dB.

It catches scaling artifacts

VMAF accounts for both quantization damage like blockiness and scaling damage like the softness introduced when a 720p encode gets upscaled to a 1080p display. Metrics that compare same-resolution frames miss half of that, which matters enormously for lower ladder rungs where resolution changes are the whole point.

It’s open source and auditable

The open-source VMAF repository ships the C library, the Python bindings, the model files, and the training code. You can retrain on your own subjective data if your content differs from what Netflix trained on. Animation, screen content, and sports all have quirks the default models weren’t fitted for.

Automation makes it cheap to act on

Once VMAF is in your pipeline, it stops being a report and becomes a control signal. You can target a score instead of a bitrate, which is the foundation of per-title encoding: encode each title at multiple bitrates and resolutions, find the settings that hit your quality target for the fewest bits, and ship that ladder. Compared against VP9 or H.264 baselines, the savings are usually double digits.

Limitations of VMAF

VMAF is the best general-purpose metric available, and it will still mislead you in specific, predictable ways.

It can be gamed

Preprocessing a video before encoding can inflate its VMAF score without improving how it looks. Research on preprocessing vulnerability found sharpening and histogram equalization pushing scores up by as much as 218.8% in extreme cases, with subjective quality flat or worse.

The NEG variant reduces this but doesn’t eliminate it. The same study found NEG still inflatable by up to 23.6%.

So if a vendor quotes you a VMAF number, ask what preprocessing ran first.

Resolution assumptions distort low-res scores

The default model assumes a 1080p display. Feed it a 480p file directly and VMAF treats it as a crop from 1080p, effectively modeling a viewer sitting 6.75 picture heights away, which hides artifacts and returns an implausibly high score. The fix is mandatory: upscale the encode to the model’s resolution before measuring, and use bicubic if you don’t know what the actual display device uses.

Averaging hides the failures that matter

The arithmetic mean over a two-hour film tells you almost nothing about the thirty seconds that made someone close the tab. Percentile pooling and per-frame logs are the mitigation, and most teams skip both.

It scores files, not sessions

VMAF measures encode quality. It says nothing about rebuffering, startup delay, or ABR switching behavior, which drive abandonment at least as much as picture quality. A ladder with a perfect average VMAF that causes buffering on real connections is a worse product than a slightly softer one that plays through.

It’s expensive at scale

Running VMAF across every asset in a large library costs real compute. VMAF v1 is cheaper than v0 after the VIF removal, and GPU acceleration through libvmaf_cuda helps considerably, but a full-reference metric still means decoding two videos in lockstep for every measurement.

That’s what VMAF measures and where it breaks down. Now for the practical side: how to install it, how to run it, and how to fit it into a working pipeline.

How to Run VMAF with FFmpeg

The libvmaf filter is the standard path. Everything below assumes an FFmpeg build with VMAF support compiled in.

Check whether your build already has it

ffmpeg -filters | grep vmaf

If nothing comes back, check the configuration flags:

ffmpeg -version | tr ' ' '\n' | grep vmaf

You want --enable-libvmaf in the output.

Install libvmaf and rebuild FFmpeg

libvmaf builds with Meson and Ninja. Version 3.0.0 is the current stable release.

git clone https://github.com/Netflix/vmaf.git
cd vmaf/libvmaf
meson setup build --buildtype release
ninja -C build
sudo ninja -C build install

Then rebuild FFmpeg against it:

./configure --enable-libvmaf --enable-gpl
make -j"$(nproc)"
sudo make install

On macOS, brew install ffmpeg ships with libvmaf enabled in most recent formulas, so check before you build anything.

Run a basic comparison

Order matters. The first input is the distorted file, the second is the reference.

ffmpeg -i encoded.mp4 -i source.mp4 \
  -lavfi libvmaf=log_fmt=json:log_path=vmaf.json \
  -f null -

You’ll see a line like VMAF score: 92.417213 when it finishes, and the JSON log will contain every per-frame value.

Handle a resolution mismatch

This is the step teams skip, and it’s the one that produces wrong numbers. If your encode is 720p and your source is 1080p, upscale the encode first:

ffmpeg -i encoded_720p.mp4 -i source_1080p.mp4 \
  -lavfi "[0:v]scale=1920:1080:flags=bicubic,setsar=1[dist];\
[1:v]setsar=1[ref];\
[dist][ref]libvmaf=model='version=vmaf_v0.6.1':n_threads=8:log_fmt=json:log_path=vmaf.json" \
  -f null -

Frame rates have to match too. Add fps=fps=30 to whichever branch needs it.

Pick a model and a pooling method

ffmpeg -i encoded.mp4 -i source.mp4 \
  -lavfi "libvmaf=model='path=/usr/local/share/model/vmaf_v1.0.16_3d0h.json':\
pool=harmonic_mean:n_threads=8:log_fmt=json:log_path=vmaf.json" \
  -f null -

The filter’s useful options are model, feature, log_path, log_fmt, pool, n_threads, and n_subsample. Setting n_subsample=5 scores every fifth frame, which cuts runtime by roughly 80% at the cost of missing short dips. Use it for sweeps, not for final QC.

Compute PSNR and SSIM in the same pass

ffmpeg -i encoded.mp4 -i source.mp4 \
  -lavfi "libvmaf=feature='name=psnr|name=float_ssim':log_fmt=json:log_path=metrics.json" \
  -f null -

Use GPU acceleration

libvmaf_cuda runs the feature extraction on NVIDIA hardware and is dramatically faster on large libraries. It pairs naturally with a hardware encoding workflow where the frames are already on the GPU.

ffmpeg -hwaccel cuda -hwaccel_output_format cuda -i encoded.mp4 \
       -hwaccel cuda -hwaccel_output_format cuda -i source.mp4 \
       -lavfi libvmaf_cuda=log_fmt=json:log_path=vmaf.json \
       -f null -

Skip FFmpeg entirely

The standalone vmaf CLI takes raw YUV or Y4M input and gives you more direct control:

vmaf --reference source.y4m --distorted encoded.y4m \
     --model version=vmaf_v0.6.1 \
     --feature psnr --feature float_ssim \
     --output vmaf.json --json

For scripted analysis, the ffmpeg-quality-metrics Python package wraps all of this and returns parsed results, which saves you from writing yet another JSON reader. If you’d rather not touch a terminal, FFMetrics and similar VMAF GUI tools wrap the same libraries with a drag-and-drop interface.

Where VMAF Fits in a Streaming Pipeline

Measuring VMAF is straightforward. Building the pipeline that acts on it is where the work actually lives.

Encoder tuning and codec selection

The first place VMAF earns its keep is settings comparison. Encode the same source at a range of CRF or bitrate values, plot VMAF against bitrate, and you get a rate-quality curve that tells you exactly where diminishing returns start. Do it per codec and you have a defensible answer on whether a transcoding migration pays for itself.

Per-title and per-shot ladder construction

This is what Netflix built VMAF for. Instead of one static ABR ladder for every asset, you encode each title at multiple bitrate and resolution combinations, score each with VMAF, and keep the points that sit on the convex hull of the rate-quality curve.

An animated short and a handheld sports clip need very different ladders. A static ladder overspends on one while starving the other, and teams that switch typically cut delivery bitrates by 20-40% at matched quality.

Automated QC gates

Once VMAF is in CI, it becomes a gate. Any encode landing below your floor fails the build instead of reaching viewers. Pair the aggregate score with a per-frame minimum so a clean average can’t smuggle a broken scene through.

The build-versus-buy reality

Running this yourself means a cloud-based video encoding farm, a quality-measurement layer, ladder logic, packaging, and CDN delivery. That’s a team and a roadmap, not a sprint. Most product teams don’t want to own it.

This is where a video transcoding API changes the math. LiveAPI handles encoding, adaptive bitrate rendition generation, and HLS output, with instant encoding that makes uploads playable within seconds regardless of file length, support up to 4K, and delivery across Akamai, Cloudflare, and Fastly.

You still measure VMAF on your own mezzanine files when you need to make a codec or quality decision. You just don’t operate the encoding farm that produces the renditions, or the multi-CDN layer that delivers them.

Is VMAF Worth Measuring Yourself?

Not every team needs this. Running VMAF properly means storing mezzanine sources, budgeting compute, and having someone who can interpret the output.

Measure VMAF yourself if:

• You encode enough volume that a 20% bitrate reduction pays real money
• You’re evaluating a codec or encoder migration and need evidence
• Your content is unusual (animation, screen recordings, high-motion sports) and generic presets underperform
• You have contractual quality obligations to a customer or licensor
• You’re building per-title or per-shot ladders

Skip it if:

• You stream live and never re-encode from a mezzanine
• Your volume is low enough that engineering time costs more than the bandwidth you’d save
• You’re using a managed encoding service whose defaults already land above 90
• You don’t retain source files to compare against

If you’re in the second group, the useful move is picking infrastructure with sane defaults and spending your attention on playback reliability instead. Buffering and startup time drive more churn than a few VMAF points ever will.

VMAF FAQ

What does VMAF stand for?

Video Multimethod Assessment Fusion. The name describes the design: multiple quality assessment methods fused by a trained model into one score.

Is a VMAF score of 80 good?

For most delivery it’s acceptable but not premium. VMAF 80 means visible artifacts under scrutiny and fine during normal viewing. Aim for 90+ on your top ladder rung and treat 80 as reasonable for mid-tier renditions.

Can VMAF work without the original video?

No. VMAF is a full-reference metric and needs both the source and the encode. If you only have the encode, you need a no-reference metric instead, and those are considerably less accurate.

Why does my 480p video score higher than expected?

The default model assumes a 1080p display. A 480p file gets treated as a small crop of a 1080p frame, which models an unrealistically distant viewer and hides artifacts. Upscale the encode to 1080p with bicubic before measuring.

What’s the difference between VMAF and VMAF NEG?

NEG stands for no-enhancement gain. It caps the score boost that preprocessing like sharpening can produce, so it’s the right choice for honest encoder comparisons. In VMAF v1, NEG behavior is the default rather than a separate model.

Should I switch to VMAF v1?

For new work, yes. VMAF v1 detects banding and chroma artifacts that v0 was blind to, and it runs faster after VIF was removed. Just don’t compare v1 scores to historical v0.6.1 numbers directly. Rebaseline first.

Does VMAF work for live streaming?

Not in the delivery path. Live encoding has no mezzanine reference to compare against in real time, and the compute cost is prohibitive at low latency. Teams use VMAF offline to tune the live encoder profiles they then run in production.

How long does VMAF take to run?

Roughly real time to several times real time on CPU, depending on resolution, thread count, and model. GPU acceleration through libvmaf_cuda cuts that substantially, and n_subsample trades accuracy for speed when you’re sweeping settings rather than doing final QC.

Can I use VMAF for images?

It’s built for video and its motion feature does nothing on a single frame. For still images, SSIM, MS-SSIM, or a dedicated image metric will serve you better.

Which VMAF model should I use for mobile?

Use vmaf_v1.0.16_5d0h.json, the 5H viewing-distance model, which replaces the old phone_model=1 flag from the v0 generation. Small screens held close tolerate more compression than a TV across a room.

The Bottom Line on VMAF

VMAF gives you a number that tracks what viewers actually perceive, which makes it the right tool for encoder tuning, codec decisions, and per-title ladder construction. VMAF v1 extends that to banding and chroma artifacts the previous generation couldn’t see, and it does so at lower compute cost.

The trap is treating the average score as the whole answer. Match your model to your viewing context, upscale before you measure, watch the per-frame minimums, and remember that a metric tuned against itself stops measuring anything real.

Ready to ship video without building the encoding stack behind it? LiveAPI handles transcoding, adaptive bitrate renditions, HLS delivery up to 4K, and global CDN distribution through a single API, so your team can go live in days instead of months. Get started with LiveAPI.