# Gemini Connected Apps Platform: what a data MCP needs > Google opened the Connected Apps Platform on Oct 28, 2026. We checked a live data MCP against 12 of its rules: auth, tool design, prompts, and call cost. - Canonical page: https://everyinfra.com/en/blog/gemini-connected-apps-platform-data-tools - Published: 2026-11-12T01:07:00+08:00 · Fact-checked: 2026-11-11T01:30:00+08:00 Google opened a preview of the Connected Apps Platform on October 28, 2026. This post is for developers who already run a remote MCP server for social media or e-commerce data. The question is simple: can that server go into the Gemini app and Google Search, and should it? Here is what we tested and what we did not. We did not register in Google Connected Console, build a Developer Mode app, or submit anything for review. The preview is open to US developers only, so every Google-side step below is a configuration example. We took those steps from the text on developers.google.com and support.google.com. Every EveryInfra number comes from live calls to `https://api.everyinfra.com/mcp` on November 11, 2026, between 00:17 and 00:35 Singapore time. EveryInfra is not listed in Gemini or Search, and this post does not imply that Google approves of anyone. The short answer comes first. We took 12 rules from Google's docs that a server response can prove or disprove. EveryInfra's general endpoint `/mcp` meets 6 of them. The OAuth endpoint `/mcp/all` meets 5 and partly meets 3 more. Transport and protocol version are not the problem. Two deeper issues block a typical data MCP. First, Gemini has no field for an API key header, so OAuth is the only way in. Second, Google's policy forbids one generic tool that dispatches to many capabilities, and that is how most data MCP servers work. A third issue is response size. On November 11, one `youtube/search` call returned 20 videos in 39,732 bytes of text. With only the 6 fields that answer the question, the same rows take 5,062 bytes, or 12.7%. A bigger response costs more for the model to read. We estimate that cost in tokens later in this post. > **Key points** > > - The Connected Apps Platform preview opened on 2026-10-28. One remote MCP server can reach the Gemini app and AI Mode in Search. The preview is US-only, and Google reviews each app before launch. > - Gemini accepts OAuth, not an API key header. Google's OAuth guide says the Gemini app needs a separate `registration_endpoint`. EveryInfra's metadata has PKCE S256 and CIMD but no such field, so the flow stops at step 4. > - Against 12 rules from Google's docs, `/mcp` and `/mcp/youtube` each meet 6, and `/mcp/all` meets 5 and partly meets 3. The hard parts are the ban on generic dispatch tools and `destructiveHint=true` on a read tool, which triggers a confirmation. > - 8 live data calls (2026-11-11, 00:18 to 00:35 Singapore time) took 4.3 to 55.7 seconds. Seven cost $0.000556 each at that day's price, the empty one was free, and the total was $0.003892. > - Responses can shrink a lot. A 20-row `youtube/search` result is 39,732 bytes raw and 5,062 bytes with 6 fields (12.7%). A 14-row `reddit/search` result drops from 25,212 to 4,274 bytes (17.0%). By our token estimate, the model input for a raw read costs more than the data fee for that call. ![Illustration with two paths from one starting platform that holds a box for an MCP server. On the left, wide stairs go up to a plaza with a guard booth, a barrier, and a blank review sign. On the right, a teal path goes straight to a desk with a laptop and a stack of data cards. Only the right path is teal.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/img-explain.webp) The same MCP server must pass review to reach the Gemini app and Search. For your own agents, the Gemini API and Gemini CLI connect directly. ## What is the Gemini Connected Apps Platform On October 28, 2026, Google announced the Connected Apps Platform on its blog. The pitch is to build once and reach both the Gemini app and Search ([Google blog, Oct 28, 2026](https://blog.google/innovation-and-ai/technology/developers-tools/connected-apps-one-place)). Before this, a third-party app in Gemini needed a direct deal with Google. On launch day, 9to5Google counted more than 50 such apps, including Adobe, Dropbox, Instacart, OpenTable, and Ticketmaster ([9to5Google, Oct 28, 2026](https://9to5google.com/2026/10/28/gemini-google-connected-apps-platform)). The same report said Calm would join in the coming weeks. The new platform makes the process self-service. A developer needs a cloud-hosted MCP server, or Android MCP through AppFunctions. Then the developer registers, tests, and submits the app in the new Google Connected Console. The developer also picks the surface: Search, the Gemini app, or both. The product page lists the two paths ([Connected Apps Platform home](https://developers.google.com/connected-apps)). A remote MCP server connects tools and authorized data to Google products. It can also show interactive UI through MCP Apps. Android MCP runs on the phone and uses the Jetpack AppFunctions library. The Android docs add a limit: AppFunctions needs Android 16 or later. As of May 2026, the Gemini integration was a private preview for trusted testers ([AppFunctions overview](https://developer.android.com/ai/appfunctions)). Most data teams do not ship an Android app, so this post covers the remote MCP path only. Access is the first thing to check. Google posted a developer session on October 29. At minute 6, a Google engineer says that the preview is open to US developers only ([Android Developers video, Oct 29, 2026](https://www.youtube.com/watch?v=-4G-4w9FKDw)). He then says Developer Mode is open to all users in the US. The user side is narrow too. The Gemini help center lists the conditions to connect a custom MCP app. You must be 18 or over and in the US, use a personal Google account, and turn on Keep Activity ([Gemini Help: custom apps](https://support.google.com/gemini/answer/17209137?hl=en)). The feature is in English only, and the connection is made in the web app. The Search help page says connected apps in AI Mode are US-only and English-only for now ([Google Search Help](https://support.google.com/websearch/answer/17265703)). If your users live outside the US, this sets a hard limit on near-term value. ![Animated flow with two lanes that shows how Gemini connects to a remote MCP server. Step 1 is POST initialize, step 2 is a 401 with WWW-Authenticate, step 3 reads protected resource metadata, step 4 registers a client, step 5 is user sign-in, and step 6 calls a tool with a token. The upper lane is EveryInfra /mcp/all, with teal pass marks on steps 1 to 3 and a stop at step 4 because the metadata has no registration_endpoint. The lower lane is /mcp, which stops at step 1 because it accepts only an API key header and Gemini has no place for one.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/fig-01-connect-flow.en.light.svg) ## The last 60 days: from partner apps to a developer platform The platform did not appear overnight. The changes Google posted over two months show a clear path. Google first picked partners. Then it published the rules. Then it opened applications. | Date | Change | What it means for data tool developers | Source | | --- | --- | --- | --- | | 2026-09-23 | New connected apps in Gemini: Airtable, Linear, monday.com, Adobe, Webflow, Experian, Peloton, and more | The @ mention pattern for third-party apps is in place, but Google still picks the list | [Google blog](https://blog.google/innovation-and-ai/products/gemini-app/new-connected-apps-gemini) | | 2026-10-13 | Gemini adds a Customize page for connected apps, with more than 40 apps, most in US English | Users get one fixed place to find apps | [Gemini release notes](https://gemini.google/release-notes/) | | 2026-10-27 to 10-30 | Full docs go live: MCP guide, server optimization, OAuth, Developer Mode, Connected Console | The rules are in writing for the first time, so you can check your server line by line | [MCP developer guide](https://developers.google.com/connected-apps/mcp), [Prerequisites, updated Oct 30](https://developers.google.com/connected-apps/gpc/prerequisites) | | 2026-10-28 | Connected Apps Platform preview opens | Self-service registration with review, for US developers | [Google blog](https://blog.google/innovation-and-ai/technology/developers-tools/connected-apps-one-place) | | 2026-10-29 | Google developer session: FastMCP server, Cloud Run deploy, Developer Mode test, Console submit | First full demo of the flow, and a clear statement that it is US-only | [Video](https://www.youtube.com/watch?v=-4G-4w9FKDw) | | 2026-11-02 | Policy update: Integration integrity bans dynamic discovery and generic dispatch tools | The common one-tool-calls-everything design does not comply | [Connected apps policy](https://developers.google.com/connected-apps/connected-apps-policy) | | 2026-11-10 | Gemini API ships Gemini 4 Carbon as GA, $2 input and $10 output per 1M tokens through Nov 30 | More model and price options on the Gemini API route | [Gemini API release notes](https://ai.google.dev/gemini-api/docs/changelog) | ## Gemini Connected Apps Platform API: three ways to connect "Put my data tool in Gemini" can mean three different things. Each has its own users, auth options, and review rules. Many forum threads mix them up. People spend hours in Developer Mode and then find that they wanted the Gemini API. The first way is the Connected Apps Platform itself. Your app shows up in the app list of the Gemini app and of AI Mode in Search. Every eligible user can @ mention it. You register in Connected Console and must pass review. Auth is limited to three options: no auth, machine-to-machine OAuth client credentials, or user-delegated OAuth authorization code ([Console steps, updated Oct 28](https://developers.google.com/connected-apps/gpc/perform-the-steps)). The second way is a custom app in Developer Mode. You enter an MCP server URL at `gemini.google.com/devmode`. Only your own account can use the app, and no review is needed. The auth choices are again OAuth or no auth ([Use Developer Mode, updated Oct 28](https://developers.google.com/connected-apps/mcp/dev-mode/usage)). The third way is the Interactions API in the Gemini API. You add an `mcp_server` entry to the `tools` list of a request. It can carry any HTTP header, and `allowed_tools` limits which tools the model may call. It works with Streamable HTTP only ([Gemini API function calling](https://ai.google.dev/gemini-api/docs/function-calling)). Gemini CLI belongs in the same group. In `settings.json`, `httpUrl` plus `headers` carries an API key ([Gemini CLI MCP setup](https://geminicli.com/docs/tools/mcp-server/)). | Route | Who can use it | API key header? | Review? | Region and account limits | Best for | | --- | --- | --- | --- | --- | --- | | Connected Apps Platform listing | All eligible Gemini and Search users | No, only no auth or OAuth | Yes, step 9 in Console | Preview for US developers; users in the US, English | Services with their own user accounts that want discovery | | Developer Mode custom app | Only the account that built it | No, only no auth or OAuth | No | 18+, US, personal account, web app to connect | Testing before launch, personal use | | Gemini API `mcp_server` | Your own programs and agents | Yes, any `headers` | No | Gemini API regions | Teams that run analysis, monitoring, reports | | Gemini CLI | Your own terminal | Yes, any `headers` | No | Gemini CLI availability | Developers who query data and write scripts | | Gemini Enterprise | Company staff | Not directly; goes through ADK and Agent Gateway | Company admin approval | Enterprise contract | Central control of tools in a company | For the enterprise case, see our earlier post on [Gemini Enterprise with MCP for brand sentiment](/en/blog/gemini-enterprise-agent-platform-mcp-brand-sentiment). The finding there was the same. The enterprise MCP connection takes OAuth or no auth, and an API key needs an ADK agent in the middle. For a weekly digest of hot posts, Gemini skills fit better. See [Gemini skills replace Gems: a weekly hot posts digest](/en/blog/gemini-skills-weekly-hot-posts-digest). For a long report with citations, the Deep Research API can also use MCP. See [Gemini Deep Research API with MCP for social data](/en/blog/gemini-deep-research-api-mcp-social-data). This post answers one question only. For the two routes into the Gemini app, what must a data tool prepare, and where does it get stuck? ## Requirements and review: nine steps in Connected Console The Console guide splits launch into 9 steps. We have no Console account. The table below is a configuration example that follows the doc text, and we did not run it. | Step | Task | What to prepare | Hard part for data tools | | --- | --- | --- | --- | | 1 | Create the app and pick a category | The category cannot change later | "Data lookup" is not a category, so you pick the closest one | | 2 | App details | Name, one-sentence description under 30 words, 512×512 icon up to 1 MB, 3+ capabilities, 3+ example prompts | At least 2 prompts must start with @AppName, and at least 1 must mention the name naturally | | 3 | MCP endpoint and domain check | Public HTTPS URL; a file at `/.well-known/google-connected-apps` that returns 200 with no redirect | The file must sit on the MCP server's own domain | | 4 | Auth method | No auth; machine-to-machine (Client ID, optional secret); or user-delegated (pre-registered, CIMD, or DCR) | No API key header option | | 5 | Test accounts | Seeded accounts for reviewers, with 2-step verification off | A paid data service must pre-fund reviewer accounts | | 6 | Sync tool snapshot | The published version is frozen; the doc suggests a new URL per version | Any change to a tool description needs a new sync | | 7 | Availability | Countries, languages, products; per-tool switches; context signals; user confirmation | Write and paid tools need confirmation settings | | 8 | Testers | Testers must use @gmail.com accounts; changes take up to 10 minutes | Team members need personal Gmail accounts | | 9 | Submit for review | Status changes to ready to publish after review | The doc gives no review time | ![Screenshot of a Google developer doc page titled Perform the steps in Google Connected Console, step 4 on authentication. It lists three options: No authentication; Machine-to-machine (OAuth Client Credentials) with a Client ID and an optional Client Secret; and User-delegated (Authorization Code) through Google Account Linking. Below, the page recommends CIMD or DCR and says Google checks CIMD first, then DCR. The user-delegated part has a teal box. The footer shows Last updated 2026-10-28 UTC.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/img-doc-console-auth.webp) Step 4 in Console offers three auth options and no place for an API key header (screenshot from the page as read on 2026-11-11, cropped to this section). [Google Connected Apps docs: Perform the steps in Google Connected Console](https://developers.google.com/connected-apps/gpc/perform-the-steps) The prerequisites page has more hard rules that are easy to miss ([Prerequisites, updated Oct 30](https://developers.google.com/connected-apps/gpc/prerequisites)). First, each connected app gets one global MCP URL. Separate data center URLs are not allowed, and a country domain is only allowed for a launch in that one country. Second, a server that filters by source IP must allow 7 Google ranges. Google also suggests a regular refresh from its [list of user-triggered agent IP ranges](https://developers.google.com/static/crawling/ipranges/user-triggered-agents.json). Third, an owner or admin of the organization must accept the Console terms before other members can continue. Fourth, you need public URLs for terms of service and privacy policy. The MCP request flow page adds one more rule. Every JSON-RPC request from Google carries `User-Agent: Google` ([MCP request flow, updated Oct 27](https://developers.google.com/connected-apps/mcp/mcp-flow)). If your gateway blocks bots by user agent, make sure it lets this one through. At 00:17 Singapore time we probed EveryInfra with `User-Agent: Google`. On `/mcp`, the handshake and the tool list both returned 200. `GET /mcp` returned 405 with `Allow: POST`. Google's server optimization page says that is fine ([Server optimization, updated Oct 27](https://developers.google.com/connected-apps/mcp/server-optimization)). The path `/.well-known/google-connected-apps` returned 404, because we never applied and have no verification file. Here is a self-check you can copy. It is a configuration example, so put in your own domain. ```bash # Configuration example: pre-launch self-check (replace api.example.com with your MCP domain) curl -s -o /dev/null -w "%{http_code} %{redirect_url}\n" \ https://api.example.com/.well-known/google-connected-apps # needs 200 and no redirect curl -s -o /dev/null -w "%{http_code}\n" -X GET https://api.example.com/mcp # 405 is acceptable curl -s https://api.example.com/mcp -A "Google" \ -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" \ -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-11-25","capabilities":{},"clientInfo":{"name":"self-check","version":"0"}}}' ``` ## Auth: how Gemini can get into your server Auth is the first wall for a data tool. Like most data services, EveryInfra's `/mcp` accepts only an API key in a request header. A customer creates a key in the console and puts it in Claude Desktop, Cursor, or their own code. Every request then carries the key. None of Google's three auth options covers this. Developer Mode is the same: its auth tab offers dynamic client registration or manual client registration, and both are OAuth ([Use Developer Mode](https://developers.google.com/connected-apps/mcp/dev-mode/usage)). So a key-only data MCP fails at the first step in the Gemini app, however well it is built. What about OAuth? EveryInfra has a second set of endpoints, `/mcp/all` and one per platform such as `/mcp/youtube`, that accept OAuth sign-in. In the same minute, we walked the discovery order from the MCP authorization spec to see what Gemini would see ([MCP authorization, 2025-11-25](https://modelcontextprotocol.io/specification/2025-11-25/basic/authorization)). A call to `/mcp/all` with no credentials returned 401 at 00:17:48 Singapore time. The `WWW-Authenticate` header carried the resource metadata URL and the scopes. That matches section 5.1 of [RFC 9728](https://www.rfc-editor.org/rfc/rfc9728). ```text HTTP/1.1 401 Unauthorized www-authenticate: Bearer resource_metadata="https://api.everyinfra.com/.well-known/oauth-protected-resource/mcp/all", scope="data:call search:call captcha:call ai:call account:read offline_access" GET https://api.everyinfra.com/.well-known/oauth-protected-resource/mcp/all -> 200, authorization_servers: https://auth.everyinfra.com/oidc GET https://auth.everyinfra.com/oidc/.well-known/oauth-authorization-server -> 200 code_challenge_methods_supported: ["S256"] # PKCE: pass client_id_metadata_document_supported: true # CIMD: pass registration_endpoint: (field not present) ``` The first three steps pass. The 401 points to the resource metadata, that metadata returns 200, and the authorization server metadata returns 200 ([RFC 8414](https://www.rfc-editor.org/rfc/rfc8414)). PKCE uses S256 ([RFC 7636](https://www.rfc-editor.org/rfc/rfc7636)). Step 4, client registration, is where it stops. Google's OAuth guide lists four required fields: `authorization_endpoint`, `token_endpoint`, `response_types_supported` with code, and `registration_endpoint`. The guide adds one more rule. The Gemini app currently needs a dedicated registration endpoint, even if the server supports Client ID Metadata Documents ([OAuth guide, updated Sep 14](https://developers.google.com/connected-apps/mcp/oauth)). That endpoint is dynamic client registration from [RFC 7591](https://www.rfc-editor.org/rfc/rfc7591). EveryInfra supports CIMD ([CIMD draft](https://datatracker.ietf.org/doc/draft-ietf-oauth-client-id-metadata-document/)) but does not offer dynamic registration. By that guide, the Gemini app stops here. Two Google pages disagree on this point. The Console steps page, updated later on October 28, recommends CIMD or DCR for user-delegated auth. It says Google checks CIMD first and DCR second ([Console steps](https://developers.google.com/connected-apps/gpc/perform-the-steps)). The OAuth guide from September 14 says the Gemini app needs a registration endpoint. Field reports lean toward the older page. An r/mcp thread from October 19 asks about Gemini custom connectors. One reply says Gemini does not support CIMD yet, so you enter a client ID by hand ([r/mcp thread](https://www.reddit.com/r/mcp/comments/1xaba94/custom_connectors_gemini/)). Our read is this. CIMD may work for a Console listing. For Developer Mode tests, a registration endpoint is the safer bet. We cannot test either path from outside the US, so a US developer needs to confirm it. Even with full metadata, one more gate remains: who may sign in. EveryInfra's OAuth sign-in is open to a short list of registered AI clients, matched by their CIMD URL. Google's redirect URLs are not on that list. Google's OAuth guide lists the Gemini redirect URLs under `oauth-redirect.googleusercontent.com`, with sandbox and test variants. It also asks for long-lived account links with no refresh token rotation ([OAuth guide](https://developers.google.com/connected-apps/mcp/oauth), [Google Account Linking](https://developers.google.com/identity/account-linking/oauth-linking)). So "support OAuth" means a chain of work for a data service. Open dynamic registration or confirm that CIMD is accepted. Add Google's redirect URLs to the allow list. Issue separate tokens for machine calls and user calls. Keep refresh tokens stable. That is not a weekend job. Many developers get stuck here. A thread on the Google AI developer forum from October 2 says a custom app's OAuth flow stops at the callback. Gemini never calls the token endpoint, while the same server works in Claude and ChatGPT ([Google AI developer forum](https://discuss.ai.google.dev/t/gemini-app-spark-custom-apps-mcp-oauth-never-exchanges-the-code-cannot-complete-request-on-oauth-redirect-googleusercontent-com/186405)). On October 22, a post in r/GeminiAI asked which callback URL a custom connector needs ([r/GeminiAI](https://www.reddit.com/r/GeminiAI/comments/1xcbzub/gemini_app_adding_custom_connectors/)). Another r/GeminiAI thread reports a server that sent protocol version `2026-07-28`. Gemini then said the URL did not look like a valid MCP server ([r/GeminiAI](https://www.reddit.com/r/GeminiAI/comments/1wwe3u1/gemini_now_supports_general_mcp_servers/)). That last report fits the docs. The server optimization page supports MCP versions up to 2025-11-25 ([Server optimization](https://developers.google.com/connected-apps/mcp/server-optimization)). At 00:27 Singapore time we asked EveryInfra for version `2026-07-28`, and it answered with `2025-11-25`. The MCP spec allows this kind of negotiation, where the server replies with the version it supports ([MCP spec 2026-07-28](https://modelcontextprotocol.io/specification/2026-07-28)). So version is not a blocker. We also labeled the 14 posts from our November 11 `reddit/search` call by title. Of these, 8 are about connecting MCP to Gemini. Most of them ask about OAuth that fails for custom connectors. Others ask how to link Gemini on the web with Antigravity, or how one server can serve Claude, ChatGPT, and Gemini at once. On October 17 in r/modelcontextprotocol, a developer of a stock market data MCP shared their setup ([r/modelcontextprotocol](https://www.reddit.com/r/modelcontextprotocol/comments/1x8lxcq/how_i_got_one_stock_market_data_mcp_server_into/)). Claude and ChatGPT use OAuth with dynamic client registration, and other clients use a Bearer header. For Gemini, they used a Gemini CLI extension install, not the Gemini app. ## Tool design: 12 rules from Google's docs After auth, reviewers and the Gemini model see your tool list. Google's quality, server optimization, and policy pages set many rules for tools. We picked 12 that a server response can prove or disprove. Then we checked them against the real `tools/list` and `initialize` responses of three EveryInfra endpoints. One author made each call, and the data file records the rule and the evidence for each cell. A 2 means the endpoint meets the rule, 1 means it partly meets it, and 0 means it does not. ![Heat table with 12 rows for rules from Google's docs and 3 columns for EveryInfra /mcp, /mcp/youtube, and /mcp/all. Teal cells meet the rule, light cells partly meet it, and gray cells do not. Transport, protocol version, server instructions, annotations on every tool, and JSON in TextContent meet the rule in all three columns. Read-only tools without destructive, no generic dispatcher, enums for fixed values, and rate limits as JSON-RPC errors fail in all three columns. Date format is partial in all three. Tool count is partial for /mcp/all. Auth method is partial for /mcp/all and fails for the other two. The title says /mcp meets 6 rules and /mcp/all meets 5.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/fig-02-requirements-heat.en.light.svg) | Google rule | Source | `/mcp` | `/mcp/youtube` | `/mcp/all` | Evidence | | --- | --- | --- | --- | --- | --- | | Streamable HTTP, one URL for POST | Server optimization | Meets | Meets | Meets | POST returns 200 on all three; GET returns 405 | | Handshake version no newer than 2025-11-25 | Server optimization | Meets | Meets | Meets | All return `2025-11-25` | | Server instructions in `initialize` | Troubleshooting | Meets | Meets | Meets | 3,993 / 2,092 / 3,973 characters | | Annotations on every tool | Server optimization | Meets | Meets | Meets | 12/12 and 3/3 | | Read-only data tool not marked destructive | Server optimization, video | Fails | Fails | Fails | `everyinfra_call_api` has `destructiveHint=true` | | No generic dispatch or discovery tools | Policy, Integration integrity | Fails | Fails | Fails | One tool dispatches by platform and action | | Enums for fixed values | Server optimization | Fails | Fails | Fails | platform and action are free strings | | Not dozens of tools | Server optimization | Meets | Meets | Partly | 12 / 3 / 24 tools | | Results as JSON in TextContent | Server optimization | Meets | Meets | Meets | Success results sit in `content[0].text` | | Terminal errors as JSON-RPC codes | Server optimization | Fails | Fails | Fails | Rate limit returns 200 with `isError` | | Dates in a stated format | Server optimization | Partly | Partly | Partly | Search uses ISO time, comments use "11 days ago" | | Auth method among Google's options | Console step 4 | Fails | Fails | Partly | See the auth section | Start with what works. Google's troubleshooting page flags a missing `instructions` field in `initialize` as a warning ([Troubleshooting, updated Oct 27](https://developers.google.com/connected-apps/gpc/troubleshooting)). The server optimization page says instructions should tell the model which tool to use and how to combine them. EveryInfra's `/mcp` sends 3,993 characters of instructions at handshake. One example line tells the model to ask about platform, keyword, count, freshness, and budget, then run a small test first. At about 4 characters per token, that is about 998 tokens ([Gemini API tokens](https://ai.google.dev/gemini-api/docs/tokens)). Results are JSON inside TextContent, which is the format Google wants now. The server optimization page says `structuredContent` is not supported yet, so the JSON goes into the text content. Two of the failures are about style and are easy to fix. The first is enums. In `everyinfra_call_api`, `platform` and `action` are free strings. Google suggests enums for fixed values, so the model guesses less. EveryInfra corrects bad guesses after the fact. At 00:24 Singapore time we sent `serch` instead of `search` on purpose. The response had `isError`, the code `unknown_capability`, a "did you mean `search`" hint, the list of valid actions, and a note that nothing was charged. That helps a model fix itself, but it costs one more round trip. The per-platform `/mcp/youtube` serves one platform with 8 actions, so it could use an enum today. The second is time format. `youtube/search` returns ISO times, but `youtube/comments` returns relative text like "11 days ago". The model must convert before it can compare. Google suggests stating the format in the field description. The other two failures are design problems that take more work. The next section covers them. ## Policy: generic dispatch tools and confirmation prompts The November 2 version of the Connected Apps policy has a section called Integration integrity. In short, a listed app must not expose dynamic discovery functions such as `list_tools` or `get_schema`. It also must not expose a generic runtime dispatcher such as `execute_command` or `invoke_dynamic_tool`. Tool definitions are fixed at registration, so reviewers see what users will get ([Connected apps policy, updated Nov 2](https://developers.google.com/connected-apps/connected-apps-policy)). The same policy also asks for data minimization and bans requests for chat history. ![Screenshot of the Integration integrity section on the Google Connected apps policy page. It lists several rules. The Dynamic tool schemas rule has a teal box: no dynamic discovery functions such as list_tools or get_schema, and no generic runtime dispatchers such as execute_command or invoke_dynamic_tool. The footer shows Last updated 2026-11-02 UTC.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/img-doc-policy-integrity.webp) The Integration integrity section bans generic dispatch and dynamic discovery tools (screenshot from the page as read on 2026-11-11, cropped to this section). [Google Connected Apps docs: Connected apps policy](https://developers.google.com/connected-apps/connected-apps-policy) This rule hits data MCP servers directly. The EveryInfra catalog we read at 00:17 Singapore time lists 106 platforms and 573 capabilities, with 538 available. One tool per capability would mean hundreds of tools. Google's server optimization page says "dozens of tools" will get flagged. So EveryInfra, like most multi-platform data services, uses one `everyinfra_call_api` that dispatches by platform and action. A free `everyinfra_list_capabilities` tool lets the model look up the catalog first. Here is that tool from the `tools/list` result at 00:17, trimmed: ```text { "name": "everyinfra_call_api", "title": "Call a data capability", "annotations": { "readOnlyHint": false, "openWorldHint": true, "destructiveHint": true }, "description": "Call any EveryInfra data capability and get structured JSON. ... Check platform/action, required params and max_limit or page_size with everyinfra_list_capabilities first. ...", "inputSchema": { "type": "object", "required": ["platform", "action"], "properties": { "platform": { "type": "string", "description": "e.g. xiaohongshu / twitter / tiktok / web" }, "action": { "type": "string", "description": "e.g. search / profile / user_posts / post" }, "params": { "type": "object" }, "mode": { "type": "string", "enum": ["sync", "async"], "default": "sync" } } } } ``` This design works well in Claude, ChatGPT, and Cursor. The model reads the catalog, then calls with the right parameters. Under Google's policy, though, it breaks two rules at once: generic dispatch and dynamic discovery. A listing would need fixed tools named by task, such as `search_youtube_videos`, `search_reddit_posts`, and `get_reddit_comments`. Each would have fixed parameters with enums. Google's naming advice is the same: verb_noun names, one job per tool, and flat parameters. The `/mcp/youtube` endpoint is a step in that direction. It has 3 tools and a 4,020-byte list. Inside, though, it still pairs `call_api` with `list_capabilities` and does not split tools by task. The second design problem is confirmation prompts. Google's server optimization page says a tool with both `destructiveHint` and `openWorldHint` triggers a user confirmation. A tool with no `readOnlyHint` counts as destructive. The developer session is more direct at 7:52. Confirmation strength follows risk, it does not pop up on every call, and a lookup should feel smooth ([developer session](https://www.youtube.com/watch?v=-4G-4w9FKDw)). The Gemini help center also says Gemini asks the user to confirm write actions by hand ([Gemini Help: custom apps](https://support.google.com/gemini/answer/17209137?hl=en)). Seven of EveryInfra's 12 tools are read-only. They list capabilities, read job status, read the account, read tickets, get a top-up link, list CAPTCHA types, and list past requests. The main data tool, `everyinfra_call_api`, carries `destructiveHint=true`. The reason is that each call takes money from a wallet. Under the MCP spec, a tool that changes outside state should say so ([MCP spec: tools](https://modelcontextprotocol.io/specification/2025-11-25/server/tools)). The result in Gemini is a likely confirmation prompt on every data lookup. This is a real trade-off. A read-only mark gives a smooth flow but is not honest for a paid tool. A destructive mark is honest but shows a prompt each time. The Google session asks developers to mark tools honestly. Our suggestion is to move the payment out of the tool's meaning. The user agrees to a monthly budget during OAuth consent. Inside that budget, data tools are honestly read-only. Over budget, they return an error and do not charge. That needs a per-grant budget on the server, which EveryInfra does not have today. ## One real round trip: what tools/list and tools/call return Below is the kind of request Gemini would send to an MCP server. We sent it from our own machine with an EveryInfra API key and `User-Agent: Google`. The first data call ran at 00:18:30 Singapore time and searched YouTube for videos about Gemini Connected Apps. ```bash curl -s https://api.everyinfra.com/mcp -A "Google" \ -H "Authorization: Bearer $EVERYINFRA_API_KEY" \ -H "Content-Type: application/json" -H "Accept: application/json, text/event-stream" \ -H "MCP-Protocol-Version: 2025-11-25" \ -d '{"jsonrpc":"2.0","id":10,"method":"tools/call","params":{"name":"everyinfra_call_api", "arguments":{"platform":"youtube","action":"search","params":{"keyword":"Gemini Connected Apps Platform","sort":"relevance","limit":20}}}}' # Response (trimmed): HTTP 200, 8.36 s, 41,840 bytes # {"jsonrpc":"2.0","id":10,"result":{"content":[{"type":"text","text":"{\"platform\":\"youtube\",\"action\":\"search\", # \"results\":[{...}, {...}, {\"title\":\"Extend your app to Gemini and Search with the Connected Apps Platform\", # \"posted_at\":\"2026-10-29T19:55:04+00:00\",\"view_count\":1265, ...}, ... 20 rows], # \"billing\":{\"charged\":true,\"charged_usd\":0.000556, ...}}"}]}} ``` ![Screenshot of a code card. The top part shows a tools/call request to https://api.everyinfra.com/mcp with tool everyinfra_call_api, platform youtube, action search, keyword Gemini Connected Apps Platform, and limit 20, labeled 2026-11-11 00:18:30 Singapore time, HTTP 200, 8.36 s, 41,840 bytes. The middle shows the JSON-RPC envelope with the result in content[0\].text. The bottom shows parsed video titles, dates, and view counts with individual creator names hidden, and billing charged_usd 0.000556 in a teal box.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/img-mcp-response.webp) A real MCP tool call. The result is JSON inside TextContent, and the billing data sits in the same text (individual creator names and the account balance are hidden). [EveryInfra MCP endpoint, raw response from 2026-11-11](https://api.everyinfra.com/mcp) The shape is what Google asks for. The result is JSON text in `content[0].text`, with no `structuredContent`. Each video has 22 fields, such as title, link, channel, date, views, length, thumbnail, and a text snippet. They match the fields on the [YouTube video search API page](/en/youtube-api/search). The table lists all 8 data calls. All went to the same MCP URL, except one transcript call through the REST API for comparison. | Time (Singapore time) | Via | Capability | Result | Latency | Charge | | --- | --- | --- | --- | --- | --- | | 00:18:30 | MCP | `youtube/search` | 20 videos | 8.36 s | $0.000556 | | 00:18:52 | MCP | `reddit/search` | 14 posts | 5.14 s | $0.000556 | | 00:19:08 | MCP | `reddit/comments` (r/mcp post) | 5 comments | 11.60 s | $0.000556 | | 00:19:20 | MCP | `reddit/comments` (r/GoogleGemini post) | 4 comments | 9.68 s | $0.000556 | | 00:19:30 | MCP | `reddit/comments` (post with no comments) | 0 | 55.66 s | $0 | | 00:22:38 | REST | `youtube/transcript` (developer session) | 454 segments | 6.09 s | $0.000556 | | 00:24:28 | MCP | `youtube/comments` (developer session) | 2 comments | 13.66 s | $0.000556 | | 00:35:03 | MCP | `reddit/search`, newest first | 1 post | 4.30 s | $0.000556 | ![Horizontal bar chart of latency in seconds for 8 data calls on November 11, 2026: youtube/search 8.4, reddit/search 5.1, reddit/comments first 11.6, second 9.7, third 55.7, youtube/transcript 6.1, youtube/comments 13.7, and reddit/search second 4.3. The third reddit/comments bar is teal. The subtitle says it was a post with no comments, took 55.7 seconds, returned 0 rows, and cost nothing, while the other 7 calls cost $0.000556 each.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/fig-05-latency-bar.en.light.svg) The median latency was 9.0 seconds. The slowest call deserves a note. A Reddit post with no comments took 55.7 seconds to return 0 rows, and it cost nothing. For Gemini this means two things. First, the MCP client needs a long timeout. Gemini CLI waits 10 minutes by default ([Gemini CLI MCP setup](https://geminicli.com/docs/tools/mcp-server/)). The Gemini app's timeout is not in the docs, and we could not test it. Second, because empty results are free, asking the model to try one more post costs only time. For a pay-per-call data tool, test keywords and sort order on a small scale first. Error responses matter too, because Google has its own rules for them. At 00:21:27 Singapore time we hit this key's limit of 10 requests per minute. In the same second, the REST API returned HTTP 429. The MCP endpoint returned HTTP 200 with `isError: true`, the code `rate_limited`, and `retry_after` of 33 seconds, with a note that nothing was charged. At 00:24:42 a call with no key also returned HTTP 200 with `isError`, this time with the code `unauthorized`. The MCP spec lets a server put tool errors in the result, so the model can see them and fix its call. Google's server optimization page adds a rule for terminal errors. Errors the model cannot fix, such as rate limits or a need to sign in again, should be JSON-RPC errors. A rate limit should use -32300 (USER_RATE_LIMITED). EveryInfra's current style works well in Claude and Cursor, where the model waits for `retry_after` and tries again. In Gemini, by the docs, it counts as a normal tool failure. | Case (Singapore time) | REST API | MCP endpoint | What Google's page asks | | --- | --- | --- | --- | | Rate limit, 00:21:27 | HTTP 429, `retry-after: 33` | HTTP 200, `isError`, `rate_limited`, `retry_after` 33 | JSON-RPC error -32300 | | Wrong action name, 00:24:41 | Not tested | HTTP 200, `isError`, `unknown_capability`, hint for `search` | Tool error is fine, because the model can fix it | | No key, 00:24:42 | Not tested | HTTP 200, `isError`, `unauthorized` | A sign-in problem the model cannot fix, so a JSON-RPC error | | Charge in each case | None | None | No rule; the docs do not cover billing | ## Response size: the model's reading costs more than the data This is the most surprising finding in this test. Developers of pay-per-call data tools usually watch only the data fee. In Gemini, the whole JSON response goes into the model's context, and the model's reading has a price too. ![Grouped bar chart of bytes in two live search responses on November 11, 2026. youtube/search with 20 videos is 39,732 bytes as returned and 5,062 bytes with 6 fields. reddit/search with 14 posts is 25,212 bytes as returned and 4,274 bytes with 6 fields. The 6-field bars are teal, and the title says youtube/search drops to 12.7% of its size.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/fig-03-payload-bar.en.light.svg) The `youtube/search` response text was 39,732 bytes. The 20 results took 38,825 bytes, with 22 fields each. To answer "which recent videos cover Connected Apps," you need only 6 fields: title, link, channel, date, views, and comment count. With those 6, the size drops to 5,062 bytes, or 12.7% of the original. The `reddit/search` response had 14 posts in 25,212 bytes. With title, link, community, time, likes, and comments, it drops to 4,274 bytes, or 17.0%. Google's server optimization page gives the same advice: aggregate on the server, and do not dump raw data into the model. ![Horizontal bar chart of estimated cost per call in US dollars at November 11, 2026 prices: youtube/search data fee 0.000556, model reads the full result about 0.00745, model reads 6 fields about 0.00095; reddit/search data fee 0.000556, model reads the full result about 0.004727, model reads 6 fields about 0.000801. The data fee bars are teal. The subtitle says the estimate uses about 4 characters per token and Gemini 3.8 Flash input at $0.75 per 1M tokens.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/fig-04-cost-bar.en.light.svg) The dollar view is clearer. The Gemini API docs say one token is about 4 characters ([tokens](https://ai.google.dev/gemini-api/docs/tokens)). By that rule, the raw `youtube/search` result is about 9,933 tokens. Gemini 3.8 Flash on the paid tier charges $0.75 per 1M input tokens through December 31, 2026 ([Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing)). One read of that result is about $0.00745, or 13.4 times the $0.000556 data fee. With 6 fields it is about 1,266 tokens and $0.00095, or 1.7 times the data fee. For `reddit/search` the ratio drops from 8.5 to 1.4. These ratios use the fee that the November 11 call actually charged. We read the catalog again on November 12. `youtube/search` now costs $0.000778, and `reddit/search` costs $0.000792. At these prices, `youtube/search` goes from 9.6 times to 1.2 times, and `reddit/search` goes from 6.0 times to 1.0 times. This counts only one read of the tool result. It leaves out the prompt, chat history, and output. From January 1, 2027, Gemini 3.8 Flash input goes to $1.50 per 1M tokens, which doubles these ratios. | Capability | Rows | Raw bytes | Raw tokens (est.) | Model input (est.) | 6-field tokens | 6-field input | Data fee | | --- | --- | --- | --- | --- | --- | --- | --- | | `youtube/search` | 20 | 39,732 | 9,933 | $0.00745 (13.4×) | 1,266 | $0.00095 (1.7×) | $0.000556 | | `reddit/search` | 14 | 25,212 | 6,303 | $0.004727 (8.5×) | 1,068 | $0.000801 (1.4×) | $0.000556 | In the Gemini app, Google pays the model cost, and users do not see it. Still, Google's server optimization page lists large responses as a quality problem. Bigger responses make the model lose details in long context and answer more slowly. That can hurt both review and ranking. When you connect MCP through the Gemini API, you pay this cost yourself. On any route, a data tool should offer a "these fields only" parameter, or ship task-shaped tools that return trimmed rows. ## The tool list also takes context Before any tool call, the model reads the whole tool list. You pay for that on every turn. ![Horizontal bar chart of tools/list response size in bytes for three endpoints on November 11, 2026: /mcp/youtube with 3 tools 4,020 bytes; /mcp with 12 tools 16,250 bytes; /mcp/all with a key and 24 tools 32,921 bytes. The /mcp/youtube bar is teal. The subtitle gives estimated tokens at 4 characters per token: about 1,005, 4,063, and 8,230.](https://everyinfra.com/articles/gemini-connected-apps-platform-data-tools/fig-06-tools-size-bar.en.light.svg) We read three tool lists at 00:17 and 00:27 Singapore time. The general `/mcp` endpoint has 12 tools in 16,250 bytes, about 4,063 tokens. The per-platform `/mcp/youtube` has 3 tools in 4,020 bytes, about 1,005 tokens. The `/mcp/all` endpoint with a key has 24 tools in 32,921 bytes, about 8,230 tokens. The longest single tool definition is the ticket tool at 2,958 bytes, and the search tool is next at 2,640 bytes. | Endpoint | Tools | `tools/list` bytes | Tokens (est.) | Fits | | --- | --- | --- | --- | --- | | `/mcp/youtube` | 3 | 4,020 | about 1,005 | One platform, short tool list | | `/mcp` | 12 | 16,250 | about 4,063 | General use with an API key | | `/mcp/all` (with key) | 24 | 32,921 | about 8,230 | Clients that sign in with OAuth | A user who only wants Gemini to search YouTube saves about 3,000 tokens per turn with `/mcp/youtube` instead of `/mcp`. Gemini API `allowed_tools` and Gemini CLI `includeTools` filter tools on the client. Still, the client may read the full list once first. A server that splits endpoints by use case gives a more reliable result. This points the same way as the last section: for Gemini, narrow tools are better. ## What data tools can do today: the Gemini API and Gemini CLI Maybe your goal is for your own team or your customers' agents to use your data on Gemini models. Discovery by ordinary users in the Gemini app may not matter. In that case you can connect today, with no review and no US limit. Both blocks below are configuration examples that follow Google's field names. We did not run them with a Gemini API key. The Interactions API in the Gemini API supports remote MCP. The docs say it works with Streamable HTTP only and that server names must not contain a hyphen. The `headers` object goes to the MCP server with every request, and `allowed_tools` limits which tools the model may call ([Gemini API function calling](https://ai.google.dev/gemini-api/docs/function-calling)). Put the read-only catalog tool and the data tool on the allow list. Keep the model away from the others, such as tickets and top-up links. ```text # Configuration example: Gemini API Interactions with the EveryInfra remote MCP (not run) import os from google import genai client = genai.Client() interaction = client.interactions.create( model="gemini-3.8-flash", input="Find this week's Reddit posts about Gemini custom MCP apps and list the main problems people report.", tools=[{ "type": "mcp_server", "name": "everyinfra_youtube_reddit", # the docs say: no hyphen in the name "url": "https://api.everyinfra.com/mcp", "headers": {"Authorization": "Bearer " + os.environ["EVERYINFRA_API_KEY"]}, "allowed_tools": ["everyinfra_list_capabilities", "everyinfra_call_api", "everyinfra_get_job"], }], ) ``` Gemini CLI uses `mcpServers` in `settings.json` ([Gemini CLI MCP setup](https://geminicli.com/docs/tools/mcp-server/)). `httpUrl` uses Streamable HTTP, and `headers` carries request headers. `includeTools` is a tool allow list, and `timeout` defaults to 600,000 ms. Setting `trust` to true skips all confirmations, so keep it false for paid tools. The same page warns against secrets written into the config file. The block below uses a placeholder. Replace it with the environment variable syntax from the docs. ```text { "mcpServers": { "everyinfraYoutube": { "httpUrl": "https://api.everyinfra.com/mcp/youtube", "headers": { "Authorization": "Bearer " }, "includeTools": ["everyinfra_list_capabilities", "everyinfra_call_api"], "timeout": 120000, "trust": false } } } ``` Which one to pick depends on who uses it. For a program on a schedule, such as a morning digest or an hourly keyword check, the Gemini API fits better. The request, tool allow list, and model version all live in code. You can trace a problem by request ID and track cost per call. For a developer or analyst who asks questions in a terminal, Gemini CLI is easier. You set it up once, then ask in plain words, and the CLI uses the `trust` setting to decide on confirmations. Both use the same remote MCP URL, the same key, and the same wallet, so you can switch without server changes. | Setting | Gemini API `mcp_server` | Gemini CLI `mcpServers` | | --- | --- | --- | | Server address | `url` | `httpUrl` | | API key | `headers` | `headers` | | Tool allow list | `allowed_tools` | `includeTools` | | Timeout | Not in the docs we read | `timeout`, 600,000 ms by default | | Confirmations | Your own code decides | `trust: false` keeps them on | Both routes share two benefits. An API key works as is, with no OAuth work just for Google. The tool allow list is in your hands, so you can expose data tools only and decide on confirmations in your own code. The cost is reach: ordinary users will not see you in the @ list. Most users of data tools are developers, analysts, and teams that build their own agents, and for them this route is enough. Parameters and fields for each platform are on the [YouTube data API](/en/youtube-api) and [Reddit data API](/en/reddit-api) pages. For comments and transcripts, see the [Reddit comments API page](/en/reddit-api/comments), the [YouTube comments API page](/en/youtube-api/comments), and the [YouTube transcript API page](/en/youtube-api/transcript). ## What to change before a Connected Apps listing A listing makes sense for a service with its own user accounts. There, users keep their own data, such as orders, projects, saved items, or monitoring jobs. Google's quality page puts "better when signed in" first among the traits of a good app. The same page says a connected app is not a replacement for a data feed. It also says connected apps are not for generic information that needs no sign-in ([Quality, updated Oct 28](https://developers.google.com/connected-apps/mcp/quality)). That line matters a lot for public data tools. If your tool only searches public YouTube videos, a reviewer may ask why a user must sign in to your app for that. Some tools show the user's own data. Examples: what the user's brand monitor found this week, or the user's saved competitor posts grouped by sentiment. That is a good fit. Check the policy and the platform terms early. The Connected Apps policy does not allow a service to wrap or repackage third-party APIs that it does not own. Each platform also has its own terms, such as the [YouTube API Services Developer Policies](https://developers.google.com/youtube/terms/developer-policies) and the [Reddit Data API Terms](https://redditinc.com/policies/data-api-terms). Both set rules on how you show and store data. Before a listing, be ready to explain what your tool adds on top of raw data. Examples are aggregation, deduplication, scoring, long-term storage, and organization around each user's own tasks. Only that part is yours. From the checks above, a data MCP needs at least these changes before a listing. Open dynamic client registration, and add Google's redirect URLs to the allow list. Split the generic dispatch tool into a few task-named tools with fixed parameters and enums. Mark data tools read-only, and control spending through a budget set at consent. Return rate limits and sign-in errors as JSON-RPC errors. Return only the fields the model needs, and use ISO time everywhere. Put a verification file at `/.well-known/google-connected-apps`. Google's UI guidelines also ask MCP Apps to meet WCAG AA contrast with a 13 pt minimum font size ([UI guidelines, updated Oct 28](https://developers.google.com/connected-apps/mcp/guidelines)). If you plan interactive cards, design for that from the start. During development, debug locally with the [MCP Inspector](https://github.com/modelcontextprotocol/inspector). Then deploy to a public HTTPS service such as Cloud Run, as the Google session does ([Cloud Run deploy docs](https://cloud.google.com/run/docs/deploying)). Google's vertical journeys page lists the app types it wants, such as music, content creation, groceries with the Universal Commerce Protocol, and real estate. Each type has an expected user journey ([Vertical journeys, updated Oct 28](https://developers.google.com/connected-apps/mcp/vertical-journeys)). Data analysis and social monitoring are not on the list. That does not rule them out. It does mean you must pick an existing category, and reviewers have no ready model for what such an app should do. ## Monthly cost: a small example Take a team that runs an agent on the Gemini API with the EveryInfra remote MCP. Each day the agent builds a "Gemini developer news" digest. It runs one YouTube search, one Reddit search, comments on 3 hot posts, and comments on 1 video, for 6 data calls a day. We read the catalog again on November 12, 2026. `youtube/search` costs $0.000778 per call, `reddit/search` and `reddit/comments` cost $0.000792, and `youtube/comments` costs $0.000556. Over 30 days that is 180 calls and about $0.1351 in data fees. At the November 11 prices, when all 4 capabilities cost $0.000556, the same use cost $0.1001. The [pricing page](/en/pricing) has the current prices. | Item | Per day | Per month (30 days) | Note | | --- | --- | --- | --- | | EveryInfra data fees | $0.000778 + 4 × $0.000792 + $0.000556 | about $0.1351 | `youtube/search`, `reddit/search`, 3 × `reddit/comments`, `youtube/comments` | | Model reads both raw search results (est.) | $0.00745 + $0.004727 | about $0.3653 | Gemini 3.8 Flash input, tool results only | | Model reads both 6-field results (est.) | $0.00095 + $0.000801 | about $0.0525 | Same basis | | Tool list on `/mcp` (est.) | about 4,063 tokens per turn | depends on turns | About 1,005 tokens per turn on `/mcp/youtube` | The table shows ratios, not a full bill. For the two searches alone, raw reads cost about $0.3653 a month, or 2.7 times the whole month of data fees. With 6 fields, the cost is about $0.0525, which is less than the data fees. The free empty result also helps in practice: 1 of our 8 calls was empty and cost nothing. Our 8 live data calls on November 11 cost $0.003892 in total. ## Limits and open points First, the docs do not give the Gemini app's timeout, the look of the confirmation prompt, or the review time. The developer session says confirmation follows risk but gives no rule for it. Second, Google's redirect URLs, IP ranges, and supported MCP versions may change during the preview. Check the "Last updated" date on each page before a listing. Third, token counts use the rule of about 4 characters per token. Real tokenization differs, so read the model costs as ratios only. Fourth, the EveryInfra latency and size numbers come from one round of live calls on November 11. The prices come from the catalog as we read it on November 12. Check the API pages and the catalog again before you connect. ## FAQ ### Does the Gemini Connected Apps Platform cost money? The Google blog, product page, and Console docs do not mention a fee to register or list, or a per-call charge ([product page](https://developers.google.com/connected-apps)). You still pay for your own servers, hosting, and data. If you connect MCP through the Gemini API instead, model calls follow [Gemini API pricing](https://ai.google.dev/gemini-api/docs/pricing). ### Can I use the Connected Apps Platform outside the US? Not yet. The developer session says the preview is for US developers only. On the user side, custom apps need a US location. Connected apps in AI Mode are US and English only ([Gemini Help](https://support.google.com/gemini/answer/17209137?hl=en), [Search Help](https://support.google.com/websearch/answer/17265703)). Teams outside the US can start with the Gemini API or Gemini CLI. ### Is there a Gemini Connected Apps Platform API? There is no separate API. The interface of the Connected Apps Platform is MCP. You run a remote MCP server, and Gemini and Search call it as MCP clients ([MCP developer guide](https://developers.google.com/connected-apps/mcp)). Registration, testing, and submission happen in the Connected Console web UI, and the docs do not mention a management API. To call MCP from Gemini in your own code, use the `mcp_server` tool in the Gemini API. That is a different route. ### My MCP server works in Claude. Why does Gemini fail to connect? There are three common causes. The protocol version is newer than 2025-11-25. The OAuth metadata has no `registration_endpoint`, or Google's redirect URLs are not on the allow list. Or the server accepts only an API key header. Start with Google's troubleshooting page. It lists common errors such as 405, missing protected resource metadata, missing authorization server metadata, and failed registration ([Troubleshooting](https://developers.google.com/connected-apps/gpc/troubleshooting)). ## Get started: make it work in your own code first 1. Create an API key in the EveryInfra console. 1. Follow the [quickstart](/en/docs#quickstart) to send one `tools/list` and one `tools/call` with curl, and check that the response has `billing`. Remote MCP setup for each client is on the [MCP server page](/en/mcp-server). 1. Pick a narrow endpoint. For YouTube only, use `/mcp/youtube`, which cuts the tool list from about 4,063 tokens to about 1,005. 1. Configure `mcp_server` in the Gemini API or `mcpServers` in Gemini CLI. Use `allowed_tools` or `includeTools` to expose data tools only. 1. Run one keyword with a small `limit` first. Check the response size, and tell the model in the prompt which fields to read. 1. For a Connected Apps listing with your own user accounts, work through the changes in the section above. Test in Developer Mode after that. Search parameters are on the [YouTube video search API page](/en/youtube-api/search) and the [Reddit post search API page](/en/reddit-api/search). For other clouds, see [Bedrock AgentCore Gateway with MCP: response format and bill](/en/blog/bedrock-agentcore-gateway-mcp-social-data). Also see [a social data agent with Airbyte MCP](/en/blog/airbyte-mcp-social-data-agent). ## References We read all Google pages on November 11, 2026 (Singapore time). Dates in parentheses are the publish or update dates shown on each page; pages without a date have none. EveryInfra numbers come from raw responses of live calls on the same day. 1. Google blog: Connected Apps Platform: bring your apps to Gemini and Search (2026-10-28) 1. Google for Developers: Connected Apps Platform home 1. Google for Developers: Connected Apps Platform MCP server developer guide (updated 2026-10-27) 1. Google for Developers: MCP request flow (updated 2026-10-27) 1. Google for Developers: Quality guidelines for connected apps (updated 2026-10-28) 1. Google for Developers: MCP server optimization (updated 2026-10-27) 1. Google for Developers: MCP Apps UI guidelines (updated 2026-10-28) 1. Google for Developers: Vertical user journeys (updated 2026-10-28) 1. Google for Developers: OAuth 2.1 implementation guide (updated 2026-09-14) 1. Google for Developers: Developer Mode (updated 2026-10-28) 1. Google for Developers: Use Developer Mode (updated 2026-10-28) 1. Google for Developers: Google Connected Console overview 1. Google for Developers: Prerequisites for using connected apps (updated 2026-10-30) 1. Google for Developers: Perform the steps in Google Connected Console (updated 2026-10-28) 1. Google for Developers: Troubleshooting (updated 2026-10-27) 1. Google for Developers: Connected apps policy (updated 2026-11-02) 1. Gemini Help: Connect custom apps to Gemini 1. Gemini Help: Use and manage Connected Apps in Gemini 1. Gemini Help: Availability and requirements of Connected Apps 1. Google Search Help: Use and manage Connected Apps in Search 1. Gemini app release notes (2026.10.13 entry) 1. Google blog: New connected apps roll out to Gemini (2026-09-23) 1. Android Developers channel: Extend your app to Gemini and Search with the Connected Apps Platform (2026-10-29) 1. 9to5Google: Google adding more Connected Apps to Gemini and Search (2026-10-28) 1. Model Context Protocol: Specification 2025-11-25 1. Model Context Protocol: Authorization (2025-11-25) 1. Model Context Protocol: Tools (2025-11-25) 1. Model Context Protocol: Specification 2026-07-28 1. IETF RFC 9728: OAuth 2.0 Protected Resource Metadata 1. IETF RFC 8414: OAuth 2.0 Authorization Server Metadata 1. IETF RFC 7591: OAuth 2.0 Dynamic Client Registration Protocol 1. IETF RFC 7636: Proof Key for Code Exchange 1. IETF draft: OAuth Client ID Metadata Document 1. GitHub: modelcontextprotocol/inspector 1. Gemini API docs: Function calling, Remote MCP section 1. Gemini API release notes (2026-11-10 entry) 1. Gemini API pricing 1. Gemini API docs: Understand and count tokens 1. Gemini CLI docs: MCP servers with the Gemini CLI 1. Android Developers: Overview of AppFunctions 1. Google Identity: OAuth-based Account Linking 1. Google Cloud docs: Deploying to Cloud Run 1. Google: User-triggered agents IP ranges (JSON) 1. YouTube API Services: Developer Policies 1. Reddit: Data API Terms 1. Google AI developer forum: Gemini app custom apps MCP OAuth never exchanges the code (2026-10-02) 1. Reddit r/mcp: custom connectors - gemini (2026-10-19) 1. Reddit r/GeminiAI: Gemini now supports general MCP servers 1. Reddit r/GeminiAI: Gemini App adding custom Connectors (2026-10-22) 1. Reddit r/modelcontextprotocol: How I got one stock market data MCP server into Claude, ChatGPT, Cursor, Codex and Gemini CLI (2026-10-17) 1. Reddit r/GoogleGemini: MCP with Gemini (2026-10-28) 1. EveryInfra: remote MCP endpoint (live calls on 2026-11-11) 1. EveryInfra: /mcp/all protected resource metadata (read on 2026-11-11) 1. EveryInfra: authorization server metadata (read on 2026-11-11) 1. EveryInfra: data capability catalog (read on 2026-11-11 and 2026-11-12)