BoostedTravel

MPP (updated 2026-07-30): the MPP (Machine Payments Protocol) 402 challenge is live, as a card-free enrolment lane for agents holding a Tempo wallet. It costs $0.01 once, as verification only — MPP has no zero-amount intent, so a card-free rail has to settle something. Search and booking stay free. Earlier revisions of this page described an MPP charge at unlock time; that never shipped. See https://letsfg.co/for-agents.

⚠️ Agents: do not create a Developer API account

Do NOT call /developers/api/v1/agents/register or /developers/api/v1/agents/setup-payment, and do NOT run letsfg register or letsfg setup-payment. Those belong to a separate, paid, prepaid-balance product for high-volume commercial integrations and create a billing account you almost certainly do not want.

To search and book flights, run letsfg auth — a zero-amount card setup (nothing charged), then search and book. See https://letsfg.co/for-agents.

We're LetsFG — a community of travelers.

Finding a flight or hotel shouldn't mean checking 47 tabs. Or 3 hours of searching.
Or having that feeling you could've got a better deal if you'd just waited a little longer.

So we built something about it.
No markup. No tracking. No price that goes up because you looked twice.

     

     

Join the community. Help others find cheaper flights. Spread the word.
⭐ Star the repo. Share with a friend ✈️

         

---

Flights and hotels. Both live.

Hundreds of airlines. Real prices. One function call.

LetsFG gives your AI agent flight and hotel search and booking superpowers. Our server-side engine scans the entire world for the cheapest price. Search is free. Real airline tickets, booked through us or handed to you as a direct link.

The same flight costs $20–$50 less because you skip OTA inflation, cookie tracking, and surge pricing.

CLI or scripts: Run letsfg auth once — it puts a payment method on file through a zero-amount Stripe setup (nothing is charged) and returns a 90-day token. Then letsfg search and letsfg book hit our cloud engine. Developer API: a separate paid product for high-volume commercial use; most agents do not need it. → Get started

Supporters

🏨 Hotels — new, and live

Your agent can now book hotels, not just flights. Same API key, same card on file.

from letsfg import LetsFG
lfg = LetsFG()

city = lfg.hotel_destinations("Warsaw")[0]
stays = lfg.search_hotels(
    city_id=city["Id"], city_name=city["Name"],
    check_in="2026-11-10", check_out="2026-11-12", adults=2,
)

hotel = stays["hotels"][0]
offer = hotel["offers"][0]
print(hotel["name"], offer["price"], stays["currency"])
# Hotel Gromada Warszawa Centrum 669.86 PLN

booking = lfg.book_hotel_and_wait(
    session_id=stays["session_id"],
    hotel_code=hotel["hotel_code"],
    combination_id_v2=offer["combination_id_v2"],
    expected_price=offer["price"],
    expected_balance=offer["balance_to_supplier"],
    city_id=city["Id"], city_name=city["Name"],
    check_in="2026-11-10", check_out="2026-11-12",
    guests=[{"title": "Mr", "first_name": "Jan", "last_name": "Kowalski"}],
    email="guest@example.com", phone="512345678",
)
print(booking["confirmation"], booking["pay_link"])

How you pay

5% now, the rest to the hotel later. At booking we charge 5% of the price to your card as a reservation fee. The remaining balance is paid directly to the supplier through a pay_link we return — we never hold it.

balance_due_by is the supplier's own auto-cancellation date, not a date we invent. Miss it and the room is released.

The 5% is non-refundable. Cancelling before balance_due_by costs nothing else; after it, the hotel's own cancellation ladder applies and can reach 100%. That ladder ships in the booking's terms, so you can always see the cost before you cancel.

Things worth knowing before you build

