FAQ and troubleshooting

Differences between using the Gemini Developer API and the Agent Platform Gemini API (formerly Vertex AI)

The following table lists important differences between the two "Gemini API" providers in general regardless of how you access them:

¹ The two API providers have different pay-as-you-go pricing (learn more in their respective documentation).

² The Files API for the Gemini Developer API is not supported through the Firebase AI Logic SDKs.

The following table lists the availability of commonly asked about features for the two "Gemini API" providers. This table applies specifically when using the Firebase AI Logic client SDKs.

How to use both the Gemini Developer API and the Agent Platform Gemini API (formerly Vertex AI)

You can have both Gemini API providers enabled in your Firebase project, and you can use both APIs in your app itself.

To switch between API providers in your code, just make sure that you've set the backend service appropriately in your code.

Required APIs and how to enable them

To use the Firebase AI Logic SDKs with the Gemini Developer API, your project must have the following two APIs enabled:

• Gemini Developer API (generativelanguage.googleapis.com)
• Firebase AI Logic API (firebasevertexai.googleapis.com)

You should enable these two APIs using the Firebase console:

1. In the Firebase console, go to AI Services > AI Logic.

2. Click Get started.

3. Select to get started with the Gemini Developer API.

   This launches a guided workflow that enables the two APIs for you. Firebase will also provision a Google-managed service account (P4SA) for authorizing use of the Gemini API, as well as add the Firebase AI Logic API to the allowlist for your Firebase API key.

How to disable APIs in a Firebase project

For Firebase AI Logic, we try to make setup of your Firebase project to use your chosen Gemini API provider as easy as possible. This includes enabling the required APIs in your Firebase project during specific journeys, like the guided workflow in the Firebase console.

However, if you decide to not use Firebase AI Logic or one of the Gemini API providers, you can disable the associated APIs in your Firebase project.

Required permissions to use Firebase AI Logic

Supported models when using Firebase AI Logic

See the list of supported models. We frequently add new capabilities to the SDKs, so check back on this FAQ for updates (as well as in release notes, blogs, and social posts).

• Firebase AI Logic supports the following models:

  • Gemini Developer API

    • Most of the Gemini foundation models

  • Agent Platform Gemini API (formerly Vertex AI)

    • Most of the Gemini foundation models

• Firebase AI Logic does not support the following models (regardless of your chosen Gemini API provider):

  • Fine-tuned models

  • Embedding models, Veo models, Lyria models, robotics models, computer use models, Gemini Omni models, or Gemini Cyber models

How to set a per-user rate limit

By default, Firebase AI Logic sets the request limit per user at 100 requests per minute (RPM).

If you want to adjust your per-user rate limit, you need to adjust the quota settings for the Firebase AI Logic API.

Learn more about the Firebase AI Logic API quota. On that page, you can also learn how to view and edit your quota.

How to reduce latency and high token usage

If you're experiencing high latency or high token usage, it's likely due to the thinking level configuration for the model you're using.

Gemini 3 and later models always use an internal "thinking process" that significantly improves their reasoning and multi-step planning abilities, making them highly effective for complex tasks such as coding, advanced mathematics, and data analysis.

However, depending on the task, higher levels of thinking aren't always needed, and you can configure the model to use a lower thinking level. A lower thinking level will help reduce latency and token usage. To help you decide how much a model might need its thinking capability, review the comparison of task difficulties.

Note that for most Gemini 3 and later models, the default thinking level is set to HIGH.

MIME type requirements for multimodal requests (like for images, PDFs, video, and audio input)

In each multimodal request, you must always provide the following:

• The file's mimeType. See an exception below.

• The file. You can either provide the file as inline data or provide the file using its URL.

Learn about supported input file types, how to specify MIME type, and the two options for providing the file in Supported input files and requirements.

Exception to including MIME type in your request

An exception to providing the MIME type is inline image inputs for requests from native Android and Apple platform apps.

The Firebase AI Logic SDKs for Android and Apple platforms provide a simplified and platform-friendly way to handle images in requests — all images (no matter their format) are converted client-side to JPEG at 80% quality before being sent to the server. This means that when you provide images as inline data using the Android and Apple platforms SDKs, you don't need to specify the MIME type in the request.

