Bu sayfa, Cloud Translation API ile çevrilmiştir.

Live API capabilities guide

Bu kapsamlı kılavuzda, Live API ile kullanılabilen özellikler ve yapılandırmalar ele alınmaktadır. Genel bakış ve yaygın kullanım alanlarına ilişkin örnek kod için Live API'yi kullanmaya başlama sayfasına bakın.

Başlamadan önce

Temel kavramlar hakkında bilgi edinin: Henüz yapmadıysanız önce Live API'yi kullanmaya başlama sayfasını okuyun. Bu doküman, Live API'nin temel ilkeleri, nasıl çalıştığı ve farklı uygulama yaklaşımları hakkında bilgi verir.
Live API'yi AI Studio'da deneyin: Uygulama geliştirmeye başlamadan önce Google AI Studio'da Live API'yi denemeniz faydalı olabilir. Google AI Studio'da Live API'yi kullanmak için Yayın'ı seçin.

Bağlantı kurma

Aşağıdaki örnekte, API anahtarıyla nasıl bağlantı oluşturulacağı gösterilmektedir:

Python

import asyncio
from google import genai

client = genai.Client()

model = "gemini-2.5-flash-native-audio-preview-09-2025"
config = {"response_modalities": ["AUDIO"]}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        print("Session started")
        # Send content...

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

JavaScript

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

const ai = new GoogleGenAI({});
const model = 'gemini-2.5-flash-native-audio-preview-09-2025';
const config = { responseModalities: [Modality.AUDIO] };

async function main() {

  const session = await ai.live.connect({
    model: model,
    callbacks: {
      onopen: function () {
        console.debug('Opened');
      },
      onmessage: function (message) {
        console.debug(message);
      },
      onerror: function (e) {
        console.debug('Error:', e.message);
      },
      onclose: function (e) {
        console.debug('Close:', e.reason);
      },
    },
    config: config,
  });

  console.debug("Session started");
  // Send content...

  session.close();
}

main();

Etkileşim biçimleri

Aşağıdaki bölümlerde, Live API'de bulunan farklı giriş ve çıkış yöntemleriyle ilgili örnekler ve destekleyici bağlamlar verilmektedir.

Ses gönderme ve alma

En yaygın ses örneği olan ses-ses, Başlangıç kılavuzunda ele alınmaktadır.

Ses biçimleri

Live API'deki ses verileri her zaman ham, little-endian ve 16 bit PCM'dir. Ses çıkışında her zaman 24 kHz örnekleme hızı kullanılır. Giriş sesi, doğal olarak 16 kHz'dir ancak gerekirse Live API yeniden örnekleme yapacağından herhangi bir örnekleme hızı gönderilebilir. Giriş sesinin örnekleme hızını iletmek için ses içeren her Blob'un MIME türünü audio/pcm;rate=16000 gibi bir değere ayarlayın.

Kısa mesaj gönderiliyor

Metin göndermek için:

Python

message = "Hello, how are you?"
await session.send_client_content(turns=message, turn_complete=True)

JavaScript

const message = 'Hello, how are you?';
session.sendClientContent({ turns: message, turnComplete: true });

Artımlı içerik güncellemeleri

Metin girişi göndermek, oturum bağlamı oluşturmak veya oturum bağlamını geri yüklemek için artımlı güncellemeleri kullanın. Kısa bağlamlarda, etkinliklerin tam sırasını göstermek için adım adım etkileşimler gönderebilirsiniz:

Python

turns = [
    {"role": "user", "parts": [{"text": "What is the capital of France?"}]},
    {"role": "model", "parts": [{"text": "Paris"}]},
]

await session.send_client_content(turns=turns, turn_complete=False)

turns = [{"role": "user", "parts": [{"text": "What is the capital of Germany?"}]}]

await session.send_client_content(turns=turns, turn_complete=True)

JavaScript

let inputTurns = [
  { "role": "user", "parts": [{ "text": "What is the capital of France?" }] },
  { "role": "model", "parts": [{ "text": "Paris" }] },
]

