Traduzione di testo (modalità Avanzata)

Cloud Translation - Advanced supporta la traduzione del testo utilizzando modelli personalizzati e la creazione di glossari per garantire che l'API Cloud Translation traduca correttamente la terminologia specifica del dominio di un cliente.

Per istruzioni su come installare Google Cloud CLI, configurare un progetto con un account di servizio e ottenere un token di accesso, consulta la pagina Configurazione. Se prevedi di utilizzare un glossario o le funzionalità di batch, devi anche creare un bucket Cloud Storage e concedere al tuo account di servizio l'accesso.

Per tradurre documenti formattati, come i PDF, consulta Tradurre documenti.

Prima di iniziare

Prima di poter iniziare a utilizzare l'API Cloud Translation, devi avere un progetto in cui è attivata l'API Cloud Translation e disporre delle credenziali appropriate. Puoi anche installare librerie client per linguaggi di programmazione comuni per aiutarti a effettuare chiamate all'API. Per ulteriori informazioni, consulta la pagina Configurazione.

Confronto dei modelli

Quando richiedi una traduzione da Cloud Translation - Advanced, puoi specificare quale modello di traduzione utilizzare. Se non viene specificato alcun modello, viene utilizzato il modello nmt.

Modello ID modello Vestibilità ottimale Esempi
Modello di traduzione automatica neurale (NMT) general/nmt

Casi d'uso di testo generico, come i contenuti comuni dei siti web che non sono specifici per un dominio, ad esempio gli articoli di notizie.

Articoli di notizie, Social media, App di chat, Recensioni
Modello linguistico di grandi dimensioni (LLM) per la traduzione (anteprima) general/translation-llm

Modello alternativo offerto in Cloud Translation - Avanzata in due modalità. Traduzione di testi per casi d'uso generici, come i messaggi di conversazione, che non richiedono personalizzazione. E la traduzione adattiva, che supporta la personalizzazione in tempo reale utilizzando un set di dati con esempi.

Articoli di notizie, Social media, App di chat, Recensioni
Modello AutoML Translation L'ID modello viene generato al termine dell'addestramento del modello. Testo specifico del dominio. I clienti forniscono dati di addestramento specifici per i loro casi d'uso, per determinate coppie di lingue, per personalizzare il modello di NMT di Google in base alle finalità del dominio. Notizie finanziarie, documenti tecnici, qualsiasi testo che utilizzi termini e linguaggio tecnico specifici del settore.

Considerazione

Ogni modello supporta le proprie lingue impostate. Verifica che le lingue di origine e di destinazione siano supportate. Per ulteriori informazioni, vedi Lingue supportate.

Traduzione di testo

Per le traduzioni, l'input può essere in testo normale o HTML. L'API Cloud Translation non traduce i tag HTML nell'input, ma solo il testo visualizzato tra i tag. L'output conserva i tag HTML (non tradotti), con il testo tradotto tra i tag, nella misura del possibile a causa delle differenze tra le lingue di origine e di destinazione.

Traduzione delle stringhe di input

REST

Per tradurre il testo, effettua una richiesta POST e fornisci JSON nel corpo della richiesta che identifica la lingua di partenza (source_language_code), la lingua di destinazione (target_language_code) e il testo da tradurre (contents). Puoi fornire più stringhe di testo da tradurre includendole nel tuo JSON (vedi esempio). Identifica le lingue di origine e di destinazione utilizzando i relativi codici ISO-639.

Di seguito è riportato un esempio di richiesta POST mediante curl o PowerShell. L'esempio utilizza il token di accesso per un account di servizio configurato per il progetto utilizzando Google Cloud CLI. Per istruzioni su come installare Google Cloud CLI, configurare un progetto con un account di servizio e ottenere un token di accesso, consulta la pagina Configurazione.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud

Metodo HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID:translateText

Corpo JSON della richiesta: 

{
  "sourceLanguageCode": "en",
  "targetLanguageCode": "ru",
  "contents": ["Dr. Watson, come here!", "Bring me some coffee!"]
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "translations": [
    {
      "translatedText": "Доктор Ватсон, иди сюда!",
    },
    {
      "translatedText": "Принеси мне кофе!",
    }
  ]
}

L'array translations contiene due campi translatedText con le traduzioni fornite nella lingua targetLanguageCode richiesta (ru: russo). Le traduzioni sono elencate nello stesso ordine dell'array di origine corrispondente nella richiesta.

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go riportate nella guida rapida di Cloud Translation che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per autenticarti a Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

// Imports the Google Cloud Translation library
import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	"cloud.google.com/go/translate/apiv3/translatepb"
)


