‫Interactions API זמין עכשיו לכלל המשתמשים. מומלץ להשתמש ב-API הזה כדי לקבל גישה לכל התכונות והמודלים העדכניים.

‫Google משתמשת בטכנולוגיית AI כדי לתרגם תוכן לשפה המועדפת עליך. בתרגומים כאלו עשויות להיות שגיאות.

תמלול בזמן אמת באמצעות Gemini Live API

‫Gemini Live API תומך בתמלול דיבור לטקסט בזמן אמת עם זמן טעינה נמוך באמצעות מודל gemini-3.5-transcribe-live. אם מתחברים ל-Live API באמצעות WebSockets או באמצעות Google Gen AI SDK, אפשר להזרים קלט אודיו רציף ולקבל תמלולים מצטברים של טקסט בזמן אמת, בזמן שהדיבור מתרחש.

כדאי לנסות תמלול בזמן אמת ב-Google AI Studio פתיחת ספר המתכונים של Colab שימוש במיומנויות של סוכן תכנות

באמצעות Gemini Live API, פלטפורמות למפתחים כמו Agora,‏ Fishjam,‏ LiveKit,‏ Pipecat,‏ Vercel ו-Vision Agents מאפשרות למפתחים ליצור ולפרוס בקלות ממשקים מבוססי קול עם ביצועים גבוהים. הפלטפורמות האלה מנהלות מאחורי הקלעים תשתית מורכבת של סטרימינג מדיה בזמן אמת, ומאפשרות למפתחים להתמקד לחלוטין ביצירת חוויית משתמש.

נציג תמיכה לעומת תמלול בזמן אמת

למרות ששניהם משתמשים בחיבור סטרימינג דו-כיווני של Live API, תמלול בזמן אמת פועל כצינור ייעודי לזיהוי דיבור עם זמן אחזור נמוך, ולא כסוכן שיחה.

תכונה	נציג תמיכה	תמלול בזמן אמת
תפקיד ראשי	עוזר אישי מבוסס-AI בממשק שיחה, שמקשיב, מסיק מסקנות ומשיב.	צינור להמרת דיבור לטקסט בזמן אמת, שמתמלל אודיו נכנס.
Response modality	אודיו של דיבור וטקסט (`response_modalities=["AUDIO"]`).	תמלילים של סטרימינג (`response_modalities=["TEXT"]`).
סגנון האינטראקציה	דיאלוג מבוסס-תור עם זיהוי של הפסקות והפרעות.	עיבוד רציף של זרמי נתונים (stream processing) בזמן שהדובר מדבר.
תכונות נתמכות	בקשה להפעלת פונקציה, חיפוש Google, הוראות מערכת.	הטיה של זיהוי הדיבור (`custom_vocabulary`), זיהוי שפה, זיהוי פעילות קולית (VAD) ידני והיברידי, תמלול חכם.
Input stream	מולטי-מודאלי: אודיו, וידאו, תמונות, טקסט.	קלט אודיו (PCM גולמי של 16 ביט).

שנתחיל?

בדוגמאות הבאות אפשר לראות איך פותחים סשן סטרימינג דו-כיווני עם gemini-3.5-transcribe-live ומקבלים תמלילים בזמן אמת.

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

תמלילים זמניים ותמלילים סופיים

כשזרם אודיו נכנס אל Live API, השרת פולט שני שדות תמלול משלימים בתוך server_content:

‫interim_input_transcription: השערות חלקיות ספקולטיביות עם השהיה נמוכה, שמתעדכנות בזמן שהדובר מדבר. העדכונים החלקיים האלה מתרחשים במהירות עם עיכוב מינימלי. אפשר להשתמש ב-interim_input_transcription כדי להציג כתוביות רספונסיביות בזמן אמת בממשק המשתמש או בתצוגה מקדימה של כתוביות.
‫input_transcription: התמליל הסופי שמופק כשהדובר מפסיק לדבר, כשהתור מסתיים או כשהדיבור מסתיים. אחרי שהטקסט הזה מופק, הוא מייצג את התמלול המוסמך של המודל של קטע הדיבור הזה. במצב תמלול חכם, התשובה תכלול את התמלול הנקי והמעוצב.