session.sendClientContent({ turns: inputTurns, turnComplete: false })

inputTurns = [{ "role": "user", "parts": [{ "text": "What is the capital of Germany?" }] }]

session.sendClientContent({ turns: inputTurns, turnComplete: true })

Daha uzun bağlamlarda, sonraki etkileşimler için bağlam penceresini boşaltmak amacıyla tek bir mesaj özeti sağlamanız önerilir. Oturum bağlamını yüklemenin başka bir yöntemi için Oturum Devam Ettirme'ye bakın.

Sesten dönüştürülen metinler

Model yanıtının yanı sıra hem ses çıkışının hem de ses girişinin transkriptlerini de alabilirsiniz.

Modelin ses çıkışının metne dönüştürülmesini etkinleştirmek için kurulum yapılandırmasında output_audio_transcription gönderin. Metne dönüştürme dili, modelin yanıtından çıkarılır.

Python

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

client = genai.Client()
model = "gemini-2.5-flash-native-audio-preview-09-2025"

config = {
    "response_modalities": ["AUDIO"],
    "output_audio_transcription": {}
}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        message = "Hello? Gemini are you there?"

        await session.send_client_content(
            turns={"role": "user", "parts": [{"text": message}]}, turn_complete=True
        )

        async for response in session.receive():
            if response.server_content.model_turn:
                print("Model turn:", response.server_content.model_turn)
            if response.server_content.output_transcription:
                print("Transcript:", response.server_content.output_transcription.text)

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

JavaScript

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

const ai = new GoogleGenAI({});
const model = 'gemini-2.5-flash-native-audio-preview-09-2025';

const config = {
  responseModalities: [Modality.AUDIO],
  outputAudioTranscription: {}
};

async function live() {
  const responseQueue = [];

  async function waitMessage() {
    let done = false;
    let message = undefined;
    while (!done) {
      message = responseQueue.shift();
      if (message) {
        done = true;
      } else {
        await new Promise((resolve) => setTimeout(resolve, 100));
      }
    }
    return message;
  }

  async function handleTurn() {
    const turns = [];
    let done = false;
    while (!done) {
      const message = await waitMessage();
      turns.push(message);
      if (message.serverContent && message.serverContent.turnComplete) {
        done = true;
      }
    }
    return turns;
  }

  const session = await ai.live.connect({
    model: model,
    callbacks: {
      onopen: function () {
        console.debug('Opened');
      },
      onmessage: function (message) {
        responseQueue.push(message);
      },
      onerror: function (e) {
        console.debug('Error:', e.message);
      },
      onclose: function (e) {
        console.debug('Close:', e.reason);
      },
    },
    config: config,
  });

  const inputTurns = 'Hello how are you?';
  session.sendClientContent({ turns: inputTurns });

  const turns = await handleTurn();

  for (const turn of turns) {
    if (turn.serverContent && turn.serverContent.outputTranscription) {
      console.debug('Received output transcription: %s\n', turn.serverContent.outputTranscription.text);
    }
  }

  session.close();
}

async function main() {
  await live().catch((e) => console.error('got error', e));
}

main();

Modelin ses girişinin metne dönüştürülmesini etkinleştirmek için kurulum yapılandırmasında input_audio_transcription gönderin.

Python

import asyncio
from pathlib import Path
from google import genai
from google.genai import types

client = genai.Client()
model = "gemini-2.5-flash-native-audio-preview-09-2025"

config = {
    "response_modalities": ["AUDIO"],
    "input_audio_transcription": {},
}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        audio_data = Path("16000.pcm").read_bytes()

        await session.send_realtime_input(
            audio=types.Blob(data=audio_data, mime_type='audio/pcm;rate=16000')
        )

        async for msg in session.receive():
            if msg.server_content.input_transcription:
                print('Transcript:', msg.server_content.input_transcription.text)

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

JavaScript

import { GoogleGenAI, Modality } from '@google/genai';
import * as fs from "node:fs";
import pkg from 'wavefile';
const { WaveFile } = pkg;

