# seaborn: statistical data visualization on top of matplotlib

> seaborn is a Python library that gives matplotlib a high-level interface for statistical graphics. It is a good fit for pandas-shaped data and exploratory plotting, and a poor fit if you want an interactive or web-native chart.

**mwaskom/seaborn** — Statistical data visualization in Python

- Repository: https://github.com/mwaskom/seaborn
- Website: https://seaborn.pydata.org
- Stars: 14,050 · Forks: 2,143
- Language: Python
- License: BSD-3-Clause
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/mwaskom-seaborn

## What seaborn is for, and who ends up using it

seaborn is a Python visualization library based on matplotlib. The README states that it provides a high-level interface for drawing attractive statistical graphics. That sentence carries the whole positioning: it is not a replacement for matplotlib, it is a layer above it, and it assumes you are working with data that has already been organised into columns.

The audience follows from the dependencies. Installation requires numpy, pandas and matplotlib. Some advanced statistical functionality requires scipy or statsmodels. If your data is a list of numbers and a list of labels, seaborn will still draw something, but you are paying for an abstraction you are not using. If your data is a pandas DataFrame with named columns, seaborn reads those names directly and you stop writing loops to group, aggregate and colour your points.

The repository's examples directory is a fair summary of the intended use: anscombes_quartet.py, grouped_boxplot.py, faceted_histogram.py, kde_ridgeplot.py, logistic_regression.py, many_pairwise_correlations.py. These are exploratory and reporting figures, not dashboards. The library is aimed at people who want a statistical question answered visually before they decide what to do next.

## How seaborn sits on top of matplotlib and pandas

The mechanism is a translation layer. You hand seaborn a DataFrame and the names of columns; it maps those names to visual properties and then builds matplotlib artists. The output is a matplotlib Axes object, which is why you can keep using matplotlib calls on the result. That detail matters more than it sounds: it means seaborn is not a separate rendering stack you have to learn from scratch, it is a front end that hands you back something you already know how to modify.

The dependency floor is explicit in pyproject.toml: requires-python is ">=3.10", and the runtime dependencies are numpy>=2.0, pandas>=2.2 and matplotlib>=3.9. The optional stats extra adds scipy>=1.14 and statsmodels>=0.14.3. The project metadata also declares the classifier "Framework :: Matplotlib", which is an unusually direct way of saying what the library is coupled to.

That coupling is the design. seaborn inherits matplotlib's static rendering model, its figure and axes objects, and its export path to PNG, PDF and SVG. The repository layout reflects the same split: seaborn/ holds the library, tests/ holds the pytest suite, doc/ builds the documentation, and examples/ holds the standalone scripts that the gallery is generated from.

## Installing seaborn and drawing a first statistical figure

The README gives the install command directly. The latest stable release and its required dependencies come from PyPI, and the documented invocation uses uv:

```bash
uv pip install seaborn
```

If you need the statistical extras, the README shows the same command with an extra name:

```bash
uv pip install seaborn[stats]
```

conda is also supported. The README notes that the main anaconda repository lags PyPI in adding new releases, while conda-forge typically updates quickly:

```bash
conda install seaborn
```

Once installed, the shape of a first real use is: import the library, load a dataset, and call a plot function with column names rather than arrays. The README points to the tutorial and the example gallery at seaborn.pydata.org for the full API, and the API reference is the place to check the exact signature of whichever function you pick. What you should see is a matplotlib figure, because that is what seaborn returns. If you are in a Jupyter notebook, it renders inline; if you are in a script, you still need to save or show the figure yourself.

## Where seaborn stops being the right tool

The clearest limitation is the one baked into the dependency list: seaborn produces static matplotlib figures. There is no interactive panning, no hover tooltips, no browser-native output. If your requirement is a chart a reader can zoom into on a web page, seaborn is the wrong layer and no amount of customization will change that, because the rendering backend is matplotlib.

The second constraint is pandas. Because the high-level interface is organised around named columns in a DataFrame, the ergonomics degrade when your data is not in that shape. You can pass arrays, but then you are using seaborn as a thin wrapper and losing the main reason to adopt it.

The third is version reach. The most recent release listed for this repository is v0.13.2 from January 2024, and the repository's last push is 2026-07-06. That gap between the last tagged release and ongoing repository activity is worth knowing about before you pin a version in a production pipeline: the code on master and the code in your lockfile are not the same thing.

Finally, seaborn is a plotting library, not a statistics library. It will draw a regression line, and with the stats extra it reaches further, but it does not replace a modelling package. Treating a seaborn output as an inferential result rather than a visual summary is a misuse of the tool.

