You’ve just run quality control on 48 samples. Now what?
You executed FastQC on your RNA-seq dataset and now have 48 HTML files sitting in your results folder. Click through each one? Tedious. Open them all in tabs? Your browser hates you. Stare at FastQC reports individually and manually track quality metrics across samples? That’s not how you spend your postdoc.
This is where MultiQC comes in. It aggregates quality control reports from dozens of bioinformatics tools into a single, interactive HTML file. One dashboard instead of 48 separate reports. No installation, no database, no web server required.
But is MultiQC the best solution for aggregating QC across large cohorts? That depends on your workflow, the tools you use, and how customizable you need your reports to be. I’ve used it on projects ranging from 20 samples to 500+ samples, across multiple sequencing technologies and analysis pipelines. Here’s what I’ve learned.
What is MultiQC and why does it matter?
MultiQC is a bioinformatics tool that parses output from commonly used QC and analysis software, extracts key metrics, and produces a single interactive HTML report. You run it once after your pipeline completes, point it at your results directory, and it automatically finds and aggregates reports from all the tools it recognizes.
The value proposition is simple: consolidate dozens of individual reports into one searchable, filterable dashboard. Instead of opening FastQC report #1, scanning for contamination, closing it, opening FastQC report #2, and repeating 47 more times, you see all samples’ quality metrics in a single interface. You can plot metrics across samples, sort by column, and download summary tables.
MultiQC doesn’t re-analyze data. It doesn’t touch your raw files. It reads the output files your tools already generate (logs, JSON files, text reports) and synthesizes them into a unified visualization.
Installation and basic usage
MultiQC is distributed via conda, pip, and Docker. The conda approach is most common for bioinformaticians.
# Install via conda (recommended for most labs)
conda install -c bioconda multiqc
# Or via pip
pip install multiqc
# Or via Docker
docker run -v $(pwd):/data ewels/multiqc /data
Once installed, usage is straightforward.
# Run on a directory containing all your QC output files
multiqc /path/to/results/
# This creates a file: multiqc_report.html
# Open it in your browser
That’s the basic workflow. MultiQC recursively searches the directory, identifies known file formats (FastQC fastqc_data.txt, Salmon quant.sf, samtools stats output, etc.), parses them, and generates the report.
For more control, specify the output directory and name:
multiqc /path/to/results/ --outdir ./qc_reports --filename multiqc_report.html
You can also run it directly in your Snakemake or Nextflow pipeline as a final aggregation step. I typically add it as the last rule in RNA-seq pipelines, after all upstream QC tools have run.
What MultiQC aggregates well
MultiQC supports 150+ tools out of the box. Here’s a breakdown of the most common ones in bioinformatics workflows.
| Tool | What it measures | Support quality |
|---|---|---|
| FastQC | Read quality, adapter content, GC bias | Native |
| Trim Galore | Adapter trimming statistics | Native |
| STAR | Alignment rates, splice junctions, mismatch rates | Native |
| Salmon | Transcript-level quantification, read mapping rates | Native |
| Picard | Duplication rates, insert size, coverage | Native |
| samtools | Alignment statistics, coverage, flagstat metrics | Native |
| fastp | Trimming, quality filtering, duplication | Native |
| bcftools | VCF statistics, variant counts | Native |
| RSeQC | RNA-seq QC metrics | Native |
| Qualimap | BAM/SAM coverage analysis | Native |
“Native” support means MultiQC recognizes the file format automatically. You don’t need to do anything special; just run MultiQC and it finds and parses the output.
I’ve run MultiQC on hundreds of RNA-seq and whole-genome sequencing samples across multiple projects. The aggregation of FastQC and alignment metrics is rock solid. The interactive plots let you drill into sample-level details quickly. The filtering and search capabilities are genuinely useful when you have more than 20 samples.
One feature I use often is the ability to exclude samples from the report dynamically. You can add a sample_name filter, search for specific patterns, or hide outlier samples in the interface without re-running the tool.
Where MultiQC falls short
MultiQC is excellent for short-read, Illumina-focused workflows. It’s weaker in other areas.
Long-read sequencing: If you’re working with PacBio or Oxford Nanopore data, MultiQC support is limited. Tools like NanoPlot and PycoQC have plugins, but the quality of integration is inconsistent. For long-read projects, I often fall back to running those tools’ native HTML reports separately.
Custom tools and in-house pipelines: If you’ve written custom QC metrics or use proprietary analysis software, MultiQC won’t automatically parse them. You can write a custom plugin, but that requires Python and familiarity with MultiQC’s plugin architecture. For most labs, this is not worth the overhead.
Performance on very large cohorts: I’ve run MultiQC on a directory with 800+ samples, and the HTML report became sluggish. The interactive plots lagged, filtering took seconds, and downloading summary tables was slow. For datasets of this scale, you might prefer a proper database or visualization framework rather than an HTML file.
Configuration complexity: While basic usage is trivial, if you want to customize which modules appear, adjust colors, exclude certain metrics, or change the report structure, you need to write a multiqc_config.yaml file. The configuration options are extensive but poorly documented for non-developers.
No filtering at input time: MultiQC aggregates everything it finds. If you want to include only samples matching a pattern (e.g., only samples from a specific timepoint), you have to either manually move files or post-process the report. It would be useful to have a --pattern or --include-only flag.
Customizing MultiQC with a config file
For most projects, the default report is fine. But if you want to customize module order, colors, or which tools to include, create a multiqc_config.yaml in your working directory.
# multiqc_config.yaml
# Customize MultiQC report generation
# Specify which modules to run (order matters)
module_order:
- fastqc
- trim_galore
- star
- salmon
- picard
- samtools
# Customize the report title and introduction
title: "RNA-seq QC Report"
subtitle: "Batch 3: TimePoint 2"
intro_text: "This report aggregates quality metrics from 48 RNA-seq samples prepared on 2025-12-01."
# Exclude samples matching a pattern (useful for removing controls)
exclude_patterns:
- "Mock"
- "NTC"
# Customize colors
plot_config:
fastqc:
per_sequence_quality_scores:
colors:
- "#2ecc71"
- "#e74c3c"
# Set custom column names for easier reading
sample_names_replace_dict:
"Sample_R1": "Sample"
"_L001": ""
Run it alongside your MultiQC command:
multiqc /path/to/results/ --config multiqc_config.yaml
The config file approach is tedious for one-off reports but invaluable if you run MultiQC regularly on similar datasets. I keep a template config in my project’s repo and adjust it as needed.
How does MultiQC compare to alternatives?
You have options for aggregating QC reports. Let’s be honest about the trade-offs.
MultiQC vs. FastQC standalone: FastQC only handles raw read quality; it doesn’t aggregate alignment metrics, trimming statistics, or quantification output. If you only care about read quality, FastQC’s individual reports are fine. But if you need to see quality across multiple preprocessing and alignment steps, MultiQC wins. Bottom line: MultiQC for comprehensive QC across a full pipeline, FastQC if you only need pre-alignment quality.
MultiQC vs. fastp’s built-in reports: fastp generates a JSON output that includes trim and quality filter statistics with an interactive HTML report. It’s fast and self-contained. However, fastp only covers trimming and filtering; it doesn’t aggregate downstream alignment or quantification QC. If your entire workflow is fastp, you can use its report. But if you run STAR, Salmon, or other tools downstream, you need MultiQC (or multiple separate reports). Winner: MultiQC for multi-stage pipelines, fastp if you’re only doing trimming.
MultiQC vs. custom dashboards: Some labs build Shiny, Plotly, or R Markdown dashboards to visualize QC metrics. These are powerful but require data science skills and ongoing maintenance. MultiQC requires zero coding for standard workflows. Custom dashboards win on flexibility and aesthetics; MultiQC wins on ease of use and maintenance.
The verdict: Who should use MultiQC?
Use MultiQC if you:
- Work with Illumina or other short-read data
- Run standard bioinformatics tools (STAR, Salmon, FastQC, samtools, etc.)
- Have 10 or more samples per project and want to avoid clicking through individual reports
- Want a lightweight, no-database solution for QC visualization
- Work in a lab without a bioinformatician to maintain custom dashboards
Think twice about MultiQC if you:
- Work primarily with long-read data (PacBio, Nanopore) and need deep QC integration
- Use niche or custom tools whose output MultiQC doesn’t parse
- Have very large cohorts (500+ samples) where HTML report performance matters
- Need granular filtering or database-backed QC tracking across years of projects
- Want to build a long-term, project-agnostic QC platform
My honest take: MultiQC is not perfect, but it’s the best general-purpose solution for most bioinformaticians working with standard pipelines. It saves hours of clicking through individual reports. The configuration is straightforward for basic use cases, and the interactive features are useful. The limitations (long-read support, custom tools, large-cohort performance) matter only for specific workflows.
For a typical RNA-seq or whole-genome sequencing project in an academic lab, MultiQC is the right tool. Install it, run it once after your pipeline completes, and spend your time on analysis instead of report aggregation.
If you’re just starting with bioinformatics pipelines, you might also find our guide on Nextflow vs. Snakemake useful for understanding how to integrate MultiQC into your workflow. And if you’re new to conda-based installation and dependency management, check out our conda setup post for context.
Next steps
Start small. Run MultiQC on your next project with default settings. If the output is useful (and it probably will be), you’ve won. If you find yourself wanting custom colors, filtered samples, or module reordering, reach for the config file.
For documentation, the official MultiQC docs are comprehensive. The plugin development guide is solid if you need to write a parser for a custom tool.