const ai = new GoogleGenAI({});
const model = 'gemini-2.5-flash-native-audio-preview-09-2025';

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

async function live() {
  const responseQueue = [];

  async function waitMessage() {
    let done = false;
    let message = undefined;
    while (!done) {
      message = responseQueue.shift();
      if (message) {
        done = true;
      } else {
        await new Promise((resolve) => setTimeout(resolve, 100));
      }
    }
    return message;
  }

  async function handleTurn() {
    const turns = [];
    let done = false;
    while (!done) {
      const message = await waitMessage();
      turns.push(message);
      if (message.serverContent && message.serverContent.turnComplete) {
        done = true;
      }
    }
    return turns;
  }

  const session = await ai.live.connect({
    model: model,
    callbacks: {
      onopen: function () {
        console.debug('Opened');
      },
      onmessage: function (message) {
        responseQueue.push(message);
      },
      onerror: function (e) {
        console.debug('Error:', e.message);
      },
      onclose: function (e) {
        console.debug('Close:', e.reason);
      },
    },
    config: config,
  });

  // Send Audio Chunk
  const fileBuffer = fs.readFileSync("16000.wav");

  // Ensure audio conforms to API requirements (16-bit PCM, 16kHz, mono)
  const wav = new WaveFile();
  wav.fromBuffer(fileBuffer);
  wav.toSampleRate(16000);
  wav.toBitDepth("16");
  const base64Audio = wav.toBase64();

  // If already in correct format, you can use this:
  // const fileBuffer = fs.readFileSync("sample.pcm");
  // const base64Audio = Buffer.from(fileBuffer).toString('base64');

  session.sendRealtimeInput(
    {
      audio: {
        data: base64Audio,
        mimeType: "audio/pcm;rate=16000"
      }
    }
  );

  const turns = await handleTurn();
  for (const turn of turns) {
    if (turn.text) {
      console.debug('Received text: %s\n', turn.text);
    }
    else if (turn.data) {
      console.debug('Received inline data: %s\n', turn.data);
    }
    else if (turn.serverContent && turn.serverContent.inputTranscription) {
      console.debug('Received input transcription: %s\n', turn.serverContent.inputTranscription.text);
    }
  }

  session.close();
}

async function main() {
  await live().catch((e) => console.error('got error', e));
}

main();

Ses ve video akışı yapma

Sesi ve dili değiştirme

Doğal ses çıkışı modelleri, metin okuma (TTS) modellerimiz için kullanılabilen tüm sesleri destekler. Tüm sesleri Yapay Zeka Studio'da dinleyebilirsiniz.

Bir ses belirtmek için speechConfig nesnesindeki ses adını oturum yapılandırmasının bir parçası olarak ayarlayın:

Python

config = {
    "response_modalities": ["AUDIO"],
    "speech_config": {
        "voice_config": {"prebuilt_voice_config": {"voice_name": "Kore"}}
    },
}

JavaScript

const config = {
  responseModalities: [Modality.AUDIO],
  speechConfig: { voiceConfig: { prebuiltVoiceConfig: { voiceName: "Kore" } } }
};

Live API birden fazla dili destekler. Doğal ses çıkışı modelleri, uygun dili otomatik olarak seçer ve dil kodunun açıkça ayarlanmasını desteklemez.

Yerel ses özellikleri

En yeni modellerimizde yerel ses çıkışı özelliği bulunur. Bu özellik, doğal ve gerçekçi bir konuşma sesi ile çok dilli performansı iyileştirir. Doğal ses, duygusal (duygulara duyarlı) diyalog, proaktif ses (modelin girişe ne zaman yanıt vereceğine akıllıca karar verdiği yer) ve "düşünme" gibi gelişmiş özellikleri de etkinleştirir.

Moda uygun diyalog

Bu özellik, Gemini'ın yanıt tarzını giriş ifadesine ve tonuna uyarlamasına olanak tanır.