בדוגמה הבאה אפשר לראות איך מציגים תוצאות חלקיות זמניות של סטרימינג ואיך שומרים תמלילים סופיים:

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

שליחת אודיו

הזרמת נתחי אודיו בחיבור הפעיל כאודיו PCM גולמי של 16 ביט.

פורמט אודיו: Raw 16-bit PCM at 16kHz (מונו, little-endian).
גודל המקטע: שליחת אודיו במקטעים של 100 אלפיות השנייה (1,024 עד 2,048 פריימים).
סוג MIME: audio/pcm;rate=16000 (או תדירות הדגימה התואמת).

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

תכונות התמלול

זיהוי שפה אוטומטי

כברירת מחדל, אם לא מציינים את language_codes או אם מגדירים את language_codes=[], זיהוי השפה האוטומטי מופעל. המודל מזהה באופן דינמי את השפה המדוברת בכל אמירה, כולל שיחות רב-לשוניות ומעבר בין שפות.

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

רמז לשפה ספציפית

כדי להטות את הזיהוי לשפות ספציפיות, צריך לספק קודים מפורשים של שפות בתקן BCP-47 (לדוגמה, ["es-ES"] לספרדית או ["fr-FR"] לצרפתית) (ראו שפות נתמכות).

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

הטיה של אוצר מילים בהתאמה אישית

אפשר לספק רשימה של עד 1,000 ביטויים, שמות עצם פרטיים, שמות מותגים או מונחים טכניים ב-custom_vocabulary כדי להטות את זיהוי הדיבור לכיוון טרמינולוגיה ספציפית (בדרך כלל מתקבלות התוצאות הטובות ביותר עם עד 100 מונחים).

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

תמלול חכם

מגדירים את הפורמט של פלט התמלול באמצעות הפרמטר mode ב-input_audio_transcription:

‫VERBATIM (ברירת מחדל): יוצר תמליל מדויק של כל מה שנאמר, כולל מילות מילוי ("אה", "הממ", "כאילו"), חזרות והתחלות שגויות.
‫SMART (תמלול חכם): מנקה ומארגן את התמליל כדי שיהיה קל לקריאה:
- הסרת שיבושים בדיבור: הסרת מילים מיותרות, גמגום והתחלות שגויות.
- תיקונים עצמיים בתוך השורה: תיקונים שנעשים במהלך הדיבור נפתרים באופן טבעי.
- עיצוב מובנה: עיצוב אוטומטי של רשימות, תבליטים, מספרים, תאריכים ומעברי פסקאות.
- דקדוק ושימוש באותיות רישיות: שיפור השימוש באותיות רישיות ובסימני פיסוק.

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

אסטרטגיות לזיהוי דיבור (VAD)

זיהוי אוטומטי של פעילות קולית (ברירת מחדל)

כברירת מחדל, זיהוי דיבור אוטומטי בצד השרת מזהה מתי הדובר מתחיל לדבר ומתי הוא מפסיק.

Hybrid VAD

זיהוי פעילות קולית היברידי משלב זיהוי אוטומטי של תחילת הדיבור בצד השרת עם זיהוי של סיום הדיבור בצד הלקוח, כדי להשלים את תור הדיבור ללא השהיה:

ה-VAD האוטומטי בצד השרת נשאר מופעל כדי לזהות במדויק את תחילת הדיבור באמצעות הוספת ריווח לאודיו של הקידומת, וכך למנוע חיתוך של המילה הראשונה.
זיהוי דיבור (VAD) בצד הלקוח מזהה שקט: כשזיהוי דיבור (VAD) מקומי במכשיר מזהה שהדובר הפסיק לדבר, הלקוח שולח אות audio_stream_end באופן מיידי.
סיום מהיר: השרת מתייחס אל audio_stream_end כאל הנחיה לסיום מיידי של התור, מדלג על זמן ההמתנה המוגדר כברירת מחדל בצד השרת ומחזיר את התמליל הסופי עם זמן אחזור מינימלי.
מעבר לגיבוי: אם לא מופעלת VAD בצד הלקוח, VAD בצד השרת פועלת כגיבוי אוטומטי.

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 האוטומטי ולשלוט באופן מפורש על גבולות התור באמצעות activity_start ו-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: {},
  },
}));

טוקנים זמניים באפליקציות לקוח

באפליקציות שמתקשרות בין לקוח לשרת (כמו אפליקציות לנייד או אפליקציות אינטרנט שמשדרות סטרימינג ישירות ממיקרופון), מומלץ להשתמש בטוקנים זמניים כדי למנוע חשיפה של מפתח ה-API בקוד הלקוח.

יוצרים אסימון זמני מוגבל בשרת לפני שמתחילים את החיבור של הלקוח:

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

שפות נתמכות

השפות הבאות וקודי השפות בתקן BCP-47 נתמכות ב-Gemini 3.5 Transcribe Live:

שפה	קוד BCP-47	שפה	קוד BCP-47
אפריקאנס	`af-ZA`	יפנית	`ja-JP`
אמהרית	`am-ET`	ג'אווה	`jv-ID`
ערבית (מצרים)	`ar-EG`	קאבוורדיאנו	`kea-CV`
ארמנית	`hy-AM`	קנאדה	`kn-IN`
אסאמית	`as-IN`	קזחית	`kk-KZ`
אזרית	`az-AZ`	קוריאנית	`ko-KR`
בלארוסית	`be-BY`	קירגיזית	`ky-KG`
בנגלית (בנגלדש)	`bn-BD`	לטבית	`lv-LV`
בנגלית (הודו)	`bn-IN`	לינגלה	`ln-CD`
בוסנית	`bs-BA`	ליטאית	`lt-LT`
בולגרית	`bg-BG`	מקדונית	`mk-MK`
בולגרית (ארומנית)	`rup-BG`	מלאית	`ms-MY`
בורמזית	`my-MM`	מליאלאם	`ml-IN`
קנטונזית (מסורתית)	`yue-Hant-HK`	מלטית	`mt-MT`
קטלאנית	`ca-ES`	סינית מנדרינית (פשוטה)	`cmn-Hans-CN`
סבואנו	`ceb`	מראטהית	`mr-IN`
חמר מרכזית	`km-KH`	מונגולית	`mn-MN`
קרואטית	`hr-HR`	נפאלית	`ne-NP`
צ'כית	`cs-CZ`	נורווגית	`nb-NO`
דנית	`da-DK`	אורייה	`or-IN`
הולנדית	`nl-NL`	פולנית	`pl-PL`
אנגלית (בריטניה)	`en-GB`	פורטוגזית (ברזיל)	`pt-BR`
אנגלית (הודו)	`en-IN`	פורטוגזית (פורטוגל)	`pt-PT`
אנגלית (ארצות הברית)	`en-US`	פנג'אבי	`pa-IN`
אסטונית	`et-EE`	פנג'אבי (כתב גורמוקי)	`pa-Guru-IN`
פרסית	`fa-IR`	רומנית	`ro-RO`
פיליפינית	`fil-PH`	רוסית	`ru-RU`
פינית	`fi-FI`	סרבית	`sr-RS`
צרפתית	`fr-FR`	סינדהי (כתב ערבי)	`sd-Arab-IN`
גליציאנית	`gl-ES`	סלובקית	`sk-SK`
גאורגית	`ka-GE`	סלובנית	`sl-SI`
גרמנית	`de-DE`	ספרדית (אמריקה הלטינית)	`es-419`
יוונית	`el-GR`	ספרדית (ארצות הברית)	`es-US`
גוג'ראטי	`gu-IN`	סוואהילית (קניה)	`sw-KE`
האוסה	`ha-NG`	שוודית	`sv-SE`
עברית	`he-IL`	טג'יקית	`tg-TJ`
הינדי	`hi-IN`	טלוגו	`te-IN`
הונגרית	`hu-HU`	תאית	`th-TH`
איסלנדית	`is-IS`	טורקית	`tr-TR`
אנגלית הודית	`en-IN`	אוקראינית	`uk-UA`
אינדונזית	`id-ID`	אוזבקית	`uz-UZ`
איטלקית	`it-IT`	וייטנאמית	`vi-VN`

