Skip to content

Google /goto Redirect URLs and CAES Tokens: Resolve the Real Destination

A Google search result can now point to Google's own /goto endpoint instead of the destination site. The link carries an opaque CAES value, and the destination only appears after Google processes the redirect. This guide explains what the token contains, why it cannot be turned back into the URL locally, and how to recover the destination reliably with a plain HTTP GET request.

What a Google /goto link is

A /goto link is an intermediate URL that Google can place behind a search result. Instead of an anchor pointing straight at the destination, the href looks like a Google endpoint with a url parameter beginning with CAES. Opening the link sends a request to Google, which then redirects the browser to the real page.

For a person clicking a result, the experience is unchanged. For a scraper that previously read the href and treated it as the destination, the result is a Google URL, a dropped result, or a stored opaque token. The practical pipeline changes from "extract href, keep URL" to "extract href, detect the redirect, resolve it, keep the destination."

Google has described /goto as part of technical measures against evolving abuse of Search. The exact client-detection logic has not been publicly documented, so treat /goto as one possible link format rather than a permanent replacement for every result.

When /goto links appear

The captured experiments tested whether /goto is limited to automation, a particular browser engine, an IP address, or a country. The short answer is that none of those single factors explained the behavior.

In manually operated Chrome and Edge, external results were wrapped in /goto?url=CAES... . Brave and LibreWolf returned direct destination URLs for the same search. Safari returned a different Google wrapper, /url, whose url parameter also contained a CAES token. Playwright sessions and requests through a scraping API also received /goto links. Routing Chrome through a proxy with an exit IP in another EU country did not switch it back to direct URLs, and proxy locations in the UK, Germany, and Brazil all produced /goto links.

The strongest correlation observed was with the client or browser environment, but that is deliberately broad. Headers, Client Hints, cookies, privacy settings, Google integrations, fingerprinting characteristics, rollout logic, account state, session history, and IP reputation could all play a role. The experiments do not identify which signals, if any, Google uses.

A scraper should therefore be prepared for several href forms: a direct destination URL, a /goto?url=CAES... link, and a /url?...&url=CAES... wrapper. Do not hard-code a rule such as "Chrome gets /goto, Brave gets direct URLs." That was an observation in one set of tests, not a contract.

Inside a CAES token

The CAES value is valid Base64URL. Decoding it produces binary data, not a readable URL. Across 324 unique tokens collected from the experiments, the decoded bytes followed the same simple structure: a protobuf envelope with field 1 set to 1 and field 2 holding a binary blob. The literal characters CAES are simply what the start of that binary structure looks like after Base64URL encoding.

Every field 2 value began with the same five bytes, 01 eb 3b 30 15. That matches the documented output-prefix format used by Google's Tink cryptography library: a one-byte version followed by a four-byte key hint. The rest of field 2 behaved like protected or encrypted output.

The same destination URL produced different tokens across separate SERPs: 56 destinations that appeared in multiple searches received a new token each time, with zero reuse between SERPs. Within a single SERP, the behavior was different. In 81 groups of anchors pointing to the same destination on the same page, the token was identical. So a token appears to be generated per search result page and reused where the same destination appears again on that page.

Comparing protected payloads for identical destinations across 864 pairs, no two payloads were identical, and the mean proportion of matching bytes at the same position was 0.003827, close to the 1/256 expected for independent random bytes. That rules out a simple deterministic encoding such as URL to Base64, but it does not identify the exact cryptographic primitive.

One hypothesis was Tink's HPKE hybrid encryption with X25519, whose layout is prefix, encapsulated key, then encrypted data, with a 32-byte encapsulated key. If the first 32 bytes after the prefix were canonical X25519 public values, their highest bit should not behave randomly. In the 324 samples it did: 178 tokens had the highest bit set to 0 and 146 had it set to 1. The obvious X25519 HPKE layout does not fit the data. That does not prove no elliptic-curve cryptography is involved anywhere; it only rules out that specific layout.

What token size reveals

The protected bytes cannot be decrypted locally, but their length is informative. For all 324 tokens, the protected payload was exactly the destination URL length plus 50 bytes plus the protobuf varint size of the URL length. Destinations shorter than 128 bytes produced payloads 51 bytes longer than the URL; destinations of 128 bytes or more produced payloads 52 bytes longer. There were zero exceptions.

The extra byte at the 128-byte boundary lines up with protobuf varints: values up to 127 fit in one byte, and values from 128 require two. The size behavior suggests the protected plaintext contains a length-delimited value that tracks the complete destination URL. A plain result URL produced a shorter payload than the same page with a #:~:text= fragment attached, which indicates the full destination target is included, not just the domain or canonical path.