## seaborn vs matplotlib, and when a different library fits better

The comparison people actually search for is seaborn vs matplotlib, and the honest answer is that it is not a competition. seaborn is built on matplotlib and returns matplotlib objects. matplotlib is the lower-level drawing library: you place lines, patches and text yourself, and you control every element. seaborn is the higher-level layer: you name columns and statistical relationships, and it decides the marks.

The practical difference is the amount of code and the default aesthetics. For a grouped boxplot or a faceted histogram, matplotlib requires you to build the grouping yourself; seaborn's examples directory contains grouped_boxplot.py and faceted_histogram.py as single scripts for exactly those tasks. For a bespoke diagram that does not correspond to any statistical plot, matplotlib is the better starting point and seaborn adds nothing.

A genuine alternative with a different approach is Plotly, which people also ask about. Plotly renders interactive charts, typically for the browser, which is a different output target rather than a better or worse version of the same thing. If your deliverable is a static figure in a paper or a PDF report, seaborn's matplotlib foundation is the simpler path. If your deliverable is a chart a user manipulates, seaborn is not in that category at all.

## Maintenance, releases and the licence in practice

The repository is not archived, and the last push was on 2026-07-06. The most recent tagged release in the list is v0.13.2 from 2024-01-25, preceded by v0.13.1 on 2023-12-31 and v0.13.0 on 2023-09-29. So the release cadence visible here is not continuous, and anyone who needs a predictable upgrade schedule should plan around that rather than assume a steady stream of point releases.

The upgrade cost is bounded by the dependency floors. Because pyproject.toml requires numpy>=2.0 and pandas>=2.2, moving to a current seaborn means moving to a current numpy and pandas. In an environment pinned to older scientific Python versions, that is the real work, not the seaborn upgrade itself.

The licence is BSD-3-Clause, declared both in the repository and in the project metadata classifier "License :: OSI Approved :: BSD License". A permissive licence of that kind generally imposes few obligations on redistribution, but the terms are in LICENSE.md and the specifics are for you and your legal team to read. Nothing here is legal advice.

For contributors, the repository documents its own tooling: tests run through pytest with a coverage report via make test, code style is enforced with ruff through make lint, and pre-commit can be installed with pre-commit install to run lint checks on each commit. The Makefile shows these targets invoking uv run --no-sync, so a source checkout is expected to be managed with uv.

## Conclusion

Adopt seaborn if your data already lives in pandas and your plots are meant for a notebook, a report or a static figure. Do not adopt it if you need interactive charts in a browser or a plotting layer that does not depend on matplotlib. Before committing, verify which release your package index resolves to, note that the latest listed release is v0.13.2 from January 2024, and check whether your workflow needs the optional stats extra, which pulls in scipy and statsmodels.

## FAQ

### What is seaborn used for?

seaborn is a Python visualization library based on matplotlib that provides a high-level interface for drawing statistical graphics. It is used to turn pandas DataFrames into statistical plots such as distributions, boxplots and faceted figures.

### Is seaborn the same as matplotlib?

No. seaborn is built on top of matplotlib and returns matplotlib objects, but it sits at a higher level: you name columns and statistical relationships instead of placing marks manually. matplotlib is the underlying drawing library that seaborn depends on.

### How do I install seaborn in Python?

The README gives uv pip install seaborn for the latest stable release and its required dependencies, or uv pip install seaborn[stats] to include the optional statistical dependencies. conda install seaborn is also documented, with the note that conda-forge usually updates faster than the main anaconda repository.

### How do I use seaborn in a Jupyter notebook?

seaborn produces matplotlib figures, so in a notebook those figures render inline once the library is imported. The README points to the tutorial and the example gallery at seaborn.pydata.org for the API details of individual plot functions.

### Which is better, seaborn or Plotly?

They target different outputs. seaborn renders static figures through matplotlib, while Plotly is aimed at interactive charts. If you need a figure a reader can manipulate in a browser, seaborn is not the right layer.

## Sources

- [License: BSD-3-Clause](https://github.com/mwaskom/seaborn/blob/master/LICENSE)
- [mwaskom/seaborn on GitHub](https://github.com/mwaskom/seaborn)
- [Project website](https://seaborn.pydata.org)
- [README](https://github.com/mwaskom/seaborn/blob/master/README.md)
- [Releases](https://github.com/mwaskom/seaborn/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/mwaskom-seaborn