Transkriptim i drejtpërdrejtë me Gemini Live API

API-ja Gemini Live mbështet transkriptimin e të folurit në tekst me vonesë të ulët dhe në kohë reale duke përdorur modelin gemini-3.5-transcribe-live . Duke u lidhur me API-në Live nëpërmjet WebSockets ose duke përdorur SDK-në Google Gen AI, mund të transmetoni të dhëna audio të vazhdueshme dhe të merrni transkriptime graduale të tekstit në kohë reale ndërsa ndodh të folurit.

Provoni Transkriptimin Live në e Google AI Studio Hapni e librit të gatimit Colab Përdorni aftësive të agjentit të kodimit

Duke përdorur Gemini Live API, platformat e zhvilluesve si Agora , Fishjam , LiveKit , Pipecat , Vercel dhe Vision Agents u mundësojnë zhvilluesve të ndërtojnë dhe vendosin me lehtësi ndërfaqe zëri me performancë të lartë. Këto platforma menaxhojnë infrastrukturë komplekse të transmetimit të medias në kohë reale prapa skenave, duke u lejuar zhvilluesve të përqendrohen tërësisht në krijimin e përvojës së përdoruesit.

Agjent i drejtpërdrejtë kundrejt transkriptimit të drejtpërdrejtë

Ndërkohë që të dyja përdorin lidhjen bidirektive të transmetimit Live API, Transkriptimi Live funksionon si një tubacion i dedikuar për njohjen e të folurit me vonesë të ulët, në vend të një agjenti bisedor.

Karakteristikë Agjent i drejtpërdrejtë Transkriptim i drejtpërdrejtë
Roli kryesor Asistent bisedor që dëgjon, arsyeton dhe përgjigjet. Tubacion konvertimi i të folurit në tekst në kohë reale që transkripton audion hyrëse.
Modaliteti i përgjigjes Audio dhe tekst i folur ( response_modalities=["AUDIO"] ). Transkriptime teksti duke transmetuar ( response_modalities=["TEXT"] ).
Stili i ndërveprimit Dialog me radhë me zbulimin e pauzës dhe ndërprerjeve. Përpunim i vazhdueshëm i transmetimit ndërsa folësi flet.
Karakteristikat e mbështetura Thirrja e funksioneve, Kërkimi në Google, udhëzimet e sistemit. Paragjykimi i të folurit ( custom_vocabulary ), zbulimi i gjuhës, VAD manual dhe hibrid, transkriptim inteligjent.
Rrjedha hyrëse Multimodale: audio, video, imazhe, tekst. Hyrje audio (PCM 16-bitëshe e papërpunuar).

Filloni

Shembujt e mëposhtëm demonstrojnë se si të hapni një seancë transmetimi bidirekcional me gemini-3.5-transcribe-live dhe të merrni transkriptime në kohë reale.

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);
  }
};

Transkriptime të ndërmjetme dhe të finalizuara

Ndërsa audio transmetohet në Live API, serveri lëshon dy fusha plotësuese të transkriptimit brenda server_content :

  • interim_input_transcription : hipoteza pjesore spekulative me vonesë të ulët përditësohen ndërsa folësi flet në mënyrë aktive. Këto përditësime pjesore ndodhin shpejt me vonesë minimale. Përdorni interim_input_transcription për të paraqitur titrat e ndërfaqes së përdoruesit të drejtpërdrejtë ose titrat paraprakisht të përgjegjshëm.
  • input_transcription : transkriptimi i finalizuar i emetuar kur folësi ndalet, radha përfundon ose fjalimi finalizohet. Pasi të emetohet, ky tekst përfaqëson transkriptimin autoritar të modelit të atij segmenti të fjalimit. Në modalitetin e transkriptimit inteligjent, kjo do të përfshijë përgjigjen e pastruar dhe të formatuar.

Shembulli i mëposhtëm demonstron se si të shfaqen pjesët e ndërmjetme të transmetimit dhe transkriptet përfundimtare të kryera:

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);
  }
};

Duke dërguar audion

Transmetoni pjesë audio mbi lidhjen aktive si audio PCM të papërpunuar 16-bit.

  • Formati audio: PCM 16-bit i papërpunuar në 16kHz (mono, little-endian).
  • Madhësia e copës: Dërgoni audion në copëza prej 100ms (1,024 deri në 2,048 korniza).

  • Lloji MIME: audio/pcm;rate=16000 (ose ritmi i mostrës që përputhet).

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
  }
}));

Karakteristikat e transkriptimit

Zbulimi automatik i gjuhës

Si parazgjedhje, lënia jashtë language_codes ose vendosja e language_codes=[] mundëson identifikimin automatik të gjuhës. Modeli zbulon në mënyrë dinamike gjuhën e folur në të gjitha shprehjet, duke përfshirë bisedat shumëgjuhëshe dhe ndërrimin e kodeve.

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));

