How To Convert Text To Speech Using gTTS Python

Text-to-Speech Converter Demo

Watch our Text To Audio converter in action. Here you can see how smoothly it converts text into audio in any language. You can download the audio in MP3 format for free. Our text-to-speech converter operates without third-party APIs, allowing you to download files of any size. You can add or remove languages and customize the software to suit your needs. Let’s get started!

Introduction

Hey there! Welcome to our guide where we’ll explore how Python can turn your written words into spoken ones. It is just like teaching your computer to have a conversation! We’re enter into the world of text-to-speech (TTS) conversion, where we’ll learn the magic of transforming written text into spoken words. It’s pretty awesome because it opens up a world of possibilities.

We’ll explore how TTS can be a game-changer for the people with vision impairments, and also we can explore how it can make learning and entertainment more accessible. Whether you’re new to Python or an experienced professional, this guide will help you launch your own text-to-speech projects.

As we journey together, we’ll cover some key points, like setting up the environment and using Python tools for text-to-speech. We’ll reveal the behind-the-scenes magic of transforming text into speech and explore real-life examples of Python in action, bringing words to life.

So, if you’re eager to give your text a voice and curious about the incredible possibilities Python offers with speech, hang tight as we start on this exciting journey through the world of text-to-speech with Python!

Understanding TTS Text To Speech Conversion

TTS has come a long way in recent years. It is possible only with these smart advancements in natural language processing (NLP), machine learning, and deep learning algorithms.

It’s just like chatting with your computer. Instead of just reading words off a page. TTS technology has opened up a world of possibilities for people with visual impairments, making written content accessible in a whole new way. Plus, it’s revolutionizing how we interact with technology, from virtual assistants to educational tools.

So, the next time you hear your computer speaking to you, remember that it’s not just reading words—it’s using some seriously impressive technology to bring them to life.

Python Libraries for Convert Text To Audio Conversion

Python offers several libraries and frameworks for text-to-speech conversion, each with its own set of features and capabilities. One of the most popular libraries for TTS conversion in Python is the Google Text-to-Speech (gTTS) library. 

Let’s see it in detail. These libraries are like toolkits that provide ready-made functions and capabilities for converting written text into spoken words using Python code.

One of the standout options in this area is the Google Text-to-Speech (gTTS) library. It’s gained popularity for its simplicity and effectiveness. With gTTS, you can generate audio files directly from text strings using Google’s Text-to-Speech API. This means you don’t need to pre-record audio files or rely on external services—you can dynamically create spoken content right within your Python scripts.

How gTTS works

It is very simple just provide the text you want to convert to speech, specify parameters like language and speed if needed, and gTTS handles the rest. It sends the text to Google’s servers, where it’s transformed into an audio file, which is then downloaded back to your Python environment.

One of the key advantages of gTTS is its ease of use. You don’t need to deal with complex setup procedures or manage any external dependencies. Plus, it’s powered by Google’s strong infrastructure. 

pyttsx3 Library

Another notable Python library for text-to-speech conversion is pyttsx3. Unlike gTTS, it relies on external services, pyttsx3 is an offline solution, meaning it doesn’t require an internet connection to function. It uses the capabilities of the platform’s native speech synthesis engine, making it suitable for situations with limited internet access or significant privacy concerns.

With pyttsx3, you can control various aspects of speech synthesis, such as voice selection, speaking rate, and volume. It provides a flexible and customizable interface for generating spoken output from text strings directly within your Python scripts.

Additionally, pyttsx3 supports multiple platforms, including Windows, macOS, and Linux, making it a adaptable choice for cross-platform applications. Its API makes it easy to integrate into your projects, whether you’re developing desktop applications, interactive chatbots, or accessibility tools.

In summary, while gTTS offers a convenient cloud-based solution for text-to-speech conversion with Python, pyttsx3 provides an offline alternative with greater control and customization options. Depending on your project requirements and constraints, you can choose the library that best suits your needs.

