ScreenshotNeo
Sign in Get a free key

BlogAI agents

Google Web Search MCP Server: What It Is and How to Connect It

Understand which Google search MCP servers are official, how live SERP access works, and how to connect one to Claude, Cursor, or your own agent.

By the ScreenshotNeo team1 October 20267 min read

Short answer: “Google Web Search MCP Server” usually refers to a third-party hosted MCP service that returns live, parsed Google Search results. HasData documents a remote server at https://mcp.hasdata.com/mcp?apis=google_serp. Google does not publish a general Google Search MCP server or general web-search API; its official MCP offerings target Google developer documentation and Google Cloud services.

That distinction matters when you choose a connector. A live SERP server searches the wider web and can expose result types such as AI Overviews, People Also Ask, news, shopping, product details and short videos. Google’s Developer Knowledge MCP searches curated Google product documentation through its global endpoint. Google Cloud remote MCP servers expose governed cloud operations and resource tools.

What “Google Web Search MCP Server” means

Model Context Protocol (MCP) lets an AI application call tools exposed by a server. Google’s Developer Knowledge reference describes an MCP server as a proxy between an external service and an AI application. In practice, the label can describe three different implementations:

Implementation Search scope Typical output Action model
Hosted SERP MCP, such as HasData Live Google web results Parsed SERP, AI Overview, PAA, news, shopping, products and videos Read-only search tools
Google Developer Knowledge MCP Google developer-product documentation Document matches, retrieved pages and generated answers Read-only documentation lookup
Google Cloud remote MCP Google Cloud resources and service toolsets Discovery, service-specific data and operations Depends on the enabled toolset; governance and IAM apply

HasData’s documentation states that Google publishes no MCP server and no general search API. Therefore, call a hosted SERP service a third-party integration, and call Google’s Developer Knowledge or Cloud endpoints official Google MCP services.

HasData’s hosted Google Search MCP server

HasData documents a remote, streamable HTTP MCP server using the x-api-key header:

https://mcp.hasdata.com/mcp?apis=google_serp

It advertises eight read-only Google Search tools covering regular SERPs and specialized result types. The service documents a free tier of 1,000 credits per month with no card required. Clients that only support local stdio can use the launcher packages described in HasData’s README; use the package and configuration shown in that README rather than guessing a package name.

Connect a remote Google Search MCP server

1. Collect an API key

Create an account with the provider you selected and copy its API key. Keep the key in an environment variable or your client’s secret store.

export HASDATA_API_KEY='YOUR_API_KEY'

2. Add a remote MCP server in your client

Client configuration differs by application version. Look for an “MCP servers” or “remote server” setting and add:

{
  "mcpServers": {
    "google-search": {
      "url": "https://mcp.hasdata.com/mcp?apis=google_serp",
      "headers": {
        "x-api-key": "${HASDATA_API_KEY}"
      }
    }
  }
}

Some clients call the key serverUrl instead of url, and some do not expand environment variables inside JSON. If yours does not, use its secret or environment-variable mechanism and never commit the literal key.

3. Verify the connection

  1. Restart the MCP-capable client if it only loads servers at startup.
  2. Open the MCP tool list and confirm that Google Search tools are visible.
  3. Run a narrow query such as site:developers.google.com OAuth refresh token.
  4. Check that the response contains parsed result fields rather than an HTML page.

Test the endpoint with cURL

MCP uses JSON-RPC messages over the server’s streamable HTTP transport. The exact session headers can vary by client, but this request is useful for checking authentication and endpoint reachability:

curl -i -X POST 'https://mcp.hasdata.com/mcp?apis=google_serp' \
  -H 'Content-Type: application/json' \
  -H "x-api-key: ${HASDATA_API_KEY}" \
  --data '{
    "jsonrpc":"2.0",
    "id":1,
    "method":"initialize",
    "params":{
      "protocolVersion":"2025-03-26",
      "capabilities":{},
      "clientInfo":{"name":"curl-check","version":"1.0"}
    }
  }'

Use the protocol version and Accept headers required by the server version documented by your provider. A successful HTTP response proves that the endpoint and key are reachable; it does not prove that your AI client has completed MCP initialization.

Call MCP from Python

The following helper sends a JSON-RPC message and prints the response. It is useful for connectivity checks and for clients that expose the response as a single HTTP payload.

import os
import requests

endpoint = "https://mcp.hasdata.com/mcp?apis=google_serp"
headers = {
    "Content-Type": "application/json",
    "Accept": "application/json, text/event-stream",
    "x-api-key": os.environ["HASDATA_API_KEY"],
}

payload = {
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
        "protocolVersion": "2025-03-26",
        "capabilities": {},
        "clientInfo": {"name": "python-check", "version": "1.0"},
    },
}

response = requests.post(endpoint, headers=headers, json=payload, timeout=60)
response.raise_for_status()
print(response.text)

For production use, use an MCP SDK that handles streamable HTTP sessions, message IDs and server notifications. Do not assume every response is ordinary JSON; streamable HTTP can return event-stream data.

Call MCP from Node.js

const endpoint = 'https://mcp.hasdata.com/mcp?apis=google_serp';

