The latest Gemini models, like Gemini 3.1 Flash Image (Nano Banana 2), are available to use with Firebase AI Logic! Learn more.

Gemini 2.0 Flash and Flash-Lite models will shut down on June 1, 2026. To avoid service disruption, update to a newer model like gemini-2.5-flash-lite. Learn more.

All Imagen models will shut down on June 24, 2026. Learn about migrating your apps to use Nano Banana.

Audiodateien mit der Gemini API analysieren

Sie können ein Gemini Modell bitten, Audiodateien zu analysieren, die Sie bereitstellen entweder inline (base64-codiert) oder über eine URL. Wenn Sie Firebase AI Logic, verwenden, können Sie diese Anfrage direkt aus Ihrer App stellen.

Mit dieser Funktion können Sie beispielsweise Folgendes tun:

Audioinhalte beschreiben, zusammenfassen oder Fragen dazu beantworten
Audioinhalte transkribieren
Bestimmte Audiosegmente mithilfe von Zeitstempeln analysieren

Zu den Codebeispielen springen Zum Code für gestreamte Antworten springen

Weitere Anleitungen mit zusätzlichen Optionen für die Arbeit mit Audio
Strukturierte Ausgabe generieren Wechselseitiger Chat Bidirektionales Streaming

Hinweis

Klicken Sie auf Ihren Gemini API Anbieter, um anbieterspezifische Inhalte und Code auf dieser Seite aufzurufen.

Wenn Sie es noch nicht getan haben, folgen Sie der Anleitung für den Einstieg. Dort wird beschrieben, wie Sie Ihr Firebase-Projekt einrichten, Ihre App mit Firebase verbinden, das SDK hinzufügen, den Back-End-Dienst für Ihren ausgewählten Gemini API Anbieter initialisieren und eine GenerativeModel Instanz erstellen.

Zum Testen und Iterieren Ihrer Prompts empfehlen wir Google AI Studio.

Benötigen Sie eine Beispiel-Audiodatei?

Sie können diese öffentlich verfügbare Datei mit dem MIME-Typ audio/mp3 (Datei ansehen oder herunterladen) verwenden. https://storage.googleapis.com/cloud-samples-data/generative-ai/audio/pixel.mp3

Text aus Audiodateien generieren (base64-codiert)

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Hinweis dieser Anleitung aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für Ihren ausgewählten Gemini API Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden..

Sie können ein Gemini Modell bitten, Text zu generieren, indem Sie Text und Audio als Prompt verwenden. Dazu müssen Sie den `mimeType` der Eingabedatei mimeType und die Datei selbst angeben. Anforderungen und Empfehlungen für Eingabedateien finden Sie weiter unten auf dieser Seite.

Swift

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu generieren.


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

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu generieren.

^{In Kotlin sind die Methoden in diesem SDK Suspend-Funktionen, die aus einem Coroutine-Bereich aufgerufen werden müssen.}


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

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu generieren.

^{In Java geben die Methoden in diesem SDK ein
ListenableFuture zurück.}


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

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu generieren.


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

Sie können generateContent() aufrufen, um Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu generieren.


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

Einheit

Sie können GenerateContentAsync() aufrufen, um Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu generieren.


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

Informationen zum Auswählen eines Modells , der für Ihren Anwendungsfall und Ihre App geeignet ist

Antwort streamen

Bevor Sie dieses Beispiel ausprobieren, führen Sie die Schritte im Abschnitt Hinweis dieser Anleitung aus, um Ihr Projekt und Ihre App einzurichten.
In diesem Abschnitt klicken Sie auch auf eine Schaltfläche für Ihren ausgewählten Gemini API Anbieter, damit auf dieser Seite anbieterspezifische Inhalte angezeigt werden..

Sie können schnellere Interaktionen erzielen, indem Sie nicht auf das gesamte Ergebnis der Modellgenerierung warten, sondern Streaming verwenden, um Teilergebnisse zu verarbeiten. Rufen Sie generateContentStream auf, um die Antwort zu streamen.

Beispiel ansehen: Generierten Text aus Audiodateien streamen

Swift

Sie können generateContentStream() aufrufen, um generierten Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu streamen.


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

Sie können generateContentStream() aufrufen, um generierten Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu streamen.

^{In Kotlin sind die Methoden in diesem SDK Suspend-Funktionen, die aus einem Coroutine-Bereich aufgerufen werden müssen.}