Convert Text To Audio Converter Python coding

from gtts import gTTS
import os
import tempfile
import pygame

def text_to_audio(text, language, voice):
    """
    Convert text to audio and return the temporary file path.

    :param text: Text to be converted to speech
    :param language: Language of the text
    :param voice: Voice choice (1 for male, 2 for female)
    :return: Path to the temporary audio file
    """
    # Define language and voice options
    lang_map = {
        'en': 'en-US',  # English
        'es': 'es-ES',  # Spanish
        'fr': 'fr-FR',  # French
        'de': 'de-DE'   # German
    }

    voice_map = {
        '1': 'en-US-Standard-B',  # Male voice
        '2': 'en-US-Standard-C'   # Female voice
    }

    lang_code = lang_map.get(language)
    if lang_code is None:
        raise ValueError("Unsupported language code.")

    voice_code = voice_map.get(voice)
    if voice_code is None:
        raise ValueError("Unsupported voice choice.")

    # Create a gTTS object
    tts = gTTS(text=text, lang=lang_code, slow=False)

    # Save the audio to a temporary file
    temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp3')
    tts.save(temp_file.name)

    return temp_file.name

def preview_audio(file_path):
    """
    Play the audio file for preview.

    :param file_path: Path to the audio file
    """
    # Initialize pygame mixer
    pygame.mixer.init()
    pygame.mixer.music.load(file_path)
    pygame.mixer.music.play()

    # Wait for the audio to finish playing
    while pygame.mixer.music.get_busy():
        continue

def save_audio(file_path, output_filename='output.mp3'):
    """
    Save the temporary audio file to the desired output filename.

    :param file_path: Path to the temporary audio file
    :param output_filename: Name of the final output audio file (default is 'output.mp3')
    """
    # Ensure the pygame mixer is stopped
    pygame.mixer.music.stop()
    pygame.mixer.quit()

    # Remove the output file if it already exists
    if os.path.exists(output_filename):
        os.remove(output_filename)

    # Rename the temporary file to the desired output filename
    os.rename(file_path, output_filename)
    print(f"Audio content saved as {output_filename}")

# Main block to get user input and convert to audio
if __name__ == "__main__":
    # Get text input from the user
    text = input("Enter the text you want to convert to audio: ")

    # Define supported languages
    supported_languages = ['en', 'es', 'fr', 'de']

    # Prompt the user to choose a language
    print("Supported languages: en (English), es (Spanish), fr (French), de (German)")
    while True:
        language = input("Enter the language code (e.g., 'en' for English): ").strip().lower()
        if language in supported_languages:
            break
        else:
            print("Error: Unsupported language code.")

    # Prompt the user to choose a voice
    print("Available voices:")
    print("1: Male voice")
    print("2: Female voice")
    voice_choice = input("Enter the voice choice (1 for male, 2 for female): ").strip()

    # Convert text to audio and get the temporary file path
    try:
        temp_file_path = text_to_audio(text, language, voice_choice)

        # Preview the audio
        print("Previewing the audio...")
        preview_audio(temp_file_path)

        # Confirm to save the audio
        save_confirm = input("Do you want to save the audio as 'output.mp3'? (yes/no): ").strip().lower()
        if save_confirm == 'yes':
            save_audio(temp_file_path)
        else:
            os.remove(temp_file_path)
            print("Audio preview discarded.")
    except ValueError as e:
        print("Error:", e)

Exploring the Code

Getting Started with gTTS

To begin using the gTTS library for text-to-speech conversion, we first need to install the library using pip, the Python package manager. We can install gTTS by running the following command in the terminal:

Step 1 Import Libraries

pip install gtts

Now that we’ve installed the gTTS library, let’s start the Python code for converting text to audio. We’ll break down each component of the code and explain its purpose in detail.

Let’s break down the code step by step

from gtts import gTTS
import os
import tempfile
import pygame

First step we import necessary libraries like gtts, pygame, tempfile

