Como usar a tradução de fala para fala

Experimental

Este recurso está sujeito aos "Termos da Oferta Pré-GA" na seção Termos Gerais de Serviço dos Termos Específicos de Serviço. Os recursos pré-GA estão disponíveis no estado em que se encontram e podem ter assistência limitada. Para mais informações, consulte as descrições das fases de lançamento.

O recurso de tradução de fala para fala usa IA para interpretar idiomas, permitindo conversas entre pessoas e sistemas que falam línguas diferentes. Seu aplicativo pode usar esse recurso para processar um fluxo de áudio que contém fala em um idioma e traduzir para outro em tempo real.

Ao contrário de outros recursos da API Live que oferecem suporte a conversas baseadas em turnos, a tradução de voz para voz processa continuamente a entrada de áudio e transmite as seguintes saídas à medida que elas ficam disponíveis:

• Transcrição:o texto reconhecido do fluxo de áudio de entrada no idioma original.
• Tradução:o texto traduzido no idioma de destino.
• Áudio sintetizado:um stream de áudio do texto traduzido falado no idioma de destino que corresponde à voz do falante original.

Modelos compatíveis

É possível usar a tradução de voz para voz com o seguinte modelo:

Versão do modelo	Nível de disponibilidade
gemini-2.5-flash-s2st-exp-11-2025	Experimental particular

Observação: o modelo gemini-2.5-flash-s2st-exp-11-2025 é compatível apenas com a tradução de fala para fala e não com outros recursos da API Live, como o áudio proativo.

Requisitos de áudio de entrada

A tradução de voz para voz só aceita entrada de áudio. Para informações sobre formatos de áudio, codecs e especificações compatíveis, como taxa de amostragem, consulte Formatos de áudio compatíveis.

Usar a tradução simultânea

Para usar a tradução de fala para fala, consulte os seguintes exemplos de código:

Python

# Set language_code to your desired language, in this case, Mandarin Chinese.
speech_config = SpeechConfig(language_code="cmn")

config = LiveConnectConfig(
    response_modalities=["AUDIO"],
    speech_config=speech_config,
    input_audio_transcription=input_transcription,
    output_audio_transcription=output_transcription,
)

audio_file = Part.from_uri(file_uri=audio_url, mime_type="audio/mpeg")
contents = [audio_file]

response = client.models.generate_content(model=MODEL_ID, contents=contents)
display(Markdown(response.text))

Python

import asyncio

# Set model generation_config
CONFIG = {
    "response_modalities": ["AUDIO"],
    "speech_config": {
        "language_code": "cmn",
    },
}

headers = {
    "Content-Type": "application/json",
    "Authorization": f"Bearer {bearer_token[0]}",
}

