Hassan Agmir Hassan Agmir

Text-to-Speech with Python: with Code Examples

Hassan Agmir
Text-to-Speech with Python: with Code Examples

Text-to-speech (TTS) technology has come a long way in recent years, revolutionizing how we interact with machines. Whether you’re building a virtual assistant, creating an accessibility tool, or simply automating the conversion of written content to audio, Python offers a diverse range of libraries and APIs to bring your TTS ideas to life. In this guide, we’ll explore various Python libraries—from cloud-based APIs to offline engines—and walk through detailed code examples to help you master text-to-speech in Python.

Table of Contents

Introduction

Imagine a world where computers can not only read text on your screen but also speak it aloud in a human-like voice. This technology is not just a novelty—it’s a powerful tool that can enhance accessibility, create interactive user experiences, and provide a hands-free way to consume content. In this guide, we’ll dive deep into the world of text-to-speech using Python. Whether you are a beginner wanting to experiment with simple libraries or an experienced developer looking to integrate advanced APIs, this guide will cover a spectrum of solutions along with practical code examples.

Understanding Text-to-Speech (TTS)

Text-to-speech is the process of converting written text into spoken words. TTS systems rely on natural language processing and speech synthesis algorithms to generate audio that sounds human-like. Over time, these systems have evolved—from simple concatenative methods (stitching together prerecorded words) to sophisticated deep learning models that can produce natural intonation, emotion, and cadence.

How TTS Works

At a high level, TTS involves:

  1. Text Analysis: The system analyzes the input text to understand punctuation, abbreviations, and sentence structure.
  2. Phonetic Conversion: The text is then converted into a sequence of phonetic representations.
  3. Prosody Generation: The system assigns appropriate intonation, stress, and rhythm.
  4. Waveform Synthesis: Finally, the phonetic and prosodic information is used to generate the audio waveform, which is then output as sound.

Why Use Text-to-Speech?

There are many compelling reasons to incorporate TTS into your projects:

  • Accessibility: Make digital content accessible to visually impaired users or those with reading difficulties.
  • Convenience: Enable hands-free operation for applications like navigation or smart home control.
  • Learning: Enhance language learning with pronunciation guides and interactive study aids.
  • Automation: Create automated voice responses for customer service bots or virtual assistants.
  • Content Creation: Generate audiobooks, podcasts, or narrated presentations from text.

Overview of Python TTS Libraries

Python provides a rich ecosystem of libraries and APIs to implement text-to-speech. Here are some popular options:

gTTS (Google Text-to-Speech)

  • Type: Cloud-based API
  • Features: Uses Google Translate’s TTS engine; supports multiple languages and accents.
  • Pros: Simple to use and produces natural-sounding speech.
  • Cons: Requires an Internet connection and has usage limitations.

pyttsx3

  • Type: Offline, cross-platform library
  • Features: Works with native speech engines on Windows (SAPI5), macOS (NSSpeechSynthesizer), and Linux (espeak).
  • Pros: Does not require an Internet connection; customizable voice properties.
  • Cons: The quality depends on the system’s installed voices.

Windows SAPI via win32com

  • Type: Windows-specific solution
  • Features: Leverages the Microsoft Speech API (SAPI) for high-quality speech synthesis.
  • Pros: Provides access to high-quality voices on Windows.
  • Cons: Limited to Windows environments.

Advanced APIs: OpenAI and Transformers

  • Type: Cloud-based (OpenAI) and advanced offline (Transformers)
  • Features: Use pre-trained models like SpeechT5 or cloud APIs from OpenAI to generate state-of-the-art speech.
  • Pros: Capable of producing extremely natural-sounding speech with extensive customization.
  • Cons: OpenAI API is paid; Transformers require more computational resources.

Getting Started: Setting Up Your Environment

Before diving into code, ensure you have Python 3 installed on your machine. You can install the required libraries using pip. For example:

bash
Copy
Editpip install gTTS pyttsx3 playsound

For Windows SAPI support, you might also need:

bash
Copy
Editpip install pypiwin32

If you plan to experiment with advanced models, consider installing additional packages like transformers, torch, and soundfile.

Using gTTS: A Cloud-Based Approach

Google Text-to-Speech (gTTS) provides a simple way to convert text into speech by leveraging Google’s TTS API. This method is perfect if you need natural-sounding speech with minimal setup.

Code Example: gTTS

Below is a basic example that converts text to an MP3 file and plays it:

python
Copy
Editfrom gtts import gTTS
import os

# Define the text you want to convert
text = "Hello, welcome to text-to-speech with Python. This is a demonstration using Google Text-to-Speech."

# Create a gTTS object
tts = gTTS(text=text, lang='en')

# Save the generated speech to an MP3 file
tts.save("hello_google.mp3")

# Play the MP3 file (this works on Windows; for Linux/Mac adjust the command accordingly)
os.system("start hello_google.mp3")