Duygusal diyaloğu kullanmak için API sürümünü v1alpha olarak ayarlayın ve kurulum mesajında enable_affective_dialog değerini true olarak ayarlayın:

Python

client = genai.Client(http_options={"api_version": "v1alpha"})

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    enable_affective_dialog=True
)

JavaScript

const ai = new GoogleGenAI({ httpOptions: {"apiVersion": "v1alpha"} });

const config = {
  responseModalities: [Modality.AUDIO],
  enableAffectiveDialog: true
};

Proaktif ses

Bu özellik etkinleştirildiğinde Gemini, içerik alakalı değilse yanıt vermemeye proaktif olarak karar verebilir.

Kullanmak için API sürümünü v1alpha olarak ayarlayın, kurulum mesajında proactivity alanını yapılandırın ve proactive_audio değerini true olarak ayarlayın:

Python

client = genai.Client(http_options={"api_version": "v1alpha"})

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"],
    proactivity={'proactive_audio': True}
)

JavaScript

const ai = new GoogleGenAI({ httpOptions: {"apiVersion": "v1alpha"} });

const config = {
  responseModalities: [Modality.AUDIO],
  proactivity: { proactiveAudio: true }
}

Düşünüyorum

En yeni yerel ses çıkışı modeli gemini-2.5-flash-native-audio-preview-09-2025 düşünme yeteneklerini destekler. Dinamik düşünme özelliği varsayılan olarak etkindir.

thinkingBudget parametresi, yanıt oluştururken kullanılacak düşünme parçalarının sayısı konusunda modele yol gösterir. thinkingBudget değerini 0 olarak ayarlayarak düşünme özelliğini devre dışı bırakabilirsiniz. Modelin thinkingBudget yapılandırma ayrıntıları hakkında daha fazla bilgi için düşünme bütçeleri belgelerine bakın.

Python

model = "gemini-2.5-flash-native-audio-preview-09-2025"

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"]
    thinking_config=types.ThinkingConfig(
        thinking_budget=1024,
    )
)

async with client.aio.live.connect(model=model, config=config) as session:
    # Send audio input and receive audio

JavaScript

const model = 'gemini-2.5-flash-native-audio-preview-09-2025';
const config = {
  responseModalities: [Modality.AUDIO],
  thinkingConfig: {
    thinkingBudget: 1024,
  },
};

async function main() {

  const session = await ai.live.connect({
    model: model,
    config: config,
    callbacks: ...,
  });

  // Send audio input and receive audio

  session.close();
}

main();

Ayrıca, yapılandırmanızda includeThoughts değerini true olarak ayarlayarak düşünce özetlerini etkinleştirebilirsiniz. Daha fazla bilgi için düşünce özetleri bölümüne bakın:

Python

model = "gemini-2.5-flash-native-audio-preview-09-2025"

config = types.LiveConnectConfig(
    response_modalities=["AUDIO"]
    thinking_config=types.ThinkingConfig(
        thinking_budget=1024,
        include_thoughts=True
    )
)

JavaScript

const model = 'gemini-2.5-flash-native-audio-preview-09-2025';
const config = {
  responseModalities: [Modality.AUDIO],
  thinkingConfig: {
    thinkingBudget: 1024,
    includeThoughts: true,
  },
};

Ses Etkinliği Algılama (VAD)

Ses Etkinliği Algılama (VAD), modelin bir kişinin konuştuğu zamanı tanımasına olanak tanır. Bu, kullanıcının modeli istediği zaman kesmesine olanak tanıdığı için doğal sohbetler oluşturmak açısından önemlidir.

VAD bir kesinti algıladığında devam eden oluşturma işlemi iptal edilir ve silinir. Yalnızca müşteriye daha önce gönderilen bilgiler oturum geçmişinde saklanır. Ardından sunucu, kesintiyi bildirmek için BidiGenerateContentServerContent mesajı gönderir.

Ardından Gemini sunucusu, bekleyen işlev çağrılarını siler ve iptal edilen çağrıların kimliklerini içeren bir BidiGenerateContentServerContent mesajı gönderir.

