Google Gemini Enterprise

The Parallel Search API is available in the Google Gemini Enterprise Agent Platform as an external grounding provider. Use it to ground Gemini model responses with up-to-date context from the public web. There are two ways to get started:

	Google Cloud Marketplace	Bring Your Own Key (BYOK)
Setup	Subscribe via Google Cloud Marketplace	Get an API key from Parallel Platform
Authentication	Automatic — no API key needed	API key passed in each request
Billing	Consolidated through Google Cloud	Billed through Parallel
Zero Data Retention	Available via the ZDR offering	Not available

Both paths have the same 200 prompts per minute quota. If a request carries both a Marketplace subscription and an API key, the API key takes precedence. Google classifies Grounding with Parallel as a Separate Offering under your Google Cloud Agreement, so Parallel’s terms govern the search itself. See Google’s Grounding with Parallel documentation for their side of the integration.

Use cases

Using web data for information completion or enrichment.
Multi-hop agents that require deeper web searches for complex questions.
Building APIs that integrate web search data.
Employee-facing assistants for up-to-date analysis and reporting.
Consumer apps (retail, travel) supporting informed purchase decisions.
Automated agents (e.g., news analysis, KYC checks).
Vertical agents (sales, coding, finance) fetching the latest context from the web.

Example

Who won the 2025 Las Vegas F1 Grand Prix?

Without Grounding	With Grounding
The 2025 Las Vegas Grand Prix has not happened yet. The race is scheduled to take place on the weekend of November 20-22, 2025. Therefore, the winner is currently unknown.	The winner of the 2025 Las Vegas F1 Grand Prix was Max Verstappen of Red Bull Racing. The race took place on November 22, 2025. Sources: domain1.com, domain2.com, …

Supported models

The following models support Grounding with Parallel web search:

Gemini 2.5 Flash (gemini-2.5-flash)
Gemini 2.5 Flash-Lite (gemini-2.5-flash-lite)
Gemini 2.5 Pro (gemini-2.5-pro)
Gemini 3.1 Pro (gemini-3.1-pro-preview)
Gemini 3.1 Flash-Lite (gemini-3.1-flash-lite)
Gemini 3.5 Flash (gemini-3.5-flash)

Setup

Google Cloud Marketplace (Recommended)
Bring Your Own Key

The fastest way to get started is through the Google Cloud Marketplace. This approach requires no API key — authentication is handled automatically through your Google Cloud project.

Go to the Parallel Web Search listing on Google Cloud Marketplace.
Click Subscribe.
Review the pricing, accept the terms of service, and confirm your subscription.
Ensure the subscription is active in the Google Cloud project you plan to use with Gemini Enterprise.

Once subscribed, you can start making grounded requests immediately.

For sensitive workloads, a separate Zero Data Retention (ZDR) offering is available on Google Cloud Marketplace. To use ZDR, you must be subscribed to the ZDR offering and set enable_zero_data_retention: true in your requests (see Make a grounded request). ZDR is only available through Google Cloud Marketplace.

With either option, Google Cloud sends data such as queries derived and rewritten from the original user prompt to Parallel Web Search for processing. Use of the service is governed by the Google Cloud Marketplace terms for Parallel Web Search if you subscribe through Marketplace, or by Parallel’s terms of use and acceptable use policy if you bring your own key.

Agent Studio

You can also use Parallel as a grounding source directly in Agent Studio — no code required. This requires an active Google Cloud Marketplace subscription.

Open Agent Studio in the Google Cloud Console.
In the side panel under Model settings, find Grounding and turn on Partners (Search results from grounding partners).
Select Parallel Web Search, then click Apply.
Enter your prompt and send it. The model response will be grounded with web results from Parallel.

Agent Studio is a great way to experiment with grounded responses before integrating via the API.

Make a grounded request

Request grounded responses from Gemini by using the Google Gen AI SDK or the REST API. Before running the examples, complete one of the setup options. Replace MODEL_ID with a supported model, such as gemini-3.5-flash. Both setup paths make the same call. Marketplace subscribers send no key; Bring Your Own Key users set the API key on the parallelAiSearch tool, shown commented out in each example.

Google Gen AI SDK

Authenticate with Google Cloud, then set the environment variables the SDK clients read:

gcloud auth application-default login

