Analisar arquivos de áudio usando a API Gemini

Você pode pedir a um Gemini modelo para analisar arquivos de áudio que você fornece inline (codificados em base64) ou por URL. Ao usar Firebase AI Logic, você pode fazer essa solicitação diretamente do seu app.

Com essa capacidade, você pode fazer coisas como:

  • Descrever, resumir ou responder a perguntas sobre conteúdo de áudio
  • Transcrever conteúdo de áudio
  • Analisar segmentos específicos de áudio usando carimbos de data/hora

Pular para exemplos de código Pular para código de respostas transmitidas


Consulte outros guias para mais opções de trabalho com áudio
Gerar saída estruturada Conversa multiturno Transmissão bidirecional

Antes de começar

Clique no seu provedor Gemini API para conferir o conteúdo específico do provedor e o código nesta página.

Se ainda não fez isso, conclua o guia de iniciação, 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 de GenerativeModel.

Para testar e iterar seus comandos, recomendamos o uso do Google AI Studio.

Gerar texto de arquivos de áudio (codificados em base64)

Antes de testar este exemplo, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, você também vai clicar em um botão para o provedor Gemini API escolhido para que o conteúdo específico do provedor seja exibido nesta página.

Você pode pedir a um modelo Gemini para gerar texto usando texto e áudio, fornecendo o mimeType do arquivo de entrada e o próprio arquivo. Encontre requisitos e recomendações para arquivos de entrada mais adiante nesta página.

Swift

Você pode chamar generateContent() para gerar texto de entrada multimodal de texto e um único arquivo de áudio.


import FirebaseAILogic

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-3-flash-preview")


// Provide the audio as `Data`
guard let audioData = try? Data(contentsOf: audioURL) else {
    print("Error loading audio data.")
    return // Or handle the error appropriately
}

// Specify the appropriate audio MIME type
let audio = InlineDataPart(data: audioData, mimeType: "audio/mpeg")


// Provide a text prompt to include with the audio
let prompt = "Transcribe what's said in this audio recording."

// To generate text output, call `generateContent` with the audio and text prompt
let response = try await model.generateContent(audio, prompt)

// Print the generated text, handling the case where it might be nil
print(response.text ?? "No text in response.")

Kotlin

Você pode chamar generateContent() para gerar texto de entrada multimodal de texto e um único arquivo de áudio.

Para Kotlin, os métodos nesse SDK são funções de suspensão e precisam ser chamados de um escopo de corrotina. 

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-3-flash-preview")


val contentResolver = applicationContext.contentResolver

val inputStream = contentResolver.openInputStream(audioUri)

if (inputStream != null) {  // Check if the audio loaded successfully
    inputStream.use { stream ->
        val bytes = stream.readBytes()

        // Provide a prompt that includes the audio specified above and text
        val prompt = content {
            inlineData(bytes, "audio/mpeg")  // Specify the appropriate audio MIME type
            text("Transcribe what's said in this audio recording.")
        }

        // To generate text output, call `generateContent` with the prompt
        val response = model.generateContent(prompt)

        // Log the generated text, handling the case where it might be null
        Log.d(TAG, response.text?: "")
    }
} else {
    Log.e(TAG, "Error getting input stream for audio.")
    // Handle the error appropriately
}

Java

Você pode chamar generateContent() para gerar texto de entrada multimodal de texto e um único arquivo de áudio.

Para Java, os métodos nesse SDK retornam um ListenableFuture. 

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-3-flash-preview");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


ContentResolver resolver = getApplicationContext().getContentResolver();

try (InputStream stream = resolver.openInputStream(audioUri)) {
    File audioFile = new File(new URI(audioUri.toString()));
    int audioSize = (int) audioFile.length();
    byte audioBytes = new byte[audioSize];
    if (stream != null) {
        stream.read(audioBytes, 0, audioBytes.length);
        stream.close();

        // Provide a prompt that includes the audio specified above and text
        Content prompt = new Content.Builder()
              .addInlineData(audioBytes, "audio/mpeg")  // Specify the appropriate audio MIME type
              .addText("Transcribe what's said in this audio recording.")
              .build();

        // To generate text output, call `generateContent` with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String text = result.getText();
                Log.d(TAG, (text == null) ? "" : text);
            }
            @Override
            public void onFailure(Throwable t) {
                Log.e(TAG, "Failed to generate a response", t);
            }
        }, executor);
    } else {
        Log.e(TAG, "Error getting input stream for file.");
        // Handle the error appropriately
    }
} catch (IOException e) {
    Log.e(TAG, "Failed to read the audio file", e);
} catch (URISyntaxException e) {
    Log.e(TAG, "Invalid audio file", e);
}