# Connect to the server
async with connect(SERVICE_URL, additional_headers=headers) as ws:
    # Setup the session
    await ws.send(
        json.dumps(
            {
                "setup": {
                    "model": MODEL,
                    "generation_config": CONFIG,
                    "input_audio_transcription": {},
                    "output_audio_transcription": {},
                    "enable_speech_to_speech_translation": True,
                }
            }
        )
    )

    # Receive setup response
    raw_response = await ws.recv(decode=False)
    setup_response = json.loads(raw_response.decode("ascii"))
    print(setup_response)

    msg = {
        "realtime_input": {
            "audio": {
                "mime_type": "audio/pcm",
                "data": base64.b64encode(wav_data).decode('utf-8'),
            }
        }
    }

    await ws.send(json.dumps(msg))

    overall_responses = []
    timeout_seconds = 10 # Set timeout to 3 seconds

    # Receive chucks of server response with a timeout
    try:
        while True:
            try:
                raw_response = await asyncio.wait_for(ws.recv(decode=False), timeout_seconds)
                response = json.loads(raw_response.decode())
                server_content = response.pop("serverContent", None)
                if server_content is None:
                    break

                # Input Transcription.
                input_transcription = server_content.pop("inputTranscription", None)
                if input_transcription is not None:
                  raw_text = input_transcription.pop("text", None)
                  if raw_text is not None:
                    display(Markdown(f"**Input >** {raw_text}"))

                # Output Transcription.
                output_transcription = server_content.pop("outputTranscription", None)
                if output_transcription is not None:
                  raw_text = output_transcription.pop("text", None)
                  if raw_text is not None:
                    display(Markdown(f"**Response >** {raw_text}"))

                model_turn = server_content.pop("modelTurn", None)
                if model_turn is not None:
                    parts = model_turn.pop("parts", None)
                    if parts is not None:
                        for part in parts:
                            pcm_data = base64.b64decode(part["inlineData"]["data"])
                            overall_responses.append(np.frombuffer(pcm_data, dtype=np.int16))

                # End of turn
                # turn_complete = server_content.pop("turnComplete", None)
                # if turn_complete:
                #     break
            except asyncio.TimeoutError:
                print(f"Timeout: No response received from the websocket within {timeout_seconds} seconds.")
                if overall_responses:
                  display(Audio(np.concatenate(overall_responses), rate=24000, autoplay=True))
                break # Exit the loop on timeout
            except websockets.exceptions.ConnectionClosed as e:
              print(f"Connection closed by exception, code: {e.code}, reason: {e.reason}")
              if overall_responses:
                display(Audio(np.concatenate(overall_responses), rate=24000, autoplay=True))
              break # Exit the loop on connection closed
            except Exception as e:
              print(f"An unexpected error occurred: {e}")
              if overall_responses:
                display(Audio(np.concatenate(overall_responses), rate=24000, autoplay=True))
              break # Exit the loop on other exceptions

    finally:
        try:
          await ws.close(code=1000, reason="Normal closure") #example close
        except websockets.exceptions.ConnectionClosed as e:
          print(f"Connection closed by exception, code: {e.code}, reason: {e.reason}")
        except Exception as e:
          print(f"An unexpected error occurred: {e}")

Idiomas compatíveis

