Free tool · 100% client-side
Google Flights URL Parser & Builder
Every Google Flights URL hides its search in an encoded tfs= blob. Paste one and see inside it: route, dates, and the API request that reproduces it. Or go the other way and build a link.
How it works
Wire format in, working request out
1
Paste the URL
Any Google Flights link with a tfs= parameter: a share link, or a buy_link straight from an API response.
2
We decode it in your browser
base64url to bytes, then a generic protobuf wire-format parse: field numbers, wire types, nested messages. No server, no schema, no upload.
3
Read the route, take the request
Dates and airport codes are extracted best-effort, and the equivalent FlightPowers API call is generated in cURL, Python, and Node.
Under the hood
What’s inside a tfs parameter
Undocumented doesn’t mean unreadable: the protobuf wire format always reveals its structure, even without the schema.
The tfs value is URL-safe base64 wrapping a binary protocol-buffer message. Protobuf encodes each field as a tag (a field number plus a wire type) followed by the value, and nested messages are just length-delimited fields whose bytes parse as messages themselves. That structure is recoverable without knowing what any field means.
What the wire format can't tell you is the meaning of field 3 or field 19; that lives in Google's private schema. So this tool labels only what it can honestly recognize: strings shaped like YYYY-MM-DD are dates, 3-letter A–Z strings are airport codes, and the rest is shown as-is. The raw tree is always on screen; the labels are annotations, never substitutions.
On the right: the pre-filled example URL, a real buy_link returned by the API on 2026-08-26 for TLV → JFK, decoded. The arrows are our reading, not Google's documentation.
3 {
2 (string): "2026-10-13" ← departure date
4 { ← the flight leg
1 (string): "TLV" ← origin
2 (string): "2026-10-13"
3 (string): "JFK" ← destination
5 (string): "LY" ← airline code
6 (string): "11" ← flight number
}
13 {
2 (string): "TLV"
}
14 {
2 (string): "JFK"
}
}
8 (bytes): 0x01
9 (varint): 1
19 (varint): 2Who uses it
A dev-tools page for a dev-tools problem
Debugging a scraper
Your pipeline produced a Google Flights URL and the results look wrong. Decode the tfs blob and see exactly what query the URL actually encodes. No more guessing which leg or date went sideways.
Reproducing a user-reported fare
A user sends “I saw it cheaper, here's the link.” Paste it, read the real route and dates out of the URL, and re-run the exact search through the API to see what the fare is now.
Building deep links
Send readers to a pre-filled Google Flights search from your app or newsletter. The builder emits the documented query form: stable, shareable, and honest about not being a tfs link.
Need the live price too?
Decoding tells you what the URL asks for. The Flight Price Checker runs the search live and adds Google's price band and the low | typical | high verdict.
Questions, answered plainly
- Does my URL get sent anywhere?
- No. This tool is 100% client-side: the decoding runs as JavaScript in your browser and the URL never leaves your machine. That is also why it has no rate limit and no signup: there is nothing on our side to protect.
- What exactly is the tfs parameter?
- It is Google Flights’ search state (route, dates, passengers, options) serialized as a protocol-buffer message and wrapped in URL-safe base64. Google does not document the format and can change it at any time.
- How can you decode an undocumented format?
- The protobuf wire format is self-describing at the structural level: every field carries a number and a wire type, so the tree of fields and values can always be recovered without the schema. What the schema would add is the meaning of each field. That part we infer, label as best-effort, and always show the raw tree alongside.
- Why are some fields unlabeled?
- Because we won’t guess in print. Values that match obvious shapes (YYYY-MM-DD dates, 3-letter airport codes) get labeled. Bare integers and flags stay as field numbers, honestly unexplained, rather than confidently mislabeled.
- Can it decode every Google Flights URL?
- Only URLs that carry a tfs= parameter; share links and the buy_link URLs our API returns do. A plain search URL (?q=Flights from …) carries text, not an encoded blob, so there is nothing to decode; paste it and the tool says so. Multi-city URLs decode fine, but the two-airports-one-date inference can misread them, so read the tree.
- Can the builder create a tfs deep link?
- No, and that is deliberate: fabricating an undocumented binary format would break silently the day Google changes it. The builder emits the documented search-query form, a q= phrase Google parses like a search-box entry, which is stable and shareable.
- How do I get the fares behind a URL as JSON?
- That is the API. Decode the URL here, and the card under the result shows the exact cURL, Python, or Node request for the same route and dates: live fares with Google’s price band and low | typical | high verdict on every row.
The URLs decode themselves. The fares are the product
Every API result already carries a working buy_link, plus Google’s price band and verdict. Free tier on RapidAPI, no card to try.
Free tier: 10 requests/month. No card to try.