Explanation:

  • The gTTS object sends your text to Google’s TTS API.
  • The result is saved as an MP3 file, which you can play using your operating system’s default media player.

Using pyttsx3: An Offline, Cross-Platform Library

Unlike gTTS, pyttsx3 works entirely offline by using your system’s native TTS engines. This library is ideal if you need a solution that does not rely on an Internet connection.

Code Example: pyttsx3 Basic Usage

Here’s how to convert text to speech using pyttsx3:

python
Copy
Editimport pyttsx3

# Initialize the TTS engine
engine = pyttsx3.init()

# Set the text you want to convert
text = "Hello, welcome to text-to-speech with Python using pyttsx3."

# Add the text to the speaking queue
engine.say(text)

# Process the queued commands and speak the text
engine.runAndWait()

Customizing Speech with pyttsx3

One of the strengths of pyttsx3 is the ability to tweak various properties such as voice, speaking rate, and volume. Below are some examples of customization:

Changing the Voice

python
Copy
Editimport pyttsx3

engine = pyttsx3.init()

# Retrieve available voices
voices = engine.getProperty('voices')

# Print available voices (optional)
for index, voice in enumerate(voices):
    print(f"Voice {index}: {voice.name}")

# Set a specific voice (e.g., the second voice in the list)
engine.setProperty('voice', voices[1].id)

engine.say("Hello, this is a different voice.")
engine.runAndWait()

Adjusting the Speaking Rate and Volume

python
Copy
Editimport pyttsx3

engine = pyttsx3.init()

# Set speaking rate (default is usually around 200)
engine.setProperty('rate', 150)  # slower rate

# Set volume level (0.0 to 1.0)
engine.setProperty('volume', 0.8)

engine.say("This text is spoken at a slower rate with a slightly lower volume.")
engine.runAndWait()

Saving Speech to a File

You can also save the synthesized speech directly to an audio file:

python
Copy
Editimport pyttsx3

engine = pyttsx3.init()

text = "Saving this text as an audio file using pyttsx3."

# Save the speech to a file instead of playing it immediately
engine.save_to_file(text, "output_pyttsx3.mp3")
engine.runAndWait()

Windows SAPI for TTS via win32com

If you are on Windows, you can use the built-in Microsoft Speech API (SAPI) to synthesize speech. This method uses COM to access native Windows functionality.

Code Example: Windows SAPI

python
Copy
Editimport win32com.client as wincl

# Create a SAPI.SpVoice object
speak = wincl.Dispatch("SAPI.SpVoice")

# Use the Speak method to say the text
speak.Speak("Hello, this is text-to-speech using Windows SAPI through Python.")

Note: This approach is specific to Windows and leverages the high-quality voices available through SAPI.

Combining TTS with Speech Recognition

A truly interactive application might combine TTS with speech recognition, allowing your program to both listen and respond. The SpeechRecognition library makes it easy to integrate speech-to-text capabilities.

Code Example: TTS and Speech Recognition

python
Copy
Editimport speech_recognition as sr
import pyttsx3

# Initialize the TTS engine
engine = pyttsx3.init()

# Initialize the speech recognition engine
recognizer = sr.Recognizer()

# Use the microphone as the audio source
with sr.Microphone() as source:
    print("Please say something...")
    audio = recognizer.listen(source)

try:
    # Recognize speech using Google's speech recognition
    recognized_text = recognizer.recognize_google(audio)
    print("You said:", recognized_text)
    
    # Respond using TTS
    engine.say("You said: " + recognized_text)
    engine.runAndWait()

except sr.UnknownValueError:
    print("Sorry, I did not understand what you said.")
except sr.RequestError as e:
    print("Could not request results from the speech recognition service; {0}".format(e))

Explanation:

  • The script listens to the microphone and attempts to recognize the spoken words using Google’s speech recognition service.
  • It then uses pyttsx3 to speak back what was heard.

Advanced TTS Solutions with OpenAI and Transformers

For projects that demand state-of-the-art voice synthesis, you may want to explore advanced APIs like the OpenAI Text-to-Speech API or leverage models available through HuggingFace Transformers such as SpeechT5.

Using the OpenAI Text-to-Speech API

While the OpenAI API is a paid service, it provides high-quality, customizable speech synthesis. Below is a conceptual example (ensure you have the latest version of the OpenAI library installed and a valid API key):

python
Copy
Editimport openai

# Set your OpenAI API key
openai.api_key = "YOUR_OPENAI_API_KEY"

# Define the text input
text = ("In his miracle year, he published four groundbreaking papers that changed the world of physics.")

# Request speech synthesis from the API
response = openai.Audio.speech_create(
    model="tts-1",           # Model name; refer to OpenAI documentation
    voice="nova",            # Choose a voice; options may include alloy, echo, fable, etc.
    input=text,
    speed=1.0                # Default speed; adjust as necessary
)

# Save the generated audio to an MP3 file
with open("openai_speech.mp3", "wb") as audio_file:
    audio_file.write(response.audio_content)