Python

async for response in session.receive():
    if response.server_content.interrupted is True:
        # The generation was interrupted

        # If realtime playback is implemented in your application,
        # you should stop playing audio and clear queued playback here.

JavaScript

const turns = await handleTurn();

for (const turn of turns) {
  if (turn.serverContent && turn.serverContent.interrupted) {
    // The generation was interrupted

    // If realtime playback is implemented in your application,
    // you should stop playing audio and clear queued playback here.
  }
}

Otomatik VAD

Model, varsayılan olarak sürekli bir ses girişi akışında otomatik olarak VAD gerçekleştirir. VAD, kurulum yapılandırmasının realtimeInputConfig.automaticActivityDetection alanı ile yapılandırılabilir.

Ses akışı bir saniyeden uzun süre duraklatıldığında (örneğin, kullanıcı mikrofonu kapattığı için) önbelleğe alınan sesleri temizlemek için bir audioStreamEnd etkinliği gönderilmelidir. İstemci, ses verilerini göndermeye istediği zaman devam edebilir.

Python

# example audio file to try:
# URL = "https://storage.googleapis.com/generativeai-downloads/data/hello_are_you_there.pcm"
# !wget -q $URL -O sample.pcm
import asyncio
from pathlib import Path
from google import genai
from google.genai import types

client = genai.Client()
model = "gemini-live-2.5-flash-preview"

config = {"response_modalities": ["TEXT"]}

async def main():
    async with client.aio.live.connect(model=model, config=config) as session:
        audio_bytes = Path("sample.pcm").read_bytes()

        await session.send_realtime_input(
            audio=types.Blob(data=audio_bytes, mime_type="audio/pcm;rate=16000")
        )

        # if stream gets paused, send:
        # await session.send_realtime_input(audio_stream_end=True)

        async for response in session.receive():
            if response.text is not None:
                print(response.text)

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

JavaScript

// example audio file to try:
// URL = "https://storage.googleapis.com/generativeai-downloads/data/hello_are_you_there.pcm"
// !wget -q $URL -O sample.pcm
import { GoogleGenAI, Modality } from '@google/genai';
import * as fs from "node:fs";

const ai = new GoogleGenAI({});
const model = 'gemini-live-2.5-flash-preview';
const config = { responseModalities: [Modality.TEXT] };

async function live() {
  const responseQueue = [];

  async function waitMessage() {
    let done = false;
    let message = undefined;
    while (!done) {
      message = responseQueue.shift();
      if (message) {
        done = true;
      } else {
        await new Promise((resolve) => setTimeout(resolve, 100));
      }
    }
    return message;
  }

  async function handleTurn() {
    const turns = [];
    let done = false;
    while (!done) {
      const message = await waitMessage();
      turns.push(message);
      if (message.serverContent && message.serverContent.turnComplete) {
        done = true;
      }
    }
    return turns;
  }

  const session = await ai.live.connect({
    model: model,
    callbacks: {
      onopen: function () {
        console.debug('Opened');
      },
      onmessage: function (message) {
        responseQueue.push(message);
      },
      onerror: function (e) {
        console.debug('Error:', e.message);
      },
      onclose: function (e) {
        console.debug('Close:', e.reason);
      },
    },
    config: config,
  });

  // Send Audio Chunk
  const fileBuffer = fs.readFileSync("sample.pcm");
  const base64Audio = Buffer.from(fileBuffer).toString('base64');

  session.sendRealtimeInput(
    {
      audio: {
        data: base64Audio,
        mimeType: "audio/pcm;rate=16000"
      }
    }

  );

  // if stream gets paused, send:
  // session.sendRealtimeInput({ audioStreamEnd: true })

  const turns = await handleTurn();
  for (const turn of turns) {
    if (turn.text) {
      console.debug('Received text: %s\n', turn.text);
    }
    else if (turn.data) {
      console.debug('Received inline data: %s\n', turn.data);
    }
  }

  session.close();
}

async function main() {
  await live().catch((e) => console.error('got error', e));
}