export GOOGLE_CLOUD_PROJECT=PROJECT_ID
export GOOGLE_CLOUD_LOCATION=global
export GOOGLE_GENAI_USE_ENTERPRISE=True

GOOGLE_GENAI_USE_ENTERPRISE routes the client to the Gemini Enterprise Agent Platform rather than the Gemini Developer API. Use global for the location unless you have a data residency requirement, in which case set a region such as us-central1.

Python
Java
TypeScript

Install the Google Gen AI SDK for Python:

pip install --upgrade google-genai

from google import genai
from google.genai import types

client = genai.Client()

response = client.models.generate_content(
    model="MODEL_ID",
    contents="Who won the 2025 Las Vegas F1 Grand Prix?",
    config=types.GenerateContentConfig(
        tools=[
            types.Tool(
                parallel_ai_search=types.ToolParallelAiSearch(
                    # Omit api_key when using a Marketplace subscription.
                    # Otherwise, provide your Parallel API key.
                    # api_key="API_KEY",
                    # Keys in custom_configs use the Search API's
                    # snake_case field names. All fields are optional.
                    custom_configs={
                        "mode": "basic",
                        "max_results": 10,
                        "source_policy": {
                            "include_domains": ["wikipedia.org"]
                        },
                    },
                )
            )
        ],
    ),
)

print(response.text)
print(response.candidates[0].grounding_metadata.grounding_chunks)

Install or update the Google Gen AI SDK for Java. See the SDK reference for package details.

import com.google.genai.Client;
import com.google.genai.types.GenerateContentConfig;
import com.google.genai.types.GenerateContentResponse;
import com.google.genai.types.Tool;
import com.google.genai.types.ToolParallelAiSearch;
import java.util.List;
import java.util.Map;

public class ParallelGroundingSample {
  public static void main(String[] args) {
    try (Client client = Client.builder().build()) {
      GenerateContentConfig config =
          GenerateContentConfig.builder()
              .tools(
                  Tool.builder()
                      .parallelAiSearch(
                          ToolParallelAiSearch.builder()
                              // Omit apiKey when using a Marketplace
                              // subscription. Otherwise, provide your
                              // Parallel API key.
                              // .apiKey("API_KEY")
                              // Keys in customConfigs use the Search API's
                              // snake_case field names. All fields are optional.
                              .customConfigs(
                                  Map.of(
                                      "mode", "basic",
                                      "max_results", 10,
                                      "source_policy",
                                      Map.of(
                                          "include_domains",
                                          List.of("wikipedia.org"))))
                              .build())
                      .build())
              .build();

      GenerateContentResponse response =
          client.models.generateContent(
              "MODEL_ID",
              "Who won the 2025 Las Vegas F1 Grand Prix?",
              config);

      System.out.println(response.text());
      response.candidates().get().get(0).groundingMetadata()
          .ifPresent(metadata -> System.out.println(metadata.groundingChunks()));
    }
  }
}

Install the Google Gen AI SDK for JavaScript:

npm install @google/genai

import {GoogleGenAI} from '@google/genai';

const ai = new GoogleGenAI({});

const response = await ai.models.generateContent({
  model: 'MODEL_ID',
  contents: 'Who won the 2025 Las Vegas F1 Grand Prix?',
  config: {
    tools: [
      {
        parallelAiSearch: {
          // Omit apiKey when using a Marketplace subscription.
          // Otherwise, provide your Parallel API key.
          // apiKey: 'API_KEY',
          // Keys in customConfigs use the Search API's snake_case
          // field names. All fields are optional.
          customConfigs: {
            mode: 'basic',
            max_results: 10,
            source_policy: {include_domains: ['wikipedia.org']},
          },
        },
      },
    ],
  },
});

console.log(response.text);
console.log(response.candidates[0].groundingMetadata);

Configure the search with the tool’s custom_configs field (customConfigs in Java and TypeScript). It accepts the optional parameters in Configuration options, including source_policy, excerpts, max_results, and mode.

enable_zero_data_retention is not exposed by the Gen AI SDKs — ToolParallelAiSearch accepts only the API key and custom configs. To use the ZDR offering, call the REST API directly.

REST API

Send requests to the regional endpoint:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent

PROJECT_ID: Your Google Cloud project ID.
LOCATION: The Google Cloud region that processes the request. Regional availability varies by model — check the model’s page in Google’s docs before picking one. To use the global endpoint, drop the region prefix from the hostname (https://aiplatform.googleapis.com) and use global in place of LOCATION in the path. This is unrelated to the location search parameter below.
MODEL_ID: The Gemini model to use (for example, gemini-3.5-flash).

Google Cloud Marketplace
Bring Your Own Key

No api_key field is needed when using the Marketplace subscription. Set enable_zero_data_retention to true to use the ZDR offering for the request (requires an active ZDR subscription); if unspecified, the standard offering is used:

{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "MODEL_PROMPT_TEXT"
    }]
  }],
  "tools": [{
    "parallelAiSearch": {
      "enable_zero_data_retention": ENABLE_ZERO_DATA_RETENTION,
      "customConfigs": {
        "mode": "MODE",
        "location": "SEARCH_LOCATION",
        "max_results": MAX_RESULTS,
        "source_policy": {
          "exclude_domains": ["EXCLUDE_DOMAINS"],
          "include_domains": ["INCLUDE_DOMAINS"]
        },
        "excerpts": {
          "max_chars_per_result": MAX_CHARS_PER_RESULT,
          "max_chars_total": MAX_CHARS_TOTAL
        }
      }
    }
  }],
  "model": "projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID"
}

Include your API key in the parallelAiSearch object:

{
  "contents": [{
    "role": "user",
    "parts": [{
      "text": "MODEL_PROMPT_TEXT"
    }]
  }],
  "tools": [{
    "parallelAiSearch": {
      "api_key": "PARALLEL_API_KEY",
      "customConfigs": {
        "mode": "MODE",
        "location": "SEARCH_LOCATION",
        "max_results": MAX_RESULTS,
        "source_policy": {
          "exclude_domains": ["EXCLUDE_DOMAINS"],
          "include_domains": ["INCLUDE_DOMAINS"]
        },
        "excerpts": {
          "max_chars_per_result": MAX_CHARS_PER_RESULT,
          "max_chars_total": MAX_CHARS_TOTAL
        }
      }
    }
  }],
  "model": "projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID"
}

Execute the request:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:generateContent"

For error responses, see Warnings and errors.

Read the grounded response

Grounded responses include a groundingMetadata object alongside the generated text. Use it to render citations and to see which search queries Gemini sent to Parallel. Gemini decides whether to search. If it answers without grounding, groundingMetadata is absent — check for it before rendering citations.

{
  "candidates": [{
    "content": {
      "role": "model",
      "parts": [{ "text": "The winner of the 2025 Las Vegas F1 Grand Prix was Max Verstappen of Red Bull Racing." }]
    },
    "finishReason": "STOP",
    "groundingMetadata": {
      "webSearchQueries": ["2025 Las Vegas F1 Grand Prix winner"],
      "groundingChunks": [
        {
          "web": {
            "uri": "https://...",
            "title": "2025 Las Vegas Grand Prix",
            "domain": "domain.com"
          }
        }
      ],
      "groundingSupports": [
        {
          "segment": {
            "startIndex": 0,
            "endIndex": 85,
            "text": "The winner of the 2025 Las Vegas F1 Grand Prix was Max Verstappen of Red Bull Racing."
          },
          "groundingChunkIndices": [0]
        }
      ]
    }
  }],
  "usageMetadata": {
    "promptTokenCount": 33,
    "candidatesTokenCount": 106,
    "totalTokenCount": 284,
    "trafficType": "ON_DEMAND",
    "toolUsePromptTokensDetails": [{ "modality": "TEXT", "tokenCount": 39 }]
  }
}

Field	Description
`groundingMetadata.webSearchQueries`	The queries Gemini derived from the prompt and sent to Parallel. Gemini may issue several searches for one prompt, or none.
`groundingMetadata.groundingChunks[].web`	Each source used for grounding, with its `uri`, `title`, and `domain`
`groundingMetadata.groundingSupports[]`	Maps a `segment` of the answer text to the `groundingChunkIndices` that support it
`usageMetadata.toolUsePromptTokensDetails`	Tokens consumed by grounding, on top of your prompt and output tokens

The REST API returns these fields in camelCase. The Gen AI SDKs expose the same fields in snake_case — REST’s groundingMetadata.groundingSupports is grounding_metadata.grounding_supports in Python.

Render inline citations

Each groundingSupports entry carries a segment that locates the cited claim in the answer. Two details matter:

startIndex and endIndex are byte offsets, not character positions. Slicing a Python string directly by them misplaces markers in any answer containing non-ASCII text. Splice in byte space instead.
The offsets are relative to a single Part, identified by partIndex — not to the whole concatenated answer.

Walk each part’s supports in reverse so that inserting a marker doesn’t shift the offsets you haven’t used yet:

candidate = response.candidates[0]
metadata = candidate.grounding_metadata
supports = (metadata.grounding_supports or []) if metadata else []

rendered = []
for part_index, part in enumerate(candidate.content.parts):
    data = part.text.encode("utf-8")
    part_supports = [s for s in supports if (s.segment.part_index or 0) == part_index]

    for support in sorted(part_supports, key=lambda s: s.segment.end_index, reverse=True):
        markers = "".join(f"[{i + 1}]" for i in support.grounding_chunk_indices)
        end = support.segment.end_index
        data = data[:end] + markers.encode("utf-8") + data[end:]

    rendered.append(data.decode("utf-8"))

print("".join(rendered))

if metadata and metadata.grounding_chunks:
    for i, chunk in enumerate(metadata.grounding_chunks, start=1):
        print(f"[{i}] {chunk.web.title} — {chunk.web.uri}")

Configuration options

All customConfigs fields are optional. For best performance, use defaults unless you have specific requirements. In addition, the parallelAiSearch object accepts an optional enable_zero_data_retention field (a sibling of customConfigs, not nested inside it). Set it to true to route the request through the ZDR offering for sensitive workloads — this requires an active ZDR subscription on Google Cloud Marketplace and is not available with Bring Your Own Key.

Parameter	Default	Range	Description
`max_results`	10	1–20	Maximum number of search results used for grounding
`excerpts.max_chars_per_result`	30,000	1,000–100,000	Maximum characters per excerpt
`excerpts.max_chars_total`	100,000	1,000–1,000,000	Maximum total excerpt characters
`source_policy.include_domains`	—	See below	Only return results from these domains
`source_policy.exclude_domains`	—	See below	Exclude results from these domains
`location`	—	—	ISO 3166-1 alpha-2 country code for geo-targeted search results (for example, `us`). Unrelated to the Google Cloud `LOCATION` region in the request URL.
`mode`	`basic`	`basic` \| `advanced`	Search mode. Use `advanced` for more thorough results at the expense of higher latency.

Both source_policy lists accept either a full domain (www.example.com) or a domain extension beginning with a period (.gov, .edu, .co.uk). The leading period is required for extensions. The combined number of entries across include_domains and exclude_domains cannot exceed 200. The defaults suit most workloads. Reach for source_policy when you need to restrict sources, mode: advanced when answer quality matters more than latency, and excerpts when you are managing context length. For guidance on writing search queries, see Search API Best Practices.

For a complete working example, see the Gemini demo in the Parallel Cookbook.

Quota

The default quota is 200 prompts per minute. To request higher rate limits, share your use case and requirements with:

Google Cloud Marketplace: your Google account team.
Bring Your Own Key: support@parallel.ai and your Google account team.

Billing

Using Gemini with Parallel can incur charges for:

Gemini token consumption — prompt, thinking, and output tokens.
Gemini grounding requests — Google charges per grounded prompt in addition to tokens.
Parallel Web Search API usage.

See Google’s Gemini Enterprise Agent Platform pricing for the Google charges. Search API charges depend on your setup path:

Google Cloud Marketplace: consolidated into your Google Cloud billing.
Bring Your Own Key: billed through Parallel’s pricing.

Getting started

Web Tools

Web Agents

Developer Tools

Platform Integrations

Data Integrations

Additional Resources

Google Gemini Enterprise

Use cases

Example

Supported models

Setup

Agent Studio

Make a grounded request

Google Gen AI SDK

REST API

Read the grounded response

Render inline citations

Configuration options

Quota

Billing

​Use cases

​Example

​Supported models

​Setup

​Agent Studio

​Make a grounded request

​Google Gen AI SDK

​REST API

​Read the grounded response

​Render inline citations

​Configuration options

​Quota

​Billing

Use cases

Example

Supported models

Setup

Agent Studio

Make a grounded request

Google Gen AI SDK

REST API

Read the grounded response

Render inline citations

Configuration options

Quota

Billing