Improve transcription accuracy with speech adaptation boost

Before you begin

Speech adaptation boost is an optional feature of speech adaptation. Make sure you have reviewed the speech adaptation documentation before you implement boost. To see whether the boost feature is available for your language, see the language support page.


By default, speech adaptation provides a relatively small effect, especially for one-word phrases. Speech adaptation boost allows you to increase the recognition model bias by assigning more weight to some phrases than others. For example, you have many recordings of people asking about the "fare to get into the county fair," with the word "fair" occurring more frequently than "fare." In this case, you want Speech-to-Text to recognize "fair" and "fare" more often than, for example, "hare" or "lair." However, "fair" should be recognized more often than "fare" due to its more frequent appearances in the audio.

In this case, you might want to boost both "fair" and "fare" to increase the likelihood of these words being recognized correctly. However, because "fair" occurs more than "fare," you can assign a higher weighted value to "fair" to bias the Speech-to-Text API toward picking that word more frequently than "fare".

Setting boost values

When you use boost, you assign a weighted value to a SpeechContext object. Speech-to-Text refers to this weighted value when selecting a possible transcription for words in your audio data. The higher the value, the higher the likelihood that Speech-to-Text chooses that phrase from the possible alternatives.

Higher boost values can result in fewer false negatives, which are cases where the word or phrase occurred in the audio but wasn't correctly recognized by Speech-to-Text. However, boost can also increase the likelihood of false positives; that is, cases where the word or phrase appears in the transcription even though it didn't occur in the audio.

Boost values must be a float value greater than 0. The practical maximum limit for boost values is 20. For best results, experiment with your transcription results by choosing an initial boost value and adjusting it up or down.

Example of speech adaptation boost

To set different boost values for "fair" and "fare" in your speech transcription request, set two SpeechContext objects to the speechContexts array of the RecognitionConfig object. Set a boost value to a non-negative float value for each SpeechContext object, one containing "fair" and the other containing "fare".

The following snippet shows an example of a JSON payload sent to the Speech-to-Text API. The JSON snippet includes a RecognitionConfig object that uses boost values to weight the words "fair" and "fare" differently.

"config": {
    "sampleRateHertz": 8000,
    "speechContexts": [{
      "phrases": ["fair"],
      "boost": 15
     }, {
      "phrases": ["fare"],
      "boost": 2

The following code sample demonstrates how to send a request using speech adaptation boost.


For details about the API endpoint, see speech:recognize.

Before using any of the request data below, make the following replacements:

  • language-code: the BCP-47 code of the language spoken in your audio clip.
  • phrases-to-boost: phrase or phrases that you want Speech-to-Text to boost, as an array of strings.
  • storage-bucket: a Cloud Storage bucket.
  • input-audio: the audio data that you want to transcribe.

HTTP method and URL:


Request JSON body:

          "boost": 2

To send your request, expand one of these options:

You should receive a JSON response similar to the following:

  "results": [
      "alternatives": [
          "transcript": "When deciding whether to bring an umbrella, I consider the weather",
          "confidence": 0.9463943
      "languageCode": "en-us"



public class SpeechAdaptation {

  public void speechAdaptation() throws IOException {
    String uriPath = "gs://cloud-samples-data/speech/brooklyn_bridge.mp3";

  public static void speechAdaptation(String uriPath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (SpeechClient speechClient = SpeechClient.create()) {

      // Provides "hints" to the speech recognizer to favor specific words and phrases in the
      // results.
      SpeechContext speechContext =
          SpeechContext.newBuilder().addPhrases("Brooklyn Bridge").setBoost(20.0F).build();
      // Configure recognition config to match your audio file.
      RecognitionConfig config =
      // Set the path to your audio file
      RecognitionAudio audio = RecognitionAudio.newBuilder().setUri(uriPath).build();

      // Make the request
      RecognizeRequest request =

      // Display the results
      RecognizeResponse response = speechClient.recognize(request);
      for (SpeechRecognitionResult result : response.getResultsList()) {
        // First alternative is the most probable result
        SpeechRecognitionAlternative alternative = result.getAlternativesList().get(0);
        System.out.printf("Transcript: %s\n", alternative.getTranscript());


const speech = require('@google-cloud/speech').v1p1beta1;

 * Performs synchronous speech recognition with speech adaptation.
 * @param sampleRateHertz {number} Sample rate in Hertz of the audio data sent in all
 * `RecognitionAudio` messages. Valid values are: 8000-48000.
 * @param languageCode {string} The language of the supplied audio.
 * @param phrase {string} Phrase "hints" help Speech-to-Text API recognize the specified phrases from
 * your audio data.
 * @param boost {number} Positive value will increase the probability that a specific phrase will be
 * recognized over other similar sounding phrases.
 * @param uriPath {string} Path to the audio file stored on GCS.
function sampleRecognize(
) {
  const client = new speech.SpeechClient();
  // const sampleRateHertz = 44100;
  // const languageCode = 'en-US';
  // const phrase = 'Brooklyn Bridge';
  // const boost = 20.0;
  // const uriPath = 'gs://cloud-samples-data/speech/brooklyn_bridge.mp3';
  const encoding = 'MP3';
  const phrases = [phrase];
  const speechContextsElement = {
    phrases: phrases,
    boost: boost,
  const speechContexts = [speechContextsElement];
  const config = {
    encoding: encoding,
    sampleRateHertz: sampleRateHertz,
    languageCode: languageCode,
    speechContexts: speechContexts,
  const audio = {
    uri: uriPath,
  const request = {
    config: config,
    audio: audio,
    .then(responses => {
      const response = responses[0];
      for (const result of response.results) {
        // First alternative is the most probable result
        const alternative = result.alternatives[0];
        console.log(`Transcript: ${alternative.transcript}`);
    .catch(err => {


from import speech_v1p1beta1
from import enums

def sample_recognize(storage_uri, phrase):
    Transcribe a short audio file with speech adaptation.

      storage_uri URI for audio file in Cloud Storage, e.g. gs://[BUCKET]/[FILE]
      phrase Phrase "hints" help recognize the specified phrases from your audio.

    client = speech_v1p1beta1.SpeechClient()

    # storage_uri = 'gs://cloud-samples-data/speech/brooklyn_bridge.mp3'
    # phrase = 'Brooklyn Bridge'
    phrases = [phrase]

    # Hint Boost. This value increases the probability that a specific
    # phrase will be recognized over other similar sounding phrases.
    # The higher the boost, the higher the chance of false positive
    # recognition as well. Can accept wide range of positive values.
    # Most use cases are best served with values between 0 and 20.
    # Using a binary search happroach may help you find the optimal value.
    boost = 20.0
    speech_contexts_element = {"phrases": phrases, "boost": boost}
    speech_contexts = [speech_contexts_element]

    # Sample rate in Hertz of the audio data sent
    sample_rate_hertz = 44100

    # The language of the supplied audio
    language_code = "en-US"

    # Encoding of audio data sent. This sample sets this explicitly.
    # This field is optional for FLAC and WAV audio formats.
    encoding = enums.RecognitionConfig.AudioEncoding.MP3
    config = {
        "speech_contexts": speech_contexts,
        "sample_rate_hertz": sample_rate_hertz,
        "language_code": language_code,
        "encoding": encoding,
    audio = {"uri": storage_uri}

    response = client.recognize(config, audio)
    for result in response.results:
        # First alternative is the most probable result
        alternative = result.alternatives[0]
        print(u"Transcript: {}".format(alternative.transcript))

What's next