Step 2

Here, the code imports necessary modules. `gTTS` is from the Google Text-to-Speech library (`gtts`), `os` is for interacting with the operating system, `tempfile` for creating temporary files and directories, and `pygame` for playing audio.

2. ```python
def text_to_audio(text, language, voice):

This line defines a function text_to_audio which takes three parameters: text (the input text to be converted to audio), language (the language of the input text), and voice (the voice choice, either male or female).

Step 3 Mapping language

lang_map = {
'en': 'en-US', # English
'es': 'es-ES', # Spanish
'fr': 'fr-FR', # French
'de': 'de-DE' # German
}

You can add more languages by defining correct language code

step 4 Mapping Voices

This dictionary `lang_map` maps language codes to their corresponding language codes recognized by the Google Text-to-Speech service.

4. ```python
voice_map = {
    '1': 'en-US-Standard-B',  # Male voice
    '2': 'en-US-Standard-C'   # Female voice
}

Similarly, voice_map maps voice choices to their corresponding voice codes recognized by the Google Text-to-Speech service.

Step 5

lang_code = lang_map.get(language)

This line retrieves the language code corresponding to the language entered by the user.

Step 6

if lang_code is None:
    raise ValueError("Unsupported language code.")
    

If the entered language code is not supported, it raises a ValueError.

Step 7

voice_code = voice_map.get(voice)
if voice_code is None:
    raise ValueError("Unsupported voice choice.")
tts = gTTS(text=text, lang=lang_code, slow=False, tld='com', lang_check=False, lang_force=True)
temp_file = tempfile.NamedTemporaryFile(delete=False, suffix='.mp3')
tts.save(temp_file.name)
return temp_file.name

Here, a `gTTS` object is created with the input text, language code, and other optional parameters. It creates a temporary file with a `.mp3` extension to store the audio. The audio generated by `gTTS` is saved to the temporary file. The function returns the path to the temporary audio file.

Step 8 Preview and Playing audio

def preview_audio(file_path):
pygame.mixer.init()
pygame.mixer.music.load(file_path)
pygame.mixer.music.play()
while pygame.mixer.music.get_busy():
def save_audio(file_path, output_filename='output.mp3'):
pygame.mixer.music.stop()
pygame.mixer.quit()
if os.path.exists(output_filename):
    os.remove(output_filename)

Here we have to define a function `preview_audio` which takes the path to an audio file as a parameter. Then Initializes the Pygame mixer module for playing audio. It loads the audio file for playback. Now we can play the loaded audio file . But we have to Waits until the audio playback is finished. Then defines a function `save_audio` which takes the path to a temporary audio file and an optional output filename. After that Stops the Pygame mixer and quits the Pygame mixer module. Checks if the output filename already exists, and if it does, removes it. Renames the temporary audio file to the desired output filename.

Text-to-Speech Converter – Gets Input

Step 1: Text Input

The first step in the text-to-speech conversion process is to prompt the user to input the text they want to convert into audio. We use the input() function in Python to achieve this.

 text = input("Enter the text you want to convert to audio: ")

Step 2: Language Selection

After receiving the text input, the script prompts the user to select the language of the text. We provide a list of supported languages and ask the user to enter the language code corresponding to their desired language.

supported_languages = ['en', 'es', 'fr', 'de']
language = input("Enter the language code (e.g., 'en' for English): ").strip().lower()

Language Options and Available Languages

The gtts library is pretty awesome because it speaks a ton of languages. Let me break it down for you:

English (en): You know how English is everywhere? gtts gets that, so it’s got you covered whether you’re feeling American English (en-US) or British English (en-GB). It’s like having your own personal English-speaking assistant.

Spanish (es): Spanish is huge, right? Well, gtts knows that too. So whether you’re into European Spanish (es-ES) or Latin American Spanish (es-LA), gtts can speak your language – literally!

