Travel Fare & Hotel Price Intel

TL;DR for OTAs, fare-drop apps, corporate-travel tools, and travel fintech: Pulls structured flight fares and hotel prices into one normalized schema - origin/destination, dates, carrier, fare, cabin, stops, times (flights); property, dates, total + per-night price, stars, review score (hotels) - from the open, logged-out result pages metasearch sites render. On top of the raw fares it adds the layers a fare-drop product actually needs: route summaries (min/median/max fare + carrier spread), a cheapest-per-date grid, and monitor-mode price-drop alerts. The gate is the whole point: Google Flights has no public API, the ITA Software API was discontinued, and the airline/GDS APIs (Amadeus, Sabre) are approval- and contract-gated - so structured fare data has no clean free path. Public data only, polite rate limits, no PII. Free Apify plan covers exploration runs on your $5 platform credit.

Run it in 30 seconds

# Via the Apify Python SDK
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("seibs.co/travel-fare-intel").call(run_input={
    "mode": "flight_fares",
    "routes": [{"origin": "JFK", "destination": "LAX", "departure_date": "2026-07-15"}]
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

Or via curl:

curl -X POST "https://api.apify.com/v2/acts/seibs.co~travel-fare-intel/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode": "flight_fares", "routes": [{"origin": "JFK", "destination": "LAX", "departure_date": "2026-07-15"}]}'

Or click "Try for free" on this page if you prefer the no-code UI.

What you get

Each run produces:

• A clean dataset, filterable in the Apify console and downloadable as CSV or JSON
• An access_notes record up top documenting each provider's access method, proxy needs, anti-bot escalation, and the responsible-use posture
• A sample-output preview at ./.actor/sample-output.json

What does Travel Fare Intel do?

It queries each selected provider's public result page for your routes/destinations and normalizes every result into one schema. For flights: origin, destination, departure_date, return_date, carrier (+ name), fare_amount (+ fare_amount_usd, currency), fare_class (normalized to economy / premium_economy / business / first), stops, duration_minutes, departure_time, arrival_time, booking_url, and observed_at. For hotels: property_name, destination, check_in/check_out, nights, price_total (+ price_total_usd), price_per_night, star_rating, review_score, room_type. Then it runs the enrichment layer:

• Route summaries (route_history) - min / median / max fare, carrier count and spread, and the cheapest carrier across all offers for a route+date+cabin slice. A trend snapshot, not a single price.
• Date grid - the cheapest fare per departure date across a window, so a fare-drop UI can answer "which day is cheapest?".
• Price-drop alerts (price_drop_alert) - in monitor mode, diffs this run's cheapest fares against the previous scheduled run and flags drops past your USD/percent thresholds. The fare-watch signal.

Modes

Mode	What it returns
flight_fares (default)	Current fares per route from each selected flight provider, plus route summaries.
hotel_prices	Property prices per destination/date window from each selected hotel provider.
route_grid	Cheapest-per-date grid across date_from..date_to for each route (date-grid enrichment) + route summaries.
fare_watch	Monitor mode: diffs cheapest fares vs the previous scheduled run and emits price_drop alerts. Pair with an Apify Schedule.

Why this is gated (and the honest coverage tiers)

Structured fare data has no clean public API - Google Flights never shipped one, ITA's was discontinued, and the GDS APIs are contract-gated. The open path is the public result pages, which sit behind edge WAFs and consent walls. The actor handles that with the portfolio's three-tier anti-bot escalation and is honest about which providers are wired:

Fully wired

• google_flights - the flagship. Because Google Flights has no API, the actor builds the same base64 protobuf tfs query string the website itself uses (origin, destination, date, cabin, passengers, trip type) and parses the rendered fare cards off the public results page. No login, no OAuth.

Catalog-registered (anti-bot pipeline wired, provider parser pending -> returns a documented provider_pending note)

• Flights: skyscanner, kayak, kiwi
• Hotels: google_hotels, booking, hotels_com

Upgrading a catalog provider to fully-wired is one parser - the orchestration, normalization, grid, and monitor layers are already provider-agnostic. This is the same architecture the portfolio's business-registry-intel uses for 50-state coverage.

Anti-bot escalation ladder

Each fetch escalates only when challenged, then fails soft:

1. httpx over the DATACENTER proxy - cheapest, tried first.
2. curl_cffi with real Chrome TLS impersonation over the RESIDENTIAL proxy - defeats JA3/TLS-fingerprint WAFs.
3. Playwright (patchright stealth) headful Chromium over RESIDENTIAL - for JS/consent interstitials. Optional; set browser_cdp_url (or the BROWSER_CDP_URL env var) to a warm anti-detect browser to clear the metasearch consent/Cloudflare walls, or run on the apify/actor-python-playwright image.
4. Fail-soft - if every tier is blocked/unavailable, the provider emits a documented fetch_error / provider_pending note and the run still finishes SUCCEEDED.

Legal-safety & responsible use

Per the gated-data playbook: public, logged-out result pages only. The client paces requests politely (a per-request delay plus a concurrency cap), never logs in, never submits payment, and never carries traveller PII - fares and prices are facts, not personal data. Honor each provider's terms and your own counsel's guidance; use the data for price research and fare monitoring, not abuse. The opt-in browser/CDP tier is provided so an operator can bring their own warm browser deliberately.

Pricing (pay-per-event)

Event	Price	When
fare_record	$0.004	Per normalized flight fare
hotel_record	$0.004	Per normalized hotel price
route_history	$0.008	Per route summary (min/median/max + carrier spread)
price_drop_alert	$0.010	Per route whose cheapest fare dropped vs the previous run
scheduled_delta_run	$0.050	Once per scheduled monitor/fare-watch run

A run that returns nothing costs nothing. A 5-layer cost-control defense (pre-flight caps, demo-mode soft-fail, a _RunBudget guard, in-loop budget checks, and hardcoded PPE prices) prevents runaway compute.

MCP twin

An AI-agent-native wrapper ships as mcp-travel-fare-intel - tools: search_flight_fares, get_route_grid, watch_fare, search_hotel_prices. It is x402 (USDC on Base) and Skyfire ready for token-less agentic payments.

Cross-sell

Part of the seibs.co intel portfolio. Diversification play into travel; pairs with the other monitor-mode intel actors for recurring, scheduled data feeds.