Começar a usar a API Gemini Live com o Firebase AI Logic

Prévia: usar os SDKs Firebase AI Logic com o Gemini Live API é um recurso em prévia, o que significa que ele não está sujeito a SLAs ou políticas de descontinuação e pode mudar de maneira incompatível com versões anteriores.

O Gemini Live API permite interações de voz e vídeo em tempo real e de baixa latência com um modelo Gemini bidirecional.

O Live API e sua família especial de modelos podem processar fluxos contínuos de áudio, vídeo ou texto para oferecer respostas faladas imediatas e semelhantes às humanas, criando uma experiência de conversa natural para seus usuários.

Nesta página, descrevemos como começar a usar o recurso mais comum, que é o streaming de entrada e saída de áudio, mas o Live API oferece vários recursos e opções de configuração.

Importante: o Gemini Live API é para streaming bidirecional em tempo real, especificamente para respostas de áudio.
Se você quiser streaming básico de respostas de texto (usando generateContentStream ou sendMessageStream), confira nossa visão geral de como fazer streaming de respostas de texto.

O Live API é uma API com estado que cria uma conexão WebSocket para estabelecer uma sessão entre o cliente e o servidor Gemini. Para mais detalhes, consulte a documentação de referência do Live API (Gemini Developer API | Vertex AI Gemini API).

Ir para exemplos de código

Confira recursos úteis

• Swift: em breve! | Android: app de início rápido | Web: app de início rápido | Flutter: app de início rápido | Unity: em breve!

• Teste o Gemini Live API em um app implantado de verdade. Confira o app Flutter AI Playground acessível pelo console Firebase.

Antes de começar

Se ainda não tiver feito isso, conclua o guia de primeiros passos, que descreve como configurar seu projeto do Firebase, conectar seu app ao Firebase, adicionar o SDK, inicializar o serviço de back-end para o provedor Gemini API escolhido e criar uma instância LiveModel.

É possível criar protótipos com comandos e a Live API em Google AI Studio ou Vertex AI Studio.

Modelos compatíveis com esse recurso

Os modelos Gemini 2.5 Flash Live são os modelos de áudio nativo que oferecem suporte ao Gemini Live API. Embora o modelo tenha nomes diferentes dependendo do provedor da API Gemini, o comportamento e os recursos são os mesmos.

• Gemini Developer API

  • gemini-2.5-flash-native-audio-preview-12-2025
  • gemini-2.5-flash-native-audio-preview-09-2025

  Embora sejam modelos de prévia, eles estão disponíveis no "nível sem custo financeiro" da Gemini Developer API.

• Vertex AI Gemini API

  • gemini-live-2.5-flash-native-audio (lançado em dezembro de 2025)
  • gemini-live-2.5-flash-preview-native-audio-09-2025

  Ao usar o Vertex AI Gemini API, os modelos Live API não são compatíveis com o local global.

Transmitir entrada e saída de áudio

Clique no seu provedor de Gemini API para conferir o conteúdo e o código específicos do provedor nesta página. API Gemini Developer API Gemini da Vertex AI

O exemplo a seguir mostra a implementação básica para enviar áudio de entrada transmitido e receber áudio de saída transmitido.

Para mais opções e recursos do Live API, consulte a seção "O que mais você pode fazer?" mais adiante nesta página.

Swift

Para usar o Live API, crie uma instância LiveModel e defina a modalidade de resposta como audio.

import FirebaseAILogic

// Initialize the Gemini Developer API backend service
// Create a `liveModel` instance with a model that supports the Live API
let liveModel = FirebaseAI.firebaseAI(backend: .googleAI()).liveModel(
  modelName: "gemini-2.5-flash-native-audio-preview-12-2025",
  // Configure the model to respond with audio
  generationConfig: LiveGenerationConfig(
    responseModalities: [.audio]
  )
)

do {
  let session = try await liveModel.connect()

  // Load the audio file, or tap a microphone
  guard let audioFile = NSDataAsset(name: "audio.pcm") else {
    fatalError("Failed to load audio file")
  }

  // Provide the audio data
  await session.sendAudioRealtime(audioFile.data)

  var outputText = ""
  for try await message in session.responses {
    if case let .content(content) = message.payload {
      content.modelTurn?.parts.forEach { part in
        if let part = part as? InlineDataPart, part.mimeType.starts(with: "audio/pcm") {
          // Handle 16bit pcm audio data at 24khz
          playAudio(part.data)
        }
      }
      // Optional: if you don't require to send more requests.
      if content.isTurnComplete {
        await session.close()
      }
    }
  }
} catch {
  fatalError(error.localizedDescription)
}

