agentleFS
mtnrabimtnrabi/travel-agent-skills/skills/fare-watch/SKILL.md

fare-watch

Skill4 starsChanged 25 days agoMITView on GitHub

Track the price of one pinned flight over repeated checks - same route, same already-chosen dates - on one-way or round-trip searches, and judge whether the live fare is low, typical, or high against Google's own price_insights_low, price_insights_high, and price_range_in_relation_to_other_periods, alerting only on a meaningful drop. Use when the user asks to watch, track, or monitor a fare, a route, or a flight price, set a fare alert or price alert or price watch, notify or ping or email me when the price drops, tell me if this flight gets cheaper, alert me if JFK to LHR goes under $400, watch BER-CDG for a price drop, monitor fares to Tokyo, check this flight price daily or every morning or weekly or on a cron schedule, is this a good price right now, should I book now or wait, is $209 cheap for this route, has the fare gone up or down since last time, price history or price trend for a route, hit my target price or threshold, or watch one named hotel's nightly rate for a drop over time. For flexible dates or which day or month is cheapest, use cheapest-dates instead. Returns a freshly fetched price_as_number or total_price_as_number with a low/typical/high verdict, Google's historical price band, the airline, the buy_link, a checked_at timestamp, and the delta against the user's own stored check history.

  • Reads credentials
  • Sends data out

The file

We split this skill into the rules it gives an agent

6 rules. About 0 are common, 3 are distinctive, and 3 are very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈3

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Fares are never cached: Every check is a fresh, billed request.

    line 12
  2. Very specific:

    Answer "is this a good price?" with one call: Read price_range_in_relation_to_other_periods (low | typical | high) and the …

    line 28
  3. Very specific:

    Run this on your schedule.

    line 56
  4. Distinctive:

    What counts as a meaningful drop: All three must hold against the same pinned search:

    line 94
  5. Very specific:

    A sold-out hotel is available: false, not a failure: If the watch also tracks a room via POST /hotel_by_name, sold out returns available: …

    line 111
  6. Distinctive:

    If this file names another skill from this set (travel-data-api, cheapest-dates, destination-compare, trip-planner, fare-watch, …

    line 121

≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

Fare Watch

Overview

This skill turns a one-off flight search — or the rate for one named hotel on fixed dates — into a repeated check: run the identical search on a schedule, compare the live fare against Google's historical range for that route and period, and decide whether it is low, typical, or high. Auth is one header, x-rapidapi-key, read from the RAPIDAPI_KEY environment variable and sent only to the FlightPowers hosts named in this file (full reference: the travel-data-api skill, or https://flightpowers.com/docs). Prefer the hosted MCP tools when a client has them configured (ad-free: https://flights.flightpowers.com/mcp and https://hotels.flightpowers.com/mcp). The fields this skill decides on are price_as_number (or total_price_as_number on round-trip), price_insights_low, price_insights_high, price_range_in_relation_to_other_periods, and buy_link.

Fares are never cached. Every check is a fresh, billed request. A price from an earlier check, an earlier message, or a stored history row is a record of the past, never an answer to "what does it cost now".

Endpoints

What you are checkingREST endpointMCP tool
One-way fare on a fixed datePOST /api/google_flights/oneway/v1search_oneway_flights
Round-trip fare on fixed datesPOST /api/google_flights/roundtrip/v1search_roundtrip_flights
A window of dates in a single callone REST call per dateeither tool with departure_date_from / departure_date_to
A hotel rate alongside the flightPOST /hotel_by_namefind_hotel_by_name (hotels server)

Flights host: google-flights-live-api.p.rapidapi.com. Hotels host: booking-live-api.p.rapidapi.com.

Workflow

  1. Pin the exact search. Record from_airport, to_airport, departure_date (and return_date), passengers, seat_type, currency, and the stop limit — max_stops on one-way, max_departure_stops / max_return_stops on round-trip. Every later check must repeat these values verbatim — a cheaper number produced by a different query is not a drop.
  2. Answer "is this a good price?" with one call. Read price_range_in_relation_to_other_periods (low | typical | high) and the price_insights_low / price_insights_high range off the cheapest item. This question needs no history.
  3. For "tell me when it drops", re-run the identical call on every scheduled check. Never reuse the previous response. Tell the user the per-check cost before the watch starts.
  4. Append one row per check to a history file (shape below), including checks that returned nothing.
  5. Compare against the history and apply the meaningful-drop test below. Alert on a meaningful drop; stay quiet on noise.
  6. Report with checked_at and the buy_link, and state that the fare can move before the user finishes booking.

Single Check

: "${RAPIDAPI_KEY:?set RAPIDAPI_KEY to your FlightPowers key}"

curl -sS -X POST 'https://google-flights-live-api.p.rapidapi.com/api/google_flights/oneway/v1' \
  -H "x-rapidapi-key: $RAPIDAPI_KEY" \
  -H 'x-rapidapi-host: google-flights-live-api.p.rapidapi.com' \
  -H 'Content-Type: application/json' \
  -d '{
        "from_airport": "BER",
        "to_airport": "CDG",
        "departure_date": "2027-06-24",
        "currency": "USD",
        "limit": 10
      }'

