Rotate Axis Labels in Seaborn Plots in Python: X-Axis, Y-Axis & Examples

Rotate Axis Labels in Seaborn Plots in Python, Long category names can quickly turn a clean Seaborn chart into a difficult-to-read visualization. When labels overlap, one of the easiest solutions is to rotate the axis labels.

This is particularly useful for bar charts, count plots, heatmaps, time-series visualizations, and other charts containing long category or date labels.

Because Seaborn is built on Matplotlib, you have several ways to rotate labels. You can rotate labels by 45, 90, or any other angle, align them to improve readability, or rotate only the x-axis or y-axis labels.

This guide shows practical ways to rotate Seaborn axis labels and explains which method is best for different situations.

Why Rotate Axis Labels?

Consider a chart containing categories such as:

North America
United Kingdom
Australia
Very Long Product Category Name

If these categories are placed next to one another on the x-axis, the text may overlap.

Rotating the labels can make the chart much easier to read.

Common situations where rotated labels help include:

• Long category names
• Product names
• Company names
• Dates
• Month names
• Geographic regions
• Database column categories
• Survey responses
• Large numbers of categorical values

For slightly long labels, a 30° or 45° rotation often works well. For extremely long labels, 90° rotation may be more appropriate.

Create a Seaborn Plot With Long Labels

Let’s begin with a DataFrame containing basketball teams and points.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "team": [
        "Mavericks",
        "Mavericks",
        "Mavericks",
        "Mavericks",
        "Warriors",
        "Warriors",
        "Blazers",
        "Blazers",
        "Kings",
        "some_really_really_long_name"
    ],
    "points": [
        22, 14, 9, 7, 29,
        20, 30, 34, 19, 12
    ]
})

sns.countplot(
    data=df,
    x="team"
)

plt.show()

The final category has a particularly long name, which can make the x-axis crowded.

Rotating the labels is a simple way to improve the layout.

Rotate Seaborn X-Axis Labels by 45 Degrees

One of the simplest approaches is to use Matplotlib’s xticks() function.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "team": [
        "Mavericks",
        "Mavericks",
        "Mavericks",
        "Mavericks",
        "Warriors",
        "Warriors",
        "Blazers",
        "Blazers",
        "Kings",
        "some_really_really_long_name"
    ],
    "points": [
        22, 14, 9, 7, 29,
        20, 30, 34, 19, 12
    ]
})

sns.countplot(
    data=df,
    x="team"
)

plt.xticks(rotation=45)

plt.tight_layout()
plt.show()

The important line is:

plt.xticks(rotation=45)

This rotates the x-axis tick labels by 45 degrees.

plt.tight_layout() is also useful because it gives the rotated labels enough space and helps prevent them from being cut off.

Rotate X-Axis Labels Using tick_params()

When you’re working with an explicit Matplotlib axes object, tick_params() provides a clean approach.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "team": [
        "Mavericks",
        "Mavericks",
        "Mavericks",
        "Mavericks",
        "Warriors",
        "Warriors",
        "Blazers",
        "Blazers",
        "Kings",
        "some_really_really_long_name"
    ],
    "points": [
        22, 14, 9, 7, 29,
        20, 30, 34, 19, 12
    ]
})

figure, axis = plt.subplots(figsize=(10, 6))

sns.countplot(
    data=df,
    x="team",
    ax=axis
)

axis.tick_params(
    axis="x",
    labelrotation=45
)

plt.tight_layout()
plt.show()

This is especially convenient when you’re working with multiple axes or building more complex figures.

Rotate Labels and Align Them to the Right

Simply rotating labels isn’t always enough. Long labels can still appear awkwardly positioned.

You can combine rotation with horizontal alignment.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "team": [
        "Mavericks",
        "Mavericks",
        "Mavericks",
        "Mavericks",
        "Warriors",
        "Warriors",
        "Blazers",
        "Blazers",
        "Kings",
        "some_really_really_long_name"
    ],
    "points": [
        22, 14, 9, 7, 29,
        20, 30, 34, 19, 12
    ]
})

figure, axis = plt.subplots(figsize=(10, 6))

sns.countplot(
    data=df,
    x="team",
    ax=axis
)

plt.setp(
    axis.get_xticklabels(),
    rotation=45,
    ha="right"
)