This simplified handling is shown in the Firebase AI Logic documentation in the examples for sending base64-encoded images in requests.

Here's some additional platform-specific information about this feature:

• For Android:

  • You can take advantage of the simplified way to handle platform-native image types (Bitmap) in multimodal prompts that contain images as inline data (see example).

  • For more control over image formats and conversions, you may provide the images as an InlineDataPart and supply the specific MIME type. For example:

    content { inlineData(/* PNG as byte array */, "image/png") }

• For Apple platforms:

  • You can take advantage of the simplified way to handle platform-native image types (UIImage, NSImage, CIImage, and CGImage) in multimodal prompts that contain images as inline data (see example).

  • For more control over image formats and conversions, you may provide the images as an InlineDataPart and supply the specific MIME type. For example:

    InlineDataPart(data: Data(/* PNG Data */), mimeType: "image/png")

Advanced features not-yet-available when using Firebase AI Logic: Grounding with Google Image Search, fine tuning a model, embeddings generation, and semantic retrieval

The following features are supported by various models and the API providers, but they are not available when using Firebase AI Logic:

• Grounding with Google Image Search
• Fine tuning a model
• Embeddings generation
• Semantic retrieval

If you would like to add these as feature requests or vote on an existing feature request, visit Firebase UserVoice.

Data usage for training models

See Data governance & Responsible AI.

Deprecated or shut down (retired) models - list and replacements

When Google releases a stable model version, we strive to keep it available for at minimum 12 months before we shut down (retire) the model.

However, be aware of the following:

• For the Agent Platform Gemini API (formerly Vertex AI), some stable models only have short-term availability, which means that they may be shut down (retired) as early as 45 days after a replacement model is released.

• For the Gemini Developer API, sometimes instead of shutting down a model, the service will automatically route the request to a newer model. Requests to the newer model are billed at the rates of the newer model.

• Several weeks before the shutdown date, projects that have no prior usage of a model will be blocked from starting to use it.