func translateText(w io.Writer, projectID string, sourceLang string, targetLang string, text string) error {
	// projectID := "my-project-id"
	// sourceLang := "en-US"
	// targetLang := "fr"
	// text := "Text you wish to translate"

	// Instantiates a client
	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %w", err)
	}
	defer client.Close()

	// Construct request
	req := &translatepb.TranslateTextRequest{
		Parent:             fmt.Sprintf("projects/%s/locations/global", projectID),
		SourceLanguageCode: sourceLang,
		TargetLanguageCode: targetLang,
		MimeType:           "text/plain", // Mime types: "text/plain", "text/html"
		Contents:           []string{text},
	}

	resp, err := client.TranslateText(ctx, req)
	if err != nil {
		return fmt.Errorf("TranslateText: %w", err)
	}

	// Display the translation for each input text provided
	for _, translation := range resp.GetTranslations() {
		fmt.Fprintf(w, "Translated text: %v\n", translation.GetTranslatedText())
	}

	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Cloud Translation che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per autenticarti a Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

// Imports the Google Cloud Translation library.
import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslateTextRequest;
import com.google.cloud.translate.v3.TranslateTextResponse;
import com.google.cloud.translate.v3.Translation;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;


public class TranslateText {

  // Set and pass variables to overloaded translateText() method for translation.
  public static void translateText() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    // Supported Languages: https://cloud.google.com/translate/docs/languages
    String targetLanguage = "your-target-language";
    String text = "your-text";
    translateText(projectId, targetLanguage, text);
  }

  // Translate text to target language.
  public static void translateText(String projectId, String targetLanguage, String text)
      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 (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      LocationName parent = LocationName.of(projectId, "global");

      // Supported Mime Types: https://cloud.google.com/translate/docs/supported-formats
      TranslateTextRequest request =
          TranslateTextRequest.newBuilder()
              .setParent(parent.toString())
              .setMimeType("text/plain")
              .setTargetLanguageCode(targetLanguage)
              .addContents(text)
              .build();

      TranslateTextResponse response = client.translateText(request);

      // Display the translation for each input text provided
      for (Translation translation : response.getTranslationsList()) {
        System.out.printf("Translated text: %s\n", translation.getTranslatedText());
      }
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Cloud Translation che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per autenticarti a Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const text = 'text to translate';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();

async function translateText() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: 'en',
    targetLanguageCode: 'sr-Latn',
  };

  // Run request
  const [response] = await translationClient.translateText(request);

  for (const translation of response.translations) {
    console.log(`Translation: ${translation.translatedText}`);
  }
}

translateText();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python riportate nella guida rapida di Cloud Translation che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per autenticarti a Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

# Imports the Google Cloud Translation library
import os

from google.cloud import translate_v3

PROJECT_ID = os.environ.get("GOOGLE_CLOUD_PROJECT")


# Initialize Translation client
def translate_text(
    text: str = "YOUR_TEXT_TO_TRANSLATE",
    language_code: str = "fr",
) -> translate_v3.TranslationServiceClient:
    """Translating Text from English.
    Args:
        text: The content to translate.
        language_code: The language code for the translation.
            E.g. "fr" for French, "es" for Spanish, etc.
            Available languages: https://cloud.google.com/translate/docs/languages#neural_machine_translation_model
    """

    client = translate_v3.TranslationServiceClient()
    parent = f"projects/{PROJECT_ID}/locations/global"
    # Translate text from English to chosen language
    # Supported mime types: # https://cloud.google.com/translate/docs/supported-formats
    response = client.translate_text(
        contents=[text],
        target_language_code=language_code,
        parent=parent,
        mime_type="text/plain",
        source_language_code="en-US",
    )

    # Display the translation for each input text provided
    for translation in response.translations:
        print(f"Translated text: {translation.translated_text}")
    # Example response:
    # Translated text: Bonjour comment vas-tu aujourd'hui?

    return response

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione per C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione di PHP nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per Ruby.

Traduzione di testo utilizzando un modello specifico

REST

Puoi specificare il modello da utilizzare per la traduzione utilizzando il parametro di query model.

L'esempio seguente traduce il testo utilizzando un modello personalizzato con ID modello 1395675701985363739. Puoi ottenere l'ID modello per un modello personalizzato dall'elenco di modelli nella console Google Cloud o dalla risposta dell'API quando addestri il modello. Per utilizzare l'LLM di traduzione, specifica general/translation-llm come ID modello.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • PROJECT_ID: l'ID del tuo progetto Google Cloud.
  • LOCATION: la regione in cui si trova il modello personalizzato, ad esempio us-central1.

