Build Word Cloud in Python

Word clouds turn raw text into a quick visual snapshot of the most frequent or meaningful terms. With Python, you can generate them from plain strings, text files, survey responses, reviews, articles, or DataFrame columns using libraries such as wordcloud and matplotlib.

A good word cloud depends on more than counting words. Cleaning text, removing stopwords, normalizing terms, and choosing the right colors, fonts, dimensions, and layout all help produce a clearer visualization that highlights useful patterns instead of clutter.

#	Preview	Product	Price
1		Python Programming Language: a QuickStudy Laminated Reference Guide	$8.95	Buy on Amazon
2		Python Pocket Reference: Python In Your Pocket (Pocket Reference (O'Reilly))	$13.09	Buy on Amazon
3		Python Programming Advanced: a QuickStudy Laminated Reference Guide	$8.95	Buy on Amazon
4		Python Standard Library: a QuickStudy Laminated Reference Guide	$8.95	Buy on Amazon
5		Python Crash Course, 3rd Edition: A Hands-On, Project-Based Introduction to Programming	$27.53	Buy on Amazon

This guide walks through building a word cloud from raw text, improving word relevance with preprocessing, customizing the final design, and exporting the result as an image that can be used in reports, dashboards, presentations, or exploratory text analysis workflows.

Prerequisites and Python Libraries

Before building a word cloud in Python, make sure you have a working Python environment and a few common data and visualization libraries installed. Python 3.9 or newer is a good choice because it works well with current versions of wordcloud, matplotlib, pandas, and most NLP tooling. You can use a local editor such as VS Code or PyCharm, or an interactive environment such as Jupyter book, JupyterLab, or Google Colab.

#1 Best Overall

Python Programming Language: a QuickStudy Laminated Reference Guide

$8.95

Buy on Amazon

The central library is wordcloud, which takes text or word-frequency data and renders words at different sizes based on frequency. For displaying the generated image, matplotlib is typically used. If your text comes from CSV files, spreadsheets, logs, or tabular datasets, pandas makes it easier to load, filter, and combine text columns before visualization.

Install the main packages

Install the required libraries with pip. In a terminal, run:

pip install wordcloud matplotlib pandas

If you are using Jupyter book, you can run the same command in a notebook cell by prefixing it with an exclamation mark:

!pip install wordcloud matplotlib pandas

For many projects, these three libraries are enough. A typical import block looks like this:

from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt
import pandas as pd

Optional NLP and text-cleaning tools

For simple word clouds, Python’s built-in string methods and regular expressions are often sufficient. However, if you want better preprocessing, you can add NLP libraries. nltk is useful for tokenization, stopword lists, and basic normalization. spaCy is helpful when you want lemmatization, part-of-speech filtering, or more structured language processing before generating the cloud.

• re: Built-in Python module for removing punctuation, numbers, URLs, or special patterns.
• nltk: Useful for stopwords, tokenization, and basic text preprocessing.
• spaCy: Useful for lemmatization and filtering words by grammatical role.
• Pillow: Usually installed with wordcloud; used for image handling and masks.
• numpy: Useful when creating shaped word clouds from image masks.

You can install optional preprocessing libraries as needed:

pip install nltk spacy numpy pillow

For spaCy, you also need a language model. For English text, the small model is enough for many word cloud workflows:

python -m spacy download en_core_web_sm

Recommended setup

A practical setup for most beginner and intermediate word cloud projects is shown below. It covers raw text, CSV-based text, basic cleaning, stopword removal, visualization, and image export.

Once these libraries are installed, you are ready to move from raw text to a cleaned text string or frequency dictionary. That cleaned input will determine how meaningful the final word cloud looks, especially when working with noisy text such as survey comments, product reviews, scraped pages, or social media posts.

Preparing and Cleaning Text Data

Before generating a word cloud, convert your raw text into a cleaner form so the visualization highlights meaningful terms instead of punctuation, casing differences, URLs, or repeated filler words. The wordcloud library can tokenize simple text by itself, but preprocessing gives you much better control over what appears in the final image. A sentence such as “Python, python! Visit https://python.org for Python tutorials.” should ideally contribute to the word python consistently, while the URL and punctuation should be removed.

A common cleaning workflow starts by lowercasing the text, removing web links, stripping punctuation, removing numbers when they are not useful, and normalizing extra whitespace. You can do this with Python’s built-in re module. For small projects, this lightweight approach is often enough and avoids adding extra dependencies.

import re

cleaned_text = clean_text(raw_text)
print(cleaned_text)


This produces a simpler string that is easier for the word cloud generator to process. The regular expression [^a-z\s] keeps lowercase English letters and spaces while removing punctuation, digits, emojis, and symbols. If your text includes accented characters or non-English words, use a wider pattern such as [^\w\s], or handle Unicode-aware cleaning with libraries like regex, spaCy, or nltk.

Handling stopwords and repeated filler terms

Stopwords are common words such as “the”, “and”, “is”, “to”, and “for” that usually add little meaning to a word cloud. The wordcloud package includes a built-in English stopword list, but you can extend it with project-specific terms. For example, if you are analyzing customer reviews for a coffee shop, words like “coffee”, “shop”, or the brand name may appear too often and hide more useful terms like “friendly”, “slow”, “fresh”, or “expensive”.

from wordcloud import STOPWORDS

custom_stopwords = set(STOPWORDS)
custom_stopwords.update([
"python",
"learn",
"visit",
"tutorial",
"tutorials"
])


You can also remove stopwords manually before passing text into WordCloud. This is helpful when you want to inspect the cleaned tokens or reuse them for frequency analysis. The following example splits the cleaned text into words, filters out stopwords, and joins the remaining words back into a single string.

tokens = cleaned_text.split()
filtered_tokens = [word for word in tokens if word not in custom_stopwords]
filtered_text = " ".join(filtered_tokens)

print(filtered_text)


Cleaning text from mulle records

When working with datasets, your text may come from many rows, such as survey responses, product reviews, support tickets, or article titles. With pandas, combine the relevant column into one text block after removing missing values. Clean each entry before joining so that inconsistent formatting does not carry into the final word cloud.

import pandas as pd

df = pd.DataFrame({
"review": [
"Great service and friendly staff!",
"The service was slow, but the food was fresh.",
None,
"Friendly staff. Fresh food. Great location!"
]
})

Rank #2

Sale

Python Pocket Reference: Python In Your Pocket (Pocket Reference (O'Reilly))

$13.09

Buy on Amazon

text_series = df["review"].dropna().apply(clean_text)
combined_text = " ".join(text_series)

×

Recommended Free Tools

PC Slower Than It Used to Be?

Run a Free PC Scan →Free scan · Windows 10 & 11

Crashes, No Sound, or Screen Glitches?

Find the Right Drivers →Free scan · under a minute

Windows Errors? Fix Them Before They Spread

Fix My PC Now →Free scan · no reinstall

Special offer. See more information about Outbyte and uninstall instructions. Please review EULA and Privacy policy.

tokens = combined_text.split()
filtered_text = " ".join(
word for word in tokens
if word not in custom_stopwords
)


At this stage, filtered_text is ready to pass into WordCloud. Good preparation makes the resulting visualization clearer, more relevant, and easier to interpret. Instead of showing noisy words caused by punctuation, duplicate casing, or generic language, the word cloud will emphasize the terms that better represent the content of your source text.

Generating a Basic Word Cloud

Once your text has been cleaned, you can generate a basic word cloud with the wordcloud library in just a few lines. The main class you will use is WordCloud, which reads a text string, counts word frequencies, and draws the most common terms with larger words representing higher frequency. For a first version, you only need your prepared text, a few display settings, and matplotlib to render the image.

A simple example starts with a cleaned text variable such as clean_text. This should be one long string, not a list of tokens. If your preprocessing step produced a list, join it first with " ".join(tokens). Then create a WordCloud object, call .generate(), and display it with plt.imshow().

from wordcloud import WordCloud
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 5))
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis("off")
plt.show()

The width and height parameters define the canvas size in pixels. A larger canvas gives the layout more space and usually produces a clearer image, especially when there are many unique words. The background_color parameter controls the canvas background; "white" is common for reports and books, while darker colors can work well for presentations.

The line plt.imshow(wordcloud, interpolation="bilinear") displays the generated image smoothly. The plt.axis("off") call hides the chart axes because a word cloud is an image-based visualization, not a coordinate plot. Without that line, Matplotlib will show tick marks around the cloud, which usually makes the output look unfinished.

Using Word Frequencies Directly

If you already have word counts, you can skip raw text generation and pass a frequency dictionary instead. This is useful when you have processed text with custom tokenization, counted terms with collections.Counter, or aggregated words from mulle documents.

from wordcloud import WordCloud
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 5))
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis("off")
plt.show()