Kotlin

Para usar o Live API, crie uma instância LiveModel e defina a modalidade de resposta como AUDIO.

// Initialize the Gemini Developer API backend service
// Create a `liveModel` instance with a model that supports the Live API
val liveModel = Firebase.ai(backend = GenerativeBackend.googleAI()).liveModel(
    modelName = "gemini-2.5-flash-native-audio-preview-12-2025",
    // Configure the model to respond with audio
    generationConfig = liveGenerationConfig {
        responseModality = ResponseModality.AUDIO
   }
)

val session = liveModel.connect()

// This is the recommended approach.
// However, you can create your own recorder and handle the stream.
session.startAudioConversation()

Java

Para usar o Live API, crie uma instância LiveModel e defina a modalidade de resposta como AUDIO.

ExecutorService executor = Executors.newFixedThreadPool(1);
// Initialize the Gemini Developer API backend service
// Create a `liveModel` instance with a model that supports the Live API
LiveGenerativeModel lm = FirebaseAI.getInstance(GenerativeBackend.googleAI()).liveModel(
        "gemini-2.5-flash-native-audio-preview-12-2025",
        // Configure the model to respond with audio
        new LiveGenerationConfig.Builder()
                .setResponseModality(ResponseModality.AUDIO)
                .build()
);
LiveModelFutures liveModel = LiveModelFutures.from(lm);

ListenableFuture<LiveSession> sessionFuture =  liveModel.connect();

Futures.addCallback(sessionFuture, new FutureCallback<LiveSession>() {
    @Override
    public void onSuccess(LiveSession ses) {
	 LiveSessionFutures session = LiveSessionFutures.from(ses);
        session.startAudioConversation();
    }
    @Override
    public void onFailure(Throwable t) {
        // Handle exceptions
    }
}, executor);

Web

Para usar o Live API, crie uma instância LiveGenerativeModel e defina a modalidade de resposta como AUDIO.

import { initializeApp } from "firebase/app";
import { getAI, getLiveGenerativeModel, GoogleAIBackend, ResponseModality } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `LiveGenerativeModel` instance with a model that supports the Live API
const liveModel = getLiveGenerativeModel(ai, {
  model: "gemini-2.5-flash-native-audio-preview-12-2025",
  // Configure the model to respond with audio
  generationConfig: {
    responseModalities: [ResponseModality.AUDIO],
  },
});

const session = await liveModel.connect();

// Start the audio conversation
const audioConversationController = await startAudioConversation(session);

// ... Later, to stop the audio conversation
// await audioConversationController.stop()

Dart

Para usar o Live API, crie uma instância de LiveGenerativeModel e defina a modalidade de resposta como audio.

import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';
import 'package:your_audio_recorder_package/your_audio_recorder_package.dart';

late LiveModelSession _session;
final _audioRecorder = YourAudioRecorder();

await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `liveGenerativeModel` instance with a model that supports the Live API
final liveModel = FirebaseAI.googleAI().liveGenerativeModel(
  model: 'gemini-2.5-flash-native-audio-preview-12-2025',
  // Configure the model to respond with audio
  liveGenerationConfig: LiveGenerationConfig(
    responseModalities: [ResponseModalities.audio],
  ),
);

_session = await liveModel.connect();

final audioRecordStream = _audioRecorder.startRecordingStream();
// Map the Uint8List stream to InlineDataPart stream
final mediaChunkStream = audioRecordStream.map((data) {
  return InlineDataPart('audio/pcm', data);
});
await _session.startMediaStream(mediaChunkStream);

// In a separate thread, receive the audio response from the model
await for (final message in _session.receive()) {
   // Process the received message
}

Unity

Para usar o Live API, crie uma instância LiveModel e defina a modalidade de resposta como Audio.

using Firebase;
using Firebase.AI;