print("Audio saved as openai_speech.mp3")

Note: The exact API method names and parameters might differ; please consult the latest OpenAI documentation for precise details.

Using HuggingFace Transformers (SpeechT5)

HuggingFace’s Transformers library provides access to pre-trained models for many tasks—including text-to-speech. One such model is SpeechT5, which can generate speech with remarkable naturalness.

Below is an example using SpeechT5 with a HiFi-GAN vocoder:

python
Copy
Editfrom transformers import SpeechT5Processor, SpeechT5ForTextToSpeech, SpeechT5HifiGan
from datasets import load_dataset
import torch
import soundfile as sf
import random
import string

device = "cuda" if torch.cuda.is_available() else "cpu"

# Load the processor, model, and vocoder
processor = SpeechT5Processor.from_pretrained("microsoft/speecht5_tts")
model = SpeechT5ForTextToSpeech.from_pretrained("microsoft/speecht5_tts").to(device)
vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan").to(device)

# Load a dataset for speaker embeddings (optional)
embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")

# Define a dictionary of speaker IDs (example values)
speakers = {
    'awb': 0,     # Scottish male
    'bdl': 1138,  # US male
    'clb': 2271,  # US female
    'jmk': 3403,  # Canadian male
    'ksp': 4535,  # Indian male
    'rms': 5667,  # US male
    'slt': 6799   # US female
}

def save_text_to_speech(text, speaker=None):
    # Preprocess the text
    inputs = processor(text=text, return_tensors="pt").to(device)
    
    if speaker is not None:
        # Use speaker embedding from the dataset if available
        speaker_embeddings = torch.tensor(embeddings_dataset[speaker]["xvector"]).unsqueeze(0).to(device)
    else:
        # Generate a random speaker embedding
        speaker_embeddings = torch.randn((1, 512)).to(device)
    
    # Generate speech using the model and vocoder
    speech = model.generate_speech(inputs["input_ids"], speaker_embeddings, vocoder=vocoder)
    
    # Create a filename for the output
    if speaker is not None:
        output_filename = f"{speaker}-{'-'.join(text.split()[:6])}.mp3"
    else:
        random_str = ''.join(random.sample(string.ascii_letters + string.digits, k=5))
        output_filename = f"{random_str}-{'-'.join(text.split()[:6])}.mp3"
    
    # Save the generated audio file with a sampling rate of 16KHz
    sf.write(output_filename, speech.cpu().numpy(), samplerate=16000)
    return output_filename

# Example usage:
text_example = (
    "Python is a versatile language that empowers developers to create innovative applications, "
    "including those that convert text to human-like speech."
)

# Generate speech using a specific speaker (e.g., 'slt' for US female)
filename = save_text_to_speech(text_example, speaker='slt')
print(f"Audio saved as {filename}")

Explanation:

  • This code uses the SpeechT5 model to convert input text into a mel-spectrogram and then synthesizes it into audio using HiFi-GAN.
  • The function save_text_to_speech accepts an optional speaker parameter for voice customization.
  • The final output is saved as an MP3 file.

Real-World Applications and Use Cases

Text-to-speech technology is not just a technical curiosity—it has practical, real-world applications:

  • Accessibility: Empower visually impaired users by reading digital content aloud.
  • Virtual Assistants: Enable interactive voice responses in virtual assistants like Siri, Alexa, or custom solutions.
  • Language Learning: Create pronunciation guides and interactive learning tools for language learners.
  • Audiobooks and Podcasts: Convert written content into audio format for on-the-go consumption.
  • Customer Service: Integrate TTS in automated phone systems and chatbots to enhance customer interactions.
  • Home Automation: Use TTS for smart home devices to provide audio feedback and control instructions.

By combining TTS with speech recognition, you can also build interactive systems that both listen and speak, opening up endless possibilities for natural human-computer interaction.

Conclusion

In this guide, we explored a wide range of methods to implement text-to-speech in Python. We began with cloud-based approaches using gTTS and then moved to offline libraries like pyttsx3 and Windows SAPI. We also delved into advanced solutions provided by OpenAI and HuggingFace Transformers, which offer cutting-edge voice synthesis capabilities. Additionally, we saw how TTS can be combined with speech recognition to build fully interactive applications.

Whether you’re developing an accessibility tool, a language learning app, or a fully interactive virtual assistant, the variety of Python TTS libraries and APIs available ensures that you can find a solution tailored to your needs. Experiment with the code examples provided, adjust parameters such as voice, rate, and volume, and explore advanced customization options to create a truly unique user experience.

Further Resources

By leveraging these resources and the code samples in this guide, you can dive deeper into the fascinating world of text-to-speech technology and build powerful, voice-enabled applications with Python.

Happy coding, and may your applications speak volumes!

Subscribe to my Newsletters

Stay updated with the latest programming tips, tricks, and IT insights! Join my community to receive exclusive content on coding best practices.

© Copyright 2025 by Hassan Agmir . Built with ❤ by Me