• When a stable version is released for a given model, all experimental and preview versions of that model will usually be shut down (retired) within a few days or weeks (this FAQ doesn't list every previous preview and experimental model).

General-use models

^{1 For the Agent Platform Gemini API (formerly Vertex AI), this is a "short-term availability model". See Model versioning and naming patterns}

^{All the following general-use models are also shutdown: gemini-1.0-pro, gemini-1.0-pro-001, gemini-1.0-pro-002, gemini-1.0-pro-vision, gemini-1.0-pro-vision-001 gemini-1.5-flash-001, gemini-1.5-flash, gemini-1.5-flash-002, gemini-1.5-pro-001, gemini-1.5-pro, gemini-1.5-pro-002}

Image-generating (Nano Banana and Imagen) models

Audio - Live API models

Changes required when models are deprecated or shut down (retired)

Where to find the shutdown date of a model?

Here are some ways you can find the shutdown date of a model:

• Google sends emails to appropriate project members.

• We post announcements and reminders about upcoming shutdowns in various channels:

  • Release notes (see example)
  • Page-level banners in the docs, the supported models page, and the deprecated and shutdown models FAQ

What to do if the model you're using is about to be shut down?

You need to make these changes before the shutdown date; otherwise, any requests to a shutdown model will fail with a 404 error.

1. Find a suitable currently supported model and its model name.

   We also provide recommended replacement models in the deprecated and shutdown models FAQ.

2. Update the model name used by your app.

   You set the model name during initialization when you create a GenerativeModel, LiveModel, or ImagenModel instance. Make sure to review the critical recommendation below about using Firebase Remote Config or server prompt templates.

3. Check if you need to update any of your code.

   You usually don't need to modify any of the code which actually calls the model. Here are some exceptions:

   • Unsupported sampling parameters: The latest Gemini 4.x and Gemini 3.x models, several parameters are unsupported (specifically temperature, top-K, top-P, frequency penalty, presence penalty, and candidate count).

   • Thinking level vs Thinking budget: Starting with Gemini 3.x models, you should use thinkingLevel instead of thinkingBudget (but thinkingBudget is still supported for backwards-compatibility). However, starting with Gemini 4.x models, thinkingBudget is not supported. Learn more about thinking.

   • Experiment with thinking level value: When you upgrade to a new generation (for example, 2.5 to 3.8) and you want to ensure the same performance and behavior (for example, latency), we recommend experimenting with setting the thinking level to a lower value. Learn more about thinking.

4. Test your app to ensure that responses are still as expected.

Changes required for the rebranding of "Vertex AI" to "Agent Platform"

In mid-2026, Google Cloud rebranded "Vertex AI" to "Gemini Enterprise Agent Platform" (or "Agent Platform"). In the Firebase ecosystem, we refer to this service as the "Agent Platform Gemini API".

For Google Cloud, this rebranding included the following. Note that there were other changes, but they aren't applicable to Firebase AI Logic.

• Rebranding the product from "Vertex AI" to "Gemini Enterprise Agent Platform" (or "Agent Platform"), which includes new URLs for the Google Cloud console and documentation.

• Changing the display name of the API from "Vertex AI API" to "Agent Platform API". Note that the service name has stayed the same: aiplatform.googleapis.com.

• Rebranding "Vertex AI Studio" to "Agent Studio".

• No changes to the capabilities of the underlying APIs or supported models.

For the Firebase AI Logic SDKs, we accommodated this rebranding by updating the initialization syntax for the "Gemini API" backend service and updating the default location for accessing the model when using this new syntax.

• New initialization syntax for the "Gemini API" backend service:

  Swift

  Change vertexAI to agentPlatform.

  • The agentPlatform syntax is available starting with v12.17.0+ of the SDK.
  • The vertexAI syntax was removed in v13.0.0 of the SDK.

  BEFORE

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the legacy `vertexAI` syntax, the default location is `us-central1`, so
  // specifying a location is usually required since most models are *not* supported in `us-central1`.
  let ai = FirebaseAI.firebaseAI(backend: .vertexAI(location: "LOCATION"))
  
  // ...
  

  AFTER

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the `agentPlatform` syntax, the default location is `global`, so
  // specifying a location is usually optional since most models are supported in `global`.
  let ai = FirebaseAI.firebaseAI(backend: .agentPlatform(location: "LOCATION"))
  
  // ...
  

  Kotlin

  Change vertexAI to agentPlatform.

  • The agentPlatform syntax is available starting with v17.15.0+ of the SDK and v34.17.0+ of the Firebase Android BoM.
  • The vertexAI syntax was removed in v18.0.0 of the SDK and v35.0.0 of the BoM.

  BEFORE

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the legacy `vertexAI` syntax, the default location is `us-central1`, so
  // specifying a location is usually required since most models are *not* supported in `us-central1`.
  val ai = Firebase.ai(backend = GenerativeBackend.vertexAI(location = "LOCATION"))
  
  // ...
  

  AFTER

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the `agentPlatform` syntax, the default location is `global`, so
  // specifying a location is usually optional since most models are supported in `global`.
  val ai = Firebase.ai(backend = GenerativeBackend.agentPlatform(location = "LOCATION"))
  
  // ...
  

  Java

  Change vertexAI to agentPlatform.

  • The agentPlatform syntax is available starting with v17.15.0+ of the SDK and v34.17.0+ of the Firebase Android BoM.
  • The vertexAI syntax was removed in v18.0.0 of the SDK and v35.0.0 of the BoM.

  BEFORE

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the legacy `vertexAI` syntax, the default location is `us-central1`, so
  // specifying a location is usually required since most models are *not* supported in `us-central1`.
  GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.vertexAI("LOCATION"));
  
  // ...
  

  AFTER

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the `agentPlatform` syntax, the default location is `global`, so
  // specifying a location is usually optional since most models are supported in `global`.
  GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.agentPlatform("LOCATION"));
  
  // ...
  

  Web

  Change VertexAIBackend to AgentPlatformBackend.

  • The AgentPlatformBackend syntax is available starting with v12.17.0+ of the Firebase JS SDK.
  • The VertexAIBackend syntax was removed in v13.0.0 of the SDK.

  BEFORE

  import { getAI, getGenerativeModel, VertexAIBackend } from "firebase/ai";
  
  // ...
  
  // Initialize FirebaseApp
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the legacy `VertexAIBackend` syntax, the default location is `us-central1`, so
  // specifying a location is usually required since most models are *not* supported in `us-central1`.
  const ai = getAI(firebaseApp, { backend: new VertexAIBackend('LOCATION') });
  
  // ...
  

  AFTER

  import { getAI, getGenerativeModel, AgentPlatformBackend } from "firebase/ai";
  
  // ...
  
  // Initialize FirebaseApp
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the `AgentPlatformBackend` syntax, the default location is `global`, so
  // specifying a location is usually optional since most models are supported in `global`.
  const ai = getAI(firebaseApp, { backend: new AgentPlatformBackend('LOCATION') });
  
  // ...
  

  Dart

  Change vertexAI to agentPlatform.

  • The agentPlatform syntax is available starting with v3.15.0+ of the plugin and v4.18.0+ of the Firebase Flutter BoM.
  • The vertexAI syntax was removed in v5.0.0 of the plugin and v5.0.0+ of the Firebase Flutter BoM.

  BEFORE

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the legacy `vertexAI` syntax, the default location is `us-central1`, so
  // specifying a location is usually required since most models are *not* supported in `us-central1`.
  final ai = await FirebaseAI.vertexAI(location: 'LOCATION');
  
  // ...
  

  AFTER

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the `agentPlatform` syntax, the default location is `global`, so
  // specifying a location is usually optional since most models are supported in `global`.
  final ai = await FirebaseAI.agentPlatform(location: 'LOCATION');
  
  // ...
  

  Unity

  Change VertexAI to AgentPlatform.

  • The AgentPlatform syntax is available starting with Firebase SDK for Unity v13.15.0+.
  • The VertexAI syntax was removed in v14.0.0 of the SDK.

  BEFORE

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly branded Vertex AI).
  // For the legacy `VertexAI` syntax, the default location is `us-central1`, so
  // specifying a location is usually required since most models are *not* supported in `us-central1`.
  var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.VertexAI(location: "LOCATION"));
  
  // ...
  

  AFTER

  // ...
  
  // Initialize the Agent Platform Gemini API backend service (formerly Vertex AI).
  // For the `AgentPlatform` syntax, the default location is `global`, so
  // specifying a location is usually optional since most models are supported in `global`.
  var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.AgentPlatform(location: "LOCATION"));
  
  // ...
  

