After you've met the [prerequisites](https://developers.google.com/connected-apps/gpc/prerequisites), follow these steps to register,
configure, test, and publish your connected app.

## Step 1: Create a connected app

To create a connected app:

1. Sign in to [Google Connected Console](https://connected.google.com/console).
2. On the home page, select **Create app**.
3. In the **Choose what to create** dialog:
   - If prompted to accept the Connected Apps Terms of Service, select **View terms** , review and accept the agreement, and then select **Create**. Only an account administrator can accept the agreement.
   - Otherwise, select **Create** in the **Connected app** card.
4. In the **Give your connected app a name** dialog, type a name for your
   connected app. This is the name that will be used to display your connected
   app across Google products, and is how users will mention your connected app
   using `@`. Select **Next**.

5. In the **Select a connected app category** dialog, select your app's domain,
   category, or industry from the **Select a category** menu.

   > [!NOTE]
   > **Note:** Your connected app category defines baseline capability requirements and cannot be changed later. To use a different category later, you must create a new connected app.

6. In the **Choose connection type** dialog, choose one of the following
   options:

   - **MCP server**: Connect an MCP server to provide your services to Gemini and Search users across web, Android, and iOS.
   - **Android MCP**: Expose your on-device capabilities to Gemini on Android so that it can trigger actions and complete tasks for users in your app.

   Learn more about how to [set up an Android MCP connected app](https://developer.android.com/ai/appfunctions/create-manage-connected-apps). You can
   only choose one connection type per connected app, and this cannot be
   changed later.
7. Select **Create Connected app**.

This opens the management overview page for your connected app (**Set up and
test your Connected app**), where you can configure your app details, MCP server
connection, and testers.

## Step 2: Enter the details of your connected app

To provide more details about your connected app and configure how it appears to
users:

1. On your connected app's overview page, in the **App details** row, select **Get started** (or **Manage** if you are updating existing details).
2. At the top of the **App details** page, verify the **Connected app name** field. You can update the name if needed. This is shown to users across Google products, and used when users mention your app with `@`.
3. In the **Public details** section, under **Icon**, upload your app icon (JPG or PNG, up to 1 MB, and 512 px × 512 px).
4. Complete the following fields:

   - **Description**: Enter a concise, single-sentence summary (under 30 words) that describes the main features of your connected app and what it can do. This text is displayed to users; it isn't used as model instructions.
   - **Capabilities** : Enter at least three high-value tasks that your connected app can perform. Select **Add capability** to add more entries. Don't include numbers at the beginning of your capabilities. Include only a single capability per entry. If your category includes predefined capabilities, they appear at the top of the list and cannot be modified.
   - **Example prompts** : Enter at least three example prompts that help users understand what they can ask. Select **Add example prompt** to add entries.
     - Start at least **two prompts** with `@<YourAppName>` (for example, `@Order Tracker where is my last order?`).
     - Mention `<YourAppName>` **naturally in at least one prompt** without starting with your app name (for example, `Track my recent order on Order Tracker`).
     - Don't include numbered prefixes (`1.`, `2.`, `3.`) or wrap prompts in quotation marks (`"..."`).
   - **Multi-language localization** : To provide translations for
     **Description** , **Capabilities** , and **Example prompts**, wrap each
     locale's text in language tags within the input field. For example:

         <en-US>
         Play music, manage playlists, and discover artists
         </en-US>
         <es-ES>
         Reproduce música, gestiona listas y descubre artistas
         </es-ES>

     Connected Console automatically validates your tags and displays the
     detected locales underneath each field (for example,
     `Found translations for 2 languages: en-US, es-ES`).
   - **Terms of Service URL** : Enter a valid `https://` or `http://` link to
     your Terms of Service.

   - **Policy URL** : Enter a valid `https://` or `http://` link to your
     Privacy Policy.

   - **Website URL (optional)**: Enter a link to your website for
     attribution purposes.

5. Select **Save** at the bottom of the page to return to the overview page.

## Step 3: Enter your MCP endpoint and verify domain ownership

Before Google can connect to your MCP server or sync your tools, you must
provide your MCP server endpoint URL and verify that you own the domain where
it is hosted.

To enter your MCP endpoint and verify domain ownership:

1. On your connected app's overview page, in the **MCP and tools setup** card, select **Get started** (or **Manage** if you are updating existing details). This opens Step 1 (**MCP server endpoints**) of the MCP setup flow.
2. Under **Connected your MCP server endpoint** , enter the full HTTPS URL of your MCP server endpoint (for example, `https://api.yourdomain.com/v1/mcp`).
3. Under **Verify your domain**, complete the challenge token verification for
   your domain (if you have already verified the domain or its parent domain in
   your developer account, it will automatically show as verified):

   1. In the **Verify domain ownership** card, select **Download token** .
      Your browser downloads a file named `google-connected-apps.json` with
      the following structure:

          {
            "verification_tokens": [
              "YOUR_VERIFICATION_TOKEN"
            ]
          }

   2. Upload and host this JSON content on your server at
      `https://<your-domain>/.well-known/google-connected-apps`.

      - Ensure the endpoint is publicly reachable over HTTPS, returns `HTTP 200 OK` directly without HTTP redirects, and includes your token inside the `verification_tokens` array.
   3. Return to Google Connected Console and select **Verify domain**.

   4. Once verification succeeds, the **Domain verified with challenge token**
      row displays a green checkmark, and unlocks the **Access credentials**
      section below it.

## Step 4: Configure access credentials

After verifying your domain, configure how Google authenticates with your MCP
server and fetch your server's tool definitions.

To configure access credentials:

1. In the **Provide access credentials** section (on Step 1 of the **MCP and
   tools setup** page), select **Get started** (or **Update credentials** to modify an existing configuration).
2. Under **Does your server require authorization?**, select one of the
   following options:

   - **No** : Select this option if your MCP server is publicly accessible without authentication, then select **Confirm**.
   - **Yes** : Select this option if any of the tools exposed by your MCP
     server require authorization. Then, under **Select the authorization
     model your MCP server uses**, choose your authentication flow:

     - **Machine-to-machine (OAuth Client Credentials)** : Select this for service-to-service authentication ([RFC 6749](https://datatracker.ietf.org/doc/html/rfc6749#section-4.4)) where Google communicates directly with your MCP server using a shared Client ID and Secret without end-user login redirects:
       1. Enter your **Client ID** (required) and **Client secret** (optional).
       2. Optionally enter an **Authorization endpoint** (optional) and **Token endpoint** (optional) if your server does not advertise them using `/.well-known/oauth-authorization-server`.
       3. Select **Register client** (or **Update client**).
     - **User-delegated (Authorization Code)**: Select this if your MCP
       server requires individual users to sign in and authorize actions
       with their own accounts using Google Account Linking:

       1. **Allowlist Google's OAuth Redirect URIs** : In the **Ensure you
          have allow listed the provided redirect URIs** banner, select **View** (or select the copy icon) to inspect the exact app-specific Redirect URIs generated for your connected app. Add them to your OAuth server's allowlist, then return to Google Connected Console.
       2. Under **Select how Google should authenticate with your OAuth
          server** , select how your OAuth client is registered:
          - **Pre-registered** : Choose this if you generate a static **Client ID** and **Client secret (optional)** in your OAuth provider. You can also optionally provide a **Custom
            authorization endpoint (optional)** and **Custom token
            endpoint (optional)**.
          - **Client ID metadata or Dynamic client registration** *(recommended)* : Choose this if your server supports OAuth [Client ID Metadata Documents (CIMD)](https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization/client-registration) or Dynamic Client Registration ([RFC 7591](https://datatracker.ietf.org/doc/html/rfc7591)). Google checks for CIMD first and falls back to DCR using your `.well-known` discovery endpoints. You can also optionally specify custom authorization and token endpoints.
       3. Under **Authenticate with your developer credentials**, because
          you have selected User-delegated as your authorization model,
          you are required to sign in to your server before Google can
          fetch tools. Select either:

          - **Authenticate via Pop up (recommended)**: Opens your authentication flow in an overlaid dialog. This is the default experience.
          - **Authenticate via Redirect (fallback)** : Opens your authentication flow using a full-screen redirect in the same tab or window. Use this if the dialog fails to render due to display constraints or security headers (such as `X-Frame-Options` or `Content-Security-Policy`).

          We recommend first attempting to authenticate using the dialog.
          If you are unable to authenticate using the dialog, use the
          redirect method. Your selection also determines the login
          experience for users when they first use your connected app.
       4. Select **Register client** (or **Update client**).

   > [!NOTE]
   > **Note:** If you have selected User-delegated as your authorization model, you will only be asked to authenticate when we fetch tools. If a different account in your developer account is working on your connected app, they will need to authenticate before they can resync tools.

## Step 5: Provide test account details (only for User-delegated authorization)

If your connected app requires authentication, you must provide seeded test
credentials, pre-populated with realistic sample data and with two-factor
authentication (2FA) disabled, along with testing instructions to your Google
representative. This enables Google's review and QA team to verify tool
execution without being blocked by empty sandboxes, paywalls, or 2FA challenges.
If Google cannot fully test your connected app, it may be rejected during
review.

## Step 6: Sync your tools

To create each version of your connected app, Google syncs with your provided
endpoint to get the available tools and take a snapshot. These are the tools
that will be available to users in that version. While your connected app
version is in preview and available to testers, you can continue to make
changes on your server and resync tools to update. This creates a new snapshot
of your tools.

When you publish, the most recent snapshot of your tools is used for that
version of your connected app. You'll no longer be able to make changes to your
tools, descriptions, or server details. To update your tools or sync any
modifications from your server, create a new connected app version. We recommend
creating a new endpoint for each version of your connected app.

To sync tools:

1. In the **Sync tools** section:

   1. Select **Sync tools**.
   2. If prompted to sign in, authenticate with a developer account that has permissions to list all of the tools you intend to expose to users. Any tools your account cannot access aren't synced.
   3. Once connected, Connected Console displays the number of tools synced, along with a **Re-sync tools** button.

   > [!CAUTION]
   > **Caution:** If Connected Console displays a **Must fix** error card or a connection error below the sync card, such as missing `/.well-known/` discovery files, unsupported UI resource MIME types, or cumulative UI resource sizes exceeding the limit, resolve the issue before proceeding. See [Troubleshoot your registration](https://developers.google.com/connected-apps/gpc/troubleshooting) for solutions.

2. Select **Next** at the bottom of the page to advance to step 2 of the MCP
   and tools setup.

## Step 7: Determine how and where users experience your app

In the **Tools** section of the **MCP and tools setup** page, configure basic
parameters such as where your connected app is available geographically, its
language, and the Google products you want to make it available in.

1. Under **Availability** , next to **Make version available in** , configure the following targeting options:
   - **Countries / regions**: Select the geographic locations where your connected app should be available.
   - **Languages**: Select the languages your connected app supports.
   - **Products**: Select the Google products where your connected app will be available.
2. In the **Tools** section after **Availability** , review the tools synced
   from your MCP server. Select any tool in the **Tools** list to configure its
   settings in the **Manage tool** panel on the right:

   - **Enable tool** : Toggle the **Enable tool** switch to include or exclude the tool in your connected app. Disabled tools will not be available in your connected app for users to interact with.
   - **Additional context**: Select whether your tool requires contextual
     signals from Google to operate:

     - **Locale**: The locale determined by the user's Google Account.
     - **Approximate location**: Physical user or device location within an area greater than or equal to 3 square kilometers (for example, the city the user is in).
     - **Precise location**: Physical user or device location accurate to within 50 meters or less.

     > [!CAUTION]
     > **Caution:** You shouldn't request additional context unless there is a clear requirement and purpose. Your connected app may not pass review if tools request more context than required.

   - **User confirmation** : Select **User confirmation required** to require
     explicit user confirmation before executing the tool (this is
     automatically pre-selected if your tool's MCP annotations specify
     `destructiveHint: true`).

3. If your MCP server provides UI resources, switch to the **UI resources**
   tab next to **Tools** to inspect your server's UI resources (`text/html`,
   `text/html;profile=mcp-app`, `text/javascript`, `text/css`), verify which
   tools are linked to each resource, and review the Content Security Policy
   (CSP) `connectDomains` and `resourceDomains`.

   > [!NOTE]
   > **Note:** MCP Apps for Connected Apps is in beta and may not be available. UI resources found on your server may be ignored if detected.

4. Select **Save** at the bottom of the page.

Once both **App details** and **MCP and tools setup** have been saved, your
configuration is automatically available to any testers you've added to preview,
and your version status on the overview page updates to
**Available to testers**.

## Step 8: Test your connected app

To make your connected app available to testers, you must add them on the Manage
testers screen. Only users you add to your testers list can see and interact
with your unpublished connected app. You can only add testers who have an
`@gmail.com` account.

1. On your connected app's overview page, in the **Test your app** card, select
   **Add testers** (or **Manage testers** if you've already added some).

2. On the **Manage testers** screen, select existing email lists or select
   **Create email list** to add the Google Accounts authorized to test your
   integration. Make sure to include your own email address if you want to test
   the app yourself.

3. Select **Save**.

   > [!NOTE]
   > **Note:** Once you add testers, it can take up to 10 minutes for your connected app to become visible to those accounts.

4. Testers in the Gemini app can invoke your connected app by typing `@`
   followed by your connected app's name and selecting it from the menu. You
   can also view and connect your app in Gemini by navigating to
   **Settings \& help → Connected apps** in the left navigation bar.

5. We recommend thoroughly testing your integration:

   - Try all of your **Example prompts**.
   - Test both explicit `@<AppName>` invocations and natural-language queries.
   - Verify the end-to-end authentication flow, tool execution, user confirmation prompts, and any UI resources.

   > [!NOTE]
   > **Note:** You can also debug your connected app in Gemini Apps Developer Mode where you can interactively test your Model Context Protocol (MCP) server, diagnose schema or runtime errors, and benchmark tool quality before submitting your connected app for review in the Google Connected Console. For details, see the [Gemini Apps Developer Mode overview](https://developers.google.com/connected-apps/mcp/dev-mode) and [Test, debug, and evaluate in Gemini Apps Developer Mode](https://developers.google.com/connected-apps/mcp/dev-mode/usage). Make sure you are signed in to Gemini with an account.

When you are satisfied with your testing, you are ready to submit your
connected app to Google for review.

## Step 9: Initiate a review of your connected app, and publish after approval

Before your connected app can be made available to all users, Google reviews
and tests your integration.

To send your connected app for review, do the following:

1. On your connected app's overview page, in the **Releases** card on the right
   side of the page, select **Send for review** (enabled once your app
   configuration is complete and in preview without blocking issues).

2. While your version is under review:

   - Connected Console automatically creates a new editable draft version so testers can continue previewing your app and you can prepare future edits without disrupting the review.
   - Locks any changes to the version in review.
   - To view the read-only details of the version in review or cancel the review, select the more options (**⋮** ) button on the **In review** card and select **View app details** or **Cancel review**.
3. Once Google completes the review, you will receive a notification and the
   **Releases** card will update:

   - **If issues are found** : The **Releases** card displays **Issues
     found** . Select **View issues** to inspect the specific review findings. Update your configuration or MCP server in your editable preview version, verify your fixes with testers, and select **Send for review** again.
   - **If approved** : The **Releases** card displays **Ready to publish** . Select **Publish** when you are ready to release your connected app to users.

Congratulations! Your connected app is now published and rolling out to users
across your selected Google products.

## Post-publishing and ongoing version management

Once published, the bottom card under **Releases** displays **Published** along
with the live version number for your connected app, publication date, and the
count of targeted countries/regions, languages, and products. You can select the
more options (**⋮** ) menu on the **Published** card and select **View app
details** at any time to inspect the read-only configuration of your live
release.

While your published version remains live in production, you can use the **Edit
and test your Connected app** panel on the left (or select **Create new
version** if no draft exists) to configure, preview, and test updates in a new
version (`Version <N+1>`) independently before sending it for review and
publishing.

> [!TIP]
> **Tip:** Each connected app entry has a single MCP endpoint URL. To test ongoing changes against a separate staging MCP server URL after launch without affecting your production endpoint configuration, use Gemini Developer Mode or register a separate dedicated staging connected app kept in preview (**Available to testers**).