Using generate_from_frequencies() gives you more control over what appears in the cloud. For example, you can remove low-value words before plotting, merge related terms, or apply your own weighting. This approach is often better for production workflows because the visualization depends on explicit counts rather than hidden preprocessing inside the word cloud generator.

Common Basic Settings

• width and height: Control the resolution and shape of the word cloud.
• background_color: Sets the canvas color, such as "white", "black", or "lightgray".
• max_words: Limits how many words are displayed, helping avoid clutter.
• collocations: Controls whether common two-word phrases may appear; setting it to False often gives cleaner single-word clouds.

For example, a cleaner beginner-friendly version might use max_words=100 and collocations=False. This keeps the output focused and prevents repeated phrase combinations from dominating the image.

wordcloud = WordCloud(
width=1000,
height=500,
background_color="white",
max_words=100,
collocations=False
).generate(clean_text)

At this stage, the word cloud is functional: it reflects the most frequent terms in your cleaned text and can be displayed in a book, script, or Python IDE. From here, you can improve the result by customizing colors, fonts, layout, masks, and stopword handling so the final image better matches your data and presentation style.

Customizing Colors, Fonts, Size, and Layout

After generating a basic word cloud, the next step is to make it fit the style and purpose of your project. The WordCloud class provides several parameters for controlling the image dimensions, background, font, color palette, word orientation, spacing, and overall layout. These options are useful whether you are creating a quick exploratory chart in a book or exporting a polished image for a report, dashboard, or presentation.