This helps explain the structure but does not provide a way to reconstruct the URL. For practical purposes, the CAES token cannot be decrypted locally into the destination.

How to resolve a /goto URL

The reliable method is to let Google resolve the redirect. Send a GET request to the /goto URL with redirects disabled, stop at Google's response, and read the Location header from the 302. You do not need to follow the redirect to the destination site if all you need is the URL.

The key setting is allow_redirects=False. Without it, the HTTP client continues to the destination website and adds an unnecessary request. The response should be a 302 with a Location header; anything else should be treated as a resolution failure.

HEAD does not work for this. In the tests, HEAD returned 200 without a Location header, while GET returned 302 with the destination. Resolution therefore requires a GET request.

The token is portable. A CAES token collected through a scraping API could later be resolved with a plain Python HTTP request from another machine, without the original browser session, Google cookies, proxy, or browser headers. The same tokens also worked when opened manually in another browser. Tokens kept for a few days still resolved to their original destinations, so they do not appear to expire quickly, but their maximum lifetime is unknown and they should not be treated as permanent identifiers.

Overhead and concurrency

Every unique /goto URL requires an extra HTTP request, so there is an unavoidable cost. Connection reuse and moderate concurrency reduce the wall-clock overhead. The benchmark below used 50 unique /goto URLs, ran each configuration three times, and reports the median. The figures are a dated reference from the captured experiments; your network and HTTP client will produce different numbers, so treat them as a starting point rather than a universal recommendation.

Five workers performed best in that environment, completing the batch about 2.65 times faster than the sequential version. Typical request latency barely moved between the four settings, staying near 57–59 ms. What changed was the tail: at ten workers, some individual requests stretched past a second, whereas the five-worker runs kept their slowest requests noticeably tighter. Pushing concurrency higher can therefore add enough connection or network contention to slow the whole batch down.

The practical takeaway is to reuse connections and use bounded concurrency rather than maximizing simultaneous requests. If a scraping API produced the SERP, the redirects do not have to be sent back through that same API: in the tests, a plain GET request was enough to retrieve the Location header.

Handling /goto links in a Google scraper

A robust pipeline classifies each href before deciding what to do with it. The categories observed in the tests were direct destination URLs, /goto?url=CAES... links, /url?...&url=CAES... wrappers, and other links to ignore or handle separately.

Do not build the parser around the string CAES alone. CAES tokens appeared with both /goto and /url, while other browsers returned direct URLs with no token at all. Classify by host and path first, then check the token where relevant.

Deduplicate before resolving. In one sample, the page contained 78 /goto anchors but only 40 unique tokens, so resolving every anchor individually would have wasted 38 requests. The same token can appear in multiple anchors within one SERP because Google reuses it for the same destination on that page. Deduplicate the URLs, then resolve the remaining set with bounded concurrency.

Preserve the URL Google returns. Do not automatically strip fragments or other parts of the Location value. Destinations can include text fragments such as #:~:text=some%20highlighted%20text, which point the browser to a specific passage. Unless your application explicitly needs canonical URLs, keep the complete destination.

Expect failures. A production scraper should handle an invalid or expired token, rate limiting, network errors, and a response without a Location header. Timeouts and 429 responses are worth retrying with backoff because they may clear on their own. A token that is invalid, or a reply that simply lacks a Location header, will not improve with repetition, so record it as a failed result instead of looping.

Decision checklist before resolving

Use this checklist to decide whether a link needs resolution and how to handle the result.

  1. Is the href a direct http or https URL on a non-Google host? Keep it as-is.
  2. Is the href a Google /goto path with a url parameter starting with CAES? Mark it for resolution.
  3. Is the href a Google /url wrapper? Handle it separately; it may also carry a CAES token.
  4. Have you deduplicated the /goto URLs for this SERP? Resolve each unique token once.
  5. Are redirects disabled in the HTTP client? If not, the client will follow to the destination and add an unnecessary request.
  6. Did the response return 302 with a Location header? If yes, keep the full Location value. If no, record a failure.
  7. Is the failure transient (timeout, 429) or permanent (invalid token, missing Location)? Retry transient failures with backoff; do not retry permanent ones indefinitely.

A worked example from the captured data: one Playwright run produced 78 /goto links representing 40 unique tokens. Resolving the deduplicated set means 40 GET requests instead of 78. At the benchmark's five-worker median of 1.23 seconds for 50 URLs, the savings are meaningful for larger SERPs.

Token field map