main();

send_realtime_input ile API, VAD'ye göre otomatik olarak sese yanıt verir. send_client_content, iletileri model bağlamına sırayla eklerken send_realtime_input, deterministik sıralama pahasına yanıt verme hızı için optimize edilmiştir.

Otomatik VAD yapılandırması

VAD etkinliği üzerinde daha fazla kontrol sahibi olmak için aşağıdaki parametreleri yapılandırabilirsiniz. Daha fazla bilgi için API referansına bakın.

Python

from google.genai import types

config = {
    "response_modalities": ["TEXT"],
    "realtime_input_config": {
        "automatic_activity_detection": {
            "disabled": False, # default
            "start_of_speech_sensitivity": types.StartSensitivity.START_SENSITIVITY_LOW,
            "end_of_speech_sensitivity": types.EndSensitivity.END_SENSITIVITY_LOW,
            "prefix_padding_ms": 20,
            "silence_duration_ms": 100,
        }
    }
}

JavaScript

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

const config = {
  responseModalities: [Modality.TEXT],
  realtimeInputConfig: {
    automaticActivityDetection: {
      disabled: false, // default
      startOfSpeechSensitivity: StartSensitivity.START_SENSITIVITY_LOW,
      endOfSpeechSensitivity: EndSensitivity.END_SENSITIVITY_LOW,
      prefixPaddingMs: 20,
      silenceDurationMs: 100,
    }
  }
};

Otomatik VAD'yi devre dışı bırakma

Alternatif olarak, kurulum mesajında realtimeInputConfig.automaticActivityDetection.disabled değeri true olarak ayarlanarak otomatik VAD devre dışı bırakılabilir. Bu yapılandırmada, istemci kullanıcı konuşmasını algılamaktan ve uygun zamanlarda activityStart ve activityEnd mesajlarını göndermekten sorumludur. Bu yapılandırmada audioStreamEnd gönderilmez. Bunun yerine, akışın kesintiye uğraması activityEnd mesajıyla işaretlenir.

Python

config = {
    "response_modalities": ["TEXT"],
    "realtime_input_config": {"automatic_activity_detection": {"disabled": True}},
}

async with client.aio.live.connect(model=model, config=config) as session:
    # ...
    await session.send_realtime_input(activity_start=types.ActivityStart())
    await session.send_realtime_input(
        audio=types.Blob(data=audio_bytes, mime_type="audio/pcm;rate=16000")
    )
    await session.send_realtime_input(activity_end=types.ActivityEnd())
    # ...

JavaScript

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

session.sendRealtimeInput({ activityStart: {} })

session.sendRealtimeInput(
  {
    audio: {
      data: base64Audio,
      mimeType: "audio/pcm;rate=16000"
    }
  }

);

session.sendRealtimeInput({ activityEnd: {} })

Jeton sayısı

Tüketilen jetonların toplam sayısını, döndürülen sunucu mesajının usageMetadata alanında bulabilirsiniz.

Python

async for message in session.receive():
    # The server will periodically send messages that include UsageMetadata.
    if message.usage_metadata:
        usage = message.usage_metadata
        print(
            f"Used {usage.total_token_count} tokens in total. Response token breakdown:"
        )
        for detail in usage.response_tokens_details:
            match detail:
                case types.ModalityTokenCount(modality=modality, token_count=count):
                    print(f"{modality}: {count}")

JavaScript

const turns = await handleTurn();

for (const turn of turns) {
  if (turn.usageMetadata) {
    console.debug('Used %s tokens in total. Response token breakdown:\n', turn.usageMetadata.totalTokenCount);

    for (const detail of turn.usageMetadata.responseTokensDetails) {
      console.debug('%s\n', detail);
    }
  }
}

Medya çözünürlüğü

Oturum yapılandırmasının bir parçası olarak mediaResolution alanını ayarlayarak giriş medyası için medya çözünürlüğünü belirtebilirsiniz:

Python

from google.genai import types