The most common customizations are image size and background color. The width and height parameters control the canvas size in pixels, while background_color sets the area behind the words. A larger canvas usually produces a cleaner result because the layout algorithm has more room to place frequent words without excessive overlap or rotation.

from wordcloud import WordCloud
import matplotlib.pyplot as plt

Rank #3

Python Programming Advanced: a QuickStudy Laminated Reference Guide

$8.95

Buy on Amazon

custom_cloud = WordCloud(
width=1200,
height=700,
background_color="white",
colormap="viridis",
max_words=150,
prefer_horizontal=0.9,
collocations=False
).generate(clean_text)

plt.figure(figsize=(12, 7))
plt.imshow(custom_cloud, interpolation="bilinear")
plt.axis("off")
plt.show()

Colors can be customized in two main ways. The simplest method is to use a Matplotlib colormap through the colormap parameter. Popular choices include "viridis", "plasma", "inferno", "magma", "Blues", "Greens", and "Set2". For a business report, a muted sequential palette such as "Blues" often works well. For social media or exploratory analysis, brighter palettes such as "plasma" or "Set3" can make the visualization more engaging.

You can also define a custom color function when you need exact control over word colors. For example, this approach is useful if you want all words to match a brand color or if you want to assign colors dynamically:

def blue_color_func(word, font_size, position, orientation, random_state=None, **kwargs):
return "rgb(30, 90, 160)"

plt.imshow(brand_cloud, interpolation="bilinear")
plt.axis("off")
plt.show()