Web

Você pode chamar generateContent() para gerar texto de entrada multimodal de texto e um único arquivo de áudio.


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } 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 `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-3-flash-preview" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(','));
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the audio
  const prompt = "Transcribe what's said in this audio recording.";

  // Prepare audio for input
  const fileInputEl = document.querySelector("input[type=file]");
  const audioPart = await fileToGenerativePart(fileInputEl.files);

  // To generate text output, call `generateContent` with the text and audio
  const result = await model.generateContent([prompt, audioPart]);

  // Log the generated text, handling the case where it might be undefined
  console.log(result.response.text() ?? "No text in response.");
}

run();

Dart

Você pode chamar generateContent() para gerar texto de entrada multimodal de texto e um único arquivo de áudio.


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

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

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-3-flash-preview');


// Provide a text prompt to include with the audio
final prompt = TextPart("Transcribe what's said in this audio recording.");

// Prepare audio for input
final audio = await File('audio0.mp3').readAsBytes();

// Provide the audio as `Data` with the appropriate audio MIME type
final audioPart = InlineDataPart('audio/mpeg', audio);

// To generate text output, call `generateContent` with the text and audio
final response = await model.generateContent([
  Content.multi([prompt,audioPart])
]);

// Print the generated text
print(response.text);

Unity

Você pode chamar GenerateContentAsync() para gerar texto de entrada multimodal de texto e um único arquivo de áudio.


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-3-flash-preview");


// Provide a text prompt to include with the audio
var prompt = ModelContent.Text("Transcribe what's said in this audio recording.");

// Provide the audio as `data` with the appropriate audio MIME type
var audio = ModelContent.InlineData("audio/mpeg",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
        UnityEngine.Application.streamingAssetsPath, "audio0.mp3")));

// To generate text output, call `GenerateContentAsync` with the text and audio
var response = await model.GenerateContentAsync(new [] { prompt, audio });

// Print the generated text
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Saiba como escolher um modelo adequado para seu caso de uso e app.

Transmitir a resposta

Antes de testar este exemplo, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, você também vai clicar em um botão para o provedor Gemini API escolhido para que o conteúdo específico do provedor seja exibido nesta página.

Você pode conseguir interações mais rápidas sem esperar o resultado completo da geração do modelo e, em vez disso, usar a transmissão para processar resultados parciais. Para transmitir a resposta, chame generateContentStream.


Requisitos e recomendações para arquivos de áudio de entrada

Um arquivo fornecido como dados inline é codificado em base64 em trânsito, o que aumenta o tamanho da solicitação. Você recebe um erro HTTP 413 se uma solicitação for muito grande.

Consulte a página "Arquivos de entrada e requisitos com suporte" para saber mais detalhes sobre o seguinte:

Tipos MIME de áudio com suporte

Gemini modelos multimodais são compatíveis com os seguintes tipos MIME de áudio:

  • AAC - audio/aac
  • FLAC - audio/flac
  • MP3 - audio/mp3
  • MPA - audio/m4a
  • MPEG - audio/mpeg
  • MPGA - audio/mpga
  • MP4 - audio/mp4
  • OPUS - audio/opus
  • PCM - audio/pcm
  • WAV - audio/wav
  • WEBM - audio/webm

Limites por solicitação

Número máximo de arquivos por solicitação: 1 arquivo de áudio


O que mais você pode fazer?

Testar outros recursos

Saiba como controlar a geração de conteúdo

Você também pode testar comandos e configurações de modelo e até mesmo receber um snippet de código gerado usando Google AI Studio.

Saiba mais sobre os modelos com suporte

Saiba mais sobre os modelos disponíveis para vários casos de uso e as cotas e preços deles.


Envie feedback sobre sua experiência com Firebase AI Logic