Google Flights MCP – Echtzeit-Flugpreise, die Ihr Agent über einen gesamten Datumsbereich durchsuchen kann, werbefrei

claude mcp add --transport http google-flights https://google-flights-mcp.flightpowers.com/mcp --header "x-rapidapi-key: YOUR_RAPIDAPI_KEY"

Gehostet. Nichts zu klonen, nichts zu bauen. Im offiziellen MCP-Registry gelistet als com.flightpowers/google-flights-mcp. Health-Check: /health.

Sie brauchen einen Schlüssel? Abonnieren Sie die Google Flights Live API auf RapidAPI – kostenlose Stufe verfügbar – und kopieren Sie Ihren x-rapidapi-key: https://rapidapi.com/mtnrabi/api/google-flights-live-api

Noch keinen Schlüssel? Starten Sie mit dem kostenlosen Server – dieselbe Suche, keine Anmeldung: claude mcp add --transport http google-flights-free https://google-flights-lulu.flightpowers.com/mcp (werbefinanziert: eine offen gekennzeichnete Sponsorenkarte pro Ergebnis, Fan-out auf 15 begrenzt, und Clients, die die Sponsorenkarte nicht darstellen können, können weiter eingeschränkt werden.) Kommen Sie hierher zurück, wenn Ihnen die Werbung, das 15-Suche-Limit oder diese Client-Einschränkungen im Weg stehen.

Was Ihr Agent erhält

Zwei Tools, die eine Preisfrage beantworten, keine Datumsabfrage.

• Offene Fragen erder umfassen. „Günstigster One-Way-Flug nach Sri Lanka irgendwann im Oktober“, „5 bis 7 Nächte in Rom irgendwann im Mai, ab Tel Aviv oder Larnaca“ – das ist jeweils ein Tool-Aufruf. Beide Tools akzeptieren einen Abflugdaten-bereich, eine Liste von Zielflughäfen und (bei Hin- und Rückflug) einen nights-Wert statt eines festen Rückgabedatums und erweitern diese Abfragen intern.

• Sag ob ein Preis tatsächlich angenehm zu merken ist. Jedes Ergebnis enthält Googles eigenen historischen Preisbereich für diese Route und diesen Zeitraum – price_insights_low, price_insights_high sowie eine price_range_in_relation_to_other_periods-Bewertung von low / typical / high. Das ist gemeint, wenn ein Agent antworten kann: „$209 ist hier typisch, kein Grund zu „hetzen“, statt nur eine Zahl zu nennen.

• Nicht nur stöbern, sondern buchen. Jedes Ergebnis enthält einen buy_link zu Google Flights.

• Wissen, was ausgegeben wurde. Jede Antwort enthält api_usage – die von diesem Aufruf verwendeten Anforderungen und wie viel vom Plan des Aufrufers noch übrig ist. Siehe Ausgabenbericht.

• Wissen, wonach gesucht wurde. Jede Antwort enthält search_coverage, sodass das Modell ehrlich aus geben kann, auf welchen Daten und „Zielen“ die Antwort basiert.

Ergebnisse sind Live-Flugpreise. Sie werden innerhalb von Minuten veralten– cachen: Sie nie einemab einen Flugperis und verwenden Sie ein früheres Ergebnis nicht erneut; suchen Sie erneut und geben Sie an, wann die Daten abgerufen wurden.

Einen Schlüssel erhalten (kostenlose Stufe verfügbar)

Der Server speichert keinerlei eigene Upstream-Zugangsdaten. Jede Suche wird auf Ihr RapidAPI-Abonnement, abgerechnet. Deshalb ist der Schlüssel bei der Anfrage an Bord.

1. Abonnieren Sie die Google Flights Live API: https://rapidapi.com/mtnrabi/api/google-flights-live-api

2. Kopieren Sie Ihren x-rapidapi-key.

3. Übechen Sie ihn auf eine der unten folgenden drei Arten an den Server.

If a key is missing, the tools do not fail silently and do not cost anything – they return needs_api_key: true, along with the signup URL and this Anleitung, formulate it with the model so that the model reads it back to you.