Código do idioma	Idioma
aa	Afar
ab	Abcasiano
ace	Achém
ach	Acoli
af	Africâner
ak	Acã
alz	Alur
da manhã	Amárico
uma	Aragonês
ar	Árabe
as	Assamês
av	Avaric
awa	Awadhi
ay	Aimará
az	Azerbaijano
ba	Bashkir
bal	Balúchi
ban	Balinês
bbc	Batak toba
bci	Baoulé
be	Bielorrusso
bem	Bemba
ber	Berbere
bew	Betawi
bg	Búlgaro
bgc	Hariani
bho	Boiapuri
bi	Bislama
bm	Bambara
bn	Bengalês
bo	Tibetano
br	Bretão
bs	Bósnio
bts	Batak simalungun
btx	Batak karo
ac	Catalão
ce	Checheno
ceb	Cebuano
cgg	Chiga
ch	Chamorro
chk	Chuukês
cmn	Mandarim (China)
cnh	Hakha Chin
co	Córsico
cr	Cree
crh	Tártaro da Crimeia
crs	Francês crioulo de Seychelles
cs	Tcheco
cv	Chuvache
cy	Galês
da	Dinamarquês
de	Alemão
din	Dinca
doi	Dogri
dov	Dombe
dv	Diveí
dyu	Diúla
dz	Dzonga
ee	Ewe
el	Grego
en	Inglês
eo	Esperanto
es	Espanhol
et	Estoniano
eu	Basco
fa	Farsi
ff	Fulah
fi	Finlandês
fil	Filipino
fj	Fijiano
fo	Faroês
fon	Fon
fr	Francês
pelos	Friulana
fy	Frísio ocidental
ga	Irlandês
gaa	Ga
gd	Gaélico
gl	Galego
gn	Guarani
gu	Gujarati
gv	Manx
ha	Hauçá
haw	Havaiano
he	Hebraico
hi	Hindi
hil	Hiligaynon
hmn	Hmong
ho	Hiri Motu
h	Croata
hrx	Hunsrik
ht	Crioulo haitiano
hu	Húngaro
hy	Armênio
hz	Herero
iba	Iban
ID	Indonésio
ig	Igbo
ilo	Iloko
é	Islandês
it	Italiano
iu	Inuctitut
ja	Japonês
Jam	Crioulo inglês da Jamaica
jv	Javanês
ka	Georgiano
kac	Kachin
kek	Kekchi
kg	Quicongo
kha	Khasi
ki	Kikuyu
kj	Kuanyama
kk	Cazaque
kl	Groenlandês
km	Khmer central
kn	Canará
ko	Coreano
kok	Concani
kr	Kanuri
kri	Krio
ks	Caxemira
ktu	Kituba
ku	Curdo
kv	Komi
kw	Cornish
ky	Quirguiz
la	Latim
lb	Luxemburguês
lg	Ganda
li	Limburguês
lij	Lígure
lmo	Lombardo
ln	Lingala
lo	Laosiano
lt	Lituano
lu	Luba-katanga
lua	Luba-lulua
luo	Dholuo
lus	Mizo
lv	Letão
mad	Madurês
mai	Maithili
mak	Makasar
mam	Mam
mfe	Morisyen
mg	Malgaxe
mh	Marshallese
min	Minangkabau
mk	Macedônio
ml	Malaiala
mn	Mongol
mr	Marati
ms	Malaio
mt	Maltês
mwr	Marwari
my	Birmanês
na	Nauru
nb	bokmål norueguês
nd	Ndebele do norte
ndc	Ndau
ne	Nepalês
novo	Newari
ng	Ndonga
nhe	Nahuatl da Huasteca oriental
nl	Holandês
nn	Norueguês (Nynorsk)
nr	Ndebele do sul
nso	Pedi
nus	Nuer
nv	Navarro
ny	Chicheua
oc	Occitano
oj	Ojibwa
om	Oromo
ou	Oriá
os	Osseta
pa	Punjabi
pag	Língua pangasiana
pam	Pampanga
pap	Papiamento
pl	Polonês
ps	Pastó
pt	Português
qu	Quíchua
rm	Romanche
rn	Rundi
ro	Romeno
ru	Russo
rw	Quiniaruanda
sa	Sânscrito
sah	Iacuto
sentou	Santali
sc	Sardo
scn	Siciliano
sd	Sindi
se	Sami setentrional
sg	Sango
shn	Shan
si	Cingalês
sk	Eslovaco
sl	Esloveno
sm	Samoano
sn	Chona
so	Somali
sq	Albanês
sr	Sérvio
ss	Swati
st	Soto do sul
su	Sudanês
sv	Sueco
sw	Suaíli
szl	Silesiano
ta	Tâmil
tcy	Tulu
te	Télugo
tet	Tétum
tg	Tadjique
th	Tailandês
ti	Tigrínia
tiv	Tiv
tk	Turcomano
tl	Tagalo
tn	Tswana
a	Tonga
tpi	Tok pisin
tr	Turco
trp	Kokborok
ts	Tsonga
tt	Tártaro
barriga	Tumbuka
tw	Twi
ty	Taitiano
tyv	Tuviniano
udm	Udmurte
ug	Uigur
uk	Ucraniano
ur	Urdu
uz	Uzbeque
ve	Venda
vec	Vêneto
vi	Vietnamita
wa	Valão
guerra	Waray
wo	Wolof
xh	Xhosa
yi	Ídiche
yo	Iorubá
yua	Iucateque
yue	Cantonês
za	Zhuang
zh	Chinês
zu	Zulu

Faturamento

Como é um recurso experimental, não há cobranças pelo uso da tradução de voz para voz.

Para mais informações sobre preços e faturamento, consulte Preços da Vertex AI.