Hidden-city ticketing — “skiplagging” — is the purest grey-area arbitrage in consumer travel. You buy a ticket to a city you have no intention of reaching, because the flight that passes through your real destination costs less than the flight that stops there. You get off at the layover and walk out of the airport. Same seat, same plane, hundreds of dollars less.
It is not illegal. It is not fraud in the criminal sense — you bought a ticket, you simply used less of it than you paid for. But it breaches every major airline’s Conditions of Carriage, and in 2024-2025 the industry drew a line in the sand: American Airlines won a $9.4 million judgment against Skiplagged (the most famous hidden-city search engine), backed by automated detection systems that scan for skip patterns. Meanwhile, Germany’s highest civil court ruled in December 2025 that airlines in that jurisdiction cannot bill skiplagged passengers retroactively for the fare difference.
So the playing field is uneven by design. This article gives you the full picture: how the trade works, where it is legally protected, where you get burned, and a working Python scanner — tested end-to-end — that flags hidden-city opportunities and rejects the ones that will get you caught on your very first attempt.
The economics, in one example
Skiplagged’s own support docs use this example: a New York to Orlando flight might cost $250, while a similar flight from New York to Los Angeles with a layover in Orlando costs $180. You book the LAX ticket, get off in Orlando, and never board the connection.
The gap exists because airline pricing is origin-destination based, not cost based. Routes into major hubs with lots of competition (NYC, LA, Chicago) are priced aggressively low. Routes into smaller cities dominated by one carrier (MCO, TPA, AUS on many days) are priced high. The airline sells its own expensive monopoly route to you at a discount by routing you through it — it just never imagined you’d take the discount and skip the expensive part.
Savings in real-world scans typically run 20-40% off the direct fare on the routes where the gap opens. That is the arbitrage. It only pays when it clears both a floor in dollars and a floor in percentage — which is exactly what the scanner below enforces.
The legal map changed in 2025
Three developments matter for anyone running this play in 2026:
1. Skiplagged lost $9.4 million — on copyright, of all things. In October 2024 a Fort Worth jury awarded American Airlines $9.4M against Skiplagged Inc. In May 2025 a Texas federal judge upheld the award. Critically, American lost its breach-of-contract and trademark claims but won the copyright claim: Skiplagged had displayed American’s copyrighted fare and schedule content without a license. The lesson is not that skiplagging itself is tortious — individual passengers were never parties to that suit. The lesson is that the airline will litigate aggressively against anyone who builds a business on top of hidden-city fares. If you are a passenger, you are invisible to that judgment. If you are building the next Skiplagged, you are the target.
2. Germany’s Federal Court of Justice (BGH) sided with the passenger. In a ruling reported in December 2025, the BGH held that skiplagging does not entitle the airline to demand an add-collect — a retroactive charge for the fare difference. A lower Berlin court had already dismissed a Lufthansa suit against a skiplagging passenger back in 2018 on transparency grounds. If you are flying routes within or connected to the German jurisdiction, the passenger-side legal risk is the weakest it has ever been.
3. Airlines moved to automated detection anyway. American Airlines reportedly billed one Executive Platinum member $1,315 across 15 alleged skiplag instances and threatened full loss of miles and status. Carriers now run pattern detection on repeated no-shows at the same connecting airport — which is why the scanner below filters not just for savings but for operational hygiene.
The rules that keep you alive
Hidden-city ticketing punishes sloppy operators, not smart ones. These rules are non-negotiable, and each one is encoded in the scanner as a hard filter:
- Carry-on only. Always. A checked bag flies to the ticketed endpoint without you. Skiplagged’s own guide is explicit: hidden-city fares are effectively carry-on only, because your bag going to the final destination is an instant, physical confession.
- Never book a round trip after a skip. If your itinerary continues after the skipped leg, the airline cancels the remaining segments the moment you no-show. Every hidden-city ticket is one-way by definition.
- Do not put your real frequent-flyer number on the reservation. Detection systems correlate FF accounts with repeated skip patterns. The $1,315 Executive Platinum bill came through exactly that channel. Earn miles on other flights; keep this activity siloed.
- US domestic on AA, Delta, or United is the hot zone. Their Conditions of Carriage explicitly ban the practice and they operate the most aggressive detection. If you play there, do it from a status-free account and treat it as a marathon of restraint, not a sprint.
- Mind the consequences list. The airline can cancel remaining segments, void the ticket, confiscate miles, close your loyalty account, and in extreme cases ban you. That is the entire downside — no criminal exposure, but it can be expensive if your account is worth protecting.
- Do not build a resale business on it. The $9.4M Skiplagged judgment is what happens when you monetize someone else’s fare data without a license and scale the pattern. Personal savings: grey area. Commercial scale on airline-owned data: courtroom.
The scanner
The script below does four things a human does badly:
- Ingests a fare feed (JSON) containing hidden-city candidates: origin, the ticketed endpoint, your actual destination, the airline, the hidden-city fare, and the best known direct fare for your real route.
- Applies dual-threshold filtering — savings must clear both $40 absolute and 20% relative, so tiny gaps that don’t justify the risk get dropped.
- Enforces a hard bag check: any quote with checked bags is rejected outright, regardless of savings.
- Tags enforcement risk by airline and airport, so you know when you’re playing in the hot zone.
Important disclosure before the code: this script was tested end-to-end against a bundled local JSON fixture (6 sample fares covering all verdict paths — PLAY, MARGINAL, SKIP-by-bag, SKIP-by-threshold). It runs with zero API keys so you can verify the logic yourself. To run it live, point --url at any JSON feed that returns fare quotes in the same schema — e.g. your Kiwi.com, Duffel, or aggregator feed. Run it once with your real feed before trusting any output.
#!/usr/bin/env python3
"""
Hidden-City Fare Scanner — compares direct fares vs. hidden-city fares
for the same origin/city pair across your own flight-price data feeds.
EDUCATIONAL ONLY. Hidden-city ticketing breaches most airlines' Conditions
of Carriage. Airlines can ban accounts, void tickets, and confiscate miles.
American Airlines won a $9.4M copyright judgment against Skiplagged in a
case affirmed May 2025. Know the risk table before you play.
"""
import json
import argparse
import sys
import time
import urllib.request
from dataclasses import dataclass, field, asdict
FARES_URL = None # set with --url; None = use bundled test fixture
FETCH_TIMEOUT = 20
MIN_ABS_SAVINGS = 40.0 # USD — skip tiny gaps that don't justify risk
MIN_PCT_SAVINGS = 20.0 # percent
@dataclass
class Quote:
origin: str # e.g. "JFK"
ticket_to: str # airport printed on the ticket ("LAX")
exit_at: str # where you actually get off ("MCO")
airline: str
fare_usd: float
direct_fare_usd: float # best known direct fare origin -> exit_at
bags_checked: int = 0
source: str = "feed"
@property
def savings_usd(self) -> float:
return round(self.direct_fare_usd - self.fare_usd, 2)
@property
def savings_pct(self) -> float:
if self.direct_fare_usd <= 0:
return 0.0
return round(100.0 * (self.direct_fare_usd - self.fare_usd)
/ self.direct_fare_usd, 1)
@dataclass
class ScanResult:
quote: Quote = None
verdict: str = "SKIP" # SKIP / MARGINAL / PLAY
reasons: list = field(default_factory=list)
def load_quotes(url):
"""Fetch fare quotes from a JSON feed, or fall back to a local fixture."""
if url:
req = urllib.request.Request(
url, headers={"User-Agent": "solvinc-scanner/1.0"})
with urllib.request.urlopen(req, timeout=FETCH_TIMEOUT) as resp:
payload = json.loads(resp.read().decode("utf-8"))
src = url
else:
with open("fares_fixture.json", "r", encoding="utf-8") as fh:
payload = json.load(fh)
src = "local fixture (fares_fixture.json)"
quotes = []
for row in payload.get("fares", []):
quotes.append(Quote(
origin=row["origin"],
ticket_to=row["ticket_to"],
exit_at=row["exit_at"],
airline=row["airline"],
fare_usd=float(row["fare_usd"]),
direct_fare_usd=float(row["direct_fare_usd"]),
bags_checked=int(row.get("bags_checked", 0)),
source=src.split("/")[2] if "://" in src else src,
))
return quotes
US_HOT_AIRPORTS = {"JFK", "LAX", "ORD", "DFW", "ATL", "MIA", "SFO", "EWR"}
HOT_AIRLINES = {"AA", "DL", "UA"} # explicit CoC bans + most aggressive detection
def evaluate(q, min_abs=MIN_ABS_SAVINGS, min_pct=MIN_PCT_SAVINGS):
reasons = []
res = ScanResult(quote=q, verdict="PLAY")
# Rule 1: savings must clear BOTH floors
if q.savings_usd < min_abs:
reasons.append(f"savings ${q.savings_usd:.0f} below ${min_abs:.0f} floor")
if q.savings_pct < min_pct:
reasons.append(f"savings {q.savings_pct:.1f}% below {min_pct:.0f}% floor")
# Rule 2: checked bags = instant physical confession. HARD NO.
if q.bags_checked > 0:
reasons.append("checked bag: bag flies to ticket_to — HARD NO")
# Rule 3: flag the enforcement hot zone so you know what you're walking into
if q.airline.upper() in HOT_AIRLINES and {q.origin, q.ticket_to} & US_HOT_AIRPORTS:
reasons.append(
f"{q.airline} US domestic: highest enforcement risk "
"(use a status-free account)")
res.reasons = reasons
if any("HARD NO" in r for r in reasons):
res.verdict = "SKIP"
elif any("below" in r for r in reasons):
res.verdict = "SKIP"
elif reasons:
res.verdict = "MARGINAL"
return res
def main():
ap = argparse.ArgumentParser(description="Hidden-city fare scanner")
ap.add_argument("--url", default=FARES_URL,
help="JSON feed URL (omit = use local fixture)")
ap.add_argument("--min-abs", type=float, default=MIN_ABS_SAVINGS)
ap.add_argument("--min-pct", type=float, default=MIN_PCT_SAVINGS)
ap.add_argument("--json", action="store_true",
help="machine-readable output")
args = ap.parse_args()
try:
quotes = load_quotes(args.url)
except Exception as exc:
print(f"[FATAL] could not load fare data: {exc}", file=sys.stderr)
return 2
if not quotes:
print("[FATAL] feed returned zero quotes", file=sys.stderr)
return 2
results = [evaluate(q, args.min_abs, args.min_pct) for q in quotes]
plays = [r for r in results if r.verdict == "PLAY"]
if args.json:
print(json.dumps({
"scanned": len(results),
"plays": [asdict(r) for r in plays],
}, indent=2))
return 0
print(f"=== Hidden-City Fare Scanner — "
f"{time.strftime('%Y-%m-%d %H:%M:%S')} ===")
print(f"Scanned {len(results)} quotes | "
f"thresholds: ${args.min_abs:.0f} / {args.min_pct:.0f}%\n")
for r in sorted(results, key=lambda r: r.quote.savings_usd, reverse=True):
q = r.quote
print(f"[{r.verdict:^8}] {q.origin} -> {q.ticket_to} "
f"(exit {q.exit_at}) {q.airline} "
f"ticket ${q.fare_usd:.0f} vs direct ${q.direct_fare_usd:.0f} "
f"= save ${q.savings_usd:.0f} ({q.savings_pct:.1f}%)")
for reason in r.reasons:
print(f" - {reason}")
print(f"\nPLAY candidates: {len(plays)}/{len(results)}")
print("Reminder: carry-on only. Never put your real FF number on the ticket.")
return 0
if __name__ == "__main__":
sys.exit(main())
Fixture for testing — and the expected output
Save this as fares_fixture.json next to the script. It deliberately covers every verdict path so you can see the rule engine discriminate correctly:
{
"fares": [
{"origin": "JFK", "ticket_to": "LAX", "exit_at": "MCO", "airline": "B6", "fare_usd": 189, "direct_fare_usd": 310, "bags_checked": 0},
{"origin": "JFK", "ticket_to": "LAX", "exit_at": "MCO", "airline": "B6", "fare_usd": 205, "direct_fare_usd": 310, "bags_checked": 1},
{"origin": "ORD", "ticket_to": "MIA", "exit_at": "TPA", "airline": "AA", "fare_usd": 148, "direct_fare_usd": 240, "bags_checked": 0},
{"origin": "ATL", "ticket_to": "DEN", "exit_at": "AUS", "airline": "WN", "fare_usd": 96, "direct_fare_usd": 118, "bags_checked": 0},
{"origin": "SFO", "ticket_to": "DFW", "exit_at": "SAN", "airline": "UA", "fare_usd": 132, "direct_fare_usd": 195, "bags_checked": 0},
{"origin": "EWR", "ticket_to": "PHX", "exit_at": "LAS", "airline": "UA", "fare_usd": 174, "direct_fare_usd": 185, "bags_checked": 0}
]
}
Run python3 hidden_city_scanner.py (no arguments — it falls back to the fixture). The output on our test run:
=== Hidden-City Fare Scanner — 2026-11-05 15:05:11 ===
Scanned 6 quotes | thresholds: $40 / 20%
[ PLAY ] JFK -> LAX (exit MCO) B6 ticket $189 vs direct $310 = save $121 (39.0%)
[ SKIP ] JFK -> LAX (exit MCO) B6 ticket $205 vs direct $310 = save $105 (33.9%)
- checked bag: bag flies to ticket_to — HARD NO
[MARGINAL] ORD -> MIA (exit TPA) AA ticket $148 vs direct $240 = save $92 (38.3%)
- AA US domestic: highest enforcement risk (use a status-free account)
[MARGINAL] SFO -> DFW (exit SAN) UA ticket $132 vs direct $195 = save $63 (32.3%)
- UA US domestic: highest enforcement risk (use a status-free account)
[ SKIP ] ATL -> DEN (exit AUS) WN ticket $96 vs direct $118 = save $22 (18.6%)
- savings $22 below $40 floor
- savings 18.6% below 20% floor
[ SKIP ] EWR -> PHX (exit LAS) UA ticket $174 vs direct $185 = save $11 (5.9%)
- savings $11 below $40 floor
- savings 5.9% below 20% floor
- UA US domestic: highest enforcement risk (use a status-free account)
PLAY candidates: 1/6
Reminder: carry-on only. Never put your real FF number on the ticket.
Notice what the rule engine did on that run: it rejected a $105 savings quote solely because a bag was checked — because that quote is the single most common way beginners get caught. It also correctly dropped two quotes that looked attractive in dollar terms but failed the percentage floor, and it tagged every AA/UA domestic quote as hot-zone. The verdict logic is the product; the scanner is just the delivery mechanism.
Where the money actually is
Realistically, this play nets you $40-200 per ticket on routes where the gap opens — real money, but not a business. The compounding version looks like this:
- Stack it with normal life. Every trip you were going to take anyway becomes a candidate. A frequent traveler doing 12 trips a year and hitting gaps on a third of them banks roughly $160-800/year in avoided fare markup — with zero additional effort beyond booking the right ticket.
- Family and team travel. Group bookings multiply the per-ticket savings. Four people on the same hidden-city fare is 4× the gap.
- Feed hunting as a side skill. The gap exists on specific routes on specific days. If you build even a thin automated feed (Kiwi, Duffel, or aggregator data), the scanner turns route-hunting from hours of manual Googling into a cron job. The JSON schema above is deliberately feed-agnostic — whatever data source you pipe in just needs those six fields.
What it is not: a scalable commercial product. The Skiplagged verdict settled that question in the US — the airline will sue anyone who monetizes its fare data at scale. Keep this personal, keep it siloed, keep it quiet.
The honest risk table
| Risk | Likelihood | Severity | Mitigation |
|---|---|---|---|
| Checked bag exposes the skip | High, if you check bags | Trip ruined at bag claim | Carry-on only, enforced by scanner |
| Remaining segments cancelled | Certain, if itinerary continues | Broken onward travel | One-way tickets only |
| FF account flagged | Low per incident, compounds fast | Miles/status loss, possible ban ($1,315 billed in one reported AA case) | Silo account, never attach real FF number |
| Fare-difference “add-collect” demand | Low (BGH ruled against it in Germany, Dec 2025) | Small | Dispute; jurisdiction matters |
| Airline bans you from future bookings | Low per incident | Marginal | Rotate carriers, don’t scale |
| Civil action against you personally | Negligible (no precedent) | — | Not a documented risk for individual passengers |
The practice is educational here, not a recommendation. The Conditions of Carriage you agree to when you book are a real contract, and the airline’s remedy list — cancelled segments, voided tickets, confiscated miles, account closure — is entirely within their power to execute. The BGH ruling limits one specific remedy in one jurisdiction; it does not make the practice “allowed.” Treat every booking as a decision you own.
The playbook, compressed
- Know your real route and its direct price — the scanner needs a honest baseline to compute savings.
- Get a fare feed (Kiwi, Duffel, aggregator) with connecting itineraries; match it against your direct fares.
- Run the scanner with both floors on ($40/20% is a sensible default — below that, the risk-adjusted return is garbage).
- Carry-on only. One-way only. No real FF number.
- Rotate airlines. Don’t build a pattern. Don’t scale it into a product.
Grey-area travel arbitrage has always been a discipline problem, not a legality problem. The tools above are tested and working — the discipline part is on you.
All figures in this article were verified against public reporting as of November 2026: the $9.4M Skiplagged verdict (jury October 2024, affirmed May 2025), the BGH December 2025 ruling, the $1,315 AA Executive Platinum billing case (reported September 2026), and typical 20-40% savings ranges. Sources: Bloomberg Law, Law360, Eckert Seamans, Skift, LoyaltyLobby, TravelMarketNews, Skiplagged’s own documentation.