Transkrypcja na żywo za pomocą interfejsu Gemini Live API

Interfejs Gemini Live API obsługuje transkrypcję mowy na tekst w czasie rzeczywistym z krótkim czasem oczekiwania za pomocą modelu gemini-3.5-transcribe-live. Łącząc się z interfejsem Live API za pomocą protokołu WebSocket lub korzystając z pakietu Google Gen AI SDK, możesz przesyłać strumieniowo ciągłe dane wejściowe audio i otrzymywać przyrostowe transkrypcje tekstowe w czasie rzeczywistym w miarę mówienia.

Wypróbuj transkrypcję na żywo w Google AI Studio Otwórz książkę kucharską Colab Korzystaj z umiejętności agenta do kodowania

Dzięki interfejsowi Gemini Live API platformy deweloperskie, takie jak Agora, Fishjam, LiveKit, Pipecat, Vercel i Vision Agents, umożliwiają deweloperom łatwe tworzenie i wdrażanie wydajnych interfejsów sterowanych głosem. Te platformy zarządzają złożoną infrastrukturą strumieniowania multimediów w czasie rzeczywistym za kulisami, dzięki czemu deweloperzy mogą w pełni skupić się na tworzeniu wrażeń użytkownika.

Pracownik obsługi klienta a transkrypcja na żywo

Obie usługi korzystają z dwukierunkowego połączenia strumieniowego Live API, ale Transkrypcja na żywo działa jako dedykowany potok rozpoznawania mowy o niskim czasie oczekiwania, a nie jako agent konwersacyjny.

Funkcja Czat z pracownikiem Transkrypcja na żywo
Rola główna Asystent konwersacyjny, który słucha, analizuje i odpowiada. Potok zamiany mowy na tekst w czasie rzeczywistym, który transkrybuje przychodzący dźwięk.
Response modality tekst mówiony i tekst (response_modalities=["AUDIO"]); transkrypcje tekstu przesyłane strumieniowo (response_modalities=["TEXT"]);
Styl interakcji Dialogi z przerwami i wykrywaniem pauz. Ciągłe przetwarzanie strumieniowe podczas mówienia.
Obsługiwane funkcje Wywoływanie funkcji, wyszukiwarka Google, instrukcje systemowe. Wspomaganie rozpoznawania mowy (custom_vocabulary), wykrywanie języka, ręczne i hybrydowe wykrywanie aktywności głosowej, inteligentna transkrypcja.
Strumień wejściowy Multimodalne: dźwięk, wideo, obrazy, tekst. Wejście audio (surowy 16-bitowy PCM).

Rozpocznij

Poniższe przykłady pokazują, jak otworzyć sesję strumieniowania dwukierunkowego za pomocą gemini-3.5-transcribe-live i otrzymywać transkrypcje w czasie rzeczywistym.

Python

import asyncio
from google import genai
from google.genai import types

client = genai.Client()
model = "gemini-3.5-transcribe-live"

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    input_audio_transcription=types.AudioTranscriptionConfig(
        language_codes=[],  # Automatic language detection
    ),
)

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        print("Session established with Live Transcription")

        # Receive transcription events
        async for response in session.receive():
            server_content = response.server_content
            if server_content and server_content.input_transcription:
                print("Transcript:", server_content.input_transcription.text)

if __name__ == "__main__":
    asyncio.run(main())

JavaScript

import { GoogleGenAI, Modality } from '@google/genai';

const ai = new GoogleGenAI({});
const model = 'gemini-3.5-transcribe-live';

const config = {
  responseModalities: [Modality.TEXT],
  inputAudioTranscription: {
    languageCodes: [], // Automatic language detection
  },
};

async function main() {
  const session = await ai.live.connect({
    model: model,
    config: config,
    callbacks: {
      onopen: () => console.log('Connected to Live Transcription'),
      onmessage: (message) => {
        const content = message.serverContent;
        if (content?.inputTranscription) {
          console.log('Transcript:', content.inputTranscription.text);
        }
      },
      onerror: (e) => console.error('Error:', e.message),
      onclose: (e) => console.log('Connection closed:', e.reason),
    },
  });
}

main();

WebSockets