הפניה לפרמטר

הגדרת תמלול בזמן אמת באמצעות שדות ב-input_audio_transcription וב-realtime_input_config:

פרמטר	סוג	תיאור
`language_codes`	מערך של מחרוזות	קודי שפה בתקן BCP-47 (למשל, `["en-US"]`). אם לא מציינים קוד שפה או אם הקוד ריק (`[]`), המודל מזהה את השפה באופן אוטומטי ומטפל בדיבור רב-לשוני.
`custom_vocabulary`	מערך של מחרוזות	עד 1,000 מונחים מותאמים אישית, ראשי תיבות, שמות מותגים או שמות עצם כדי להטות את זיהוי הדיבור.
`mode`	מחרוזת	מצב תמלול: `"VERBATIM"` (ברירת מחדל) או `"SMART"` (תמלול חכם). כשההגדרה היא `"SMART"`, המודל מסיר מילים מיותרות, מעצב רשימות ומתקן שיבושי דיבור.
`automatic_activity_detection.disabled`	בוליאני	מגדירים את הערך `true` כדי להשבית את זיהוי הדיבור האוטומטי ולשלוח באופן ידני את האותות `activityStart` ו-`activityEnd`.

שדות של תגובת השרת

שדה	תיאור
`server_content.interim_input_transcription`	השערה של תמלול חלקי זמני עם השהיה נמוכה, שמופקת באופן רציף בזמן שהמשתמש מדבר באופן פעיל.
`server_content.input_transcription`	תמליל סופי ומהימן של הקלט שמופק כשמסתיימת תורת הדיבור.

מגבלות

משך הסשן: סשנים של תמלול בזמן אמת תומכים בסטרימינג רציף למשך עד 10 דקות.
זיהוי דוברים: זיהוי דוברים לא נתמך בשידורים חיים. כדי להשתמש בתיוג דוברים, צריך להשתמש בנקודת הקצה Audio transcription שאינה סטרימינג.
חותמות זמן ברמת המילה: אין תמיכה בחותמות זמן ברמת המילה ב-Live API. ה-API של שידור חי פולט חותמות זמן ברמת האמירה (interim_input_transcription ו-input_transcription).
אוצר מילים מותאם אישית: אפשר לספק עד 1,000 מונחים ב-custom_vocabulary, אבל בדרך כלל התוצאות הכי טובות מתקבלות עם עד 100 מונחים.
תאימות בין מצבים: התמלול החכם ("mode": "SMART") מסיר מילות קישור ומעצב טקסט שמודע לכוונה, אבל אי אפשר לשלב אותו עם הערות למילים.

המאמרים הבאים

מידע נוסף על קובצי אודיו שלא מועברים בסטרימינג זמין במאמרי העזרה בנושא Gemini Transcribe.
מידע נוסף על סוכנים קוליים בממשק שיחה זמין בסקירה הכללית על Live API.
כדי לקבל תרגום בזמן אמת מדיבור לדיבור, אפשר לקרוא את המדריך לתרגום בזמן אמת.
בדף המחירים אפשר לראות את המחירים של Live API streaming.
מידע נוסף על היכולות של API בזמן אמת