Këshillë specifike gjuhësore

Jepni kode të qarta gjuhësore BCP-47 (për shembull, ["es-ES"] për spanjisht ose ["fr-FR"] për frëngjisht) për të paragjykuar njohjen drejt gjuhëve specifike (shih Gjuhët e mbështetura ).

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));

Paragjykim i fjalorit të personalizuar

Jepni një listë me deri në 1,000 fraza, emra të përveçëm, emra markash ose terma teknikë në custom_vocabulary për të anuar njohjen e të folurit drejt terminologjisë specifike (rezultatet më të mira arrihen zakonisht me deri në 100 terma).

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));

Transkriptim inteligjent

Konfiguro formatimin e daljes së transkriptimit duke përdorur parametrin mode në input_audio_transcription :

  • VERBATIM (parazgjedhur) : Prodhon një transkript të saktë fjalë për fjalë të gjithçkaje të folur, duke ruajtur fjalët plotësuese të papërpunuara ("ëm", "ëëë", "si"), përsëritjet dhe fillimet e gabuara.

  • SMART (Transkriptim i Mençur) : Pastron dhe strukturon transkriptin për lexueshmëri:

    • Heqja e rrjedhshmërisë : Heq fjalët plotësuese, belbëzimin dhe fillimet e gabuara.
    • Vetë-korrigjime të brendshme : Zgjidh natyrshëm korrigjimet e folura.
    • Formatimi i strukturuar : Formaton automatikisht listat, pikat, numrat, datat dhe ndërprerjet e paragrafëve.
    • Gramatikë dhe shkronja të mëdha dhe të mëdha : Zbaton përdorimin e shkronjave të mëdha natyrore dhe përmirësimin e pikësimit.

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));

Strategjitë e Zbulimit të Aktivitetit të Zërit (VAD)

VAD automatike (Parazgjedhur)

Si parazgjedhje, Zbulimi automatik i Aktivitetit Zëror në anën e serverit zbulon kur një folës fillon dhe ndalon së foluri.

VAD hibrid

VAD hibrid kombinon zbulimin automatik të fillimit të të folurit nga ana e serverit me zbulimin e mbarimit të të folurit nga ana e klientit për finalizimin e kthesës me zero vonesë:

  1. VAD automatik nga ana e serverit mbetet i aktivizuar për të zbuluar me saktësi fillimet e të folurit me mbushjen audio të prefiksit, duke parandaluar shkurtimin e fjalës së parë.
  2. VAD në anën e klientit zbulon heshtjen : Kur një VAD lokal në pajisje zbulon se folësi ka ndaluar së foluri, klienti dërgon menjëherë një sinjal audio_stream_end .
  3. Finalizim i shpejtë : Serveri e trajton audio_stream_end si një kërkesë të menjëhershme për finalizimin e radhës, duke anashkaluar kohën e pritjes së heshtjes së parazgjedhur nga ana e serverit dhe duke e kthyer transkriptin e finalizuar me vonesë minimale.
  4. Rezervë : Nëse VAD i klientit dështon të aktivizohet, VAD i serverit vepron si një rezervë automatike.

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
  }
}));

VAD manual (Shtyp-për-të-folur)

Për ndërfaqet e radios ose butonat "shtyp për të folur", çaktivizoni plotësisht funksionin automatik VAD dhe kontrolloni kufijtë e kthesave në mënyrë të qartë duke përdorur activity_start dhe 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: {},
  },
}));

Tokenat e përkohshme në aplikacionet e klientëve

Për aplikacionet klient-server (siç janë aplikacionet celulare ose të internetit që transmetojnë direkt nga një mikrofon), përdorni tokena kalimtarë për të shmangur ekspozimin e çelësit tuaj API në kodin e klientit.

Krijoni një token të kufizuar efemeral në serverin tuaj përpara se të filloni lidhjen e klientit:

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: [],
        },
      },
    },
  },
});

PUSHTIM 

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": []
        }
      }
    }
  }'

Gjuhët e mbështetura

Gjuhët dhe kodet gjuhësore BCP-47 të mëposhtme mbështeten për Gemini 3.5 Transcribe Live:

