Google Flights MCP — tarifas en tiempo real que tu agente puede buscar en todo un rango de fechas, sin anuncios

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

Alojado. Nada que clonar, nada que compilar. Listado en el Registro oficial de MCP como com.flightpowers/google-flights-mcp. Comprobación de salud: /health.

¿Necesitas una clave? Suscríbete a la API de Google Flights Live en RapidAPI — plan gratuito disponible — y copia tu x-rapidapi-key: https://rapidapi.com/mtnrabi/api/google-flights-live-api

¿Aún no tienes clave? Empieza con el servidor gratuito — la misma búsqueda, sin registro: claude mcp add --transport http google-flights-free https://google-flights-lulu.flightpowers.com/mcp (con anuncios: una tarjeta patrocinada revelada por resultado, fan-out limitado a 15, y los clientes que no pueden mostrar la tarjeta patrocinada pueden verse limitados aún más.) Vuelve aquí cuando los anuncios, el límite de 15 búsquedas o esas restricciones de cliente te estorben.

Lo que obtiene tu agente

Dos herramientas que responden a una pregunta de tarifa, no a una consulta de fecha.

• Haz preguntas abiertas. "Vuelo de ida más barato a Sri Lanka en cualquier día de octubre", "5 a 7 noches en Roma en algún momento de mayo, desde Tel Aviv o Larnaca" — cada una es una llamada de herramienta. Ambas herramientas aceptan un rango de fechas de salida, una lista de aeropuertos de destino y (en ida y vuelta) un valor nights en lugar de una fecha de regreso fija, y los expanden internamente.

• Di si un precio es realmente bueno. Cada resultado incluye el rango histórico de Google para esa ruta y período — price_insights_low, price_insights_high, y un veredicto price_range_in_relation_to_other_periods de low / typical / high. Eso es lo que permite a un agente responder "$209 es típico aquí, no te apresures" en lugar de solo citar un número.

• Reserva, no solo navegues. Cada resultado incluye un buy_link a Google Flights.

• Sabe cuánto gastó. Cada respuesta incluye api_usage — solicitudes usadas por esta llamada y lo que queda en el plan del llamante. Ver Informe de gastos.

• Sabe qué buscó. Cada respuesta incluye search_coverage, para que el modelo pueda decir honestamente en qué fechas y destinos se basa la respuesta.

Los resultados son tarifas en vivo. Se vuelven obsoletos en minutos: nunca guardes en caché una tarifa ni reutilices un resultado anterior; vuelve a buscar e indica cuándo se obtuvieron los datos.

Obtén una clave (plan gratuito disponible)

El servidor no posee ninguna credencial ascendente propia. Cada búsqueda se factura a tu suscripción de RapidAPI, por eso la clave viaja con la solicitud.

1. Suscríbete a la API de Google Flights Live: https://rapidapi.com/mtnrabi/api/google-flights-live-api

2. Copia tu x-rapidapi-key.

3. Pásala al servidor de cualquiera de las tres formas siguientes.

Si falta una clave, las herramientas no fallan en silencio ni gastan nada — devuelven needs_api_key: true con la URL de registro y estas instrucciones, redactadas para que el modelo te las lea.

Tres formas de pasar tu clave

La primera fuente no vacía gana, en ese orden. La clave nunca se registra, nunca se repite en un mensaje de error y nunca se devuelve en una respuesta de herramienta.

Herramientas

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 lo aplica este servidor sobre el conjunto de resultados combinado de cada búsqueda que ejecutó, por lo que es predecible sin importar cuántas combinaciones se expandieron.

Un ejemplo práctico

Usuario: "Estoy en Tel Aviv. Viaje de una semana más barato a Roma o Atenas, saliendo cualquier día de la primera mitad de mayo."

Una llamada:

{
  "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
  }
}

Eso se expande a 15 fechas × 2 destinos = 30 combinaciones, que es exactamente el límite por llamada. La forma de la respuesta (los nombres de los campos son reales; los valores a continuación son ilustrativos, no una cotización — ejecuta la llamada para obtener tarifas en vivo):

{
  "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."
  }
}

Otras formas de respuesta que puedes esperar, todas normales:

• No hay vuelos en esas fechas. results: [] con un message — Google Flights realmente no devuelve nada para algunas combinaciones de ruta/fecha. No es un error. Prueba fechas cercanas, un aeropuerto cercano o use_fallback: true.

• Algunas búsquedas fallaron. Un campo partial indica cuántas de las búsquedas ejecutadas fallaron, y los resultados cubren el resto.

• Rango demasiado amplio. search_coverage.truncated: true más un note. El rango se muestrea uniformemente en toda la ventana (se conservan el primero y el último), no se corta — así que la muestra es representativa, no los primeros N días. Aumenta max_searches o reduce el rango para una cobertura más completa.

• Sin clave / clave rechazada. needs_api_key: true, gasto cero, con la solución. Una clave de RapidAPI válida que no esté suscrita a esta API es la causa más común.

• Plan agotado. quota_exhausted: true con api_usage, más un recordatorio de que reducir el rango hace que la cuota restante rinda más.

Informe de gastos (api_usage)

El dinero es tuyo, así que el contador es visible. Cada respuesta exitosa incluye:

plan_requests_remaining y plan_requests_limit provienen de la respuesta ascendente y se omiten cuando el ascendente no los informa; el note se adapta. La regla que el modelo debe decir en voz alta: una fecha × un destino = una solicitud facturada.

Controles de coste, en orden de contundencia: max_searches por llamada (bájalo para gastar menos en una pregunta amplia), un rango de fechas más estrecho, una lista de destinos más corta.

Una llamada contra treinta

La API REST subyacente toma exactamente una tupla (origin, destination, date) por llamada. Frente a un paso directo de una fecha por llamada, "lo más barato a Sri Lanka en cualquier día de octubre" son 31 llamadas de herramienta separadas — 31 viajes de ida y vuelta a través del modelo, 31 oportunidades de perder el hilo y una factura que el usuario solo descubre después.

Aquí es una llamada de herramienta. La expansión ocurre en el servidor, de forma concurrente, limitada, muestreada uniformemente, deduplicada en buy_link, combinada, ordenada por tu sort_by y reportada honestamente en search_coverage y api_usage.

Este servidor no lleva anuncios en absoluto — no por gusto sino por restricción: la política de directorio de conectores de Anthropic y las pautas de aplicaciones de OpenAI prohíben la publicidad y el contenido patrocinado en los resultados de herramientas, por lo que un servidor con anuncios nunca puede aparecer allí y este sí puede.

Desarrollo local

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

Apunta un cliente al proceso local de la misma manera:

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

Pruebas (124 aprobadas, verificadas):

.venv/bin/python -m pytest -q

La configuración vive en example.env; cada variable está documentada allí. Las que importan:

Rutas operativas: GET /health (pública, sin autenticación — los registros la consultan), GET /metrics, GET /metrics/calls?hours=24.

El destino de despliegue es Vercel mediante api/index.py (envoltorio FastAPI que proporciona a FastMCP su ciclo de vida, stateless_http=True). La ruta MCP canónica es /mcp, sin barra final.

Nunca confirmes una clave real. example.env se distribuye con marcadores de posición; mantenlo así.

No afiliación

Esta es una API independiente que devuelve precios de vuelos disponibles públicamente. No está afiliada, respaldada ni patrocinada por Google. "Google Flights" se utiliza únicamente para describir la fuente de datos pública. Las tarifas las proporciona el proveedor ascendente, cambian constantemente y no están garantizadas — confirma siempre el precio en el sitio de la aerolínea o de reserva antes de comprar.