Google Cloud Speech-to-Text Getting Started: API Setup (2026)

Getting started overview

Integrating Google Cloud Speech-to-Text into an application involves several core steps, from initial account setup to executing the first API call. This guide focuses on the practical aspects of getting the service operational quickly. The process typically includes setting up a Google Cloud project, enabling the Speech-to-Text API, configuring authentication, and then using a client library or the REST API to send audio for transcription.

Google Cloud Speech-to-Text provides multiple client libraries in popular languages such as Python, Node.js, and Java. These libraries abstract the underlying REST API calls, simplifying development. For direct API interaction, the service exposes a REST API, which requires manual handling of HTTP requests and JSON payloads.

Before proceeding, ensure you have a Google account. Access to Google Cloud services requires a valid Google account, which serves as the primary identifier for all interactions within the platform.

Create an account and get keys

To begin using Google Cloud Speech-to-Text, you must first establish a Google Cloud Platform (GCP) account and configure a project. This project acts as a container for your resources and billing information.

1. Sign up for Google Cloud Platform

If you do not have a GCP account, navigate to the Google Cloud Console and sign up. New accounts typically receive free credits for a limited period, which can be used to explore services like Speech-to-Text within the Google Cloud Free Tier.

2. Create a new project

Once logged into the Google Cloud Console:

1. From the project selector at the top, click Select a project.
2. Click New Project.
3. Enter a Project name and choose an optional Organization and Location.
4. Click Create.

3. Enable the Speech-to-Text API

With a project created, you need to enable the Speech-to-Text API for that project:

1. In the Google Cloud Console, navigate to the API Library.
2. Search for "Cloud Speech-to-Text API".
3. Click on the Cloud Speech-to-Text API result.
4. Click Enable.

4. Set up authentication

Google Cloud services require authenticated requests. For server-to-server or application-level authentication, service accounts are the recommended method. This involves creating a service account and generating a key file.

1. In the Google Cloud Console, go to IAM & Admin > Service Accounts.
2. Click + Create Service Account.
3. Provide a Service account name, ID, and description. Click Done.
4. On the next screen, click Grant this service account access to project and select the role Cloud Speech > Cloud Speech-to-Text User. Click Continue.
5. (Optional) Grant users access to this service account, then click Done.
6. Back on the Service Accounts page, click the three dots under Actions for your newly created service account.
7. Select Manage keys.
8. Click Add Key > Create new key.
9. Select JSON as the key type and click Create.

A JSON key file will be downloaded to your computer. This file contains your private key and other credentials. Store it securely, as it grants access to your Google Cloud resources. For local development, you will typically set the GOOGLE_APPLICATION_CREDENTIALS environment variable to the path of this JSON file. For deployment, consider using more secure methods like Google Cloud's Secret Manager or workload identity federation.

Your first request

This section outlines how to make a basic speech-to-text transcription request using the Python client library. Ensure you have Python and pip installed on your system.

1. Install the client library

pip install google-cloud-speech

2. Prepare your credentials

Set the environment variable to point to your downloaded service account key file:

export GOOGLE_APPLICATION_CREDENTIALS="/path/to/your/keyfile.json"

Replace /path/to/your/keyfile.json with the actual path to your service account key file.

3. Create a Python script

Create a file named transcribe.py with the following content. This script transcribes a short audio file (e.g., a FLAC or WAV file) stored locally.

import os
from google.cloud import speech

def transcribe_audio(audio_file_path):
    client = speech.SpeechClient()

    with open(audio_file_path, "rb") as audio_file:
        content = audio_file.read()

    audio = speech.RecognitionAudio(content=content)
    config = speech.RecognitionConfig(
        encoding=speech.RecognitionConfig.AudioEncoding.FLAC, # or LINEAR16 for WAV
        sample_rate_hertz=16000,
        language_code="en-US",
    )

    print(f"Transcribing audio from: {audio_file_path}...")
    response = client.recognize(config=config, audio=audio)

    for result in response.results:
        print(f"Transcript: {result.alternatives[0].transcript}")