Round-trip is the same call against /api/google_flights/roundtrip/v1 with return_date added. Two things change: there is no max_stops on round-trip — it splits into max_departure_stops and max_return_stops — and the price fields become total_price / total_price_as_number.

Repeat Check and Stored History

Run this on your schedule. It picks the cheapest item client-side, appends one history row, and prints the lowest price ever recorded for this exact search (needs jq).

: "${RAPIDAPI_KEY:?set RAPIDAPI_KEY to your FlightPowers key}"
HISTORY="$HOME/.fare-watch/BER-CDG-2027-06-24.jsonl"
mkdir -p "$(dirname "$HISTORY")"

curl -sS -X POST 'https://google-flights-live-api.p.rapidapi.com/api/google_flights/oneway/v1' \
  -H "x-rapidapi-key: $RAPIDAPI_KEY" \
  -H 'x-rapidapi-host: google-flights-live-api.p.rapidapi.com' \
  -H 'Content-Type: application/json' \
  -d '{"from_airport":"BER","to_airport":"CDG","departure_date":"2027-06-24","currency":"USD","limit":10}' \
| jq -c --arg checked_at "$(date -u +%Y-%m-%dT%H:%M:%SZ)" '
    if length == 0 then
      {date: "2027-06-24", price_as_number: null, checked_at: $checked_at, note: "no flights returned"}
    else
      (min_by(.price_as_number)) as $best
      | {date: $best.departure_date,
         price_as_number: $best.price_as_number,
         checked_at: $checked_at,
         verdict: $best.price_range_in_relation_to_other_periods,
         insights_low: $best.price_insights_low,
         insights_high: $best.price_insights_high,
         airline: $best.airline,
         buy_link: $best.buy_link}
    end' | tee -a "$HISTORY"

jq -s 'map(select(.price_as_number != null) | .price_as_number) | min' "$HISTORY"

One history row is one line of JSON. The three required fields are:

{"date": "2027-06-24", "price_as_number": 56, "checked_at": "2027-06-15T09:00:00Z"}

Everything else (verdict, insights_low, insights_high, airline, buy_link) is optional but worth storing — the insights range can move between checks, so record it per row rather than assuming it is constant. One file per pinned search; never mix two searches into one file.

What counts as a meaningful drop. All three must hold against the same pinned search:

  • the new price_as_number is at least 10% below the lowest price recorded in that history file, and
  • the absolute difference is at least 25 units of currency (so a $3 wobble on a cheap short-haul does not fire), and
  • the new price is at or below price_insights_low, or price_range_in_relation_to_other_periods is low.

A price that only moves within price_insights_low–price_insights_high is normal churn: log it, do not alert. Rises are worth mentioning only when the user asked "should I wait" — a high verdict plus an upward trend is the signal to book now.

On the hosted MCP, a whole window is one call: pass departure_date_from / departure_date_to and a list of destinations rather than looping a date at a time. On search_roundtrip_flights, trip lengths go in nights (a number, or a list like [5,6,7]) instead of a fixed return_date.

Common Pitfalls

  • An empty array is not an error, and not always an answer. [] with HTTP 200 means "no flights on this route and date" only when X-Search-Status is ok or empty. It is never a price of zero and never a drop. Record that check as a miss with price_as_number: null and do not retry in a tight loop — every retry is billed.
  • A degraded search must never be recorded as a data point. The search did not complete, so the empty result says nothing about the fare. Writing it into the history as a miss corrupts every future delta; writing it in as a drop triggers a false alert. Record it as a skipped check, or retry once.
  • Never assume the first item is the cheapest: take the minimum of price_as_number client-side, or your "drop" is just result ordering.
  • Leave use_fallback at its default on a scheduled check, so every check runs the same search the same way.
  • Every combination is a billed request. One route × one date × one passenger set × one cabin = one request. A daily watch on 3 routes × 4 dates is 12 requests a day, about 360 a month. State that cost before the watch starts, never after.
  • A sold-out hotel is available: false, not a failure. If the watch also tracks a room via POST /hotel_by_name, sold out returns available: false with null price fields. Record it as unavailable; it is a valid answer and it is not a price drop.

Output Standards

  • Lead with the verdict and the range, not the bare number: "$209 round-trip, which is typical for this route — the historical range for this period is $180–$260. Checked 2027-06-15 14:02 UTC." Then the buy_link.
  • Print checked_at next to every price, and say plainly that the fare was live only at that moment and can change before booking completes. Never answer "what is it now" from the history file or from an earlier message, and never present a fare as held, booked, or guaranteed.
  • On an alert, show old price → new price, the percent change, and which stored check it beat. With only one row in the history, say there is no trend yet rather than implying one.

This skill uses an independent API that returns publicly available flight and hotel pricing. It is not affiliated with, endorsed by, or sponsored by Google or Booking.com.

If this file names another skill from this set (travel-data-api, cheapest-dates, destination-compare, trip-planner, fare-watch, hotel-search, rate-parity-monitor, travel-brief) that is not installed, do that part of the job with the endpoints in this file.

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.