Three types of key extension

The first non-empty source wins, in that order. The key is never logged, never returned in an error message, and never returned in a tool response.

Tools

search_oneway_flights

search_oneway_flights(
    from_airport: str,                     # origin IATA, e.g. "TLV"
    to_airport: str | list[str],           # destination IATA, or a list to compare
    departure_date: str | None = None,     # "YYYY-MM-DD"
    departure_date_from: str | None = None,# first date of a range
    departure_date_to: str | None = None,  # last date of a range
    max_stops: int | None = None,          # 0 = non-stop only
    airline_codes: list[str] | None = None,
    exclude_airline_codes: list[str] | None = None,
    departure_time_min: int | None = None, # hour, 0-23
    departure_time_max: int | None = None,
    arrival_time_min: int | None = None,
    arrival_time_max: int | None = None,
    currency: str = "usd",
    max_price: int | None = None,
    seat_type: int | None = None,          # 1 economy, 2 premium economy, 3 business, 4 first
    passengers: list[int] | None = None,   # [adults, children, infants]
    sort_by: str = "best",                 # "best" | "price" | "duration"
    limit: int = 10,                       # results returned after merge + sort
    max_searches: int | None = None,       # cap the billed requests this call may make
    use_fallback: bool = False,            # slower, fewer empty results on hard routes
)

search_roundtrip_flights

search_roundtrip_flights(
    from_airport: str,
    to_airport: str | list[str],
    departure_date: str | None = None,
    departure_date_from: str | None = None,
    departure_date_to: str | None = None,
    return_date: str | None = None,        # use this OR nights, not both
    nights: int | list[int] | None = None, # e.g. 7, or [5, 6, 7]
    max_departure_stops: int | None = None,
    max_return_stops: int | None = None,
    departure_airline_codes: list[str] | None = None,
    return_airline_codes: list[str] | None = None,
    currency: str = "usd",
    max_price: int | None = None,
    seat_type: int | None = None,
    passengers: list[int] | None = None,
    sort_by: str = "best",
    limit: int = 10,
    max_searches: int | None = None,
    use_fallback: bool = False,
)

sort_by is applied by this server across the merged result set of all searches it performed, so the sorting is predictable regardless of how many combinations were expanded.

A worked example

User: „Ich bin in Tel Aviv. Die atemberaubendste einwöchige Reise nach Rom oder Athen, Anfang Mai ab – beliebiger Tag.“

One call:

{
  "name": "search_roundtrip_flights",
  "arguments": {
    "from_airport": "TLV",
    "to_airport": ["FCO", "ATH"],
    "departure_date_from": "2026-05-01",
    "departure_date_to": "2026-05-15",
    "nights": 7,
    "sort_by": "price",
    "limit": 5
  }
}