if __name__ == "__main__":
    # Replace 'path/to/your/audio.flac' with the actual path to your audio file.
    # Ensure the audio file is a FLAC or WAV (LINEAR16) with 16kHz sample rate.
    # A sample FLAC file can be found at: https://cloud.google.com/speech-to-text/docs/samples/speech-transcribe-sync-gcs
    # For testing, you can download a sample here: https://cloud.google.com/speech-to-text/docs/samples/audio.flac
    audio_file = "path/to/your/audio.flac" # <-- IMPORTANT: Update this path!
    transcribe_audio(audio_file)

Note: Ensure the encoding and sample_rate_hertz in the RecognitionConfig match your audio file's properties. For a WAV file, common encoding is LINEAR16. An example audio file is provided in the Google Cloud Speech-to-Text documentation samples.

4. Run the script

Execute your Python script from the terminal:

python transcribe.py

If successful, the script will print the transcribed text from your audio file.

Common next steps

After successfully completing your first transcription, consider these common next steps to expand your usage:

• Long Audio Transcription: For audio files longer than approximately 1 minute, use asynchronous transcription by storing the audio in Google Cloud Storage and making a longRunningRecognize request. This method is suitable for files up to 480 minutes long.
• Streaming Transcription: Implement streaming recognition for real-time transcription, where audio is sent continuously and transcripts are returned incrementally. This is ideal for live applications like voice assistants or call recording analysis. Details on streaming transcription are available in the official documentation.
• Enhanced Models: Explore specialized models for specific use cases, such as phone calls, video, or medical dictation. These enhanced models often provide higher accuracy for their respective domains, though they may incur different pricing.
• Error Handling: Implement robust error handling in your application to manage API rate limits, invalid audio formats, or network issues.
• Security Best Practices: Review security best practices for managing service account keys and other credentials, especially in production environments. Consider using Google Cloud Secret Manager to store and access sensitive information securely.
• Explore V2 API: The Speech-to-Text V2 API offers an updated surface, improved stability, and new features. Developers are encouraged to migrate from the legacy V1 API for access to the latest capabilities and performance improvements, as detailed in the V2 API overview.

Troubleshooting the first call

When making your initial API call, several common issues can arise. Here are some troubleshooting tips:

• Authentication Errors (401/403):
  • "Permission denied" or "Unauthorized": Double-check that the GOOGLE_APPLICATION_CREDENTIALS environment variable is correctly set and points to the right JSON key file. Ensure the service account associated with the key has the "Cloud Speech-to-Text User" role (or an equivalent role with speech.recognize permissions) within your GCP project.
  • Expired credentials: While service account keys generally don't expire, ensure the system clock is synchronized, as clock skew can sometimes lead to authentication issues with token-based systems like OAuth 2.0.
• API Not Enabled (403):
  • Confirm that the Cloud Speech-to-Text API is enabled for your specific GCP project. Navigate to the API Library in the Google Cloud Console and verify its status.
• Invalid Audio Configuration (400):
  • Mismatch in encoding or sample_rate_hertz: The RecognitionConfig must accurately describe your audio file's properties. Incorrect values for encoding (e.g., using FLAC for a WAV file or vice-versa) or sample rate will result in errors. Use audio analysis tools (e.g., FFmpeg) to confirm your audio file's exact specifications. Refer to the RecognitionConfig documentation for valid parameters.
  • Unsupported audio format: Ensure your audio file is in a supported format (e.g., FLAC, WAV (LINEAR16), MP3) as specified in the Google Cloud Speech-to-Text Best Practices.
• Billing Issues:
  • If you encounter billing-related errors, verify that billing is enabled for your GCP project and that you have sufficient quota. The Google Cloud Billing section provides details on your billing status and usage.
• Client Library Version Conflicts:
  • Ensure your google-cloud-speech library is up to date or compatible with your Python version. Use pip list to check installed packages and update with pip install --upgrade google-cloud-speech if necessary.