const API_KEY = "YOUR_API_KEY";
const MODEL_NAME = "gemini-3.5-transcribe-live";
const WS_URL = `wss://generativelanguage.googleapis.com/ws/google.ai.generativelanguage.v1beta.GenerativeService.BidiGenerateContent?key=${API_KEY}`;

const websocket = new WebSocket(WS_URL);

websocket.onopen = () => {
  console.log('WebSocket connected');

  const setupMessage = {
    setup: {
      model: `models/${MODEL_NAME}`,
      generationConfig: {
        responseModalities: ['TEXT'],
      },
      inputAudioTranscription: {
        languageCodes: []
      }
    }
  };
  websocket.send(JSON.stringify(setupMessage));
};

websocket.onmessage = (event) => {
  const response = JSON.parse(event.data);
  const content = response.serverContent;
  if (content?.inputTranscription) {
    console.log('Transcript:', content.inputTranscription.text);
  }
};

Transkrypcje tymczasowe i ostateczne

Gdy strumień audio jest przesyłany do interfejsu Live API, serwer emituje w ramach server_content 2 uzupełniające się pola transkrypcji:

  • interim_input_transcription: niskie opóźnienie, spekulacyjne częściowe hipotezy aktualizowane, gdy mówca aktywnie mówi. Te częściowe aktualizacje są wprowadzane szybko i z minimalnym opóźnieniem. Użyj interim_input_transcription, aby renderować responsywne napisy na żywo w interfejsie lub wyświetlać podgląd napisów.
  • input_transcription: ostateczna transkrypcja wyemitowana, gdy rozmówca przestaje mówić, kończy wypowiedź lub gdy mowa jest gotowa. Po wyemitowaniu ten tekst reprezentuje autorytatywną transkrypcję tego segmentu mowy przez model. W trybie inteligentnej transkrypcji będzie to oczyszczona i sformatowana odpowiedź.

Poniższy przykład pokazuje, jak wyświetlać tymczasowe częściowe transkrypcje przesyłane strumieniowo i zatwierdzać transkrypcje końcowe:

Python

async def receive_transcripts(session):
    async for response in session.receive():
        server_content = response.server_content
        if not server_content:
            continue

        # Real-time interim hypothesis (updates dynamically as user speaks)
        if server_content.interim_input_transcription:
            interim_text = server_content.interim_input_transcription.text
            print(f"\r[Interim] {interim_text}", end="", flush=True)

        # Finalized transcript (emitted on speech completion)
        if server_content.input_transcription:
            final_text = server_content.input_transcription.text
            print(f"\n[Final] {final_text}")

JavaScript

onmessage: (message) => {
  const content = message.serverContent;
  if (!content) return;

  if (content.interimInputTranscription) {
    // Update live subtitle preview on screen
    renderInterimPreview(content.interimInputTranscription.text);
  }

  if (content.inputTranscription) {
    // Append final committed transcript to chat history
    commitFinalTranscript(content.inputTranscription.text);
  }
};

WebSockets

websocket.onmessage = (event) => {
  const response = JSON.parse(event.data);
  const content = response.serverContent;
  if (content?.interimInputTranscription) {
    console.log('[Interim]:', content.interimInputTranscription.text);
  }
  if (content?.inputTranscription) {
    console.log('[Final]:', content.inputTranscription.text);
  }
};

Wysyłanie dźwięku

Przesyłaj fragmenty dźwięku przez aktywne połączenie jako surowy 16-bitowy dźwięk PCM.

  • Format audio: surowy 16-bitowy PCM przy 16 kHz (mono, little-endian).
  • Rozmiar fragmentu: wysyłaj dźwięk w fragmentach o długości 100 ms (1024–2048 klatek).

  • Typ MIME: audio/pcm;rate=16000 (lub pasująca częstotliwość próbkowania).

Python

# Stream a raw PCM audio chunk
await session.send_realtime_input(
    audio=types.Blob(
        data=audio_chunk_bytes,
        mime_type="audio/pcm;rate=16000"
    )
)

# Signal the end of the audio stream when finished
await session.send_realtime_input(audio_stream_end=True)

JavaScript

// Send base64-encoded PCM audio chunk
session.sendRealtimeInput({
  audio: {
    data: audioChunkBase64,
    mimeType: 'audio/pcm;rate=16000'
  }
});

// Signal stream end
session.sendRealtimeInput({
  audioStreamEnd: true
});

WebSockets