This is 1 dates × 2 destinations = 30 combinations, exactly the cap of one call. The response shape (field names are real; the values below are examples, not a quotation – run the call to see live prices:

{
  "results": [
    {
      "from_airport": "Tel Aviv (TLV)",
      "to_airport": "Rome (FCO)",
      "departure_date": "2026-05-05",
      "return_date": "2026-05-12",
      "total_price": "$XXX",
      "total_price_as_number": 0,
      "total_duration_seconds": 0,
      "total_stops": 0,
      "price_range_in_relation_to_other_periods": "low",
      "price_insights_low": 0,
      "price_insights_high": 0,
      "departure_flight_airline": "...",
      "departure_flight_departure_description": "...",
      "departure_flight_arrival_description": "...",
      "departure_flight_duration": "...",
      "departure_flight_stops": 0,
      "departure_stops_info": [],
      "return_flight_airline": "...",
      "return_flight_departure_description": "...",
      "return_flight_arrival_description": "...",
      "return_flight_duration": "...",
      "return_flight_stops": 0,
      "return_stops_info": [],
      "buy_link": "https://www.google.com/travel/flights?tfs=..."
    }
  ],
  "result_count": 5,
  "search_coverage": {
    "requested_combinations": 30,
    "searched_combinations": 30,
    "truncated": false,
    "max_searches_per_request": 30,
    "departure_dates_searched": ["2026-05-01", "..."],
    "destinations_searched": ["ATH", "FCO"]
  },
  "api_usage": {
    "requests_used_by_this_call": 30,
    "plan_requests_remaining": 0,
    "plan_requests_limit": 0,
    "note": "This search used 30 of your RapidAPI plan's requests; ... remain in the current period. Each date and destination combination is one billed request."
  }
}

Other response shapes you may see, all normal:

• No Flights on those dates. results: [] with a message – Google Flights genuinely returns nichts for some route/date combinations. That's no error. Try switching to nearby dates, a nearby airport, or use_fallback: true.

• Some searches failed. A partial field states how many of the searches that were started failed, and the results cover the rest.

• Range too large. search_coverage.truncated: true plus a note. The range is sampled evenly across the entire window (first and last are kept), not brockenshort – so the sample is representative, not the first N days. Raise max_searches or narrow the range for greater coverage.

• Missing or rejected key. needs_api_key: true, no price, plus the fix. Most common cause is a valid RapidAPI key that is not subscribed to this specific API.

• Plan exhausted. quota_exhausted: true with api_usage, plus a note that restricting the range can extend your remaining quota.

Spend reporting (api_usage)

The money is yours, so the meter is visible. Every toll achieved response carries:

plan_requests_remaining and plan_requests_limit come from the upstream response and are omitted when upstream doesn’t includes them; the TN is adjusted. The rule the model should say: one date × one destination = one billed request.

Cost control knobs, in order of fine-tuning: max_searches per call (reduce it to save money on an open question), a narrower date range, a shorter destination list.

One call vs. thirty

The underlying REST API accepts exactly one (origin, destination, date) triple per call. Against a one-date-per-call passthrough, “cheapest to Sri Lanka anywhere in October” means thirty-one separate tool calls – 31 round trips through the model, 31 opportunities to lose the thread, and a bill the user only sees afterwards.

Here it is one tool call. The fan-out is server-side, concurrent, limited, evenly sampled, dedouplicated by buy_link (same link, once), repiled, sorted by sort_by, and reported clearly in search_coverage and api_usage.

This server carries no ads at all – not by taste, but by necessity: Anthropics' directory policy for connectors and OpenAI’s app guidelines both prohibit ads and sponsored content in tool results, so a server that carries ads can never be included there, but this one can.

Local development

git clone <this repo> && cd mcp_server_paid
python3 -m venv .venv && .venv/bin/pip install -r requirements.txt
cp example.env .env          # fill it in; leave RAPIDAPI_KEY empty
set -a && . .env && set +a
.venv/bin/python -m src      # streamable HTTP on http://localhost:8000/mcp

Point a client at the local process the same way:

claude mcp add --transport http google-flights-local http://localhost:8000/mcp --header "x-rapidapi-key: YOUR_RAPIDAPI_KEY"

Tests (124 passed, verified):

.venv/bin/python -m pytest -q

Configuration lives in example.env; everyvariable is documented there. The ones that matter:

Betrouts: GET /health (öffentlich, ohne Authentifizierung – Registries frag en ab), GET /metris, GET /metris/calls?hours=24.

Das Deployment erfolgt über Vercel api/index.py (FastAPI-Wr, der FastMCP seinen lifespan – stateless_httP=True). Der kanonische MCP-Pfad ist /mcp, kein abschließender Slahesch.

Commite niemals einen echten Schlüssel. example.env wird mit Platzhaltern ausgeliefer t; es bleibt dabei.

Keine Zugehöigkeit

Dies ist eine unabhängige API, deren Rückgabe öffentlich verfügbare Flugpreis sind. Sie ist nicht mit Goole verbunden, von Goole gebiligt oder gesponsert. „GoFlights" wirb nur zur Bescheigung der öffentlichen Quelle verwdet. BÜKK Tagifikate werden vom Upstream-Tarifanbieter geliefert, ändern sich ständig und sind nicht garantiert – bestätigen Sie dec Preis vor dem Kauf immer auf der Website der Fluggesellschaft oder der Buchungsseite.