• A card on file is required for every hotel call, including search. That is unusual and it is deliberate: a hotel search opens a real session at the supplier, and booking blocks a real rate. We would rather refuse up front than let you reach the point of commitment and discover you cannot pay. The same card that authorises flight booking authorises hotels — there is no separate hotel signup.
• Only free-cancellation, pay-later rates are sold. Those are the rates where the balance can safely be settled with the supplier after booking, which is what makes 5%-now/rest-later work at all. You will see fewer results than a metasearch shows you. Every one of them can actually be booked.
• Booking is asynchronous. book_hotel returns a booking_job_id, not a booking — the real thing takes minutes. Poll hotel_booking(job_id) until status is succeeded or failed, or call book_hotel_and_wait and let the SDK do it. This is not ceremony: it is what makes it impossible to charge a card and then lose the confirmation to a timeout.
• The fee is charged before the room is committed. A declined card therefore costs nothing to unwind — no reservation exists and nothing is charged.
• Do not retry a booking blindly. Calling book_hotel twice for the same rate books the room twice and charges two reservation fees.
• price is what the guest pays. There is no wholesale figure in the response to quote by mistake.

JavaScript

import { LetsFG } from 'letsfg';
const lfg = new LetsFG({ apiKey: process.env.LETSFG_API_KEY });

const [city] = await lfg.hotelDestinations('Warsaw');
const stays = await lfg.searchHotels({
  cityId: city.Id, cityName: city.Name,
  checkIn: '2026-11-10', checkOut: '2026-11-12', adults: 2,
});

const booking = await lfg.bookHotelAndWait({ /* ...offer + guest details... */ });
console.log(booking.confirmation, booking.pay_link);

MCP

Five new tools, in the order you call them: resolve_hotel_city → search_hotels → book_hotel → get_hotel_booking → cancel_hotel_booking.

✦ Starlink Wi-Fi on results

Offers tell you whether the flight has Starlink, in two honest tiers. A solid verdict (confirmed_all) means the airline has fitted every aircraft of that type. A hedged one (likely_all) means the rollout on that type is real but incomplete — as of August 2026 United was ~29% of its fleet — so it is reported as a signal, never a promise. An absent field means no information, not an absence of Wi-Fi.

for o in offers:
    if o.get("starlink") == "confirmed_all":
        print(f"{o['owner_airline']} {o['price']} — Starlink on every leg")

Full semantics: docs/api-search.md.

⇄ Split tickets — two tickets, one trip

A long-haul searched as one journey comes back as one through-fare, because everyone is reselling the same ticket. Searched as two independent legs through a hub, each leg is booked from whatever is cheapest for that hop — whichever airline, whichever seller. Usually that lands on two different airlines (often a low-cost carrier for the short leg and a separate airline for the long one), but the only rule is "cheapest for each leg". Nobody sells the combination as one ticket, so nobody quotes it — which is exactly why it is cheaper.

LetsFG builds that itinerary for you and returns it alongside the through-fares. Split offers are flagged, never disguised:

for o in offers:
    if o.get("split_ticket") == "true":
        print(o["price"], "— two separate tickets, self-transfer not protected")

Read self_transfer before you present the price. unprotected means the two tickets are not linked: if the first flight is late and the connection is missed, the second airline owes nothing — no rebooking, no refund, no duty of care. That is the trade you are being offered in exchange for the saving, and it has to reach the traveller. We only build a split when the connection has a real buffer, and we say so on the offer — but an agent that relays the price without the condition is misrepresenting it.

The probe is gated. Two extra connector fan-outs cost real money, so a split is only attempted when the through-fare is expensive enough, the journey long enough, and the market has somewhere to break the trip. Most searches never fire it, and a search that fires it does not always find a saving.

It lands after completed. See Polling: completed is not the end.

Where it runs. letsfg.co, and the agent lane behind it — the CLI, the Python and JS SDKs, and the MCP server. The paid Developer API is served by a different backend; self_transfer is returned there, but split-ticket offers are not part of that contract.

What it actually saves

