Gemini Deep Research API: Google’s Agentic Research Tool

Google dropped the Gemini Deep Research API on December 11, 2025—the same day OpenAI released GPT-5.2. While OpenAI was responding to Sam Altman’s early December “code red” memo (issued around December 2nd after Gemini 3’s benchmark dominance), Google quietly opened up one of its most powerful research tools to developers. For the first time, the Deep Research agent that lives in Gemini Advanced is available via API.

Deep Research performs multi-step autonomous research across dozens of web sources, synthesizes findings, and produces comprehensive reports. It can run for up to 60 minutes (typical: ~20 minutes) and execute 80-160+ searches per query. But the API works completely differently from standard Gemini calls—you’ll need to learn the new Interactions API.

What makes Deep Research different from search APIs

Perplexity Sonar has been available via API since January 2025, offering real-time web search with citations. OpenAI now offers Deep Research via API (o3-deep-research and o4-mini-deep-research models) through the Responses API. Google’s approach sits between them: more autonomous multi-step research than Sonar, similar scope to OpenAI but with different pricing and integration patterns.

Deep Research is an agent, not a search wrapper. You give it a query, and it independently formulates search strategies, executes multiple queries, evaluates source quality, extracts relevant information, identifies knowledge gaps, and iterates until it has sufficient data. Then it synthesizes everything into a structured report. This isn’t RAG—it’s autonomous multi-step reasoning with live web data.

The underlying model is Gemini 3 Pro with a 1M token input context and 64K output tokens. That’s enough headroom for the agent to accumulate dozens of web pages, track what it’s learned, and maintain research coherence across extended sessions. Practical tasks average 250K input tokens for standard queries and 900K+ for complex research.

The Interactions API: A new paradigm

Google built a separate API surface specifically for agentic interactions. The Gemini Deep Research API doesn’t use the standard generate_content endpoint. Instead, you work with sessions, interactions, and real-time iteration updates. Think of it like a persistent conversation where the agent reports progress as it researches.

Here’s the basic Python implementation:

from google import genai

client = genai.Client(api_key="YOUR_API_KEY")

# Start a Deep Research task (background execution required)
interaction = client.interactions.create(
    input="Analyze the current state of multi-agent frameworks for LLM applications",
    agent='deep-research-pro-preview-12-2025',
    background=True
)

print(f"Research started: {interaction.id}")

# Poll for completion
import time
while True:
    interaction = client.interactions.get(interaction.id)
    if interaction.status == "completed":
        # Get the final research report
        print(interaction.outputs[-1].text)
        break
    elif interaction.status == "failed":
        print(f"Failed: {interaction.error}")
        break
    time.sleep(10)  # Check every 10 seconds

For streaming, Google provides thought_summary and content.delta events showing what Deep Research is doing in real-time. This transparency is critical for production use—you can show users research progress instead of a blank loading spinner.

SDK requirements are strict: Python needs google-genai >= 1.55.0, JavaScript requires @google/genai >= 1.33.0. Earlier versions don’t support the Interactions API. You’ll also need to explicitly specify the agent model ID deep-research-pro-preview-12-2025—generic Gemini 3 Pro won’t work for this.

Benchmark performance: How it stacks up

Google published three benchmark results for Deep Research, and they reveal the agent’s strengths and limitations:

Benchmark	Deep Research Score	What it measures
HLE (Humanity’s Last Exam)	46.4%	Expert-level knowledge across domains
DeepSearchQA	66.1%	Multi-hop reasoning with web search
BrowseComp	59.2%	Web browsing and information extraction

These numbers tell a story. Deep Research performs best on tasks requiring iterative web searches and synthesis (DeepSearchQA: 66.1%). It’s competent at extracting information from web sources (BrowseComp: 59.2%). But expert-level reasoning without extensive research shows room for improvement (HLE: 46.4%).

For context, GPT-5.2 scored 34.5-36.6% on HLE without search augmentation (depending on variant). Deep Research’s 46.4% suggests the agent effectively uses web data to fill knowledge gaps. But this also means the quality of your results depends heavily on what’s available online—garbage in, garbage out still applies.

Pricing: What research actually costs

Google has published pricing guidance in the Deep Research documentation. Standard research tasks run approximately $2-3 per query (averaging ~80 searches and ~250K input tokens with 50-70% caching). Complex research requiring ~160 searches and 900K input tokens runs $3-5 per execution.

These estimates are based on Gemini 3 Pro pricing ($2.00 per 1M input tokens for prompts up to 200K, $4.00 for longer contexts). The caching substantially reduces effective costs—without it, complex tasks would run significantly higher.