// Send base64-encoded PCM audio chunk
websocket.send(JSON.stringify({
  realtimeInput: {
    audio: {
      data: audioChunkBase64,
      mimeType: 'audio/pcm;rate=16000'
    }
  }
}));

// Signal stream end
websocket.send(JSON.stringify({
  realtimeInput: {
    audioStreamEnd: true
  }
}));

Funkcje transkrypcji

Automatyczne wykrywanie języka

Domyślnie pominięcie parametru language_codes lub ustawienie parametru language_codes=[] włącza automatyczne rozpoznawanie języka. Model dynamicznie wykrywa język mówiony w wypowiedziach, w tym w rozmowach wielojęzycznych i z przełączaniem kodu.

Python

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    input_audio_transcription=types.AudioTranscriptionConfig(
        language_codes=[],
    ),
)

JavaScript

const config = {
  responseModalities: [Modality.TEXT],
  inputAudioTranscription: {
    languageCodes: [],
  },
};

WebSockets

const setupMessage = {
  setup: {
    model: 'models/gemini-3.5-transcribe-live',
    generationConfig: {
      responseModalities: ['TEXT'],
    },
    inputAudioTranscription: {
      languageCodes: [],
    },
  },
};
websocket.send(JSON.stringify(setupMessage));

Wskazówka dotycząca konkretnego języka

Podaj wyraźne kody języków w standardzie BCP-47 (np. ["es-ES"] dla języka hiszpańskiego lub ["fr-FR"] dla języka francuskiego), aby ukierunkować rozpoznawanie na określone języki (patrz Obsługiwane języki).

Python

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    input_audio_transcription=types.AudioTranscriptionConfig(
        language_codes=["es-ES"],
    ),
)

JavaScript

const config = {
  responseModalities: [Modality.TEXT],
  inputAudioTranscription: {
    languageCodes: ['es-ES'],
  },
};

WebSockets

const setupMessage = {
  setup: {
    model: 'models/gemini-3.5-transcribe-live',
    generationConfig: {
      responseModalities: ['TEXT'],
    },
    inputAudioTranscription: {
      languageCodes: ['es-ES'],
    },
  },
};
websocket.send(JSON.stringify(setupMessage));

Preferowanie słownictwa niestandardowego

Podaj listę maksymalnie 1000 fraz, nazw własnych, nazw marek lub terminów technicznych w custom_vocabulary, aby ukierunkować rozpoznawanie mowy na konkretną terminologię (najlepsze wyniki uzyskuje się zwykle w przypadku maksymalnie 100 terminów).

Python

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    input_audio_transcription=types.AudioTranscriptionConfig(
        language_codes=[],
        custom_vocabulary=["Gemini", "Kubernetes", "BigQuery"],
    ),
)

JavaScript

const config = {
  responseModalities: [Modality.TEXT],
  inputAudioTranscription: {
    languageCodes: [],
    customVocabulary: ['Gemini', 'Kubernetes', 'BigQuery'],
  },
};

WebSockets

const setupMessage = {
  setup: {
    model: 'models/gemini-3.5-transcribe-live',
    generationConfig: {
      responseModalities: ['TEXT'],
    },
    inputAudioTranscription: {
      languageCodes: [],
      customVocabulary: ['Gemini', 'Kubernetes', 'BigQuery'],
    },
  },
};
websocket.send(JSON.stringify(setupMessage));

Inteligentna transkrypcja

Skonfiguruj formatowanie danych wyjściowych transkrypcji za pomocą parametru mode w input_audio_transcription:

  • VERBATIM (domyślny): tworzy dokładny zapis dosłowny wszystkiego, co zostało powiedziane, zachowując nieprzetworzone wypełniacze („um”, „uh”, „like”), powtórzenia i fałszywe starty.

  • SMART (Inteligentna transkrypcja): porządkuje i strukturyzuje transkrypcję, aby była czytelniejsza:

    • Usuwanie niepłynności mowy: usuwa wypełniacze, jąkanie i fałszywe starty.
    • Korekty w tekście: naturalne rozwiązywanie problemów z korektami wypowiadanymi na głos.
    • Formatowanie strukturalne: automatycznie formatuje listy, punkty, liczby, daty i podziały akapitów.
    • Gramatyka i użycie wielkich liter: stosuje naturalne użycie wielkich liter i ulepsza interpunkcję.