plt.tight_layout()
plt.show()

The ha="right" argument means horizontal alignment is set to the right.

This often produces a cleaner result for diagonally rotated labels.

Rotate Labels by 90 Degrees

If your category names are extremely long, a 90-degree rotation may be easier to read.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "team": [
        "Mavericks",
        "Warriors",
        "Blazers",
        "Kings",
        "Very Long Team Name"
    ],
    "points": [22, 29, 30, 19, 12]
})

figure, axis = plt.subplots(figsize=(8, 6))

sns.barplot(
    data=df,
    x="team",
    y="points",
    ax=axis
)

axis.tick_params(
    axis="x",
    labelrotation=90
)

plt.tight_layout()
plt.show()

A 90-degree rotation can work well when there are many categories and horizontal space is limited.

However, it can make the chart harder to scan, so it shouldn’t automatically be your first choice.

Rotate Labels by 30 Degrees

You don’t have to use 45 or 90 degrees.

For moderately long labels, 30 degrees can provide a good compromise:

plt.xticks(rotation=30)

For example:

import matplotlib.pyplot as plt
import seaborn as sns

categories = [
    "Product A",
    "Product B",
    "Long Product Category",
    "Another Long Category"
]

values = [20, 35, 28, 42]

sns.barplot(
    x=categories,
    y=values
)

plt.xticks(
    rotation=30,
    ha="right"
)

plt.tight_layout()
plt.show()

Rotate Y-Axis Labels

You can also rotate labels on the y-axis.

For example:

import matplotlib.pyplot as plt
import seaborn as sns

categories = [
    "North America",
    "United Kingdom",
    "Australia",
    "Long Region Name"
]

values = [40, 30, 25, 20]

figure, axis = plt.subplots(figsize=(8, 5))

sns.barplot(
    x=values,
    y=categories,
    ax=axis
)

axis.tick_params(
    axis="y",
    labelrotation=45
)

plt.tight_layout()
plt.show()

However, y-axis labels are often easier to read when they remain horizontal. If they are too long, consider using a horizontal bar chart rather than rotating the labels.

A Better Alternative: Use a Horizontal Bar Chart

If category names are very long, changing the chart orientation may be more effective than rotating labels.

Instead of:

sns.barplot(
    data=df,
    x="team",
    y="points"
)

you can switch the variables:

sns.barplot(
    data=df,
    x="points",
    y="team"
)

Complete example:

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "team": [
        "Mavericks",
        "Warriors",
        "Blazers",
        "Kings",
        "Some Extremely Long Team Name"
    ],
    "points": [22, 29, 30, 19, 12]
})

figure, axis = plt.subplots(figsize=(9, 6))

sns.barplot(
    data=df,
    x="points",
    y="team",
    ax=axis
)

axis.set_title(
    "Points by Team",
    fontsize=18
)

plt.tight_layout()
plt.show()

This is often the best solution when categorical labels are long because the available horizontal space is much greater.

Rotate Date Labels in Seaborn

Date labels are another common reason to rotate x-axis labels.

Suppose you have daily sales data:

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "date": pd.date_range(
        "2026-01-01",
        periods=10,
        freq="D"
    ),
    "sales": [
        120, 135, 128, 150, 165,
        155, 172, 180, 175, 195
    ]
})

figure, axis = plt.subplots(figsize=(10, 6))

sns.lineplot(
    data=df,
    x="date",
    y="sales",
    marker="o",
    ax=axis
)

axis.tick_params(
    axis="x",
    labelrotation=45
)

plt.tight_layout()
plt.show()

Rotating date labels makes the individual dates easier to distinguish.

For longer time-series charts, however, it may be better to reduce the number of displayed tick labels rather than simply rotating every label.

Rotate Heatmap Labels

Seaborn heatmaps frequently contain long category names.

You can customize the x-axis labels like this:

import matplotlib.pyplot as plt
import seaborn as sns

data = [
    [10, 20, 30],
    [15, 25, 35],
    [20, 30, 40]
]

figure, axis = plt.subplots(figsize=(8, 5))

sns.heatmap(
    data,
    annot=True,
    ax=axis
)

plt.setp(
    axis.get_xticklabels(),
    rotation=45,
    ha="right"
)

plt.tight_layout()
plt.show()