Fonts are controlled with the font_path parameter. If you do not provide a font, the library uses a default font available in your environment. To use a specific typeface, pass the full path to a .ttf or .otf file. This is especially helpful when the word cloud must support non-Latin characters or match an existing design system.

cloud_with_font = WordCloud(
width=1000,
height=600,
background_color="black",
colormap="Pastel1",
font_path="/path/to/your/font.ttf",
max_font_size=180,
min_font_size=12
).generate(clean_text)

Layout settings affect how dense, readable, and varied the final image appears. The max_words parameter limits how many terms are displayed, while max_font_size and min_font_size control the range of word sizes. The prefer_horizontal value determines how often words are placed horizontally; values close to 1.0 produce mostly horizontal text, while lower values add more vertical words. The margin parameter adds spacing between words, and scale can improve image quality without changing the al layout size.

• For readability: use a light background, high contrast colors, and prefer_horizontal=0.9 or higher.
• For dense visual output: increase max_words, reduce margin, and use a larger canvas.
• For presentation slides: use a large width and height, a simple colormap, and fewer words.
• For consistent results: set random_state so the layout stays the same each time you run the script.

A well-customized word cloud should balance visual style with readability. Large, high-frequency terms should stand out immediately, while smaller words should still be legible enough to add context. Once the appearance is tuned, you can move on to improving relevance by refining stopwords and filtering terms that do not add meaningful insight.

Removing Stopwords and Improving Word Relevance

After the first word cloud is generated, you will often notice that common words such as the, and, is, to, or with take up valuable space without adding meaning. These words are called stopwords. Removing them helps the visualization focus on terms that better represent the topic of the text. The wordcloud library includes a built-in English stopword list, and you can extend it with project-specific words that appear frequently but are not useful for interpretation.

A common approach is to combine the default stopwords with your own custom set. For example, if you are creating a word cloud from product reviews, words like product, item, buy, or a brand name may dominate the image even though they do not reveal much about customer sentiment. You can remove those terms before generating the cloud:

from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 7))
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis("off")
plt.show()

The collocations=False setting is often useful when improving word relevance. By default, wordcloud may include repeated word pairs such as customer service or high quality. This can be helpful, but it can also produce noisy duplicates when you want single-word frequency to drive the layout. Try both settings and compare the result, especially when working with reviews, survey responses, support tickets, or social media posts.

For better relevance, you can also normalize words before passing text to WordCloud. Lowercasing, removing punctuation, and filtering short tokens are simple improvements. Stemming or lemmatization can further combine related forms, such as connect, connected, and connecting. If you already use an NLP library such as spaCy or NLTK, apply that preprocessing before joining tokens back into a single string.

• Add domain stopwords: remove company names, repeated labels, product names, or template words that appear in every document.
• Filter very short words: exclude one- or two-character tokens unless they are meaningful in your dataset.
• Merge word variants: use lemmatization to reduce words like running, runs, and ran to a shared base form where appropriate.
• Review the output visually: generate the cloud, inspect dominant words, then update the stopword list and regenerate.

If you prefer frequency-based control, build a filtered token list and pass a dictionary to generate_from_frequencies(). This gives you full control over which words appear and how often they are counted:

from collections import Counter
import re

wordcloud = WordCloud(
width=1000,
height=600,
background_color="white"
).generate_from_frequencies(frequencies)

This workflow is especially effective when you need a cleaner, presentation-ready word cloud. Instead of relying only on raw text frequency, you refine the vocabulary so the largest words reflect meaningful patterns in the dataset.

Creating Word Clouds from Files or DataFrames

In real projects, the source text is often stored outside your script: a plain text file, a CSV export, an Excel worksheet, or a pandas DataFrame created from scraped data or survey responses. The main task is to load the text, combine the relevant fields into one string, clean it consistently, and then pass the result to WordCloud.generate(). This keeps the visualization step simple while letting pandas or standard Python handle the data preparation.

Rank #4

Python Standard Library: a QuickStudy Laminated Reference Guide

$8.95

Buy on Amazon

Building a word cloud from a text file