async Task SendTextReceiveAudio() {
  // Initialize the Gemini Developer API backend service
  // Create a `LiveModel` instance with a model that supports the Live API
  var liveModel = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI()).GetLiveModel(
      modelName: "gemini-2.5-flash-native-audio-preview-12-2025",
      // Configure the model to respond with audio
      liveGenerationConfig: new LiveGenerationConfig(
          responseModalities: new[] { ResponseModality.Audio })
    );

  LiveSession session = await liveModel.ConnectAsync();

  // Start a coroutine to send audio from the Microphone
  var recordingCoroutine = StartCoroutine(SendAudio(session));

  // Start receiving the response
  await ReceiveAudio(session);
}

IEnumerator SendAudio(LiveSession liveSession) {
  string microphoneDeviceName = null;
  int recordingFrequency = 16000;
  int recordingBufferSeconds = 2;

  var recordingClip = Microphone.Start(microphoneDeviceName, true,
                                       recordingBufferSeconds, recordingFrequency);

  int lastSamplePosition = 0;
  while (true) {
    if (!Microphone.IsRecording(microphoneDeviceName)) {
      yield break;
    }

    int currentSamplePosition = Microphone.GetPosition(microphoneDeviceName);

    if (currentSamplePosition != lastSamplePosition) {
      // The Microphone uses a circular buffer, so we need to check if the
      // current position wrapped around to the beginning, and handle it
      // accordingly.
      int sampleCount;
      if (currentSamplePosition > lastSamplePosition) {
        sampleCount = currentSamplePosition - lastSamplePosition;
      } else {
        sampleCount = recordingClip.samples - lastSamplePosition + currentSamplePosition;
      }

      if (sampleCount > 0) {
        // Get the audio chunk
        float[] samples = new float[sampleCount];
        recordingClip.GetData(samples, lastSamplePosition);

        // Send the data, discarding the resulting Task to avoid the warning
        _ = liveSession.SendAudioAsync(samples);

        lastSamplePosition = currentSamplePosition;
      }
    }

    // Wait for a short delay before reading the next sample from the Microphone
    const float MicrophoneReadDelay = 0.5f;
    yield return new WaitForSeconds(MicrophoneReadDelay);
  }
}

Queue audioBuffer = new();

async Task ReceiveAudio(LiveSession liveSession) {
  int sampleRate = 24000;
  int channelCount = 1;

  // Create a looping AudioClip to fill with the received audio data
  int bufferSamples = (int)(sampleRate * channelCount);
  AudioClip clip = AudioClip.Create("StreamingPCM", bufferSamples, channelCount,
                                    sampleRate, true, OnAudioRead);

  // Attach the clip to an AudioSource and start playing it
  AudioSource audioSource = GetComponent();
  audioSource.clip = clip;
  audioSource.loop = true;
  audioSource.Play();

  // Start receiving the response
  await foreach (var message in liveSession.ReceiveAsync()) {
    // Process the received message
    foreach (float[] pcmData in message.AudioAsFloat) {
      lock (audioBuffer) {
        foreach (float sample in pcmData) {
          audioBuffer.Enqueue(sample);
        }
      }
    }
  }
}

// This method is called by the AudioClip to load audio data.
private void OnAudioRead(float[] data) {
  int samplesToProvide = data.Length;
  int samplesProvided = 0;

  lock(audioBuffer) {
    while (samplesProvided < samplesToProvide && audioBuffer.Count > 0) {
      data[samplesProvided] = audioBuffer.Dequeue();
      samplesProvided++;
    }
  }

  while (samplesProvided < samplesToProvide) {
    data[samplesProvided] = 0.0f;
    samplesProvided++;
  }
}

---

Preços e contagem de tokens

Você pode encontrar informações de preços para os modelos Live API na documentação do provedor Gemini API escolhido: Gemini Developer API | Vertex AI Gemini API.

Independente do seu provedor de Gemini API, o Live API não é compatível com a API Count Tokens.

Observação: o Firebase AI Logic ainda não aceita o recebimento de UsageMetadata na resposta.

---

O que mais você sabe fazer?

• Confira o conjunto completo de recursos do Live API, como streaming de várias modalidades de entrada (áudio, texto ou vídeo + áudio).

• Personalize sua implementação usando várias opções de configuração, como adicionar transcrição ou definir a voz da resposta.

• Turbine sua implementação dando ao modelo acesso a ferramentas, como chamadas de função e embasamento com a Pesquisa Google. A documentação oficial sobre como usar ferramentas com o Live API será lançada em breve.

• Saiba mais sobre os limites e especificações para usar o Live API, como duração da sessão, limites de taxa, idiomas compatíveis etc.