• New default location for accessing the model when using the new initialization syntax:

  When using the new "Agent Platform" initialization syntax, the location defaults to global.

  This change was made because almost all Gemini models are supported in global, and Google Cloud is no longer supporting the us-central1 location for new releases of most Gemini models.

For Swift apps - Changes required to migrate from FirebaseAI to FirebaseAILogic

For Apple platform apps, starting with Firebase SDK v12.5.0, Firebase AI Logic is distributed under the FirebaseAILogic module. In SDK v13.0.0, the FirebaseAI module was removed.

Why did we make this change?

We formerly distributed this service under the FirebaseAI module. However, we needed to rename it to FirebaseAILogic for the following reasons:

• Avoid a name collision between module and class that causes issues in binary distributions.

• Enable us to use Swift macros for future feature development.

What to do if you're upgrading to v12.5.0+ or v13.0.0+?

In Firebase 12 (starting with v12.5.0+), the module name change to FirebaseAILogic is non-breaking and backward-compatible, so these changes are recommended in Firebase 12. However, in Firebase SDK v13.0.0, the old FirebaseAI module was removed, so these changes are required when upgrading to Firebase 13.

1. When choosing Swift PM dependencies, choose FirebaseAILogic (instead of FirebaseAI).

2. Change import statements to FirebaseAILogic (instead of FirebaseAI).

Understand the name change from "Vertex AI in Firebase" to "Firebase AI Logic"