For a .txt file, read the file contents as a single string. Use encoding="utf-8" to avoid common issues with accented characters, smart quotes, and symbols copied from web pages or documents.

from wordcloud import WordCloud
import matplotlib.pyplot as plt

plt.figure(figsize=(12, 6))
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis("off")
plt.show()

If your file contains one document per line, such as reviews or support tickets, you can still read the full file at once. If you need more control, read the lines, filter out empty entries, and join them with spaces before generating the cloud.

with open("reviews.txt", "r", encoding="utf-8") as file:
lines = [line.strip() for line in file if line.strip()]

text = " ".join(lines)

Creating a word cloud from a pandas DataFrame

When working with CSV data, pandas is convenient because you can select columns, remove missing values, filter rows, and combine text fields. For example, suppose reviews.csv contains columns named title, review_text, and rating. You can create a word cloud from only the review text or combine the title and body for richer context.

import pandas as pd
from wordcloud import WordCloud
import matplotlib.pyplot as plt

plt.figure(figsize=(10, 5))
plt.imshow(wordcloud, interpolation="bilinear")
plt.axis("off")
plt.show()

For more targeted insights, filter the DataFrame before building the text. This is useful when comparing positive and negative reviews, analyzing responses from a specific date range, or visualizing comments for one product category.

positive_reviews = df[df["rating"] >= 4]

text = " ".join(
positive_reviews["review_text"]
.dropna()
.astype(str)
)

Combining mulle text columns

If useful information is spread across several columns, combine them into a single field. Fill missing values first so pandas does not insert NaN into your final text. This approach works well for survey datasets with fields such as question, answer, comment, and category.

df["combined_text"] = (
df["title"].fillna("") + " " +
df["review_text"].fillna("")
)

text = " ".join(df["combined_text"].astype(str))

You can also group by a category and generate separate word clouds for each group. For example, an e-commerce team might create one word cloud for shipping complaints and another for product quality feedback. The pattern is the same: filter or group the DataFrame, join the relevant text, then pass it to WordCloud.

for category, group in df.groupby("category"):
text = " ".join(group["review_text"].dropna().astype(str))

plt.figure(figsize=(9, 4.5))
plt.imshow(wc, interpolation="bilinear")
plt.axis("off")
plt.title(category)
plt.show() Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Support on Ko-Fi

Saving and Exporting the Final Word Cloud

After generating and styling your word cloud, the final step is exporting it as an image that can be used in reports, dashboards, books, presentations, or web pages. The wordcloud library provides a direct way to save the generated cloud with to_file(), while matplotlib gives more control over figure size, padding, transparency, and output format.

If you already have a WordCloud object named wordcloud, the simplest export method is:

wordcloud.to_file("word_cloud.png")

This writes the word cloud image directly to the current working directory. PNG is usually the best default format because it preserves sharp text edges and supports transparency. For quick exports, this approach is enough, especially when the word cloud will be embedded in a document or uploaded to a website.

Best Value

Sale

Python Crash Course, 3rd Edition: A Hands-On, Project-Based Introduction to Programming

$27.53

Buy on Amazon

Exporting with Matplotlib

For more polished output, use matplotlib.pyplot.savefig(). This is useful when you want to remove axes, control the canvas, set a transparent background, or export at a specific resolution:

import matplotlib.pyplot as plt

plt.savefig(
"word_cloud_high_res.png",
dpi=300,
bbox_inches="tight",
pad_inches=0
)
plt.close()

The dpi=300 setting is suitable for print-quality images, while bbox_inches="tight" and pad_inches=0 help remove extra whitespace around the cloud. Calling plt.close() is useful in scripts or batch jobs because it releases the figure from memory after saving.

Choosing the Right Output Format

The best file format depends on where the image will be used. PNG works well for most cases, but other formats may be appropriate depending on the workflow:

When saving with matplotlib, changing the extension in savefig() is often enough. For example, plt.savefig("word_cloud.pdf") exports a PDF. If you need a transparent background for overlaying the word cloud on a slide or web layout, add transparent=True:

plt.savefig(
"word_cloud_transparent.png",
dpi=300,
bbox_inches="tight",
pad_inches=0,
transparent=True
)

Managing File Paths and Output Folders

In production scripts, it is better to save files into a dedicated output folder instead of the project root. The pathlib module makes this clean and portable across operating systems:

from pathlib import Path

wordcloud.to_file(output_dir / "customer_feedback_word_cloud.png")

This pattern is useful when generating mulle word clouds, such as one image per survey category, product, department, or month. You can create descriptive filenames from your data, for example word_cloud_support_tickets_2026_01.png, to make exported images easier to organize and reuse.

Exporting Multiple Word Clouds

If your data is grouped in a pandas DataFrame, you can loop through each group and export a separate image. The following example saves one word cloud per category:

from pathlib import Path
from wordcloud import WordCloud

safe_name = category.lower().replace(" ", "_")
wc.to_file(output_dir / f"{safe_name}_word_cloud.png")

Before exporting, verify that the image has readable contrast, the most relevant terms are visible, and the dimensions match the intended destination. For a web article, a width between 1000 and 1600 pixels is usually sufficient. For slides or printed reports, larger dimensions and a higher DPI setting produce cleaner results.

Frequently Asked Questions

How do I install the Python libraries needed to create a word cloud?

Install the main libraries with pip install wordcloud matplotlib. If you plan to load text from CSV files or work with tabular data, also install pandas with pip install pandas. On some systems, installing wordcloud may require a working C compiler, so using Anaconda or a prebuilt wheel can avoid setup issues.

How do I remove common words like “the”, “and”, or “is” from my word cloud?

The wordcloud library includes a default stopword list that removes many common English words automatically. You can add your own words by importing STOPWORDS, copying it into a set, and updating it with terms that are not useful for your dataset, such as company names, filler words, or repeated labels. This makes the final visualization focus on meaningful terms instead of generic high-frequency words.

Can I generate a word cloud from a CSV file or pandas DataFrame?

Yes, load the CSV with pandas and combine the text column into one string before passing it to WordCloud().generate(). For example, if your DataFrame has a column named review, you can use " ".join(df["review"].dropna().astype(str)). Cleaning missing values and converting entries to strings prevents errors when the column contains blanks or mixed data types.

How can I change the colors, font, shape, or size of the word cloud?

You can customize the output by setting parameters such as width, height, background_color, colormap, font_path, and max_words. To create a shaped word cloud, pass a mask image as a NumPy array using the mask parameter. For custom fonts, provide the full path to a .ttf font file so the library can render the text correctly.

How do I save the finished word cloud as an image file?

You can export the image directly with wordcloud.to_file("wordcloud.png"). If you are displaying it with matplotlib, you can also use plt.savefig("wordcloud.png", dpi=300, bbox_inches="tight") for more control over resolution and margins. PNG is usually the best format for reports, slides, and web use because it preserves image quality clearly.

Bottom Line

Building a word cloud in Python is straightforward once you have a clean text pipeline: load your raw text, normalize it, remove stopwords, generate the cloud with wordcloud, and fine-tune the design with options like colors, masks, fonts, and layout settings.

For your next step, try applying the same workflow to your own dataset, then experiment with custom stopwords and visualization settings until the image highlights the terms that matter most. When it looks right, export it as a PNG or SVG-ready asset for reports, dashboards, presentations, or web content.

Quick Recap

Bestseller No. 1

Python Programming Language: a QuickStudy Laminated Reference Guide

$8.95

SaleBestseller No. 2

Python Pocket Reference: Python In Your Pocket (Pocket Reference (O'Reilly))

$13.09

Bestseller No. 3

Python Programming Advanced: a QuickStudy Laminated Reference Guide

$8.95

Bestseller No. 4

Python Standard Library: a QuickStudy Laminated Reference Guide

$8.95

SaleBestseller No. 5

Python Crash Course, 3rd Edition: A Hands-On, Project-Based Introduction to Programming

$27.53

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.