Get started: Access the Gemini API through Apple's Foundation Models framework

Preview: Using Firebase AI Logic to access the Gemini API through Apple's Foundation Models framework is currently in public preview, which means that it isn't subject to any SLA or deprecation policy and could change in backwards-incompatible ways.
Also, this integration relies on beta APIs, so apps using it cannot be submitted to the App Store until the next Xcode version reaches General Availability (GA) and supports production submissions.

At WWDC 2026, Apple opened the Foundation Models framework to third-party model adapters, which means you can access cloud-hosted models (like Gemini) through the Foundation Models framework using the same API as you would use to access on-device models.

In your app, you can swap the model instance to route your requests to either on-device or cloud inference to fit your use case:

• On-device models offer maximum privacy, zero cost, and offline support.
• Cloud-hosted models offer large context windows, advanced capabilities, and more reasoning power.

You can access the cloud-hosted Gemini models through Apple's Foundation Models framework by using the Firebase SDK for Apple platforms – specifically the Firebase AI Logic library. This guide shows you how to get started.

To protect access to Gemini models, this guide also shows you how to set up Firebase App Check, which is critical even during development.

Prerequisites

• Install the latest Xcode 27 beta.

• An Apple platform simulator or a physical device, both running the corresponding beta OS version (for example, iOS 27 beta).

• A new Xcode project of an Apple platforms app using a SwiftUI interface.

Note: For this initial release, the following Apple platforms are supported: iOS and macOS.

Supported Gemini models

The integration with Apple's Foundation Models framework supports the following Gemini models.

• General purpose models

  • gemini-3.1-pro-preview
  • gemini-3.5-flash
  • gemini-3.1-flash-lite

• Image-generating models

  • gemini-3-pro-image-preview (aka "Nano Banana Pro")
  • gemini-3.1-flash-image-preview (aka "Nano Banana 2")
  • gemini-2.5-flash-image (aka "Nano Banana")

Gemini Live API models and Imagen models are not supported. Note that Gemini 2.5 models are technically supported, but they're not recommended for new projects and require special configuration not covered in these guides.

Step 1: Create a Firebase project

We recommend starting with a new Firebase project to explore this integration.

1. Sign into the Firebase console.

2. Click Create a new Firebase project.

3. Follow the on-screen instructions. You do not need to enable Google Analytics.

Step 2: Connect your app to Firebase

To connect your app to Firebase, you must register it with your Firebase project and add a configuration file to your codebase.

1. In the center of the project overview page, click the iOS+ icon to launch the setup workflow.

2. Register your app:

   1. Enter your app's bundle ID. Make sure it matches the bundle ID of the project you're building in Xcode.

   2. Click Register app.

3. Add the Firebase configuration file. This file contains the settings for the Firebase SDK to connect to your Firebase project.

   1. Click Download GoogleService-Info.plist to get your configuration file.

   2. Move GoogleService-Info.plist into the root of your Xcode project and add it to all targets.

   3. Click Next in the Firebase console.

4. The workflow in the console provides generic instructions for adding the Firebase SDK to your app, so skip ahead to the next step in this guide for specific instructions for Firebase AI Logic.

Step 3: Add Firebase libraries and initialize Firebase in your app

1. Use Swift Package Manager to add the required Firebase libraries:

   1. In Xcode, with your app project open, select File > Add Packages.

   2. Enter the Firebase Apple SDK repository URL:

      https://github.com/firebase/firebase-ios-sdk
      

   3. Select the Dependency Rule as Branch and enter wwdc26-preview.

   4. Click Add Package. Xcode will resolve and download the dependencies.

   5. When prompted, add the FirebaseAILogic and FirebaseAppCheck libraries to your app target.

2. Initialize Firebase when your app starts up by adding the following code to your app's main entry point:

   import SwiftUI
   import FirebaseCore
   
   @main
   struct YourApp: App {
     init() {
       FirebaseApp.configure()
     }
   
     var body: some Scene {
       WindowGroup {
         NavigationView {
           ContentView()
         }
       }
     }
   }
   

Step 4: Enable and secure Firebase services

Now that your app is configured to use Firebase, you need to enable the Firebase AI Logic service and protect access to its associated APIs using Firebase App Check.

Step 4a: Set up Firebase AI Logic in your Firebase project

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

2. Click Get started to launch the setup workflow.

3. We recommend choosing the Gemini Developer API provider to get started quickly at no cost.

Step 4b: Set up Firebase App Check in your Firebase project

Using Firebase App Check to protect the APIs associated with Firebase AI Logic is critical, even during early development.

When enforced, Firebase App Check only allows incoming requests that are from your actual app and an untampered device. Firebase App Check supports many attestation providers, including Apple's App Attest.

The following steps are for a baseline, default setup for App Check. Learn more about additional configuration options for App Check (like adjusting the TTL of tokens and enabling limited-use tokens).

Here's how to register the App Attest provider in the Firebase console:

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