Python

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    input_audio_transcription=types.AudioTranscriptionConfig(
        mode="SMART",
    ),
)

JavaScript

const config = {
  responseModalities: [Modality.TEXT],
  inputAudioTranscription: {
    mode: 'SMART',
  },
};

WebSockets

const setupMessage = {
  setup: {
    model: 'models/gemini-3.5-transcribe-live',
    generationConfig: {
      responseModalities: ['TEXT'],
    },
    inputAudioTranscription: {
      mode: 'SMART',
    },
  },
};
websocket.send(JSON.stringify(setupMessage));

Strategie wykrywania aktywności głosowej (VAD)

Automatyczne wykrywanie aktywności głosowej (domyślnie)

Domyślnie automatyczne wykrywanie aktywności głosowej po stronie serwera wykrywa, kiedy rozmówca zaczyna i kończy mówić.

Hybrydowe dostarczanie aplikacji wirtualnych

Hybrydowe VAD łączy automatyczne wykrywanie początku mowy po stronie serwera z wykrywaniem końca mowy po stronie klienta, co zapewnia finalizację tury bez opóźnień:

  1. Automatyczne wykrywanie aktywności głosowej po stronie serwera pozostaje włączone, aby dokładnie wykrywać początki mowy z dodatkowym dźwiękiem przed słowem, co zapobiega obcinaniu pierwszych słów.
  2. Wykrywanie ciszy przez VAD po stronie klienta: gdy lokalny VAD na urządzeniu wykryje, że mówca przestał mówić, klient natychmiast wysyła sygnał audio_stream_end.
  3. Szybkie zakończenie: serwer traktuje audio_stream_end jako natychmiastowy sygnał zakończenia, pomijając domyślny czas oczekiwania na ciszę po stronie serwera i zwracając sfinalizowany transkrypt z minimalnym opóźnieniem.
  4. Przełączanie awaryjne: jeśli VAD po stronie klienta nie zostanie wywołany, VAD po stronie serwera działa jako automatyczne przełączanie awaryjne.

Python

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    input_audio_transcription=types.AudioTranscriptionConfig(),
)

async with client.aio.live.connect(model=model, config=config) as session:
    # Stream audio chunks...
    await session.send_realtime_input(
        audio=types.Blob(data=chunk, mime_type="audio/pcm;rate=16000")
    )

    # When client-side VAD detects end of speech, send audio_stream_end:
    await session.send_realtime_input(audio_stream_end=True)

JavaScript

const config = {
  responseModalities: [Modality.TEXT],
  inputAudioTranscription: {},
};

// Stream audio...
session.sendRealtimeInput({
  audio: { data: chunkBase64, mimeType: 'audio/pcm;rate=16000' }
});

// When client VAD detects end of speech, send audioStreamEnd:
session.sendRealtimeInput({
  audioStreamEnd: true
});

WebSockets

const setupMessage = {
  setup: {
    model: 'models/gemini-3.5-transcribe-live',
    generationConfig: {
      responseModalities: ['TEXT'],
    },
    inputAudioTranscription: {},
  },
};
websocket.send(JSON.stringify(setupMessage));

// Stream audio...
websocket.send(JSON.stringify({
  realtimeInput: {
    audio: { data: chunkBase64, mimeType: 'audio/pcm;rate=16000' }
  }
}));

// When client VAD detects end of speech, send audioStreamEnd:
websocket.send(JSON.stringify({
  realtimeInput: {
    audioStreamEnd: true
  }
}));

Ręczne wykrywanie głosu (naciśnij, aby rozmawiać)

W przypadku interfejsów krótkofalówki lub przycisków push-to-talk całkowicie wyłącz automatyczne wykrywanie głosu i steruj granicami tury za pomocą funkcji activity_start i activity_end:

Python

config = types.LiveConnectConfig(
    response_modalities=["TEXT"],
    realtime_input_config=types.RealtimeInputConfig(
        automatic_activity_detection=types.AutomaticActivityDetection(
            disabled=True
        )
    ),
    input_audio_transcription=types.AudioTranscriptionConfig(),
)