French (fr): Ah, the language of love and culture. gtts does French too, with all its fancy accents and regional flavors. So whether you’re in Paris or Montreal, gtts speaks your language – or should I say, “gtts parle votre langue”?

German (de): Precision and efficiency – that’s German for you. And gtts nails it, speaking standard German (de-DE) like a pro. Whether you’re in Berlin or Munich, gtts has got your back.

And hey, those are just the highlights! gtts supports tons of other languages and dialects too. It’s all about making sure everyone can communicate in their own way, no matter where they’re from. So whether you’re speaking English, Spanish, French, German, or any other language, gtts is here to turn your words into natural-sounding speech, no translation needed. Cool, right?

Step 3: Voice Selection

Next, the script asks the user to choose the voice for the text-to-speech conversion. We offer two voice options: a male voice and a female voice.

voice_choice = input("Enter the voice choice (1 for male, 2 for female): ").strip()

Voice Options

• Male Voice: If you like the sound of a male voice for your text-to-speech needs, gtts has got you covered. The masculine tone works well for all kinds of contexts and preferences.
• Female Voice: Prefer a female voice? gtts offers that too! Whether it’s for telling stories, educational content, or anything else, the female voice option sounds clear and natural.

Customization:

Beyond just picking a male or female voice, gtts also lets you choose things like pitch, speed, and tone. This means you can adjust the speech output to fit exactly how you want it to sound, making it perfect for your audience or specific use case.

Use Cases:

Having different voice options in gtts makes it super and useful in many situations:

• Narration: For audiobooks, podcasts, or storytelling, picking the right voice adds depth and character, making the content more engaging.
• Education: In classrooms or learning materials, different voices can help cater to diverse learning preferences, making the content more interesting and accessible for everyone.
• Assistive Technology: For people with visual impairments or reading difficulties, being able to choose a preferred voice makes the text-to-speech technology more user-friendly, boosting independence and accessibility.

With gtts, you can choose and customize voices to suit your needs, whether you’re creating an engaging audiobook, making educational content more dynamic, or providing accessible tech solutions. It’s all about making the speech output as effective and enjoyable as possible for your audience.

Step 4: Text-to-Speech Conversion

Once the user has provided the text, language, and voice choices, the script uses the gTTS library to convert the text into audio. We pass the text, language code, and voice choice as parameters to the gTTS() function.

tts = gTTS(text=text, lang=lang_code, slow=False)
    

Step 5: Previewing the Audio

After generating the audio file, the script plays a preview of the audio to allow the user to listen to how the text will sound. We use the Pygame library to handle audio playback.

pygame.mixer.init()
pygame.mixer.music.load(file_path)
pygame.mixer.music.play()
    

Step 6: Saving the Audio

Finally, the script prompts the user to confirm whether they want to save the audio as an MP3 file. If the user chooses to save the audio, the script renames the temporary audio file to the desired output filename.

save_confirm = input("Do you want to save the audio as 'output.mp3'? (yes/no): ").strip().lower()
if save_confirm == 'yes':
    os.rename(temp_file_path, 'output.mp3')

Conclusion

In this guide, we’ve explored the process of converting text into spoken audio using Python. By exploring the Google Text-to-Speech (gTTS) library, we can easily convert written text into natural-sounding speech, opening up a world of possibilities in various applications and industries.

Summary

1. Text-to-speech (TTS) conversion allows computers to interpret written text and convert it into audible speech.
2. The Google Text-to-Speech (gTTS) library is a powerful tool for text-to-speech conversion in Python.
3. By following a series of steps, including text input, language selection, voice selection, text-to-speech conversion, and audio playback, we can convert text into audio with Python.

Future Directions for gtts Text-to-Speech Converter

Voice Diversity and Quality

• More Voice Options: It would be great to have a wider range of voices, including different age groups, accents, and emotional tones. This would make the text-to-speech output more realistic, fitting different contexts better.
• Natural Sounding Voices:Enhancing the naturalness and expressiveness of voices with advanced neural network technologies would make speech output sound even more human-like.

