Seurat vs Scanpy: Which Should You Use for Single-Cell RNA-seq Analysis?
By Pipette.bio Team
Seurat and Scanpy are two of the most widely used frameworks for analyzing single-cell RNA sequencing data.
At first glance, they appear to do many of the same things:
- quality control;
- normalization;
- dimensionality reduction;
- clustering;
- marker-gene identification;
- cell-type annotation;
- dataset integration;
- visualization.
The main difference is straightforward: Seurat is built around R. Scanpy is built around Python.
But choosing between them involves more than programming-language preference. Their data structures, surrounding ecosystems, approaches to large datasets, integration with machine-learning tools, and common workflows differ.
For many standard scRNA-seq experiments, either will work well. The better question is:
Which ecosystem fits the analysis you want to perform?
What is Seurat?
Seurat is an R toolkit developed by the Satija Lab for single-cell genomics.
A standard Seurat workflow includes:
count matrix → QC → normalization → variable genes → PCA → neighbors → clustering → UMAP → marker genes → cell-type annotation
Seurat provides functions for these steps within a single framework. Its documentation includes workflows for preprocessing, clustering, visualization, integration, multimodal analysis, and reference mapping.
The central data structure is the Seurat object, which can store:
- expression matrices;
- cell and feature metadata;
- dimensional reductions and embeddings;
- clusters and analysis results;
- multiple assays and modalities.
Seurat v5 uses a layer-based assay structure, allowing counts, normalized values, and other representations to coexist. It also introduced infrastructure for on-disk data, sketch-based analysis, multimodal analysis, and streamlined comparison of integration strategies.
What is Scanpy?
Scanpy is a Python toolkit for single-cell gene-expression analysis and part of the broader scverse ecosystem.
Its typical workflow is similar:
count matrix → QC → normalization → highly variable genes → PCA → neighbors → clustering → UMAP → marker genes → annotation
Scanpy includes preprocessing, visualization, clustering, trajectory inference, and differential-expression testing. It is built around the AnnData data structure.
An AnnData object typically stores:
- the primary data matrix in
.X; - cell metadata in
.obs; - feature metadata in
.var; - dimensional reductions and embeddings in
.obsm; - additional expression matrices in
.layers; - graphs and unstructured analysis results.
AnnData is commonly stored in .h5ad files and serves as a shared data container across much of the Python single-cell ecosystem.
Seurat vs Scanpy at a glance
| Feature | Seurat | Scanpy |
|---|---|---|
| Primary language | R | Python |
| Main data object | Seurat object | AnnData |
| Standard scRNA-seq workflow | Strong integrated workflow | Strong modular workflow |
| QC and preprocessing | Yes | Yes |
| PCA, UMAP, and graph clustering | Yes | Yes |
| Marker-gene testing | Yes | Yes |
| Dataset integration | Multiple methods through Seurat and extensions | Multiple methods through Scanpy and scverse packages |
| Multimodal analysis | Built-in and extension workflows | Interoperable scverse packages |
| Machine-learning ecosystem | Available through R packages and Python integration | Native access to Python ML libraries |
| Very large datasets | On-disk and sketch workflows | Backed storage and selected Dask-compatible workflows |
| Natural fit | R-heavy biology workflows | Python and data-science workflows |
Neither package is simply a more powerful version of the other. Both can perform high-quality standard single-cell analysis. Their differences become more important once the workflow extends beyond preprocessing, clustering, and visualization.
Seurat: strengths
1. A highly integrated single-cell workflow
One of Seurat’s biggest advantages is how much of an analysis can be performed inside one consistent framework.
CreateSeuratObject
↓ PercentageFeatureSet
↓ NormalizeData or SCTransform
↓ FindVariableFeatures
↓ RunPCA
↓ FindNeighbors and FindClusters
↓ RunUMAP
↓ FindAllMarkers
For researchers working primarily in R, this makes Seurat relatively straightforward to learn. A large amount of single-cell teaching material and published analysis code also uses this structure.
2. Multiple dataset-integration strategies
Integration is one of Seurat’s best-known capabilities. The current Seurat v5 integration vignette documents five approaches through IntegrateLayers():
- CCA;
- RPCA;
- Harmony;
- FastMNN;
- scVI.
This lets researchers compare different strategies while keeping results in a Seurat workflow. It can be useful when combining multiple donors, experimental batches, technologies, or studies.
Integration should not be performed automatically just because multiple samples exist. Unnecessary or excessive correction can remove real biological differences. The aim is to address unwanted technical structure while retaining signal relevant to the study.
3. SCTransform
Seurat provides direct access to SCTransform, a variance-stabilizing transformation for UMI counts based on the sctransform model.
SCTransform → PCA → neighbors → clustering → UMAP
It is a common alternative to the traditional sequence of library-size normalization, variable-feature selection, and scaling. The appropriate normalization still depends on the downstream method and experimental design.
4. Multimodal analysis
Modern single-cell experiments can measure RNA together with surface proteins, chromatin accessibility, perturbations, or other modalities. Seurat supports multimodal objects and methods for combining information across modalities, including weighted-nearest-neighbor and bridge-integration workflows.
5. Reference mapping and label transfer
Seurat provides dedicated workflows for mapping new datasets to annotated references. A well-annotated PBMC reference, for example, can be used to project a new PBMC dataset and transfer candidate labels.
Reference mapping can improve consistency, but transferred labels still require inspection. Differences in tissue, disease, protocol, species, or missing reference populations can make an apparently confident label misleading.
Scanpy: strengths
1. A native Python environment
Scanpy operates inside the Python scientific-computing ecosystem. Once data are represented as AnnData, they can interact naturally with tools built around:
- NumPy;
- SciPy;
- pandas;
- scikit-learn;
- PyTorch;
- JAX;
- matplotlib.
This is useful when single-cell analysis is one component of a larger computational project.
single-cell expression → feature engineering → machine-learning model → prediction
2. The scverse ecosystem
Scanpy is best understood as one component of scverse. Community packages build on shared data structures and connect Scanpy workflows to trajectory inference, spatial analysis, multimodal data, immune-receptor analysis, and probabilistic modeling.
AnnData provides a common container that helps these tools interoperate, although each package still has its own assumptions and required fields.
3. A strong connection to machine learning
Python is central to many machine-learning-driven single-cell methods. Probabilistic models such as scVI fit naturally into an AnnData-based workflow.
Scanpy → AnnData → scVI → latent representation → neighbors, UMAP, and downstream modeling
This can make Scanpy attractive to groups developing representation-learning methods or connecting single-cell data to other Python models.
4. Flexible programmatic workflows
Scanpy organizes its API into preprocessing, tools, plotting, and data-access namespaces. A basic sequence might look like:
sc.pp.normalize_total(adata)
sc.pp.log1p(adata)
sc.pp.highly_variable_genes(adata)
sc.tl.pca(adata)
sc.pp.neighbors(adata)
sc.tl.leiden(adata)
sc.tl.umap(adata)
sc.pl.umap(adata)
Results are generally written back into the AnnData object. This structure works well for scripted pipelines and notebooks when the contents of .X, .raw, and each layer are documented explicitly.
Which is faster: Seurat or Scanpy?
There is no universal answer. Performance depends on:
- numbers of cells and genes;
- normalization and integration methods;
- sparse-matrix representation;
- available memory and disk storage;
- CPU or GPU hardware;
- the specific functions and parameters used.
It is misleading to say that Scanpy is automatically faster because it uses Python, or that Seurat cannot handle large datasets.
Seurat’s official sketch-analysis example keeps a 1.3-million-cell dataset on disk with BPCells and analyzes a representative 50,000-cell sketch in memory. The documentation describes this approach as scalable beyond 10 million cells.
Scanpy’s documentation states that it can efficiently handle datasets exceeding one million cells. It also notes that many functions now have experimental Dask compatibility for data that do not fit in memory. That support is not universal, so the functions used in a particular workflow should be checked.
For very large analyses, data representation and algorithm choice usually matter more than the name of the initial framework.
Seurat vs Scanpy for batch correction
This comparison is less binary than it appears. Seurat provides anchor-based methods and interfaces to methods such as Harmony, FastMNN, and scVI. Scanpy workflows can also use multiple integration methods through Scanpy and surrounding scverse packages.
Seurat versus Scanpy is not the same question as CCA versus Harmony versus scVI.
The framework is the analysis environment. The integration algorithm is a separate methodological choice. Whether integration is appropriate at all is another choice.
Seurat vs Scanpy for differential expression
Both frameworks provide convenient functions for finding genes associated with clusters or groups. These functions are useful for identifying candidate cluster markers.
Condition-level differential expression requires more care. If an experiment contains eight treated donors and eight control donors, the thousands of cells from each donor are not thousands of independent biological replicates.
For inference about treatment or disease, methods that preserve biological replication—often including cell-type-specific pseudobulk aggregation—may be more appropriate. Scanpy’s current preprocessing tutorial explicitly warns about cell-level P-values and demonstrates aggregation by sample as a more conservative option.
This issue exists regardless of whether the initial analysis uses Seurat or Scanpy. The experimental unit and statistical design matter more than the framework.
Once a defensible gene list or signed ranking exists, it can support downstream GO over-representation analysis or GSEA.
Seurat vs Scanpy for visualization
Both provide standard single-cell figures:
- UMAP and t-SNE;
- violin plots;
- feature plots;
- dot plots;
- heatmaps.
Seurat works naturally with the R visualization ecosystem, particularly ggplot2. Scanpy uses matplotlib and related Python libraries, and many plotting functions can return objects for further customization.
If publication graphics are central to the workflow, the more useful choice may be the plotting ecosystem your group can customize reliably.
What about cell-type annotation?
Neither Seurat nor Scanpy automatically solves the biological problem of cell annotation.
Both can help identify clusters, marker genes, reference similarities, and transferred labels. A cluster expressing CD3D, CD3E, and TRBC1, for example, is consistent with T cells. Reliable annotation may still require:
- multiple positive markers;
- negative markers;
- tissue and disease context;
- reference datasets;
- experimental knowledge;
- checks for doublets, ambient RNA, and low-quality cells.
Changing frameworks does not remove this requirement.
Can Seurat and Scanpy be used together?
Yes. The choice does not have to be permanent.
Single-cell datasets can be converted or exchanged between Seurat-associated formats and AnnData workflows. Complex conversions should be checked carefully, especially for:
- raw counts and normalized matrices;
- feature and cell identifiers;
- dimensional reductions;
- categorical metadata;
- integrated assays or layers;
- multimodal data.
A team might perform exploratory analysis in Seurat and move a documented matrix and metadata into Python for machine learning. A Python-based group might use Scanpy and export defined results for R-based collaborators.
Should beginners use Seurat or Scanpy?
For a beginner, the surrounding environment is usually the best guide.
Choose Seurat if:
- your lab primarily uses R;
- collaborators already use Seurat;
- you want extensive established scRNA-seq tutorials;
- you expect to use Seurat’s integration or reference-mapping workflows;
- you are comfortable with Bioconductor and ggplot2.
Choose Scanpy if:
- your lab primarily uses Python;
- you expect extensive custom computational development;
- you want close integration with Python machine learning;
- you expect to use scverse tools or scvi-tools;
- AnnData is already the primary format in your workflow.
If you know neither R nor Python, there is no compelling reason to learn one solely because its single-cell framework is objectively superior. Neither is. Choose based on where the rest of the analysis is likely to go.
What should a computational biology lab use?
An R-heavy genomics laboratory may reasonably standardize around:
Seurat + Bioconductor + ggplot2
A machine-learning-heavy computational group may prefer:
Scanpy + AnnData + scverse + Python ML tools
Supporting both can also be reasonable. More important than enforcing one package is standardizing:
- input files and reference genomes;
- preprocessing and QC criteria;
- normalization and integration strategies;
- annotation procedures;
- statistical testing and experimental units;
- software versions, parameters, and provenance.
Two analysts can obtain different results with the same software when these choices differ. Carefully matched workflows across the two ecosystems can produce similar biological conclusions, but equivalence should be demonstrated for the actual dataset rather than assumed.
Common mistake: treating the default workflow as the correct workflow
Both packages make it easy to execute a familiar sequence:
normalize → PCA → neighbors → clustering → UMAP
Successful execution does not establish that the analysis is correct. Single-cell workflows contain decisions that should depend on the biological question:
- Should mitochondrial filtering be applied, and at what threshold?
- What defines a low-quality cell for this tissue and protocol?
- Should the samples be integrated at all?
- Which technical variables, if any, should be regressed?
- What clustering resolution is biologically defensible?
- Does a cluster represent a cell type, a state, or an artifact?
- Should differential expression use cells or biological samples as replicates?
- Is an observed difference biological or technical?
Those decisions matter much more than whether commands begin with sc. or operate on a Seurat object.
So, Seurat or Scanpy?
For standard single-cell RNA-seq analysis, both are strong choices.
Choose Seurat when your scientific workflow primarily lives in R.
Choose Scanpy when your scientific workflow primarily lives in Python.
For more complex analyses, the distinction becomes more about ecosystems. Seurat provides an extensive integrated environment for single-cell and multimodal genomics. Scanpy provides an entry point into the broader Python and scverse ecosystem and connects naturally to modern machine-learning workflows.
In some projects, the right answer is to use the best-supported tool for each stage while preserving explicit, validated data exchange between them.
Choose the ecosystem your team can maintain, then make the analysis decisions explicit. A reproducible Seurat workflow is better than an improvised Scanpy workflow, and the reverse is equally true. The framework is the container; the quality of the result comes from experimental design, appropriate methods, biological validation, and provenance.
Sources and further reading
- Getting started with Seurat v5, Satija Lab.
- Integrative analysis in Seurat v5, Satija Lab.
- Sketch-based analysis in Seurat v5, Satija Lab.
- Scanpy documentation, Scanpy development team.
- Scanpy preprocessing and clustering tutorial, including guidance on pseudobulk differential expression.
- AnnData documentation, scverse.
- scverse package ecosystem, scverse.
Running single-cell analysis with Pipette
Choosing between Seurat and Scanpy is only one decision in a single-cell experiment. Filtering thresholds, integration strategy, clustering, annotation evidence, and the unit of statistical replication usually matter more.
Pipette keeps those decisions, parameters, intermediate results, and biological reasoning attached to the analysis, whether the appropriate underlying workflow uses R or Python.
The goal is not to hide Seurat or Scanpy. It is to make every consequential decision around them visible and reproducible.