Compare this to Perplexity Sonar Pro API, which uses token-based pricing ($3 per 1M input tokens, $15 per 1M output tokens) plus per-request fees. Sonar is faster and cheaper for simple queries, but doesn’t run autonomous multi-step research. OpenAI’s o3-deep-research is more expensive—reports suggest $10-30 per complex query—but offers similar autonomous research capabilities.

The real cost comparison is Deep Research vs. hiring analysts. At $2-5 for research that would take a human 30-60 minutes, the API delivers 10-20x ROI if your use case fits. For simple lookups, stick with cheaper search APIs.

Getting started: Practical implementation

First, get API access through Google AI Studio. Deep Research is currently in preview, so availability may vary by region. Once you have a key, install the SDK and create your first session.

The Interactions API requires session management. Unlike stateless generate_content calls, Deep Research maintains conversation context across multiple queries. Sessions persist until you explicitly delete them or they timeout (typically 60 minutes of inactivity).

Key implementation considerations: First, handle iteration updates gracefully. Deep Research can run for 20+ minutes on complex queries—you need proper progress indicators. Second, implement timeout logic. The agent can run up to 60 minutes, but most production use cases should cap at 10-15 minutes. Third, parse structured output carefully. Deep Research returns markdown by default, so you’ll need to extract sections programmatically.

Google designed Deep Research to integrate with the Agent Development Kit (ADK). If you’re building with ADK in TypeScript, the Interactions API fits naturally into agent orchestration workflows. The ADK handles session lifecycle and provides typed interfaces for iteration updates.

ADK and A2A protocol support

The Deep Research API implements Google’s Agent-to-Agent (A2A) protocol, making it composable with other AI agents. In practice, this means you can build multi-agent systems where Deep Research acts as the research specialist while other agents handle synthesis, fact-checking, or content generation.

Google’s ADK integration guide shows how to chain Deep Research with other Gemini models or external tools. The A2A protocol standardizes how agents communicate research findings, making it easier to build complex workflows without custom integration code.

Real-world use cases

Deep Research excels at tasks requiring comprehensive information gathering across multiple sources. Competitive intelligence reports, market research summaries, technical due diligence, and literature reviews all fit the model perfectly.

Customer support teams can investigate complex product questions that span documentation, forums, and third-party resources. Sales teams generate detailed prospect research automatically. Product managers commission comparative analyses without manually reviewing dozens of websites. The 1M token context window handles queries referencing extensive background material—upload a 50-page RFP and get vendor recommendations grounded in your requirements.

Bad use cases: Real-time lookups (too slow), simple fact-checking (too expensive), and anything requiring guaranteed accuracy (agents still hallucinate). Note: File Search (experimental) does allow some proprietary data integration.

Limitations and caveats

The Deep Research API is in preview, and it shows. No custom Function Calling support yet—you can’t extend the agent with proprietary tools. Google plans MCP (Model Context Protocol) integration, but there’s no timeline. By default, Deep Research searches public web sources, though experimental File Search support lets you add your own documents.

Session management adds complexity. Unlike stateless API calls, you need to track session IDs, handle timeouts, and clean up resources. For high-volume applications, this means additional infrastructure for session orchestration. Google’s SDKs help, but it’s still more complex than standard API integration.

Research quality varies significantly based on query formulation. Vague prompts like “research AI trends” produce generic summaries. Specific queries like “compare inference costs for Llama 4 405B vs GPT-5.2 for batch processing workloads” deliver actionable insights. You’ll need to invest time in prompt engineering to get consistent results.

The 60-minute maximum research time is both a feature and a limitation. Complex queries can run long, but there’s no way to checkpoint progress and resume later. If a session times out or fails after 50 minutes of research, you lose everything and start over. Production applications need retry logic and fallback strategies.

Verdict: When to use Deep Research API

The Gemini Deep Research API fills a specific niche: autonomous multi-step research tasks where comprehensive coverage matters more than speed. At $2-5 per query, it’s cost-effective for high-value research but too expensive for casual lookups.

If you’re building research automation, competitive intelligence systems, or AI analysts that need to gather information from dozens of sources, Deep Research is worth evaluating. The Interactions API requires more integration work than simple REST calls, but the ability to stream research progress and maintain session context makes it viable for production applications.

The preview status means breaking changes are possible, and missing features (Function Calling, MCP support) limit extensibility. But Google shipped this API on the same day as OpenAI’s GPT-5.2 release—they’re serious about making Gemini the platform for agentic AI. For developers already invested in Google’s AI ecosystem, Deep Research is the most powerful research tool available via API.

Just don’t expect magic. Deep Research is an autonomous agent that searches the web, not an oracle. Quality depends on query formulation, source availability, and your tolerance for 20-minute latencies. Get those variables right, and you’ve got an AI research analyst for $3 per report. Get them wrong, and you’ve got an expensive way to summarize the first page of Google results.