config = {
    "response_modalities": ["AUDIO"],
    "media_resolution": types.MediaResolution.MEDIA_RESOLUTION_LOW,
}

JavaScript

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

const config = {
    responseModalities: [Modality.TEXT],
    mediaResolution: MediaResolution.MEDIA_RESOLUTION_LOW,
};

Sınırlamalar

Projenizi planlarken Canlı API'nin aşağıdaki sınırlamalarını göz önünde bulundurun.

Yanıt biçimleri

Oturum yapılandırmasında oturum başına yalnızca bir yanıt biçimi (TEXT veya AUDIO) ayarlayabilirsiniz. İkisini de ayarlamak yapılandırma hatası mesajına neden olur. Bu, modeli aynı oturumda hem metin hem de sesle yanıt verecek şekilde değil, yalnızca metinle veya sesle yanıt verecek şekilde yapılandırabileceğiniz anlamına gelir.

İstemci kimlik doğrulaması

Live API, varsayılan olarak yalnızca sunucudan sunucuya kimlik doğrulama sağlar. Live API uygulamanızı istemciden sunucuya yaklaşımı kullanarak uyguluyorsanız güvenlik risklerini azaltmak için geçici jetonlar kullanmanız gerekir.

Oturum süresi

Yalnızca sesli oturumlar 15 dakika, sesli ve görüntülü oturumlar ise 2 dakika ile sınırlıdır. Ancak oturum süresinin sınırsız uzatılması için farklı oturum yönetimi teknikleri yapılandırabilirsiniz.

Bağlam penceresi

Bir oturumun bağlam penceresi sınırı şöyledir:

Doğal ses çıkışı modelleri için 128 bin jeton
Diğer Live API modelleri için 32.000 jeton

Desteklenen diller

Live API aşağıdaki dilleri destekler.

Dil	BCP-47 Kodu	Dil	BCP-47 Kodu
Almanca (Almanya)	`de-DE`	İngilizce (Avustralya)*	`en-AU`
İngilizce (Birleşik Krallık)*	`en-GB`	İngilizce (Hindistan)	`en-IN`
İngilizce (ABD)	`en-US`	İspanyolca (ABD)	`es-US`
Fransızca (Fransa)	`fr-FR`	Hintçe (Hindistan)	`hi-IN`
Portekizce (Brezilya)	`pt-BR`	Arapça (Genel)	`ar-XA`
İspanyolca (İspanya)*	`es-ES`	Fransızca (Kanada)*	`fr-CA`
Endonezce (Endonezya)	`id-ID`	İtalyanca (İtalya)	`it-IT`
Japonca (Japonya)	`ja-JP`	Türkçe (Türkiye)	`tr-TR`
Vietnamca (Vietnam)	`vi-VN`	Bengalce (Hindistan)	`bn-IN`
Guceratça (Hindistan)*	`gu-IN`	Kannada dili (Hindistan)*	`kn-IN`
Marathice (Hindistan)	`mr-IN`	Malayalamca (Hindistan)*	`ml-IN`
Tamilce (Hindistan)	`ta-IN`	Telugu dili (Hindistan)	`te-IN`
Felemenkçe (Hollanda)	`nl-NL`	Korece (Güney Kore)	`ko-KR`
Çince (Mandarin) (Çin)*	`cmn-CN`	Lehçe (Polonya)	`pl-PL`
Rusça (Rusya)	`ru-RU`	Tay Dili (Tayland)	`th-TH`

Yıldızla işaretlenmiş diller (*) Doğal ses için kullanılamaz.

Sırada ne var?

Canlı API'yi etkili bir şekilde kullanmayla ilgili temel bilgiler için Araç Kullanımı ve Oturum Yönetimi kılavuzlarını inceleyin.
Google AI Studio'da Live API'yi deneyin.
Live API modelleri hakkında daha fazla bilgi için Modeller sayfasındaki Gemini 2.5 Flash Native Audio bölümüne bakın.
Live API cookbook, Live API Tools cookbook ve Live API Get Started script'te daha fazla örnek deneyin.