Se usó la API de Cloud Translation para traducir esta página.

Cómo analizar archivos de audio con la API de Gemini

Puedes pedirle a un modelo de Gemini que analice los archivos de audio que proporciones de forma intercalada (codificados en base64) o a través de una URL. Cuando usas Firebase AI Logic, puedes realizar esta solicitud directamente desde tu app.

Con esta capacidad, puedes hacer lo siguiente:

Describir, resumir o responder preguntas sobre el contenido de audio
Transcribe contenido de audio
Analiza segmentos específicos de audio con marcas de tiempo

Ir a muestras de código Ir al código de respuestas transmitidas

Consulta otras guías para obtener más opciones para trabajar con audio
Genera resultados estructurados Chat de varios turnos Transmisión bidireccional

Antes de comenzar

Haz clic en tu proveedor de Gemini API para ver el contenido y el código específicos del proveedor en esta página.

Si aún no lo has hecho, completa la guía de introducción, en la que se describe cómo configurar tu proyecto de Firebase, conectar tu app a Firebase, agregar el SDK, inicializar el servicio de backend para el proveedor de Gemini API que elijas y crear una instancia de GenerativeModel.

Para probar y, luego, iterar tus instrucciones, e incluso obtener un fragmento de código generado, te recomendamos usar Google AI Studio.

¿Necesitas un archivo de audio de muestra?

Puedes usar este archivo disponible públicamente con un tipo de MIME de audio/mp3 (ver o descargar archivo). https://storage.googleapis.com/cloud-samples-data/generative-ai/audio/pixel.mp3

Genera texto a partir de archivos de audio (codificados en Base64)

Antes de probar esta muestra, completa la sección Antes de comenzar de esta guía para configurar tu proyecto y tu app.
En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página.

Puedes pedirle a un modelo Gemini que genere texto con instrucciones de texto y audio, proporcionando el mimeType del archivo de entrada y el archivo en sí. Más adelante en esta página, encontrarás los requisitos y las recomendaciones para los archivos de entrada.

Swift

Puedes llamar a generateContent() para generar texto a partir de una entrada multimodal de texto y un solo archivo de audio.


import FirebaseAI

// 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-2.5-flash")


// 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

Puedes llamar a generateContent() para generar texto a partir de una entrada multimodal de texto y un solo archivo de audio.

^{En Kotlin, los métodos de este SDK son funciones de suspensión y deben llamarse desde un alcance de corrutina.}


// 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-2.5-flash")


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 = generativeModel.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

Puedes llamar a generateContent() para generar texto a partir de una entrada multimodal de texto y un solo archivo de audio.

^{En Java, los métodos de este SDK devuelven un 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-2.5-flash");

// 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

Puedes llamar a generateContent() para generar texto a partir de una entrada multimodal de texto y un solo archivo de audio.


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-2.5-flash" });


// 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

Puedes llamar a generateContent() para generar texto a partir de una entrada multimodal de texto y un solo archivo de audio.


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-2.5-flash');


// 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

Puedes llamar a GenerateContentAsync() para generar texto a partir de una entrada multimodal de texto y un solo archivo de audio.


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-2.5-flash");


// 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.");

Aprende a elegir un modelo adecuados para tu caso de uso y tu app.

Transmite la respuesta

Antes de probar esta muestra, completa la sección Antes de comenzar de esta guía para configurar tu proyecto y tu app.
En esa sección, también harás clic en un botón para el proveedor de Gemini API que elijas, de modo que veas contenido específico del proveedor en esta página.

Puedes lograr interacciones más rápidas sin esperar el resultado completo de la generación del modelo y, en cambio, usar la transmisión para controlar los resultados parciales. Para transmitir la respuesta, llama a generateContentStream.

Ver ejemplo: Transmite texto generado a partir de archivos de audio

Swift

Puedes llamar a generateContentStream() para transmitir texto generado a partir de la entrada multimodal de texto y un solo archivo de audio.


import FirebaseAI

// 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-2.5-flash")


// 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 stream generated text output, call `generateContentStream` with the audio and text prompt
let contentStream = try model.generateContentStream(audio, prompt)

// Print the generated text, handling the case where it might be nil
for try await chunk in contentStream {
    if let text = chunk.text {
        print(text)
    }
}

Kotlin

Puedes llamar a generateContentStream() para transmitir texto generado a partir de la entrada multimodal de texto y un solo archivo de audio.

^{En Kotlin, los métodos de este SDK son funciones de suspensión y deben llamarse desde un alcance de corrutina.}


// 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-2.5-flash")


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 stream generated text output, call `generateContentStream` with the prompt
        var fullResponse = ""
        generativeModel.generateContentStream(prompt).collect { chunk ->
            // Log the generated text, handling the case where it might be null
            Log.d(TAG, chunk.text?: "")
            fullResponse += chunk.text?: ""
        }
    }
} else {
    Log.e(TAG, "Error getting input stream for audio.")
    // Handle the error appropriately
}

Java

Puedes llamar a generateContentStream() para transmitir texto generado a partir de la entrada multimodal de texto y un solo archivo de audio.

^{En Java, los métodos de transmisión de este SDK devuelven un tipo Publisher de la biblioteca de Reactive Streams.}


// 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-2.5-flash");