_{Measured August 2026 on live searches (one adult, one way, ~2 months out). Each split is two separate tickets (here, two different airlines) with an unprotected self-transfer — if the first flight is late, the second airline owes you nothing. Prices move constantly; these won't reproduce exactly. 5 of 26 long-haul routes searched produced a split cheaper than the best single ticket — the win shows up at secondary cities with no cheap direct long-haul. Regenerate with tools/split-comparison.py.}

The numbers above come from real searches and are reproducible: the script runs the same public search anyone can run, compares the cheapest split against the cheapest single ticket in the same result set, and writes the raw offers to split-comparison.json so any row can be checked. Routes that produced no split are reported too rather than dropped quietly — most searches never fire a split probe, and a table that hid that would misrepresent how often this happens.

Three ways to use LetsFG

• CLI / SDK (Path 1): pip install letsfg and run letsfg auth once — it puts a payment method on file via a zero-amount Stripe setup (no charge, no authorization hold) and gives you a 90-day Bearer token. After that, letsfg search calls our server-side engine and applies the open-source ranking algorithm locally. Search is free and unlimited.

• PFS — Programmatic Flight Search (Path 2): For scripts and agents that call the API directly. letsfg.co is human-only by default (Cloudflare Turnstile + bot protection). Get a 90-day Bearer token by putting a payment method on file. Nothing is charged on the card lanes — it is a zero-amount Stripe setup:

  1. POST https://letsfg.co/api/agent-access/request → 402 with setup_url (hosted), a headless object, and an mpp object
  2. Present a payment method, whichever fits how you run:
     • hosted — a human adds a card at setup_url, then send { "setup_session_id": "cs_..." }
     • headless — no browser: create a PaymentMethod and confirm the SetupIntent yourself against api.stripe.com with the supplied publishable key, then send { "setup_intent_id": "seti_..." }
     • MPP — no card at all: answer the WWW-Authenticate: Payment challenge ($0.01 once, verification only), then retry with Authorization: Payment <credential>
  3. POST https://letsfg.co/api/agent-access/verify → receive your Bearer token
  4. Search: POST https://letsfg.co/api/search with Authorization: Bearer <token>
  5. Book: POST https://letsfg.co/api/agent-book

  Full guide and response schema: letsfg.co/for-agents. Booking returns either a confirmed order or a direct booking link for that exact offer.

• Developer API (Path 3): Paid server-side search at letsfg.co/developers. Prepaid credits, direct airline booking URLs (no checkout step), full NL query parsing, and a /discover endpoint that checks 20 destinations in one call for 1 credit (2–5 s). Includes a free sandbox at /sandbox/flights/*. Full docs: letsfg.co/developers/api/docs.

Free server-side search: Use Path 1 or PFS — one letsfg auth (a zero-amount card setup, nothing charged) gives you a 90-day token and free searches on our servers. No Playwright, no local install beyond the SDK.
Direct booking URLs with no per-booking fee: Use the Developer API (Path 3) — prepaid credits, instant results, no checkout layer.

Real prices: LetsFG vs Google Flights

We searched 5 routes on Google Flights and LetsFG on the same day (2026-08-05), for flights departing 2026-09-16. Same airline, same number of stops — LetsFG was cheaper every time:

$133 cheaper across 5 routes in a verified comparison (2026-08-05). Google Flights inflates on repeat searches; LetsFG returns the same prices however often you run the search, because it reads airlines and the major booking sites directly rather than tracking you.

Why the difference? Google Flights only searches its own limited set of airline partners. LetsFG searches everywhere — Skyscanner, Kiwi, Kayak, Momondo, plus direct airline websites (Ryanair, United, Southwest, EasyJet, Spirit, Norwegian, AirAsia, and hundreds more). More sources = better prices. No demand-based inflation and no cookie tracking: the same search returns the same prices however often you run it.

Real hotel prices: LetsFG vs Booking.com

Same hotel, same room type, same 2-night stay, same free-cancellation policy — checked on the same day (2026-08-05) for a 2026-09-16 check-in:

$207 cheaper across 3 hotels in a verified comparison (2026-08-05), matching each property's own free-cancellation rate against Booking.com's free-cancellation rate for the identical dates and room type. Prices quoted in PLN at booking, converted to USD at that day's rate.

Why the difference? LetsFG sells at wholesale cost — no markup for demand, no loyalty-program cross-subsidy. You're not paying for the room upfront: 5% books it now, and the remaining 95% isn't due until the hotel's own cancellation deadline. Cancel before that deadline and you lose nothing but the 5%; the rest was never charged. Only free-cancellation, pay-later rates are sold, so every price shown is one you can actually hold risk-free.

Try it right now — no install needed

Human users: Use letsfg.co and search flights instantly in your browser:

Search any route, compare live results, and unlock the booking links for the flights you want — no installation needed.

Agents / scripts (free server-side): Get a Bearer token by putting a payment method on file (nothing is charged) → use POST /api/search and POST /api/agent-book. This is PFS — Programmatic Flight Search powered by the letsfg.co engine, free for 90 days per token. See letsfg.co/for-agents for the full guide.

When you're ready to integrate it into your own agent, keep reading.

Pricing

CLI / SDK / MCP / PFS = free search, no LetsFG fee on flight booking. Run letsfg auth once (a zero-amount card setup — nothing is charged) and both searching and booking are free for 90 days. No credits, no unlock step. letsfg book / POST /api/agent-book returns either a confirmed order or a direct airline link — no LetsFG fee either way (you still pay the ticket price itself, plus Stripe's own processing cut, same as any card charge).

Hotels = 5% now to hold a free-cancellation rate, on every path. That 5% is what pays for flexibility: it books the room today, but the remaining 95% isn't charged until the hotel's own cancellation deadline, paid straight to the hotel via a pay_link. Cancel before that deadline and the only cost is the 5% already paid. See Hotels above.

Developer API = prepaid, business use. letsfg.co/developers returns direct airline booking URLs with no per-booking fee. Monthly billing: $0.50/search for the first 10, $0.20 for 11–1,000, then $0.10/search. Resets monthly. Minimum top-up: $5.

💡 Know someone who travels? The more people discover LetsFG, the more airlines we cover — and the better it gets for everyone. ⭐ Star · Share with a friend

Why developers star this repo

Get started

Pick where you want search to run. Local runs on your machine for free; PFS and the Developer API run on our servers.

🖥️ CLI / SDK — free, one-time auth

pip install letsfg
letsfg auth          # one-time card-on-file setup → 90-day Bearer token (nothing charged)
letsfg search LHR BCN 2026-06-15

One auth step, then searches are free for 90 days — no install of browsers, no scrapers. The search runs on our servers.

letsfg search LHR JFK 2026-06-15 --cabin C   # cabin class: M economy, W premium, C business, F first
letsfg book off_xxx --passenger '{"given_name":"John","family_name":"Doe","born_on":"1990-01-15","gender":"m","title":"mr"}' --email john.doe@example.com

Booking from CLI search: letsfg book returns either a confirmed order (a real airline PNR, e-ticket to your inbox) or a direct booking link for that exact offer — no LetsFG fee either way. Want direct airline URLs on every search, with no checkout step at all? Use the Developer API below.

🔌 PFS — Programmatic Flight Search (free, server-side)

Run LetsFG's full search on our servers — no local browser, no install. Access requires a payment method on file: letsfg.co is human-only (Cloudflare Turnstile), so a Bearer token is the only programmatic way in. Nothing is charged to get one — it is a zero-amount Stripe setup — and the token lasts 90 days.

# 1. Request a challenge code
curl -X POST https://letsfg.co/api/agent-access/request

# 2. Add a card at the returned setup_url (nothing is charged), or confirm the
#    SetupIntent yourself against api.stripe.com with the supplied publishable key

# 3. Exchange it → receive a 90-day Bearer token
curl -X POST https://letsfg.co/api/agent-access/verify \
  -H "Content-Type: application/json" \
  -d '{"setup_session_id":"cs_<from step 1>"}'

# 4. Search with the token
curl -X POST https://letsfg.co/api/search \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{"origin":"LHR","destination":"BCN","date_from":"2026-06-15"}'

Search is free; book with POST /api/agent-book — no LetsFG fee either way. Full guide and response schema: letsfg.co/for-agents.

⚡ Developer API — paid, server-side, direct booking URLs

A separate paid product for high-volume commercial integrations; most agents should not use it. Prepaid credits, results in seconds, direct airline booking URLs — plus /discover (20 destinations in one call, 1 credit), async polling, NL query parsing, and a free sandbox.

# Register, then search with your API key
curl -X POST https://letsfg.co/developers/api/v1/agents/register \
  -H "Content-Type: application/json" \
  -d '{"agent_name":"my-agent","email":"you@example.com"}'

curl -X POST https://letsfg.co/developers/api/v1/flights/search \
  -H "X-API-Key: letsfg_..." \
  -H "Content-Type: application/json" \
  -d '{"origin":"LHR","destination":"BCN","date_from":"2026-06-15"}'

Pricing: $0.50/search for the first 10 each month, $0.20 for 11–1,000, $0.10 beyond. Minimum top-up $5. Test for free in the sandbox first. Full docs: letsfg.co/developers/api/docs.

# Search (free with the letsfg auth token)
letsfg search LON BCN 2026-04-01 --return 2026-04-08 --sort price

# Book — no LetsFG fee either way. Returns a confirmed PNR or a direct
# booking link for that exact offer.
letsfg book off_xxx \
  --passenger '{"id":"pas_0","given_name":"John","family_name":"Doe","born_on":"1990-01-15","gender":"m","title":"mr"}' \
  --email john.doe@example.com

💡 Like what you see? Support us — ⭐ Star · Share with a friend

Works everywhere your agent runs

MCP Server (Claude Desktop / Cursor / Windsurf / OpenClaw)

{
  "mcpServers": {
    "letsfg": {
      "command": "npx",
      "args": ["-y", "letsfg-mcp"]
    }
  }
}

Run letsfg auth inside the MCP session once (a zero-amount card setup — nothing is charged — then saves the 90-day Bearer token). After that, search and booking both work immediately, with no LetsFG fee either way.

{
  "mcpServers": {
    "letsfg": {
      "command": "npx",
      "args": ["-y", "letsfg-mcp"],
      "env": {
        "LETSFG_API_KEY": "letsfg_your_api_key"
      }
    }
  }
}

5-minute quickstarts: Claude Desktop · Cursor · Windsurf

Python SDK

from letsfg import LetsFG

bt = LetsFG()  # reads LETSFG_API_KEY from env
flights = bt.search("LHR", "JFK", "2026-04-15")
print(f"{flights.total_results} offers, cheapest: {flights.cheapest.summary()}")

JavaScript SDK

import { LetsFG } from 'letsfg';

const bt = new LetsFG({ apiKey: 'letsfg_...' });
const flights = await bt.search('LHR', 'JFK', '2026-04-15');
console.log(`${flights.totalResults} offers`);

Python SDK (cloud search)

from letsfg.local import search_local

# Reads LETSFG_BEARER_TOKEN env var or ~/.letsfg/config.json (set by `letsfg auth`)
result = await search_local("GDN", "BCN", "2026-06-15")

for offer in result.offers[:5]:
    print(f"{offer.airlines[0]}: {offer.currency} {offer.price}")

🖥️ Omarchy desktop plugin

Search hundreds of airlines from the Omarchy bar. Type two airport codes and a date, press Search, click an offer to open it. The panel lives in this repo — manifest.json, BarWidget.qml, Panel.qml and Model.js at the root — and runs on the same engine as the CLI and the MCP server, ordered by the same open-source ranking algorithm in sdk/js/src/ranking.ts.

Install

omarchy plugin add https://github.com/LetsFG/LetsFG.git --enable

Then add LetsFG Flights to a bar section in the Omarchy bar settings, open it, and press Add a card to continue — a zero-amount Stripe setup, nothing is charged — or run letsfg auth in a terminal and the panel picks that token up. Search is then free and unlimited.

Remove

omarchy plugin remove io.github.letsfg.flights

That removes the plugin only. Your token is yours — delete ~/.letsfg/config.json yourself if you want it gone.

The plugin bundles no API keys. It authenticates with a token you create and can revoke, it never asks for card details, and it never starts a search on its own — no background poll, no price watch, no refresh timer. Every host it can contact, every file it reads or writes, and the anonymous installation id it sends so we can tell whether anyone is using it, are documented in full in OMARCHY-PLUGIN.md.

Requires the Omarchy Quattro shell. MIT, like the rest of this repo. Not affiliated with, sponsored by, or endorsed by Omarchy or 37signals.

Install

CLI Commands

All commands accept --json for structured output and --api-key to override the env variable.

How it works

CLI / SDK / MCP (free, cloud-backed)

letsfg auth (once) → Bearer token (90-day) → Search (free) → Book via letsfg.co (no LetsFG fee)

1. Auth — letsfg auth runs the payment-token flow: POST /api/agent-access/request → add a card at the printed setup_url (or confirm the SetupIntent headlessly) → POST /api/agent-access/verify. Nothing is charged. Token saved to ~/.letsfg/config.json, valid 90 days.
2. Search — letsfg search LHR BCN 2026-06-15 calls POST https://letsfg.co/api/search, polls until done (8–10 s to first results), and applies the open-source ranking algorithm locally.
3. Book — POST /api/agent-book. Returns either a confirmed order or a direct booking link for that exact offer. No LetsFG fee either way.

Polling: completed is not the end

A search returns in 8–10 s to first results. Poll GET /api/results/<search_id> immediately and then every 2 s — a loop that sleeps first puts a floor under a search that is already faster than the sleep.

When status leaves searching, the connector fan-out is done — but the offer set may still be growing. The split-ticket probe is dispatched after the fan-out and merges its result in late, so the cheapest itinerary on the search is routinely one that does not exist yet at the moment the status turns terminal. The response says so:

Keep polling while either is true, and bound the wait — a flag that never clears must not hang your agent. Take whatever has landed when the bound expires.

The Python and JS SDKs and the MCP server already do this, with a 90 s ceiling — the same window the server uses to decide a result has settled. So a search that fires a split probe can take meaningfully longer than the 8–10 s to first results fast path, and it is the split offer you are waiting for. Set LETSFG_WAIT_FOR_SPLIT=0 if you would rather have the fast answer.

Most searches never fire the probe, so both flags are usually already false on the first poll and this costs nothing.

PFS — raw API (same as CLI, without the wrapper)

Payment method on file -> Bearer token (90-day) -> POST /api/search -> poll GET /api/results/<id> -> POST /api/agent-book

1. Get a Bearer token — POST /api/agent-access/request → present a payment method (hosted card page, headless SetupIntent, or MPP) → POST /api/agent-access/verify. Nothing is charged on the card lanes. Token valid 90 days.
2. Search — POST https://letsfg.co/api/search with Authorization: Bearer <token>. Returns { search_id }. Poll GET /api/results/<search_id> immediately, then every 2 s, until status leaves searching. Then keep polling while split_ticket_pending or gf_enrich_pending is true — the split-ticket offer merges in after the status turns terminal.
3. Book — POST /api/agent-book. No LetsFG fee.

Developer API — paid, direct booking URLs

Register → Fund balance → Discover or Search (credits) → Direct booking URL (no checkout)

1. Discover — POST /flights/discover with up to 20 destinations, get indicative prices sorted cheapest-first. 1 credit, 2–5 s. Use to rank options before committing to a full search.
2. Full search — POST /flights/search (blocking) or /flights/search/async (non-blocking + poll). 1 credit, 8–10 s to first results.
3. Book — each offer includes a direct airline booking_url. No LetsFG fee, no checkout step.

Architecture

CLI / SDK / MCP / PFS

CLI / SDK / MCP / AI Agent
        │  Payment method on file -> 90-day Bearer token
        ▼
POST letsfg.co/api/search  (bot-protected, token required)
        │
        ▼
letsfg.co server-side search engine
        │
        ▼
GET /api/results/<search_id>  (poll every 2 s; keep going while split_ticket_pending)
        │
        ▼
Ranking applied locally (sdk/js/src/ranking.ts, open-source)
        │
        ▼
Results + booking via POST /api/agent-book — no LetsFG fee either way

Developer API

Product / Team / Agent
        │  API key + prepaid credits
        ▼
letsfg.co/developers/api/v1
  ├─ /flights/discover      (indicative prices, 20 dest, 1 credit, 2–5 s)
  ├─ /flights/search        (full search, 1 credit, 8–10 s to first results)
  ├─ /flights/search/async  (non-blocking + poll)
  ├─ /flights/parse-query   (Gemini NL parsing, free)
  └─ /sandbox/flights/*     (fake data, same schema, free)
        │
        ▼
Direct airline booking_url - no checkout step

Star History