// 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 stream generated text output, call `generateContentStream` with the prompt
        var fullResponse = ""
        model.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

Sie können generateContentStream() aufrufen, um generierten Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu streamen.

^{In Java geben die Streaming-Methoden in diesem SDK einen
Publisher Typ aus der Reactive Streams-Bibliothek zurück.}


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

Sie können generateContentStream() aufrufen, um generierten Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu streamen.


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

Sie können generateContentStream() generierten Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei streamen.


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

Einheit

Sie können GenerateContentStreamAsync() aufrufen, um generierten Text aus multimodalen Eingaben von Text und einer einzelnen Audiodatei zu streamen.


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

Informationen zum Auswählen eines Modells , der für Ihren Anwendungsfall und Ihre App geeignet ist

Anforderungen und Empfehlungen für Audio-Eingabedateien

Eine als Inline-Daten bereitgestellte Datei wird bei der Übertragung in base64 codiert, wodurch die Größe der Anfrage zunimmt. Wenn eine Anfrage zu groß ist, erhalten Sie einen HTTP-Fehler 413.

Auf der Seite Unterstützte Eingabedateien und Anforderungen finden Sie detaillierte Informationen zu folgenden Themen:

Verschiedene Optionen zum Bereitstellen einer Datei in einer Anfrage (entweder inline oder über die URL oder den URI der Datei)
Anforderungen und Best Practices für Audiodateien

Unterstützte Audio-MIME-Typen

Gemini Multimodale Modelle unterstützen die folgenden Audio-MIME-Typen:

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

Limits pro Anfrage

Maximale Anzahl von Dateien pro Anfrage: 1 Audiodatei

Was kannst du sonst noch alles für mich tun?

Informationen zum Zählen von Tokens, bevor Sie lange Prompts an das Modell senden
Einrichten Cloud Storage for Firebase , damit Sie große Dateien in Ihre multimodalen Anfragen einbeziehen können und eine besser verwaltete Lösung für die Bereitstellung von Dateien in Prompts haben Dateien können Bilder, PDFs, Videos und Audio enthalten.
Beginnen Sie mit der Vorbereitung auf die Produktion (siehe die Checkliste für die Produktion):
- Richten Sie Firebase App Check so früh wie möglich ein, um die Gemini API vor Missbrauch durch nicht autorisierte Clients zu schützen.
- Integrieren Firebase Remote Config Sie, um Werte in Ihrer App (z. B. den Modellnamen) zu aktualisieren, ohne eine neue App -Version zu veröffentlichen.

Andere Funktionen ausprobieren

Wechselseitige Unterhaltungen (Chat) erstellen.
Text aus Prompts generieren, die nur Text enthalten.
Strukturierte Ausgaben (z. B. JSON) generieren aus Text- und multimodalen Prompts
Bilder aus Text- und multimodalen Prompts generieren und bearbeiten.
Eingaben und Ausgaben (einschließlich Audio) mit der Gemini Live API streamen.
Tools wie Funktionsaufrufe und Fundierung mit der Google Suche) verwenden, um ein Gemini Modell mit anderen Teilen Ihrer App sowie mit externen Systemen und Informationen zu verbinden

Informationen zum Steuern der Content-Generierung

Informationen zum Prompt-Design, einschließlich Best Practices, Strategien und Beispiel-Prompts
Modellparameter konfigurieren wie Temperatur und maximale Anzahl von Ausgabetokens.
Sicherheitseinstellungen verwenden, um die Wahrscheinlichkeit zu steuern , Antworten zu erhalten, die als schädlich angesehen werden könnten

Mit Google AI Studio können Sie auch mit Prompts und Modellkonfigurationen experimentieren und sogar ein generiertes Code-Snippet erhalten. Google AI Studio

Weitere Informationen zu den unterstützten Modellen

Informationen zu den für verschiedene Anwendungsfälle verfügbaren Modellen sowie zu ihren Kontingenten und Preisen.

Feedback geben zu Ihren Erfahrungen mit Firebase AI Logic

Sofern nicht anders angegeben, sind die Inhalte dieser Seite unter der Creative Commons Attribution 4.0 License und Codebeispiele unter der Apache 2.0 License lizenziert. Weitere Informationen finden Sie in den Websiterichtlinien von Google Developers. Java ist eine eingetragene Marke von Oracle und/oder seinen Partnern.

Zuletzt aktualisiert: 2026-04-15 (UTC).