# Google search MCP-server voor Claude Desktop, Cursor en andere MCP-clients

> Voeg Google-zoekresultaten toe aan Claude Desktop en andere MCP-clients met een Python MCP-server van 40 regels op de SerpCrypto SERP-API.

- URL: https://serpcrypto.com/nl/docs/mcp/
- Laatst bijgewerkt: 2026-10-22
- Uitgever: SerpCrypto (https://serpcrypto.com)

Geef elke MCP-client een `google_search`-tool die live Google-resultaten retourneert. De server is één Python-bestand dat je zelf draait; het roept de SerpCrypto API aan en retourneert compacte tekst die een model kan lezen.

**Snel antwoord — Hoe voeg ik Google-zoekresultaten toe aan Claude Desktop of Cursor met een MCP-server?**

Sla de Python-server van 40 regels hieronder op, installeer `mcp[cli]` en `httpx`, en registreer hem in de MCP-instellingen van je client met je **SerpCrypto** API-sleutel in `env`. De client krijgt dan een `google_search`-tool die live Google-resultaten retourneert. Elke tool-call is één zoekopdracht van 1 credit, vanaf US$ 0,30/1K zoekopdrachten; credits worden betaald met crypto zonder KYC.

## De MCP-server in één oogopslag

| Attribuut | Waarde |
| --- | --- |
| Taal | Python 3.10+ met de officiële `mcp` SDK (FastMCP) en `httpx` |
| Transport | stdio: de client start het script en communiceert ermee |
| Tool | `google_search(query, gl, hl, num_results)` |
| Output | AI Overview-tekst indien getoond, dan titel, link en snippet per resultaat |
| Sleutel | Omgevingsvariabele `SERPCRYPTO_API_KEY`, ingesteld in de clientconfiguratie |
| Kosten | 1 credit per geslaagde tool-call; fouten zijn gratis |

## Wat doet de server?

Hij biedt één tool, `google_search`, aan via het Model Context Protocol. Wanneer het model hem aanroept, stuurt de server één request naar `https://serpcrypto.com/api/v1/search` en zet de JSON om in korte platte tekst: de AI Overview als Google er een toonde, en de bovenste resultaten met titel, link en snippet.

Korte tekst is belangrijk. Een volledige resultatenpagina in JSON is lang, en elk teken dat naar het model wordt gestuurd gebruikt context. De server houdt maximaal tien resultaten en kapt de overview af op 800 tekens; wijzig die limieten in de code als je client meer ruimte heeft.

Dit is copy-paste-code, geen gepubliceerd package: er is geen officieel SerpCrypto MCP-package om te installeren. Het bestand is van jou en je kunt tools toevoegen, bijvoorbeeld een voor `engine=google_news`.

*serpcrypto_mcp.py*

```python
"""serpcrypto_mcp.py: an MCP server that gives AI clients a Google search tool.

Install once:  pip install "mcp[cli]" httpx
Run by your MCP client over stdio; the API key comes from the environment.
"""
import os

import httpx
from mcp.server.fastmcp import FastMCP

API_URL = "https://serpcrypto.com/api/v1/search"
mcp = FastMCP("serpcrypto-search")


@mcp.tool()
async def google_search(query: str, gl: str = "us", hl: str = "en", num_results: int = 5) -> str:
    """Search Google and return the top results (title, link, snippet) and the AI Overview text if any.

    gl is a two-letter country code (us, gb, de...), hl a language code (en, de, pt-BR...).
    Each call uses one SerpCrypto search credit.
    """
    headers = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}
    params = {"q": query, "gl": gl, "hl": hl}
    async with httpx.AsyncClient(timeout=90) as client:
        r = await client.get(API_URL, params=params, headers=headers)
    if r.status_code != 200:
        return f"Search failed with HTTP {r.status_code}: {r.text[:300]}"
    data = r.json()
    lines = []
    overview = data.get("ai_overview") or {}
    if overview.get("text"):
        lines.append("AI Overview: " + overview["text"][:800])
    for item in data.get("organic_results", [])[: max(1, min(num_results, 10))]:
        lines.append(f"{item['position']}. {item['title']}\n{item['link']}\n{item.get('snippet', '')}")
    return "\n\n".join(lines) or "No results."


if __name__ == "__main__":
    mcp.run()  # stdio transport
```

## Waarom heet de tool google_search en niet web_search?

Verschillende clients leveren al een tool met de naam `web_search` die hun eigen provider gebruikt. Een aparte naam voorkomt een conflict en vertelt het model wat het krijgt: Google-resultaten voor een land en taal die het zelf kiest. De docstring is de beschrijving die het model leest, dus daarin staan de parameters en de kosten van een call.

## Hoe voeg ik hem toe aan Claude Desktop?

Open het configuratiebestand, `claude_desktop_config.json`: op macOS staat het in `~/Library/Application Support/Claude/`, op Windows in `%APPDATA%\Claude\`. Voeg de server toe onder `mcpServers`, met het absolute pad naar het script en je sleutel in `env`, en herstart Claude Desktop.

Als `python` niet op het pad staat dat Claude Desktop ziet, gebruik dan het volledige pad naar de interpreter, bijvoorbeeld die in je virtual environment.

*claude_desktop_config.json*

```json
{
  "mcpServers": {
    "serpcrypto-search": {
      "command": "python",
      "args": ["/absolute/path/to/serpcrypto_mcp.py"],
      "env": {
        "SERPCRYPTO_API_KEY": "paste-your-key-here"
      }
    }
  }
}
```

## Hoe voeg ik hem toe aan Claude Code en Cursor?

In Claude Code registreer je het vanuit een terminal met `claude mcp add`; `-e` stelt de environment variable in en alles na `--` is het commando dat wordt uitgevoerd. In Cursor zet je hetzelfde `mcpServers`-blok als hierboven in `~/.cursor/mcp.json` voor elk project, of in `.cursor/mcp.json` binnen één project.

Andere MCP-clients die stdio-servers starten, nemen dezelfde drie dingen: een commando, de argumenten ervan en environment variables. De [OpenClaw-pagina](https://serpcrypto.com/nl/docs/openclaw/) toont de commando's voor OpenClaw.

*Claude Code*

```bash
claude mcp add serpcrypto-search \
  -e SERPCRYPTO_API_KEY=paste-your-key-here \
  -- python /absolute/path/to/serpcrypto_mcp.py
```

## Hoe houd ik de API-sleutel veilig?

Bewaar hem in het `env`-blok van de clientconfiguratie of in je shell-profiel, nooit in `serpcrypto_mcp.py`. Zo kan het script worden gedeeld of gecommit zonder de sleutel. Als een sleutel uitlekt, trek hem dan in via het dashboard en maak een nieuwe aan: API-sleutels die je op elk moment kunt aanmaken en intrekken vanuit je dashboard.

Geef de MCP-server een eigen sleutel. Het gebruik per sleutel laat dan zien hoeveel zoekopdrachten de assistant doet, los van je scripts.

## Hoeveel credits gebruikt een assistant?

Eén per tool call die slaagt. Een chat waarin het model drie keer zoekt, kost drie credits. Op het 25.000 zoekopdrachten-pack van US$ 18,75 zijn dat duizenden ondersteunde vragen, en Prepaid zoekcredits verlopen nooit: ongebruikte zoekopdrachten blijven op je account staan tot je ze gebruikt.

Om het gebruik te beperken verlaag je `num_results` (dat verandert de prijs niet, maar het maakt antwoorden korter) en zeg je in je instructies tegen het model dat het alleen moet zoeken als het verse feiten nodig heeft.

## MCP-vragen

### Werkt de server met remote MCP-clients?

Deze versie gebruikt stdio, dus de client moet hem op dezelfde machine draaien. FastMCP kan ook via HTTP dienen; als je hem op een network beschikbaar stelt, zet er dan authenticatie voor, want iedereen die hem bereikt, uitgeeft je credits.

### Kan de tool in plaats daarvan Bing of Google News doorzoeken?

Ja. Voeg een `engine`-argument toe of een tweede tool die `engine=bing` of `engine=google_news` in `params` stuurt. Elke engine kost hetzelfde: 1 credit per zoekopdracht.

### Waarom zegt de client dat de tool is mislukt?

Voer het script handmatig uit met dezelfde Python om fouten te zien. De gebruikelijke oorzaken zijn een ontbrekend `mcp`- of `httpx`-package, een verkeerd pad in de config, of een lege `SERPCRYPTO_API_KEY`, waardoor de API `401` antwoordt.

### Heb ik een creditcard of KYC nodig voor de API-sleutel?

Nee. SerpCrypto verkoopt prepaid credits die je betaalt in BTC, USDT, USDC, ETH, SOL, LTC, zonder ID, zonder selfie en zonder documenten. Inloggen met accountnummer; e-mail is optioneel.

---

SerpCrypto: SerpCrypto is een SERP-API voor developers en AI-agents die Google- en Bing-resultaten als JSON retourneert, betaald met crypto zonder ID te uploaden. Prepaid zoekcredits vanaf US$ 0,30/1K zoekopdrachten verlopen nooit. Zonder KYC — geen ID, geen selfie, geen documenten. Betalen met crypto.