const response = await fetch(endpoint, {
  method: 'POST',
  headers: {
    'content-type': 'application/json',
    'accept': 'application/json, text/event-stream',
    'x-api-key': process.env.HASDATA_API_KEY
  },
  body: JSON.stringify({
    jsonrpc: '2.0',
    id: 1,
    method: 'initialize',
    params: {
      protocolVersion: '2025-03-26',
      capabilities: {},
      clientInfo: { name: 'node-check', version: '1.0' }
    }
  })
});

if (!response.ok) throw new Error(`${response.status} ${await response.text()}`);
console.log(await response.text());

For a complete agent, use an MCP client library that supports the server’s streamable HTTP transport. The library should perform initialization, list tools, invoke a selected tool and consume streamed events.

Use Google’s official Developer Knowledge MCP

Choose this endpoint when the agent needs authoritative Google developer documentation rather than whole-web search:

https://developerknowledge.googleapis.com/mcp

Google documents three core tools: search_documents, get_documents and answer_query. Authentication options include API keys for supported third-party IDEs and CLI agents, plus OAuth or application-default credentials in supported workflows. Follow Google’s connection guide for the client-specific authentication flow.

Use Google Cloud remote MCP services

Google Cloud’s remote MCP overview covers discovery, toolsets, administrative controls, authentication and authorization, IAM policies and Model Armor scanning. These controls apply to Google-managed Cloud services. They should not be assumed to exist on an unrelated hosted SERP server.

Choosing the right implementation

Need Use
Fresh Google web results, rankings or SERP features Hosted SERP MCP such as HasData
Answers grounded in Google product documentation Google Developer Knowledge MCP
Cloud resource discovery or operations Google Cloud remote MCP with IAM and the required toolset
Local-only MCP client A provider launcher that bridges stdio to the remote service

Reliability, performance and cost considerations

  • Latency: remote HTTP adds network time, and live search itself can take longer than a local index. Set client timeouts high enough for the provider’s documented behavior.
  • Freshness: live SERP data is appropriate for current rankings and news; documentation MCP results are limited to Google’s indexed documentation corpus.
  • Rate limits and credits: monitor the provider’s credit usage. HasData documents 1,000 free credits per month; do not equate credits with a universal Google price.
  • Retries: retry transient 5xx and connection failures with exponential backoff. Do not blindly retry authentication errors or malformed JSON-RPC requests.
  • Determinism: search results can change between requests. Store the query, timestamp, locale and returned data when reproducibility matters.
  • Security: keep API keys server-side, restrict tool access in shared agents and review whether a tool is read-only before enabling it.

Troubleshooting

Symptom Likely cause Fix
401 or 403 Missing, misspelled or expired x-api-key Check the header name, secret expansion and provider account.
404 Wrong path or missing ?apis=google_serp Copy the complete endpoint exactly.
Client says the server is not MCP Client expects stdio or legacy SSE, while the endpoint uses streamable HTTP Enable remote HTTP support or use the provider’s stdio launcher.
JSON parse error Response is an event stream or contains multiple messages Use an MCP SDK or parse SSE events instead of calling response.json().
No tools appear Initialization was not completed or the client cached an old configuration Restart the client, inspect logs and run the initialize/tools-list sequence.
Search result is empty Query, locale or provider credit limit Try a simple query, verify account credits and record the raw response for diagnosis.
Requests time out Slow upstream search or an overly short client timeout Increase the timeout, add bounded retries and avoid sending duplicate concurrent searches.

Or skip the browser setup

If your application needs screenshots of search results, documentation pages or generated reports, ScreenshotNeo provides a website screenshot API and MCP server. One GET request returns PNG, JPEG, WebP or PDF. Before capture it accepts cookie banners and removes more than 60 known consent platforms, newsletter popups and chat widgets. Bot checks, blank pages, timeouts, failed loads and cache hits are not billed, and the response identifies the result with X-Page-Verdict and X-Billed headers. Its MCP tools include take_screenshot, get_page_info and capture_pdf, so Claude, Cursor and other MCP clients can request captures.

See the ScreenshotNeo API documentation for all options.

curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webp
import requests
r = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)
open("shot.webp", "wb").write(r.content)
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' }); const res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);

ScreenshotNeo includes full-page and element capture, device presets, custom CSS and JavaScript, waits, request blocking, headers, cookies, geolocation, PDF controls, caching, signed links, async jobs, bulk capture and a usage API. The Free plan includes 1,000 screenshots a month with no card; paid plans start at $5 for 3,000. Create a free ScreenshotNeo account.

FAQ

Is there an official Google Search MCP server?

Google’s documented MCP offerings cover Developer Knowledge and Google Cloud services. A general live Google Search MCP server is provided by third parties such as HasData.

Can Claude or Cursor use a remote server?

Yes, if the client supports streamable HTTP MCP and lets you configure the endpoint and x-api-key. Otherwise use a documented stdio launcher.

Does Developer Knowledge search the whole web?

No. It searches Google developer-product documentation and exposes documentation-focused tools.

Is a SERP MCP server allowed to perform cloud actions?

HasData describes its Google Search tools as read-only. Google Cloud MCP toolsets can expose operations, so review IAM and enabled tools before granting access.

How should I preserve search evidence?

Save the exact query, timestamp, locale, provider, response and tool arguments. Live results are not guaranteed to remain identical.

Keep reading