2. Click Get started.

3. In the Apps tab, register your app to use App Check with the App Attest provider.

4. In the APIs tab, select Firebase AI Logic, and click Enforce.

Before distributing your app, configure the App Attest capability in Xcode

Note: If you're going to start with the App Check debug provider (next section), these steps aren't required until you distribute your app. For now, you can skip ahead to the next section.

1. In Xcode, add the App Attest capability to your app.

2. In your Xcode project's .entitlements file, set the App Attest environment to production.

Step 4c: Configure the App Check Debug Provider for local development

For local development, configure the App Check Debug Provider. Setting up this provider bypasses attestation during development so you can verify your app's logic without modifying the production security configuration you set up above.

1. In your Xcode project, import FirebaseAppCheck and initialize App Check with the debug provider factory before you configure Firebase.

   import SwiftUI
   import FirebaseCore
   import FirebaseAppCheck
   
   @main
   struct YourApp: App {
     init() {
       let providerFactory = AppCheckDebugProviderFactory()
       AppCheck.setAppCheckProviderFactory(providerFactory)
       FirebaseApp.configure()
     }
   
     var body: some Scene {
       WindowGroup {
         NavigationView {
           ContentView()
         }
       }
     }
   }
   

2. Obtain your debug token:

   1. Launch your app in the simulator or on your test device.

   2. Open the Xcode console and look for the App Check debug token. The token is generated at app startup, so it should be one of the first few logs you see. It will look similar to this:

      <Warning> [AppCheckCore][I-GAC004001] App Check debug token: '123a4567-b89c-12d3-e456-789012345678'.
      

   3. Copy the token (for example, 123a4567-b89c-12d3-e456-789012345678).

3. Provide your debug token to App Check within the Firebase console:

   1. In the Firebase console, navigate to Security > App Check > Apps.

   2. Find your app, click the overflow menu (), and then select Manage debug tokens.

   3. Click Add debug token, enter a name (for example, My Simulator), paste the token, and then click Save.

For details about the debug provider (including how to get a new debug token), check out the official App Check docs.

Warning: Keep your debug token private. This debug token lets anyone access your Firebase AI Logic resources (and the Gemini models) without a valid device, so you must keep it private. Do not commit it to a public repository. If a registered debug token is ever compromised, revoke it immediately in the Firebase console.

Step 5: Initialize the AI Logic service in your app

Click your Gemini API provider to view provider-specific content and code on this page. Gemini Developer API Vertex AI Gemini API

With Firebase and App Check configured, you can now initialize the Firebase AI Logic service in your app.

import FoundationModels
import FirebaseCore
import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Initialize a `geminiLanguageModel` with a Gemini model that supports your use case.
let model = ai.geminiLanguageModel(name: "gemini-3.5-flash")

Step 6: Send a request to a Gemini model

With Firebase AI Logic setup, protected, and initialized in your app, you're ready to send a request to a Gemini model.

The following example shows the most basic type of request – generating text from a text-only prompt:

import FoundationModels
import FirebaseCore
import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Initialize a `geminiLanguageModel` with a Gemini model that supports your use case.
let model = ai.geminiLanguageModel(name: "gemini-3.5-flash")


// Create a session by injecting the model into Apple's `LanguageModelSession`.
let session = LanguageModelSession(model: model)

// Generate a text response to a prompt.
let response = try await session.respond(to: "Write a story about a magic backpack.")
print(response.content)

Gemini models also support other types of requests, like analyzing images and PDFs , generating structured JSON output , and generating images (using "Nano Banana" models). See examples for these types of requests in the docs or in the sample app.

Stream the response

You can achieve faster interactions by not waiting for the entire result from the model generation, and instead use streaming to handle partial results. To stream the response, use streamResponse(to:) instead of respond(to:).

import FoundationModels
import FirebaseCore
import FirebaseAILogic

// Initialize the Gemini Developer API backend service.
let ai = FirebaseAI.firebaseAI(backend: .googleAI())
// Initialize a `geminiLanguageModel` with a Gemini model that supports your use case.
let model = ai.geminiLanguageModel(name: "gemini-3.5-flash")


// Create a session by injecting the model into Apple's `LanguageModelSession`.
let session = LanguageModelSession(model: model)

// Generate a streamed text response to a prompt.
// To stream the response, use `streamResponse(to:)` instead of `respond(to:)`
let stream = session.streamResponse(to: "Write a story about a magic backpack.")
var response = ""
for try await snapshot in stream {
  // The snapshot contains *all* content generated so far.
  response = snapshot.content
}

Next steps

• Explore the available capabilities when accessing the Gemini API through Apple's Foundation Models framework.
• Learn how to configure the model to control its responses, including setting a thinking level ("reasoning").
• Learn how to provide tools to the model, including grounding for up-to-date information.
• Read more about Firebase App Check and how it protects your resources.

Give feedback about accessing the Gemini API through Apple's Foundation Models framework