Gjuha Kodi BCP-47 Gjuha Kodi BCP-47
Afrikanisht af-ZA Japonez ja-JP
Amarike am-ET Javanisht jv-ID
Arabisht (Egjipt) ar-EG Kabuverdianu kea-CV
armenisht hy-AM Kannada kn-IN
Asamezisht as-IN Kazake kk-KZ
Azerbajxhanisht az-AZ Koreane ko-KR
Bjellorusisht be-BY kirgizisht ky-KG
Bengalisht (Bangladesh) bn-BD letonisht lv-LV
Bengalisht (Indi) bn-IN Lingala ln-CD
boshnjak bs-BA lituanisht lt-LT
bullgar bg-BG maqedonase mk-MK
Bullgarisht (arumunë) rup-BG Malajisht ms-MY
birmanisht my-MM Malajalamisht ml-IN
Kantoneze (Tradicionale) yue-Hant-HK maltezisht mt-MT
Katalanisht ca-ES Kinezishtja Mandarin (e Thjeshtuar) cmn-Hans-CN
Cebuanisht ceb Marathi mr-IN
Khmer Qendrore km-KH mongolisht mn-MN
Kroatisht hr-HR Nepalisht ne-NP
Çeke cs-CZ Norvegjisht nb-NO
danez da-DK Orija or-IN
holandez nl-NL polak pl-PL
Anglisht (Britania e Madhe) en-GB Portugalisht (Brazil) pt-BR
Anglisht (India) en-IN Portugalisht (Portugali) pt-PT
Anglisht (Shtetet e Bashkuara) en-US Punjabi pa-IN
Estonisht et-EE Punjabi (shkrimi Gurmukhi) pa-Guru-IN
Farsi fa-IR rumanisht ro-RO
Filipinase fil-PH ruse ru-RU
finlandez fi-FI serbisht sr-RS
frëngjisht fr-FR Sindhi (shkrimi arab) sd-Arab-IN
galike gl-ES Sllovakisht sk-SK
gjeorgjian ka-GE sllovenisht sl-SI
gjermanisht de-DE Spanjisht (Amerika Latine) es-419
grek el-GR Spanjisht (Shtetet e Bashkuara) es-US
Guxharatisht gu-IN Suahili (Kenia) sw-KE
Hausisht ha-NG suedeze sv-SE
Hebraisht he-IL Taxhikisht tg-TJ
Hindisht hi-IN Teluguisht te-IN
hungareze hu-HU Tajlandeze th-TH
Islandeze is-IS turk tr-TR
Anglisht indiane en-IN ukrainas uk-UA
Indonezisht id-ID Uzbekisht uz-UZ
italiane it-IT Vietnamez vi-VN

Referenca e parametrit

Konfiguro transkriptimin e drejtpërdrejtë duke përdorur fushat në input_audio_transcription dhe realtime_input_config :

Parametri Lloji Përshkrimi
language_codes Matricë vargjesh Kodet gjuhësore BCP-47 (p.sh., ["en-US"] ). Nëse lihen jashtë ose janë bosh ( [] ), modeli e zbulon automatikisht gjuhën dhe trajton të folurit shumëgjuhësh.
custom_vocabulary Matricë vargjesh Deri në 1,000 terma, akronime, emra markash ose emra të përveçëm të personalizuar për të shtrembëruar njohjen e të folurit.
mode Varg Modaliteti i transkriptimit: "VERBATIM" (parazgjedhur) ose "SMART" (Transkriptim inteligjent). Kur vendoset në "SMART" , modeli heq fjalët plotësuese, formaton listat dhe korrigjon rrjedhshmëritë e gabuara.
automatic_activity_detection.disabled Boolean Vendose në true për të çaktivizuar zbulimin automatik të aktivitetit zanor dhe për të dërguar manualisht sinjalet activityStart dhe activityEnd .

Fushat e përgjigjes së serverit

Fushë Përshkrimi
server_content.interim_input_transcription Hipotezë e transkriptimit të pjesshëm të përkohshëm me latencë të ulët, e emetuar vazhdimisht ndërsa përdoruesi flet në mënyrë aktive.
server_content.input_transcription Transkript i finalizuar dhe autoritar i të dhënave që emetohet kur përfundon një raund fjalimi.

Kufizime

  • Kohëzgjatja e seancës: Seancat e transkriptimit të drejtpërdrejtë mbështesin transmetim të vazhdueshëm deri në 10 minuta.
  • Diarizimi i folësit: Diarizimi i folësit nuk mbështetet në seancat e transmetimit të drejtpërdrejtë. Për diarizimin e folësit, përdorni pikën fundore të transkriptimit audio që nuk transmetohet.
  • Vula kohore në nivel fjalësh: Vulat kohore në nivel fjalësh nuk mbështeten në Live API. Live API lëshon vula kohore në nivel shqiptimi ( interim_input_transcription dhe input_transcription ).
  • Fjalor i personalizuar: Mund të jepni deri në 1,000 terma në custom_vocabulary , por rezultatet më të mira zakonisht arrihen me deri në 100 terma.
  • Pajtueshmëria e modalitetit: Transkriptimi inteligjent ( "mode": "SMART" ) heq fjalët plotësuese dhe formaton tekstin e vetëdijshëm për qëllimin, por nuk mund të kombinohet me shënime fjalësh.

Çfarë vjen më pas