// 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 stream generated text output, call `generateContentStream` with the prompt
        Publisher<GenerateContentResponse> streamingResponse =
                model.generateContentStream(prompt);

        StringBuilder fullResponse = new StringBuilder();
        streamingResponse.subscribe(new Subscriber<GenerateContentResponse>() {
            @Override
            public void onNext(GenerateContentResponse generateContentResponse) {
                String chunk = generateContentResponse.getText();
                String text = (chunk == null) ? "" : chunk;
                Log.d(TAG, text);
                fullResponse.append(text);
            }
            @Override
            public void onComplete() {
                Log.d(TAG, fullResponse.toString());
            }
            @Override
            public void onError(Throwable t) {
                Log.e(TAG, "Failed to generate a response", t);
            }
            @Override
            public void onSubscribe(Subscription s) {
            }
         });
    } 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

Puedes llamar a generateContentStream() para transmitir texto generado a partir de la entrada multimodal de texto y un solo archivo de audio.


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-2.5-flash" });


// 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 stream generated text output, call `generateContentStream` with the text and audio
  const result = await model.generateContentStream([prompt, audioPart]);

  // Log the generated text
  for await (const chunk of result.stream) {
    const chunkText = chunk.text();
    console.log(chunkText);
  }
}

run();

Dart

Puedes llamar a generateContentStream() para transmitir texto generado a partir de una entrada multimodal de texto y un solo archivo de audio.


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-2.5-flash');


// 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 stream generated text output, call `generateContentStream` with the text and audio
final response = await model.generateContentStream([
  Content.multi([prompt, audioPart])
]);

// Print the generated text
await for (final chunk in response) {
  print(chunk.text);
}

Unity

Puedes llamar a GenerateContentStreamAsync() para transmitir texto generado a partir de la entrada multimodal de texto y un solo archivo de audio.


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-2.5-flash");


// 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 stream generated text output, call `GenerateContentStreamAsync` with the text and audio
var responseStream = model.GenerateContentStreamAsync(new [] { prompt, audio });

// Print the generated text
await foreach (var response in responseStream) {
  if (!string.IsNullOrWhiteSpace(response.Text)) {
    UnityEngine.Debug.Log(response.Text);
  }
}

Aprende a elegir un modelo adecuados para tu caso de uso y tu app.

Requisitos y recomendaciones para los archivos de audio de entrada

Ten en cuenta que un archivo proporcionado como datos intercalados se codifica en base64 durante la transmisión, lo que aumenta el tamaño de la solicitud. Recibirás un error HTTP 413 si una solicitud es demasiado grande.

Consulta "Archivos de entrada y requisitos compatibles para Vertex AI Gemini API" para obtener información detallada sobre lo siguiente:

Diferentes opciones para proporcionar un archivo en una solicitud (ya sea de forma intercalada o con la URL o el URI del archivo)
Requisitos y prácticas recomendadas para los archivos de audio

Tipos de MIME de audio admitidos

Los modelos multimodales de Gemini admiten los siguientes tipos de MIME de audio:

Tipo de MIME de audio	Gemini 2.0 Flash	Gemini 2.0 Flash‑Lite
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`

Límites por solicitud

Puedes incluir un máximo de 1 archivo de audio en una solicitud de instrucción.

¿Qué más puedes hacer?

Aprende a contar tokens antes de enviar instrucciones largas al modelo.
Configura Cloud Storage for Firebase para poder incluir archivos grandes en tus solicitudes multimodales y tener una solución más administrada para proporcionar archivos en las instrucciones. Los archivos pueden incluir imágenes, PDFs, videos y audio.
Comienza a pensar en la preparación para la producción (consulta la lista de tareas de producción), que incluye lo siguiente:
- Configura Firebase App Check para proteger Gemini API contra el abuso de clientes no autorizados.
- Integra Firebase Remote Config para actualizar valores en tu app (como el nombre del modelo) sin lanzar una nueva versión de la app.

Prueba otras capacidades

Crea conversaciones de varios turnos (chat).
Generar texto a partir de instrucciones solo de texto
Genera resultados estructurados (como JSON) a partir de instrucciones tanto de texto como multimodales.
Generar imágenes a partir de instrucciones de texto (Gemini o Imagen)
Usa la llamada a función para conectar modelos generativos a sistemas e información externos.

Más información para controlar la generación de contenido

Comprende el diseño de instrucciones, incluidas las prácticas recomendadas, las estrategias y los ejemplos de instrucciones.
Configura los parámetros del modelo, como la temperatura y la cantidad máxima de tokens de salida (para Gemini) o la relación de aspecto y la generación de personas (para Imagen).
Usar la configuración de seguridad para ajustar la probabilidad de obtener respuestas que se puedan considerar dañinas

También puedes experimentar con instrucciones y configuraciones del modelo, y hasta obtener un fragmento de código generado con Google AI Studio.

Más información sobre los modelos compatibles

Obtén información sobre los modelos disponibles para diversos casos de uso, sus cuotas y sus precios.

Envía comentarios sobre tu experiencia con Firebase AI Logic

Salvo que se indique lo contrario, el contenido de esta página está sujeto a la licencia Atribución 4.0 de Creative Commons, y los ejemplos de código están sujetos a la licencia Apache 2.0. Para obtener más información, consulta las políticas del sitio de Google Developers. Java es una marca registrada de Oracle o sus afiliados.

Última actualización: 2025-07-09 (UTC)