Google SERP 9 min read

Google /goto URLs: what they mean and how to handle them

Google results returning /goto?url=CAES links? See the verified timeline, our HEAD vs GET test, and Node.js code for inspecting redirects without guessing URLs.

• 1,631 words

A Google search request can succeed and still leave you without a usable source URL. You get a title, a snippet and a position, but the link points back to Google:

https://www.google.com/goto?url=CAES...

This is a Google redirect wrapper. The abbreviated CAES... value represents an opaque token: the parameter does not directly expose the publisher's address. A controlled GET can sometimes reveal that address in the Location header. Until then, the source URL is unresolved.

We encountered these links while collecting results through SearchCans. For one complete link, HEAD returned 200 without a Location header, while GET returned 302 with the destination. That difference is easy to miss if your URL resolver only tries HEAD.

Check the parameter before trying to decode it

A transparent redirect might look like this:

https://www.google.com/url?q=https%3A%2F%2Fexample.com%2Farticle

Reading q with a URL parser gives you https://example.com/article. You can validate that address and pass it to the next stage.

With /goto?url=CAES..., the value is an opaque token rather than an absolute HTTP(S) URL. Removing the Google prefix does not produce a destination. Neither does the parameter name url tell you how to interpret its contents. Apply the same check to /url: if q or url contains an opaque value, it still needs resolution.

An open-source redirect-removal script ran into exactly this problem. It wrote the remaining CAES... string back into the link, which the browser treated as a relative path under google.co.jp. The resulting 404 came from a damaged link; it did not establish whether the publisher's article still existed.

Do not assume a Base64 decoder will recover the destination. We found no public Google specification defining this token format or a general decoding algorithm. Some tools recover addresses from other data already present in the results page, which is a different mechanism.

For transparent parameters, decode the parameter once. Repeatedly decoding the extracted destination can change its own encoded path or query values.

The public reports go back to June 2026

These are dates of public reports and project changes, not a Google rollout schedule. All dates in this table use UTC.

Date What the record shows
June 12, 2026 Public bug reports described intermittent search results with /goto?... URLs. The initial report did not define the complete CAES token format.
August 3, 2026 A change to an open-source newsletter project explicitly described google.com/goto?url=CAES... links in its source pipeline.
August 27, 2026 A crawler adapter was updated to resolve relative /goto and /url links against the loaded search page before enqueueing them. A separate report described returned links missing the prefix before CAES....
October 6, 2026 A public investigation documented content-fetch failures involving Google wrappers, including blocked requests and script pages in its environment.
November 4, 2026 An open-source browser adapter added handling for a script-check response encountered by background search requests in a fresh browser profile.

A fix at one stage did not necessarily solve the next. Making a relative link valid for a crawl queue, for example, does not reveal the publisher's URL or guarantee that the crawler can read its page. These project dates also do not establish when Google introduced the format worldwide.

Is this an anti-bot change?

Google does document checks for unusual or automated traffic. That help page does not explain /goto, assign it a single purpose or give a launch date for this format.

An independent browser-adapter report distinguished the results visible in a normal browser tab from a script-check page returned to a background request. It also noted that the rendered results could still contain /goto links.

Loading a normal results page can help with a script check while leaving the wrapped links in place. The two failures need separate handling. We could not verify a Google announcement saying that every /goto link was introduced solely for anti-scraping or tying it to one particular ranking update.

In our test, GET worked where HEAD did not

On November 19, 2026, we took complete Google wrapper URLs returned through the SearchCans Google Search API and inspected their responses with Node.js. We disabled automatic redirects, used the same User-Agent for the paired HEAD/GET observations, and sent requests through our configured outbound proxy.

Here is one paired observation using a link we had saved on October 29:

Request method Response Location
HEAD 200 Absent
GET 302 A Stack Overflow question

This single pair shows why a HEAD-only resolver can miss a working redirect. It cannot tell us how often GET works, whether another session would behave the same way, or how long Google tokens remain valid. The October investigation described above encountered 403, 429 and script responses in a different environment. Keep those outcomes in the resolver as well.

A small Node.js script to inspect a wrapper

Start with a GET request that does not follow redirects. It lets you inspect the status and Location without immediately requesting the publisher's page.

We tested this diagnostic with Node.js 24.19.0. It uses the built-in fetch and needs no packages.

// Save as inspect-goto.mjs
const u = new URL(process.argv[2]);
if (u.protocol !== 'https:' || u.username || u.password || u.port ||
    !['google.com', 'www.google.com'].includes(u.hostname) ||
    !['/goto', '/url'].includes(u.pathname)) {
  throw new Error('Expected an HTTPS Google result wrapper');
}