Metodo HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/PROJECT_ID/locations/LOCATION:translateText

Corpo JSON della richiesta: 

{
  "model": "projects/PROJECT_ID/locations/LOCATION/models/1395675701985363739",
  "sourceLanguageCode": "en",
  "targetLanguageCode": "ru",
  "contents": ["Dr. Watson, please discard your trash. You've shared unsolicited email with me.
  Let's talk about spam and importance ranking in a confidential mode."]
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: PROJECT_ID" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://translation.googleapis.com/v3/projects/PROJECT_ID/locations/LOCATION:translateText"

PowerShell

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente: 

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "PROJECT_ID" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://translation.googleapis.com/v3/projects/PROJECT_ID/locations/LOCATION:translateText" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "translation": {
    "translatedText": "Доктор Ватсон, пожалуйста, откажитесь от своего мусора.
    Вы поделились нежелательной электронной почтой со мной. Давайте поговорим о
    спаме и важности рейтинга в конфиденциальном режиме.",
    "model": "projects/PROJECT_NUMBER/locations/LOCATION/models/1395675701985363739"
  }
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione di Go riportate nella guida rapida di Cloud Translation che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Go.

Per autenticarti a Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import (
	"context"
	"fmt"
	"io"

	translate "cloud.google.com/go/translate/apiv3"
	"cloud.google.com/go/translate/apiv3/translatepb"
)

// translateTextWithModel translates input text and returns translated text.
func translateTextWithModel(w io.Writer, projectID string, location string, sourceLang string, targetLang string, text string, modelID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// sourceLang := "en"
	// targetLang := "fr"
	// text := "Hello, world!"
	// modelID := "your-model-id"

	ctx := context.Background()
	client, err := translate.NewTranslationClient(ctx)
	if err != nil {
		return fmt.Errorf("NewTranslationClient: %w", err)
	}
	defer client.Close()

	req := &translatepb.TranslateTextRequest{
		Parent:             fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		SourceLanguageCode: sourceLang,
		TargetLanguageCode: targetLang,
		MimeType:           "text/plain", // Mime types: "text/plain", "text/html"
		Contents:           []string{text},
		Model:              fmt.Sprintf("projects/%s/locations/%s/models/%s", projectID, location, modelID),
	}

	resp, err := client.TranslateText(ctx, req)
	if err != nil {
		return fmt.Errorf("TranslateText: %w", err)
	}

	// Display the translation for each input text provided
	for _, translation := range resp.GetTranslations() {
		fmt.Fprintf(w, "Translated text: %v\n", translation.GetTranslatedText())
	}

	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java riportate nella guida rapida di Cloud Translation che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Java.

Per autenticarti a Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

import com.google.cloud.translate.v3.LocationName;
import com.google.cloud.translate.v3.TranslateTextRequest;
import com.google.cloud.translate.v3.TranslateTextResponse;
import com.google.cloud.translate.v3.Translation;
import com.google.cloud.translate.v3.TranslationServiceClient;
import java.io.IOException;

public class TranslateTextWithModel {

  public static void translateTextWithModel() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR-PROJECT-ID";
    // Supported Languages: https://cloud.google.com/translate/docs/languages
    String sourceLanguage = "your-source-language";
    String targetLanguage = "your-target-language";
    String text = "your-text";
    String modelId = "YOUR-MODEL-ID";
    translateTextWithModel(projectId, sourceLanguage, targetLanguage, text, modelId);
  }

  // Translating Text with Model
  public static void translateTextWithModel(
      String projectId, String sourceLanguage, String targetLanguage, String text, String modelId)
      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 (TranslationServiceClient client = TranslationServiceClient.create()) {
      // Supported Locations: `global`, [glossary location], or [model location]
      // Glossaries must be hosted in `us-central1`
      // Custom Models must use the same location as your model. (us-central1)
      String location = "us-central1";
      LocationName parent = LocationName.of(projectId, location);
      String modelPath =
          String.format("projects/%s/locations/%s/models/%s", projectId, location, modelId);

      // Supported Mime Types: https://cloud.google.com/translate/docs/supported-formats
      TranslateTextRequest request =
          TranslateTextRequest.newBuilder()
              .setParent(parent.toString())
              .setMimeType("text/plain")
              .setSourceLanguageCode(sourceLanguage)
              .setTargetLanguageCode(targetLanguage)
              .addContents(text)
              .setModel(modelPath)
              .build();

      TranslateTextResponse response = client.translateText(request);

      // Display the translation for each input text provided
      for (Translation translation : response.getTranslationsList()) {
        System.out.printf("Translated text: %s\n", translation.getTranslatedText());
      }
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js riportate nella guida rapida di Cloud Translation che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Node.js.

Per autenticarti a Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';
// const text = 'text to translate';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate');

// Instantiates a client
const translationClient = new TranslationServiceClient();
async function translateTextWithModel() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: 'en',
    targetLanguageCode: 'ja',
    model: `projects/${projectId}/locations/${location}/models/${modelId}`,
  };

  // Run request
  const [response] = await translationClient.translateText(request);

  for (const translation of response.translations) {
    console.log(`Translated Content: ${translation.translatedText}`);
  }
}

translateTextWithModel();

Python

Prima di provare questo esempio, segui le istruzioni di configurazione di Python riportate nella guida rapida di Cloud Translation che utilizza le librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Cloud Translation Python.

Per autenticarti a Cloud Translation, configura le Credenziali predefinite dell'applicazione. Per maggiori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


from google.cloud import translate


def translate_text_with_model(
    text: str = "YOUR_TEXT_TO_TRANSLATE",
    project_id: str = "YOUR_PROJECT_ID",
    model_id: str = "YOUR_MODEL_ID",
) -> translate.TranslationServiceClient:
    """Translates a given text using Translation custom model."""

    client = translate.TranslationServiceClient()

    location = "us-central1"
    parent = f"projects/{project_id}/locations/{location}"
    model_path = f"{parent}/models/{model_id}"

    # Supported language codes: https://cloud.google.com/translate/docs/languages
    response = client.translate_text(
        request={
            "contents": [text],
            "target_language_code": "ja",
            "model": model_path,
            "source_language_code": "en",
            "parent": parent,
            "mime_type": "text/plain",  # mime types: text/plain, text/html
        }
    )
    # Display the translation for each input text provided
    for translation in response.translations:
        print(f"Translated text: {translation.translated_text}")

    return response

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione per C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per .NET.

PHP: segui le istruzioni di configurazione di PHP nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi consulta la documentazione di riferimento di Cloud Translation per Ruby.

Traslitterazione

La traslitterazione è un'impostazione di configurazione nel metodo translateText. Quando attivi la traslitterazione, traduci il testo romanizzato (scritto in caratteri latini) direttamente in una lingua di destinazione. Ad esempio, puoi tradurre il testo giapponese romanizzato direttamente in inglese, spagnolo o cinese. Le traduzioni risultanti sono nel sistema di scrittura della lingua di destinazione.

Nelle richieste di traslitterazione, includi solo il testo romanizzato. Se combini testo romanizzato con testo non romanizzato, Cloud Translation non può garantire traduzioni coerenti e corrette.

Considerazioni

La trascrizione differisce dalle traduzioni di testo standard nei seguenti modi:

  • La trascrizione supporta un numero limitato di lingue. Per ulteriori informazioni, consulta la colonna Trascrizione nella pagina Lingue supportate.
  • Il tipo MIME deve essere text/plain. HTML non è supportato.
  • La traslitterazione è supportata solo dal modello standard predefinito. I modelli personalizzati non sono supportati.
  • La trascrizione ha una quota di contenuti predefinita inferiore. Per ulteriori informazioni, consulta Quote e limiti.

REST

Imposta il campo transliteration_config sul metodo translateText.

Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:

  • PROJECT_NUMBER_OR_ID: l'ID numerico o alfanumerico del tuo progetto Google Cloud.
  • LOCATION: regione in cui vuoi eseguire questa operazione. Ad esempio, us-central1.
  • SOURCE_LANGUAGE: (Facoltativo) il codice lingua del testo inserito. Se noto, imposta uno dei codici lingua elencati in Supporto delle lingue.
  • TARGET_LANGUAGE: la lingua di destinazione in cui tradurre il testo inserito. Impostato su uno dei codici lingua elencati in Supporto delle lingue.
  • SOURCE_TEXT: testo romanizzato nella lingua di origine da tradurre.

Metodo HTTP e URL: 

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION:translateText

Corpo JSON della richiesta: 

{
  "source_language_code": "SOURCE_LANGUAGE",
  "target_language_code": "TARGET_LANGUAGE",
  "contents": "SOURCE_TEXT",
  "mime_type": "text/plain",
  "transliteration_config": { "enable_transliteration": true}
}

Per inviare la richiesta, espandi una di queste opzioni:

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "translations": [
    {
      "translatedText": "TRANSLATED_TEXT",
    }
  ]
}

Risorse aggiuntive