async with client.aio.live.connect(model=model, config=config) as session:
    # Button pressed: signal speech start
    await session.send_realtime_input(activity_start=types.ActivityStart())

    # Stream audio chunks...
    await session.send_realtime_input(audio=types.Blob(data=chunk, mime_type="audio/pcm;rate=16000"))

    # Button released: signal speech end
    await session.send_realtime_input(activity_end=types.ActivityEnd())

JavaScript

const config = {
  responseModalities: [Modality.TEXT],
  realtimeInputConfig: {
    automaticActivityDetection: {
      disabled: true,
    },
  },
  inputAudioTranscription: {},
};

// Signal speech start
session.sendRealtimeInput({ activityStart: {} });

// Stream audio...

// Signal speech end
session.sendRealtimeInput({ activityEnd: {} });

WebSockets

const setupMessage = {
  setup: {
    model: 'models/gemini-3.5-transcribe-live',
    generationConfig: {
      responseModalities: ['TEXT'],
    },
    realtimeInputConfig: {
      automaticActivityDetection: {
        disabled: true,
      },
    },
    inputAudioTranscription: {},
  },
};
websocket.send(JSON.stringify(setupMessage));

// Button pressed: signal speech start
websocket.send(JSON.stringify({
  realtimeInput: {
    activityStart: {},
  },
}));

// Stream audio...
websocket.send(JSON.stringify({
  realtimeInput: {
    audio: { data: chunkBase64, mimeType: 'audio/pcm;rate=16000' },
  },
}));

// Button released: signal speech end
websocket.send(JSON.stringify({
  realtimeInput: {
    activityEnd: {},
  },
}));

Tokeny tymczasowe w aplikacjach klienckich

W przypadku aplikacji typu klient-serwer (np. aplikacji mobilnych lub internetowych przesyłających strumieniowo dane bezpośrednio z mikrofonu) używaj tokenów tymczasowych, aby uniknąć ujawnienia klucza interfejsu API w kodzie klienta.

Przed zainicjowaniem połączenia klienta utwórz na serwerze ograniczony token tymczasowy:

Python

import datetime
from google import genai

client = genai.Client()
expire_time = datetime.datetime.now(tz=datetime.timezone.utc) + datetime.timedelta(minutes=30)

token = client.auth_tokens.create(
    config={
        "uses": 1,
        "expire_time": expire_time,
        "live_connect_constraints": {
            "model": "gemini-3.5-transcribe-live",
            "config": {
                "response_modalities": ["TEXT"],
                "input_audio_transcription": {
                    "language_codes": [],
                },
            },
        },
    }
)

JavaScript

import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({});
const expireTime = new Date(Date.now() + 30 * 60 * 1000).toISOString();

const token = await client.authTokens.create({
  config: {
    uses: 1,
    expireTime: expireTime,
    liveConnectConstraints: {
      model: 'gemini-3.5-transcribe-live',
      config: {
        responseModalities: ['TEXT'],
        inputAudioTranscription: {
          languageCodes: [],
        },
      },
    },
  },
});

REST

curl -X POST "https://generativelanguage.googleapis.com/v1beta/auth_tokens" \
  -H "x-goog-api-key: ${GEMINI_API_KEY}" \
  -H "Content-Type: application/json" \
  -d '{
    "uses": 1,
    "expireTime": "YYYY-MM-DDTHH:MM:SSZ",
    "liveConnectConstraints": {
      "model": "models/gemini-3.5-transcribe-live",
      "config": {
        "responseModalities": ["TEXT"],
        "inputAudioTranscription": {
          "languageCodes": []
        }
      }
    }
  }'

Obsługiwane języki

Gemini 3.5 Transcribe Live obsługuje te języki i kody języków w standardzie BCP-47:

Język Kod BCP-47 Język Kod BCP-47
afrikaans af-ZA japoński ja-JP
amharski am-ET jawajski jv-ID
arabski (Egipt) ar-EG kabuverdianu kea-CV
ormiański hy-AM kannada kn-IN
asamski as-IN kazachski kk-KZ
azerski az-AZ koreański ko-KR
białoruski be-BY kirgiski ky-KG
bengalski (Bangladesz) bn-BD łotewski lv-LV
bengalski (Indie) bn-IN lingala ln-CD
bośniacki bs-BA litewski lt-LT
bułgarski bg-BG macedoński mk-MK
bułgarski (arumuński), rup-BG malajski ms-MY
birmański my-MM malajalam ml-IN
kantoński (tradycyjny), yue-Hant-HK maltański mt-MT
kataloński ca-ES chiński mandaryński (uproszczony), cmn-Hans-CN
cebuański ceb marathi mr-IN
khmerski km-KH mongolski mn-MN
chorwacki hr-HR nepalski ne-NP
czeski cs-CZ norweski nb-NO
duński da-DK orija or-IN
niderlandzki nl-NL polski pl-PL
angielski (Wielka Brytania) en-GB portugalski (Brazylia) pt-BR
angielski (Indie) en-IN portugalski (Portugalia) pt-PT
angielski (USA) en-US pendżabski pa-IN
estoński et-EE pendżabski (pismo gurmukhi), pa-Guru-IN
perski fa-IR rumuński ro-RO
filipiński fil-PH rosyjski ru-RU
fiński fi-FI serbski sr-RS
francuski fr-FR sindhi (alfabet arabski) sd-Arab-IN
galicyjski gl-ES słowacki sk-SK
gruziński ka-GE słoweński sl-SI
niemiecki de-DE hiszpański (Ameryka Łacińska) es-419
grecki el-GR hiszpański (Stany Zjednoczone) es-US
gudżarati gu-IN suahili (Kenia) sw-KE
hausa ha-NG szwedzki sv-SE
hebrajski he-IL tadżycki tg-TJ
hindi hi-IN telugu te-IN
węgierski hu-HU tajski th-TH
islandzki is-IS turecki tr-TR
indyjski angielski en-IN ukraiński uk-UA
indonezyjski id-ID uzbecki uz-UZ
włoski it-IT wietnamski vi-VN

Dodatkowe materiały o tym parametrze

Skonfiguruj transkrypcję na żywo za pomocą pól w input_audio_transcription i realtime_input_config:

Parametr Typ Opis
language_codes Tablica ciągów znaków Kody języków w standardzie BCP-47 (np. ["en-US"]). Jeśli ten parametr zostanie pominięty lub będzie pusty ([]), model automatycznie wykryje język i obsłuży mowę wielojęzyczną.
custom_vocabulary Tablica ciągów znaków Możesz dodać do 1000 niestandardowych terminów, akronimów, nazw marek lub nazw własnych, aby wpłynąć na rozpoznawanie mowy.
mode Ciąg znaków Tryb transkrypcji: "VERBATIM" (domyślny) lub "SMART" (inteligentna transkrypcja). Gdy ta opcja jest ustawiona na "SMART", model usuwa wypełniacze, formatuje listy i poprawia błędy w mowie.
automatic_activity_detection.disabled Wartość logiczna Ustaw na true, aby wyłączyć automatyczne wykrywanie aktywności głosowej i ręcznie wysyłać sygnały activityStart i activityEnd.

Pola odpowiedzi serwera

Pole Opis
server_content.interim_input_transcription Hipoteza częściowej transkrypcji o niskim poziomie opóźnienia, która jest emitowana w sposób ciągły, gdy użytkownik aktywnie mówi.
server_content.input_transcription Ostateczna, autorytatywna transkrypcja wprowadzona po zakończeniu wypowiedzi.

Ograniczenia

  • Czas trwania sesji: sesje transkrypcji na żywo obsługują ciągłe przesyłanie strumieniowe przez maksymalnie 10 minut.
  • Dzielenie na mówców: dzielenie na mówców nie jest obsługiwane w sesjach transmisji na żywo. W przypadku podziału na mówców użyj punktu końcowego Transkrypcja audio bez transmisji strumieniowej.
  • Sygnatury czasowe na poziomie słów: sygnatury czasowe na poziomie słów nie są obsługiwane w interfejsie Live API. Interfejs Live API generuje sygnatury czasowe na poziomie wypowiedzi (interim_input_transcription i input_transcription).
  • Słownictwo niestandardowe: możesz podać maksymalnie 1000 terminów w custom_vocabulary, ale najlepsze wyniki zwykle uzyskuje się w przypadku maksymalnie 100 terminów.
  • Zgodność trybów: inteligentna transkrypcja ("mode": "SMART") usuwa wypełniacze i formatuje tekst z uwzględnieniem intencji, ale nie można jej łączyć z adnotacjami słownymi.

Co dalej?