const r = await fetch(u, {
  method: 'GET',
  redirect: 'manual',
  signal: AbortSignal.timeout(8000),
});
const location = r.headers.get('location');
await r.body?.cancel();
console.log(JSON.stringify({
  raw_result_url: u.href,
  http_status: r.status,
  location,
  canonical_status: 'not_checked',
}, null, 2));

Pass the complete result URL, including its other parameters:

node inspect-goto.mjs 'PASTE_THE_COMPLETE_GOOGLE_RESULT_URL_HERE'

For one of the successful requests, the relevant fields were:

{
  "http_status": 302,
  "location": "https://stackoverflow.com/questions/70680651/how-to-get-new-search-engine-results-in-the-past-24h-using-a-serp-api",
  "canonical_status": "not_checked"
}

The test machine also needed Node's environment-proxy option. If your environment relies on configured HTTP_PROXY or HTTPS_PROXY settings, the corresponding command is:

node --use-env-proxy inspect-goto.mjs 'PASTE_THE_COMPLETE_GOOGLE_RESULT_URL_HERE'

The eight-second timeout is a local choice. This script inspects one response; it does not retry or walk a redirect chain. Its host list covers google.com and www.google.com. Add the exact Google country hosts your application actually uses.

Keep the distinction in the output: Location is an observed redirect target. The publisher could redirect again, return an error, or declare another canonical URL. A separate page-read step needs to establish those facts.

Why the same fetch can fail in a browser console

Browser JavaScript has a different visibility boundary. A manual redirect can produce an opaqueredirect response with status 0 and inaccessible headers. As MDN explains, this is the browser's response type; it does not mean Google sent an HTTP status of zero.

Switching to no-cors will not expose the missing Location. Browser extensions may have permissions to observe requests or navigation that an ordinary page script lacks. Check which environment a GitHub tool expects before moving its code into your application.

Handle the response before adding retries

For a redirect status such as 301, 302, 303, 307 or 308, validate the Location as an HTTP(S) address. If it is another recognized Google wrapper, resolve relative locations against the current request and continue within a small hop limit. Detect cycles. Once it points outside the configured Google hosts, record it and leave page retrieval to the next stage.

A 200 without a usable target remains unresolved. You may need to inspect its body, but taking the first link from arbitrary HTML is not a reliable substitute for a verified redirect. A non-redirect status carrying Location should also remain a separately verified case rather than being silently accepted as a normal redirect.

For 403, 429, a recognized check page or a network failure, save the reason and stop that attempt. Throttle or defer as appropriate. Repeatedly retrying every result can consume the entire batch without producing more readable sources.

For batch work, return the raw URL alongside the resolved address and failure reason. Test transparent parameters, opaque tokens, ambiguous parameters and redirect loops separately. Otherwise one unexpected response can end up looking like an ordinary missing result.

A rank tracker that reads only the wrapper's hostname will see google.com rather than the publisher. Domain matching has to wait for an address it can actually attribute.

Store the original position alongside the raw result URL. Add a resolved address separately when you have one. If unresolved results could contain the domain you are tracking, a failed match is inconclusive; it should not silently become “not in the top ten.”

The displayed breadcrumb can help identify a candidate domain, but it may omit a path or contain text that is not a URL. It cannot establish a complete publisher address by itself.

When you pass results to a Reader, the same problem appears one step later. A result with a title and snippet is still a reference to inspect. Resolve its address, then use a controlled page-read step such as the Reader API to check that you received useful source text. Our source-context guide covers what belongs in the resulting evidence packet.

Unresolved links should not count as successfully read sources. If you fetch more results to fill the gap, preserve the positions from the original result sets.

Some SearchCans results in this investigation contained /goto links. We searched specifically for this issue, so the sample says nothing about their prevalence across all queries. A successful API response still needs a URL-quality check before you use its results for ranking or citations.

Keep unresolved results in a separate queue with their original links and failure reasons. The search can be complete while source retrieval still needs work.

Tags:

Google SERP URL parsing
SearchCans Team

SearchCans Team

SERP API & Reader API Experts

The SearchCans engineering team builds high-performance search APIs serving developers worldwide. We share practical tutorials, best practices, and insights on SERP data, web scraping, RAG pipelines, and AI integration.

Ready to build with SearchCans?

Test SERP API and Reader API with 100 free credits. No credit card required.