Back in 2024, we launched a set of Firebase client SDKs that could use the Agent Platform Gemini API (formerly Vertex AI) as well as a Firebase proxy gateway to protect that API from abuse and to enable integrations with other Firebase products. We called our product "Vertex AI in Firebase", and this product name accurately described our product's available use cases at that time.

Since then, though, we've expanded the capabilities of our product. For example, as of May 2025, we now offer support for the Gemini Developer API, including the ability to protect the Gemini Developer API from abuse using our integration with Firebase App Check.

As a result, the name "Vertex AI in Firebase" no longer accurately represents the expanded scope of our product. Thus, a new name — Firebase AI Logic — better reflects our evolving feature set and allows us to continue to expand our offerings in the future!

Check out the migration guide to make sure you get all the latest features from Firebase AI Logic (and optionally start using the Gemini Developer API).

Required App Check enforcement for all versions of an app

App Check needs to be enforced for all versions of your app that use Firebase AI Logic.

It's critical that App Check is enforced as early as possible — especially before you commit your app to a publicly available source code control system, share your app, or make your app publicly available.

If you implement App Check in your app's codebase right away, then all your app versions can send valid App Check tokens. A request that doesn't send a valid token is considered unverified and will be blocked when App Check is enforced.

If you've already released a version of your app to end-users that does not have App Check implemented, see the FAQ about how to implement and enforce App Check for an already released app.

Delay auto-enforcement of App Check for Firebase AI Logic

