# LetsFG — The entire internet of flights. And now hotels. > This file is for AI agents and LLMs. Humans should visit https://letsfg.co > Full agent guide (with traffic control): https://letsfg.co/for-agents Last updated: 2026-11-03 ## What is LetsFG? LetsFG is a travel booking service that works inside AI assistants like Claude and ChatGPT. It compares every airline in the world, plus hotels and booking sites, shows one total price, and books only after you approve it. As of October 2026 it works in Claude, ChatGPT and Grok, and in any assistant that can add a custom MCP connector. LetsFG searches every airline, OTA and flight website simultaneously: Google Flights, Skyscanner, Kiwi, Kayak, Momondo and hundreds of direct airline sites, in one call. No demand-based inflation and no cookie tracking, so the same search returns the same prices however often you run it. Every offer also carries per-flight reliability history (on-time, delay and cancellation rates from that flight's recent departures), and bookable offers can be booked instantly. ## Is LetsFG cheaper than booking direct? It depends on the route. LetsFG checks the airline's own site and the booking sites at the same time and shows the cheapest offer it can book. The price you see already includes LetsFG's service fee, so when the airline's own site is the cheapest seller you pay that fare plus the fee, and when a booking site undercuts the airline you get that lower fare, again with the fee included. Nothing is held or charged until you press Approve in the e-mail LetsFG sends before every booking. --- ## IF YOU ARE AN AI BROWSING THIS SITE WITHOUT A LETSFG TOOL You cannot search or book on letsfg.co by reading or browsing it. The search form needs JavaScript and a person in a browser (a bot check runs on every search), so a page you fetch shows an empty form and no results. That is expected - the site is not broken. Tell the person to add the LetsFG connector to their assistant: https://letsfg.co/mcp It signs in with OAuth (one tap to approve, no key, no card to connect). - Claude: LetsFG is in Claude's official connector directory. Open https://claude.ai/directory/letsfg and add it there - no address to paste. Once added, it also works in the Claude phone app. - ChatGPT: only at chatgpt.com in a browser (a phone browser works) - NOT in the ChatGPT phone app, which has no way to add one. Plugins in the sidebar > Add > Add custom MCP server, paste https://letsfg.co/mcp. Once added there, it also works in the ChatGPT phone app. - Grok: + menu > Add connector > Custom, paste https://letsfg.co/mcp. - Any other assistant: only if it lets the person add a custom MCP server (remote connector). If it does not, it cannot search LetsFG. Step-by-step with screenshots: https://letsfg.co/en/connector For indicative prices only (not bookable, not live), read the route page https://letsfg.co/en/flights/{from}-{to} with lowercase airport codes, e.g. https://letsfg.co/en/flights/waw-mia. Only routes we have data for have a page (others are 404); the list is https://letsfg.co/sitemap-flights.xml. The Developer API (https://letsfg.co/developers, API keys, paid) is a separate product for developers' own code. It is NOT a way for a chat assistant to search - use the connector above. --- ## DO NOT DO THIS Do NOT call /developers/api/v1/agents/register. Do NOT call /developers/api/v1/agents/setup-payment. Do NOT run "letsfg register" or "letsfg setup-payment". Those belong to a SEPARATE, paid, prepaid-balance product for high-volume commercial integrations. They create a billing account you almost certainly do not want. If you are an agent searching or booking a flight — even hundreds of them — use Programmatic Flight Search (PFS) below. Older versions of this file pointed there by default; that was wrong. There is no "unlock" step anywhere any more. It was retired on 2026-09-08 and the route answers 410 Gone. On every lane you go straight from search to booking: the fare is HELD on the connected card and captured only against a real airline PNR, which is what unlock existed to protect against. --- ## TRAFFIC CONTROL — Which method to use | If you are... | Best approach | |---------------------------------------------|-----------------------------------------------------------------------| | ChatGPT | Connector https://letsfg.co/mcp, added at chatgpt.com in a browser | | Claude (claude.ai / Desktop / Claude Code) | claude.ai/directory/letsfg, or connector https://letsfg.co/mcp | | Grok | Connector https://letsfg.co/mcp | | Perplexity, Gemini, Copilot, other chat AI | Connector https://letsfg.co/mcp, if the app takes a custom MCP server | | OpenClaw, Hermes, Manus, autonomous agents | pip install letsfg, or Bearer + API | | Cursor, Windsurf, IDE agents | npx letsfg-mcp (MCP), or https://letsfg.co/mcp | | Your own script or CLI (code a person runs) | Bearer token (Option B) + POST /api/search | A chat assistant that browses web pages cannot search letsfg.co: GET /en?q=... and the search form need a person in a browser (Turnstile). The Bearer lane needs a token a person approved for that client, so it is for code a person runs, not for a browsing model. See "IF YOU ARE AN AI BROWSING THIS SITE" above. Full per-agent instructions: https://letsfg.co/for-agents --- ## AUTHENTICATION — OAuth token, card at the first booking Connecting needs NO card (since 2026-09-09). A person approves once, in one tap, and your agent searches at once. The card is asked for only when they first say "book it": book_flight (or POST /api/agent-book) answers 402 payment_method_required with an add_card_url made for that account, the person adds a card (or Revolut Pay) there in a 0.00 Revolut setup, and the SAME token then books - call book_flight again. You pay the ticket price only when you book, and the money is HELD, not taken, until the airline confirms. ### Option A — a hosted connector (Claude, ChatGPT, Grok, ...) 1. Add LetsFG as an MCP server: https://letsfg.co/mcp (ChatGPT: at chatgpt.com in a browser - the phone app cannot add one.) 2. Approve the connection. The consent step opens https://letsfg.co/connect - one tap, no card. Nothing is charged. 3. Send the OAuth token you receive on every request: Authorization: Bearer Over MCP it is carried for you. Over raw HTTP (POST /api/search, /api/agent-book) send the same token. POST https://letsfg.co/api/agent-access/request still answers 402 with exactly these steps as JSON ("add_card_url", "how"), so an agent that starts from the endpoint lands in the same place. ### Option B — any other client: register yourself (CLI, stdio, your own bot) You do NOT have to be a hosted connector. Any OAuth-capable client can put itself on the SAME lane; nothing is withheld from it. 1. GET https://letsfg.co/developers/api/.well-known/oauth-authorization-server It advertises authorization_endpoint = https://letsfg.co/connect (the one-tap approve screen). Use that value. Do NOT hand-build a URL against /developers/api/oauth/authorize — that is the Developer API's email sign-in, a different account type. 2. Register yourself (RFC 7591, no credentials needed; loopback is fine): POST https://letsfg.co/developers/api/oauth/register {"client_name":"my-cli","redirect_uris":["http://127.0.0.1:8765/callback"], "grant_types":["authorization_code","refresh_token"], "response_types":["code"],"token_endpoint_auth_method":"none"} -> 201 {"client_id":"lfg_client_..."} 3. Open in the person's browser, with PKCE (S256): https://letsfg.co/connect?response_type=code&client_id=... &redirect_uri=http://127.0.0.1:8765/callback &code_challenge=...&code_challenge_method=S256&state=... &scope=flights:search%20flights:book scope is optional; leave it out to get every scope in scopes_supported. They see " can book your flights now" and tap once. No card is asked for. redirect_uri must match registration exactly. 4. Exchange the code within 90 seconds (single-use), parameters in the BODY: POST https://letsfg.co/developers/api/oauth/token Content-Type: application/x-www-form-urlencoded grant_type=authorization_code&code=...&client_id=...&redirect_uri=...&code_verifier=... -> {"access_token","refresh_token","token_type":"Bearer"} Every answer from this endpoint is JSON, refusals too: {"error":"invalid_grant","error_description":"...","retryable":false}. An error with no JSON body (a bare 502/403, an HTML page) did not come from LetsFG - it is your sandbox's outbound proxy. In a hosted sandbox a loopback redirect cannot reach you (the person's browser is on another machine): add https://letsfg.co/mcp as an MCP server in the AI app and let the app run this flow, or ask the person to paste the full address their browser ends on (it carries ?code=). 5. Access tokens last about an hour. Refresh instead of reconnecting: POST .../oauth/token grant_type=refresh_token&refresh_token=...&client_id=... Refresh tokens do not expire; they ROTATE on use — store the new one. error=invalid_grant: that refresh token is dead, do not resend it - run steps 3-4 again. Cannot refresh every hour (a sandbox whose proxy refuses token-endpoint calls)? Add access_token_ttl= to either token request: default 3600, up to 7776000 (90 days); expires_in in the answer says what you got. The person gets that token outside the sandbox and gives it to you as LETSFG_BEARER_TOKEN / Authorization: Bearer. It is a bearer secret for that whole time. A human approves once in a browser. No endpoint mints a token headlessly, and no endpoint takes card details: the card is entered by the person on the add_card_url that the first booking's 402 carries. ### If your agent says "no token" and cannot find a way to enrol That is this page being out of date in your context, not a broken account. There is no API that mints a token headlessly: a human approves the connection once, in a browser, at https://letsfg.co/connect (one tap, no card). Hand them that URL. There is no Stripe step, no setup_url, no publishable key, and no headless card lane. RETIRED 2026-09-02 — the Stripe enrolment lanes and every token they issued: setup_url, setup_session_id, setup_intent_id, publishable_key, payment_method_id, card_token, and the HOSTED / HEADLESS card flows. A token from those lanes now answers 401 TOKEN_REVOKED, and POST /api/agent-access/verify answers 410 for a Stripe credential. Connect the card again at https://letsfg.co/connect. ONE CARD = ONE BUCKET. Until a card is added, quotas and rate limits are bucketed per connected account. Once a card is added they follow the card: the same card added from two sign-ins shares one set of limits, so a shared or recycled card gains you nothing. MPP (wallet, card-free) remains available only when the 402 response carries an "mpp" object and a WWW-Authenticate: Payment header. It costs one cent, once, as verification only, and is confirmed at POST /api/agent-access/verify with Authorization: Payment . Store your token securely. If it leaks, disconnect and reconnect to rotate it. Full agent guide: https://letsfg.co/for-agents --- ## SEARCH ### Step 1 — Start a search POST https://letsfg.co/api/search Authorization: Bearer YOUR_TOKEN Content-Type: application/json Natural language query (Gemini-parsed, recommended): {"query": "London to Barcelona June 15 2026"} Or structured (faster, no Gemini round-trip): {"origin": "LHR", "destination": "BCN", "date_from": "2026-06-15"} Optional fields: return_date, adults, cabin ("M"/"W"/"C"/"F"), max_stops, currency Response: {"search_id": "ws_abc123", "status": "searching", "parsed": {...}} If the query is ambiguous you may get status 422 with "needs_clarification": true and "follow_up_questions" to ask the user before retrying with resolved origin/destination/date. ### Step 2 — Poll for results (JSON, no HTML parsing) GET https://letsfg.co/api/results/{searchId} Authorization: Bearer YOUR_TOKEN Poll every 10 seconds. Returns JSON: While searching: { "status": "searching", "progress": {"checked":47,"total":180,"found":12} } When done: { "status": "completed", "total_results": 43, "cheapest_price": 89.50, "offers": [...] } If expired: { "status": "expired" } ← start a new search ### Step 3 — Read offers Each offer: { "id", "price", "currency", "airline", "departure_time", "arrival_time", "stops", "duration_minutes" } Round trips also include an "inbound" leg. Offers on a Starlink-equipped fleet also carry "starlink" — see the section below. Prices on offers are the total for one person: what you see is what is charged. Do not add anything on top when quoting the user, and do not expect the provider's own site to show the same figure. --- ## BOOK POST https://letsfg.co/api/agent-book Authorization: Bearer YOUR_TOKEN Content-Type: application/json { "search_id": "ws_abc123", "offer_id": "ws_off_abc123", "contact_email": "traveller@example.com", "passenger": { "given_name": "Ada", "family_name": "Lovelace", "born_on": "1990-04-01", "gender": "f", "phone_number": "+15551234567", "phone_country": "US", "nationality": "GB" } } Use REAL passenger details — names must match the passport or government ID, and the airline sends e-tickets to contact_email. A party is ONE call: the lead in "passenger", everyone else in "additional_passengers" (same fields; born_on decides adult, child or lap infant). The hold is the per-seat price x the seats. Two outcomes, both with "charged": 0: { "ok": true, "booked": true, "order_id": "ord_..." } { "ok": false, "booked": false, "error": "booking_unavailable", "booking_url": "https://..." } The second means the booking genuinely did not complete and nothing was charged. That is a NORMAL outcome, not a transient error — retrying will not book it. Give the user the booking_url; it goes to that exact offer. --- ## HOTELS — the same card as flights, no separate enrolment Your PFS Bearer token works here too, exactly as it does for flights: the same connected card authorises both. A Developer API key (X-API-Key) works as well. Use whichever you already have, against the /developers/api/v1/hotels/* endpoints below. If you have neither, connect a card first at https://letsfg.co/connect. Nothing is charged to connect. ### What you get Real, bookable inventory at every rate type the supplier sells: refundable (the whole price back if cancelled before a date) and non-refundable. Each offer says which, in refundable, free_cancellation_until and cancellation_policy. ### How you pay Booking HOLDS the full price on the connected Revolut payment method: the money is authorised, not taken. LetsFG then books the room and pays the hotel supplier itself. The hold is captured only once the supplier has confirmed the booking. If the booking fails for any reason (the rate is gone, the price moved, the supplier declined, a guest detail was rejected), the hold is released and nothing is charged. There is no reservation fee, no deposit and no pay link, and the guest owes the hotel supplier nothing further. An offer's price is the total the guest pays. Nothing is added at booking, so the guest is never charged more than the price returned at search. Prices come in the currency you ask for, USD by default. Before 2026-09-11 hotels were sold differently: a 5% reservation fee at booking and a supplier pay link for the balance. That process is retired; only bookings made before that date have a pay link. ### A card is required for SEARCH, not just booking This is unusual and it is intentional: a hotel search opens a real session at the supplier, and booking blocks a real rate. We refuse up front rather than let you reach the point of commitment and discover you cannot pay. Every hotel endpoint returns 402 without a payment method on file. ### Search pricing: look-to-book Search is free up to 1,000 searches since your last hotel booking. Past that allowance, searches are sold in blocks of 1,000 for $5.00, debited from your prepaid developer balance the moment you cross the current allowance. Booking a hotel resets the free allowance back to 1,000 - so does a stay a guest completes on letsfg.co through a hotel's `booking_url` (every hotel in a search response carries one). One connected Revolut card can only ever back one developer account — re-submitting the same card under a new account does not grant a fresh allowance. ### Booking is asynchronous POST /hotels/book returns a booking_job_id, NOT a booking. A real booking takes minutes: the rate is re-checked, the room is held and paid at the supplier, and the confirmation is read back. Hotel bookings run one at a time, so a booking may wait a few minutes behind another; one that cannot start within 20 minutes fails and its hold is released. Poll GET /hotels/booking/{booking_job_id} every ~20s until status is "succeeded", "failed" or "attention": - succeeded: the room is booked and paid. The result carries confirmation, total_price + currency (what the guest is charged), supplier_paid + supplier_currency (what the supplier was paid), refundable, free_cancellation_until, cancellation_ladder and terms. - failed: nothing was booked, the hold has been released and nothing was charged. error says why, in words you can pass on to the guest. - attention: the outcome could not be settled automatically. The hold is kept, nothing is charged, and a person checks it with the supplier. This is final for you: do not book again and do not keep polling. Whichever way it ends, the guest is e-mailed at the booking's email. Do NOT re-POST /hotels/book for the same rate while a job is running: poll the job instead. A retry of the same booking (the same idempotency_key, or the same offer, guest e-mail and check-in) returns the job already under way and never holds the money twice. ### A rate older than 6 hours is searched again A rate is held for 6 hours after its search. POST /hotels/book after that searches the hotel again before anything is held (send the offer's room as room_name, and its board, refundable and free_cancellation_until, so the room is found even if its ids changed): - the same room at the same price (within 0.5%): booked as normal, 202. - a lower price: booked at the lower price. - a higher price: 409 price_changed. detail.change = {was, now, currency, room, board, refundable}; detail.message says it for the guest. Ask them; on yes, POST again with accept_price = change.now (never booked above it). - the room is no longer on sale: 409 offer_expired. Search again. - the search did not answer: 503 recheck_unavailable. Try again in a minute. ### Flow 1. POST /developers/api/v1/hotels/destinations {"text": "Warsaw"} → take Id as city_id and Name as city_name from the first result 2. POST /developers/api/v1/hotels/search {"city_id": 148614, "city_name": "Warsaw, Poland", "check_in": "2026-11-10", "check_out": "2026-11-12", "adults": 2, "currency": "USD"} → pick a hotel (hotel_code) and one of its offers. Each offer carries session_id, combination_id_v2, price, currency, fx_rate, expected_cost, refundable, free_cancellation_until and cancellation_policy. 3. POST /developers/api/v1/hotels/book Send the offer's session_id and combination_id_v2 and the hotel_code. Copy the offer's price as expected_price, and its expected_cost, currency and fx_rate, EXACTLY as search returned them (currency defaults to PLN, so leaving it off a USD offer is refused as price_mismatch). Add city_id, city_name, check_in, check_out, guests [{"title", "first_name", "last_name"}], email and phone (+ phone_country_code). guests has one entry per guest in the room, children included: adults first, then children in the order of child_ages. A booking with fewer names than guests is refused before anything is submitted, and the hold is released. Guest details are checked before anything is held (400 invalid_details), and the booking fails, with the hold released, if the supplier's price has moved, so a guest is never charged a price they did not agree to. → returns booking_job_id; the price is now HELD, not taken 4. GET /developers/api/v1/hotels/booking/{booking_job_id} → status succeeded, failed or attention (see above) 5. POST /developers/api/v1/hotels/cancel {"confirmation": "..."} Only your own booking, on a refundable rate before its free_cancellation_until: everything the guest paid comes back (the response's refund.amount says exactly), or the whole hold is released if nothing was captured yet. A cancellation that would cost money is refused (409); the hotel's own ladder is in the booking's terms. Takes over a minute: if it times out, do NOT assume it failed. Re-check before retrying. ### SDKs pip install -U letsfg # 2026.5.101 or later npm install letsfg@latest # 2026.5.74 or later npx -y letsfg-mcp@latest # 2026.5.77 or later lfg.hotel_destinations / search_hotels / book_hotel_and_wait / cancel_hotel Earlier SDK releases send the reservation-fee contract retired on 2026-09-11 (expected_balance, no expected_cost), and the API refuses every hotel booking they make: update before booking. The hosted MCP needs no update. MCP tools: resolve_hotel_city, search_hotels, book_hotel, get_hotel_booking, cancel_hotel_booking. --- ## WHOLE TRIPS — flights and hotels, booked 24 hours apart A traveller can plan and book a whole trip with LetsFG: flights and hotels. A flight and a hotel are always two separate bookings, never one. Under EU package-travel law, once one of them is booked, the other for overlapping dates can be booked with LetsFG from 24 hours later; a booking asked for sooner is refused with the time it can be made. An order that was opened but never paid does not count. So: plan the whole trip together, book one part now, and book the other once the 24 hours have passed. --- ## PRICE WATCH — in Claude, as a daily scheduled task watch_price follows the price of a flight trip or a hotel stay the traveller is not ready to book. LetsFG sends no e-mail and does not re-check on its own. check_price returns the watches with their latest prices: a price older than about 10 hours is checked again live (a flight takes a minute or two; if it is still running, call check_price again shortly), and a watch that got cheaper says so, with how to book it. Set it up as a scheduled task in Claude that runs once or twice a day - watch_price's answer gives the prompt. Watches set before 2026-11-03 keep their daily e-mail until the trip. MCP tools: watch_price, check_price. --- ## FLIGHT RELIABILITY — check a flight's real track record Every offer names a flight (airline_code + flight_no). You can pull that flight's actual recent performance before recommending it: POST https://letsfg.co/api/trips/check-flight Content-Type: application/json {"flightCode": "FR5873"} Returns real data scraped per flight, not an airline-wide average: { "ident": "FR5873", "origin": {...}, "destination": {...}, "cancelled": false, "diverted": false, "aircraft_type": "B738", "reliability": { "sample_size": 12, "avg_departure_delay_minutes": 15, "avg_arrival_delay_minutes": 2, "cancelled_pct": 0, "diverted_pct": 0 }, "recent_history": [ ...per-departure outcomes... ] } This is the single most useful thing you can add on top of price. Two offers at the same fare are not equal if one flight averages +15m departure delay and the other averages +2m. Use it to rank, and to warn the user about tight layovers. Takes 5-20s (it launches a real browser against a live source), so call it for the handful of offers you are actually considering, not for every result. --- ## STARLINK WI-FI — which flights actually have it Offers may carry a "starlink" field. It is absent when we have no information — absent does NOT mean the flight has no Wi-Fi. Itinerary level, on the offer: "confirmed_all" every leg is on a subfleet the carrier has FULLY fitted "confirmed_some" at least one leg confirmed, at least one leg with none "likely_all" every leg is on a subfleet where installation is underway "likely_some" some legs on such a subfleet, others with none Per leg, on each segment: "confirmed" or "likely". **Only "confirmed_*" may be stated to a user as a fact.** "likely_*" means the airline is actively fitting that exact aircraft type but has not finished — as of Aug 2026 United was ~29% of its fleet and Southwest ~300 of 800 aircraft, so a specific airframe genuinely may not have it. Say "the airline is rolling Starlink out on this aircraft type, not guaranteed on your flight", never "this flight has Starlink". Anything ending in "_some" means at least one leg has none. Do not describe such an itinerary as a Starlink trip — name the legs instead. How it is derived: a dated airline+subfleet table, matched against the operating carrier and aircraft type. It is NOT a tail-number lookup, so it cannot know which individual airframe you were assigned. Coverage is uneven by design — carriers with a single-type fleet (Southwest, airBaltic) resolve even when the aircraft type is unknown; everyone else needs the aircraft type, which not every source reports. --- ## TIMING AND RELIABILITY - A search checks every airline and the major booking sites and typically finishes in 2–3 minutes. - Poll every 10 seconds. After 3 minutes total, poll every 20 seconds. - Maximum search lifetime: 15 minutes, then status = "expired". - Offers expire with the search — book inside that window or search again. --- ## PRICING - Auth: FREE on the card lanes (zero-amount setup, no charge, no hold). MPP lane: $0.01 once, verification only. - Search: FREE. 60 search credits a day per account, refilling continuously (90 banked / 75 a day with a payment method on file). A new search costs 1; more dates or airports on a route you just searched cost 0.5; re-running the same search costs double each time (from 0.5 the same day, from 4 on a later day). Out of credits returns a 429 that says when the search becomes affordable. To follow a fare over days, use a price alert rather than re-searching. - Book: the price shown on the offer. What you see is what is charged. --- ## QUICK REFERENCE — ENDPOINTS | Endpoint | Method | Auth | Purpose | |-----------------------------|--------|--------------|--------------------------------| | /api/agent-access/request | POST | None | Get enrolment options (402) | | /api/agent-access/verify | POST | None | Present payment → Bearer token | | /api/search | POST | Bearer token | Start a search | | /api/results/{searchId} | GET | Bearer token | Poll search status as JSON | | /api/agent-book | POST | Bearer token | Book an offer | --- ## MIGRATING FROM TWITTER/X TOKEN AUTH Tokens issued through the old tweet challenge still work for now. Every response to one carries a Deprecation header, a Warning header, and a Sunset date once one is set. Re-enrol before then by connecting a card at https://letsfg.co/connect — a Stripe credential is no longer accepted and cannot be exchanged for a token. --- ## Developer API — not needed for flights or hotels https://letsfg.co/developers is a distinct API for high-volume commercial integrations, with its own X-API-Key and its own billing account. It is NOT required for agent search or booking, flights or hotels: a PFS Bearer token reaches the hotel endpoints too. Onboarding is Revolut, not Stripe (retired 2026-09-08): POST /agents/register -> your API key, no card needed POST /agents/connect-payment -> a one-time letsfg.co/connect link. Nothing is charged to connect. Search pricing: LOOK-TO-BOOK, not per search and not monthly. 200 searches free after EVERY booking you make; booking resets the counter A booking your user completes on letsfg.co through an offer's booking_url counts too Past that: blocks of 500 for $5.00 ($0.01 per search) from prepaid balance A search returning no offers never consumes allowance Minimum top-up: $5 Running out answers 402 `search_allowance_exhausted` with the numbers. The retired monthly tiers ($0.50 / $0.20 / $0.10 per search) are gone. Booking on the Developer API, same flow as PFS: POST /flights/book -> 202 + booking_id, fare HELD GET /flights/bookings/{booking_id} -> poll until terminal (4-11 min) POST /flights/bookings/{booking_id}/answer -> seat map / extra / price change POST /flights/bookings/{booking_id}/stop -> stop it (released if it had not paid) Build it in the SANDBOX first, free and keyless: the same routes under /sandbox/flights/* (search, book, bookings/{id}, answer, stop) behave like production - same responses, states, questions and 4-11 min timing - with no money and no seller. Choose the outcome with "sandbox": {"scenario": "price_change" | "extra" | "seller_failed" | "needs_attention" | "payment_declined", "speed": "fast"} in the book body (production ignores it). Guide: https://letsfg.co/developers/docs/api-sandbox#booking-in-the-sandbox The hold is captured only against a real PNR; a failed booking releases it. NO booking fee and NO transaction fee on top: the amount shown on every offer is the amount charged. Each offer's `booking_url` is a letsfg.co page for that offer, never a seller deep link. - Developer portal: https://letsfg.co/developers - REST base: https://letsfg.co/developers/api/v1 - Swagger: https://letsfg.co/developers/api/docs - OpenAPI: https://letsfg.co/developers/api/openapi.json - MCP: https://letsfg.co/mcp ## Contact - Agent guide: https://letsfg.co/for-agents - Developer docs: https://letsfg.co/developers/api/docs - GitHub: https://github.com/LetsFG/LetsFG - API Status: https://status.letsfg.co ## Programmatic Flight Pages LetsFG publishes data-rich route pages at `/[locale]/flights/[origin]-[dest]/` (e.g. `/en/flights/lhr-jfk/`). Each page contains: - Full price distribution (p10/p25/p50/p75/p90) from every airline and the major booking sites - Per-carrier offer highlights: best price, duration range, stops, amenity pricing - Bag and seat-selection fee table per airline - AI-generated route rationale (value proposition, booking tips, price context) - Hidden fee analysis and connector comparison - JSON-LD schema for structured data indexing These pages are updated by our agent search pipeline. Data is based on real connector output, not editorial guesses. **Sitemap**: https://letsfg.co/sitemap-flights.xml lists all published routes.