Customization and Personalization

• User-Customized Voices: How cool would it be to create and upload your own custom voices? This would add a personal touch to the speech output.
• Advanced Customization Features: Offering more control over voice parameters like intonation, stress patterns, and speech rate would let users fine-tune the speech to meet specific needs.

Integration with Other Technologies

• AI and Machine Learning: AI to improve pronunciation, context understanding, and emotional expression can enhance the user experience, making the speech output more accurate and engaging.
• Internet of Things (IoT): Integrating gtts with smart home devices, wearables, and other IoT gadgets can broaden its application, making it a part of everyday life.

Accessibility Enhancements

• Real-Time Translation: Combining text-to-speech with real-time translation capabilities would be a game-changer, helping bridge language barriers instantly and making global communication smoother.
• Enhanced Assistive Features: Developing features specifically for users with disabilities, like more responsive voice commands and better screen reader integration, would make the technology more inclusive.

Platform and Device Compatibility

• Cross-Platform Support: Ensuring gtts works firmly across different operating systems, devices, and platforms, including mobile, desktop, and web, can increase its accessibility and user base.
• Offline Functionality: Enhancing offline capabilities so users can convert text to speech without an internet connection would be highly beneficial, especially in areas with limited connectivity.

User Experience Improvements

• Interactive Feedback: Allowing users to provide feedback directly within the app can help continuously improve the service based on real user experiences.
• Intuitive Interface: Developing a more user-friendly and automatic interface can make it easier for users to navigate and use the various features of gtts.

Ethical and Responsible AI Use

• Bias Reduction: Ensuring the text-to-speech models are free from biases and can generate respectful and inclusive speech for all users is crucial.
• Privacy and Security: Strengthening data privacy and security measures to protect user data and ensure ethical use of the technology is paramount.

By focusing on these areas, the gtts text-to-speech converter can continue to evolve and meet the growing demands of users worldwide, making it a more powerful, versatile, and user-friendly tool.

Who Can Use a Text-To-Speech Converter?

Visually Impaired Individuals

TTS technology can read out text from screens, books, and documents, providing accessibility for those with visual impairments.

Language Learners

TTS can help learners by reading out texts in different languages, aiding in pronunciation and comprehension.

Content Creators

Those who create videos, podcasts, or audiobooks can use TTS to generate voice-overs.

People with Reading Difficulties

Individuals with dyslexia or other reading difficulties can benefit from having text read aloud to them.

Professionals and Businesses

For generating automated voice responses, such as in customer service (IVR systems) or for creating audio content.

Additional Resources

• Google Text-to-Speech (gTTS) Documentation
• Pygame Documentation

FAQ’S

pip install gtts
    

 from gtts import gTTS
import os

text = "Hello, how are you?"
language = 'en'
tts = gTTS(text=text, lang=language, slow=False)
tts.save("output.mp3")
os.system("start output.mp3")

    

 import pyttsx3

engine = pyttsx3.init()
voices = engine.getProperty('voices')
engine.setProperty('voice', voices[1].id)  # 0 for male, 1 for female
engine.say("Hello, how are you?")
engine.runAndWait()

    

About The Author

Emmimal Alexander

Emmimal Alexander is an AI & Machine Learning Expert, passionate educator, and the author of “Neural Networks and Deep Learning with Python.” As the founder of EmiTechLogic, she’s on a mission to make complex tech topics accessible, engaging, and empowering for learners at every level.

With deep expertise in Python, HTML, JavaScript, and CSS, Emmimal brings a strong coding foundation to her tutorials and educational resources. Her work focuses on blending theoretical understanding with real-world application—so readers not only learn how things work, but also why they matter.

Through EmiTechLogic, she creates hands-on guides, detailed breakdowns, and project-based learning content that bridges the gap between academic concepts and practical implementation. Whether you’re exploring AI for the first time or fine-tuning your neural networks, you’re in the right place.

See author's posts