This technique is particularly useful when heatmap column names are long.

Rotate Labels for a Seaborn Box Plot

The same approach works for box plots.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "category": [
        "Product A",
        "Product B",
        "Very Long Product Category",
        "Product D"
    ] * 5,
    "value": [
        10, 15, 12, 18,
        13, 17, 14, 20,
        11, 16, 15, 19,
        12, 18, 16, 21,
        14, 19, 17, 23
    ]
})

figure, axis = plt.subplots(figsize=(9, 6))

sns.boxplot(
    data=df,
    x="category",
    y="value",
    ax=axis
)

plt.setp(
    axis.get_xticklabels(),
    rotation=45,
    ha="right"
)

plt.tight_layout()
plt.show()

Rotate Labels in a Faceted Seaborn Plot

When using Seaborn’s FacetGrid or catplot, you may have multiple axes.

In that case, you can loop through the axes:

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.DataFrame({
    "category": [
        "Product A",
        "Product B",
        "Long Product Category",
        "Product A",
        "Product B",
        "Long Product Category"
    ],
    "value": [10, 20, 15, 14, 25, 18],
    "region": [
        "East", "East", "East",
        "West", "West", "West"
    ]
})

grid = sns.catplot(
    data=df,
    x="category",
    y="value",
    col="region",
    kind="bar",
    height=5,
    aspect=1.1
)

for axis in grid.axes.flat:
    plt.setp(
        axis.get_xticklabels(),
        rotation=45,
        ha="right"
    )

grid.figure.tight_layout()

plt.show()

This is useful because every subplot receives the same label formatting.

How to Prevent Rotated Labels From Being Cut Off

One of the most common problems after rotating labels is that the bottom of the chart gets clipped.

For example, you might have:

plt.xticks(rotation=45)

but some text disappears outside the figure.

The simplest solution is:

plt.tight_layout()

For example:

import matplotlib.pyplot as plt
import seaborn as sns

categories = [
    "Category A",
    "Category B",
    "Very Long Category Name",
    "Another Long Category"
]

values = [10, 20, 15, 25]

sns.barplot(
    x=categories,
    y=values
)

plt.xticks(
    rotation=45,
    ha="right"
)

plt.tight_layout()

plt.show()

For saved images, bbox_inches="tight" can also help:

plt.savefig(
    "chart.png",
    dpi=300,
    bbox_inches="tight"
)

Which Rotation Angle Should You Use?

The best angle depends on the length and number of labels.

As a general starting point, 45 degrees is a good choice for many categorical charts.

But don’t rotate labels automatically. If a horizontal chart can solve the problem more naturally, changing the chart orientation may produce a better visualization.

A More Modern Seaborn Pattern

For maintainable Python visualization code, explicitly create the figure and axes:

import matplotlib.pyplot as plt
import seaborn as sns

figure, axis = plt.subplots(figsize=(10, 6))

sns.barplot(
    x=["Product A", "Product B", "Long Product Category"],
    y=[25, 35, 30],
    ax=axis
)

plt.setp(
    axis.get_xticklabels(),
    rotation=45,
    ha="right"
)

axis.set_title(
    "Product Performance",
    fontsize=18
)

plt.tight_layout()
plt.show()

This approach makes it clear which axes are being customized and scales well to more complicated visualizations.

If Seaborn Is Not Installed

If you see an error such as:

ModuleNotFoundError: No module named 'seaborn'

you can install Seaborn with:

python -m pip install seaborn

Inside a Jupyter Notebook, you can use:

%pip install seaborn

After installation, restart the kernel if necessary and import Seaborn again:

import seaborn as sns

Conclusion

Rotating axis labels is a simple but valuable technique for improving the readability of Seaborn visualizations.

For a quick solution, use:

plt.xticks(rotation=45)

For explicit axes-based charts:

axis.tick_params(
    axis="x",
    labelrotation=45
)

And when you want better alignment for long labels:

plt.setp(
    axis.get_xticklabels(),
    rotation=45,
    ha="right"
)

Don’t forget to use:

plt.tight_layout()

when rotated labels need additional space.

Finally, remember that rotation isn’t always the best solution. If labels are extremely long, a horizontal bar chart, shorter labels, fewer tick marks, or a larger figure can often create a cleaner and more professional visualization.