Starting November 2, 2026, Firebase will automatically enforce Firebase App Check for Firebase AI Logic in your Firebase project (if it's not already enforced).

When App Check is enforced, any requests to Firebase AI Logic without a valid App Check token will be blocked. This includes released app versions that don't have a production attestation provider implemented.

If you have released app versions that don't have App Check implemented, then you can temporarily delay automatic enforcement of App Check for Firebase AI Logic. However, before January 21, 2027, it's critical that you work towards implementing and enforcing App Check for your already released apps.

Here's how to delay the auto-enforcement of App Check for Firebase AI Logic:

1. In the Firebase console, go to the Security > App Check > APIs tab.

2. Find the row for Firebase AI Logic.

3. At the end of the row, find the Enforces: date picker with its editEdit icon.

4. Select the date that you want App Check to be automatically enforced for Firebase AI Logic.

   The last possible date is January 21, 2027. After that date, you can't delay auto-enforcement of App Check for Firebase AI Logic.

5. Click Save.

How to implement and enforce App Check for an app that's already released

For app versions that don't have App Check implemented, requests to Firebase AI Logic from those versions don't have valid App Check tokens and are considered unverified. These requests will be blocked when App Check is enforced for Firebase AI Logic.

The following instructions help you migrate your app so that you can enforce App Check in a way that avoids service disruptions for an already released app that doesn't have App Check.

1. Delay automatic enforcement of App Check for Firebase AI Logic:

   1. In the Firebase console, go to the Security > App Check > APIs tab.

   2. Find the row for Firebase AI Logic.

   3. At the end of the row, find the Enforces: date picker with its editEdit icon.

   4. Select the date that you want App Check to be automatically enforced for Firebase AI Logic.

      The last possible date is January 21, 2027. After that date, you can't delay auto-enforcement of App Check for Firebase AI Logic.

   5. Click Save.

2. Implement a production attestation provider in your app as soon as possible.

   • Apple platforms: DeviceCheck or App Attest or reCAPTCHA Enterprise
   • Android: Play Integrity or reCAPTCHA Enterprise
   • Web: reCAPTCHA Enterprise
   • Flutter: Supports all the providers above, including reCAPTCHA Enterprise
   • Unity: Supports all the providers above (support for reCAPTCHA Enterprise is coming soon)

3. Monitor the requests from your app to help you decide when it's safe to enforce App Check.

   For example, if almost all of the recent requests are from verified clients, then you should consider enforcing App Check.

4. Enforce App Check for Firebase AI Logic.

5. For local development when App Check is enforced, you can set up the App Check debug provider and still keep App Check enforced for Firebase AI Logic.

Understand the security upgrades (mid-2026) for the Gemini Developer API and Firebase AI Logic

Historically, the Gemini Developer API relied on standard Gemini API keys for authorizing use of the Gemini Developer API (generativelanguage.googleapis.com). If you enabled Firebase AI Logic and chose to use the Gemini Developer API, then Firebase created a Gemini API key for you that was restricted to the Gemini Developer API. This key was named Gemini Developer API key (auto created by Firebase).

Starting in mid-2026, the Gemini Developer API is upgrading to a more secure alternative called "Authorization (auth) keys" (which are essentially service accounts). Firebase AI Logic has upgraded in tandem. Instead of using a standard Gemini API key, Firebase AI Logic now handles authorization for the Gemini Developer API using a Google-managed service account (P4SA) that we automatically provision for you:
Firebase AI Logic Service Agent (service-PROJECT_ID@gcp-sa-firebasevertexai.iam.gserviceaccount.com)

For both existing and new projects, if you access the Gemini Developer API via Firebase AI Logic, no action is needed on your part to take advantage of these security upgrades from mid-2026.

How to migrate a Gemini API key to an "Authorization (auth) key"

For both existing and new projects, if you access the Gemini Developer API via Firebase AI Logic, no action is needed on your part to take advantage of security upgrades from mid-2026 (including migrating to an "Authorization (auth) key").

On behalf of our developers, Firebase AI Logic is automatically handling all the required security changes to accommodate the transition of the Gemini Developer API to require "Authorization (auth) keys".

Starting in mid-2026, Firebase AI Logic no longer provisions or uses standard Gemini API keys. Instead, Firebase AI Logic now handles authorization for the Gemini Developer API using a Google-managed service account (P4SA) that we automatically provision for you in your Firebase project:
Firebase AI Logic Service Agent (service-PROJECT_ID@gcp-sa-firebasevertexai.iam.gserviceaccount.com)

Given this change, you can review and delete any API key named Gemini Developer API key (auto created by Firebase). You can delete this key in the Google Cloud console. Review the following before deleting the key:

• This Gemini API key was created by Firebase for the sole purpose of using with Firebase AI Logic, so it should be safe to delete. However, before you delete this key, you should still check to make sure that you haven't erroneously used the key with other tools that can give access to the Gemini Developer API, like the GenAI server SDKs or Genkit. Here's how to check the usage:
  1. In the Google Cloud console, go to the page for the Gemini Developer API, then click Manage.
  2. In the Metrics tab, in the Credentials dropdown, select the key named Gemini Developer API key (auto created by Firebase).
  3. If the displayed graphs show no usage since early July 2026 (which was when Firebase AI Logic stopped using these API keys), then the key is safe to delete.
     However, if the graphs show usage, then you're using the key with another tool and you should rename the key so that it's clear that it's being used with that tool (and not with Firebase AI Logic).
• Make sure that you do not delete any other API key with a name that contains the segment (auto created by Firebase).

Do not add a Gemini API key into a mobile or web app's codebase

When using the Firebase AI Logic SDKs, you do not need a Gemini API key for authorizing use of the Gemini Developer API, and you should not add a Gemini API key into your app's codebase.

Do not use a "Firebase API key" as a Gemini API key

Never use your "Firebase API key" as a Gemini API key. We strongly recommend that you do not add the Gemini Developer API to the allowlist for your Firebase API key.

Your Firebase API key is the API key that's listed in your Firebase configuration file or object that you add into your app's codebase to connect your app to Firebase. It's OK to include your Firebase API key in your code when you use the key only with Firebase-related APIs (like Firebase AI Logic). Learn important information about Firebase API keys.

In the APIs & Services > Credentials panel of the Google Cloud console, this is what Firebase API keys look like:

Because you need to add your Firebase API key into your app's codebase for Firebase-related APIs to work, and because the Gemini Developer API can be authorized via API key, we strongly recommend that you do NOT add the Gemini Developer API (called the "Generative Language API" in the Google Cloud console) to the API allowlist for your Firebase API key. If you do, then you're exposing the Gemini Developer API to potential abuse.

How to keep a Gemini API key secure