The layers observed in the 324-token dataset can be described as follows. This map is descriptive, not a decryption recipe.

  • Outer form: a CAES... string in the url query parameter of a Google redirect.
  • First layer: Base64URL. Decoding yields binary data, not text.
  • Second layer: a protobuf envelope. Field 1 equals 1; field 2 is a length-delimited binary blob.
  • Third layer: a five-byte Tink-style prefix, 01 eb 3b 30 15, where 01 is a version byte and eb 3b 30 15 is a key hint.
  • Fourth layer: protected binary payload. Its length equals the destination URL length plus 50 plus the protobuf varint size of the URL length.

What the map does not provide: the cryptographic key, the exact primitive, or a reversible local transformation from the protected bytes to the destination. The practical resolution path remains a GET request to Google and a read of the 302 Location header.

Browser link formats observed in manual tests
BrowserLink format we observed
Google Chrome/goto?url=CAES...
Microsoft Edge/goto?url=CAES...
BraveDirect destination URLs
LibreWolfDirect destination URLs
Safari/url?...&url=CAES...

These are observations from one set of manual browser tests. Link formats can change, and a scraper should not assume a particular browser will always receive one specific format.

Frequently asked questions

What is a Google /goto redirect URL?

It is a hop through Google that can stand in for a direct result link. The href targets Google's /goto endpoint with a url parameter beginning with CAES, and the browser only reaches the real page after Google answers with a redirect. The visible click behaves normally; the difference matters to code that reads hrefs.

Can I decode a Google /goto URL locally?

Partly. Base64URL decoding works and exposes a binary structure, but the destination is not sitting in there as readable text. The decoded value held a protobuf envelope followed by protected binary data carrying a Tink-style prefix, and no local transformation was found that reverses it. If the goal is the actual URL, resolve the redirect through Google instead.

What is the CAES token in Google /goto links?

It is an opaque value carried in the url query parameter of a Google redirect. All 324 tokens examined were valid Base64URL and decoded to the same basic protobuf shape: field 1 equal to 1, and field 2 holding protected binary data. That binary data always opened with the same five-byte Tink-style prefix, and the destination URL never appeared as plain text.

How do I get the destination URL from a Google /goto link?

Send a GET request to the /goto URL with redirects disabled and read the Location header from the 302 response. You do not need to request the destination website itself if all you want is its URL. In the tests, Google returned 302 Found with the real destination in Location.

Can I use HEAD to resolve a Google /goto URL?

No, not based on the tests. HEAD came back as 200 OK with no Location header, whereas GET produced a 302 carrying the real destination. Resolving the redirect therefore takes a GET request.

Why is Google using /goto redirect URLs?

According to Google, the redirect belongs to a set of technical measures aimed at evolving abuse of Search. Which clients receive /goto links, and why, has not been publicly documented. For scrapers the practical effect is that the destination is no longer always present in the SERP HTML, so extracting it may take an extra network request.

Does Google show /goto links to every browser?

Not in the tests. Chrome and Edge showed /goto?url=CAES... links, and that held even when Chrome was driven by hand rather than by automation. Brave and LibreWolf, by contrast, handed back the destination URLs directly. Safari took a third route: an older-style Google /url wrapper whose url parameter still carried a CAES token. Playwright sessions and requests through a scraping API also came back with /goto links. Since this can shift, a scraper should not assume any given browser will always receive one fixed link format.

Do Google CAES tokens expire?

They do not appear to expire quickly. Tokens gathered during the experiments were tried again several days later and still pointed to the same destinations, which means they stayed usable for well over 24 hours and were not tied to the browser session that first produced them. No maximum lifetime has been established, so treat them as opaque temporary tokens rather than permanent URLs.

Are Google /goto tokens tied to cookies, an IP address, or a browser session?

No such requirement was observed when resolving them. A /goto URL collected through a scraping API could be resolved later with a normal Python HTTP request from another machine. The original proxy, browser session, and Google cookies were not required. That does not prove every future token variant will behave identically, but the tokens tested were portable between clients.

Do I need a proxy or browser automation to resolve /goto links?

Not for the resolution step in the tests. Pulling a Google SERP may still call for whatever proxy or browser setup your scraper already relies on, but once a valid /goto?url=CAES... link is in hand, an ordinary HTTP GET request was sufficient to read its 302 Location header. In general, you do not need to route every redirect through another browser-rendered or premium-proxy request.

Redirect resolution benchmark: 50 unique /goto URLs
WorkersMedian wall timeMedian throughput
13.27 s15.29 URLs/s
21.85 s27.01 URLs/s
51.23 s40.59 URLs/s
101.44 s34.85 URLs/s

Each configuration was run three times; the table shows the median. These are dated results from one environment. The exact sweet spot depends on your network and HTTP client, so five workers is not a universal recommendation.