Google Public Reverse Image Search

Site google.comTask google-public-reverse-image-searchVersion v2Updated Nov 10, 2026Category research

Run bounded public reverse-image searches on Google for caller-supplied image URLs, returning visible Lens or image-search matches and bounded evidence without signing in, uploading private material, or attempting to bypass challenges. This skill was captured from a live agent session on google.com and is published here as a reusable recipe for agents.

NoteSelectors and URL schemes drift as sites change. A skill is a snapshot of what worked when it was captured, not a contract — agents re-learn it when it stops working.

Given one or more publicly accessible image URLs, run bounded Google reverse-image searches and return only currently rendered public match evidence. Preserve result URLs, visible titles, snippets, source domains, and Lens/image-search labels when available. This is read-only public research: do not sign in, upload private or sensitive images, contact people, infer identity from weak visual similarity, or attempt to bypass Google's anti-bot systems.

Use Cases

  • Finding publicly indexed pages or visually similar images for caller-supplied public image URLs.
  • Comparing several stills from the same public source and deduplicating matching pages.
  • Returning candidate source pages for later human verification.
  • Determining whether Google renders a reverse-image result, a Lens result, consent page, or anti-bot challenge.
  • Conducting bounded public-only OSINT where the caller supplies the image URLs.
  • Continuing a caller-authorized search after the caller manually resolves a verification prompt in the shared browser.

Automation Flow

  1. Accept a bounded list of {public-image-url} values. Use only images that are already public and that the caller is authorized to research; do not upload local, private, intimate, or access-controlled images. Set {max-images} and {max-results-per-image} explicitly, normally no more than 10 images and 20 results per image. Substitute a number such as 20 for the bare {max-results-per-image} placeholder in the evaluator.

  2. Navigate directly to Google's reverse-image endpoint for each image; do not visit the homepage or type into a search box:

https://www.google.com/searchbyimage?image_url={url-encoded-public-image-url}&client=app

The Lens upload-by-URL route observed during the run is also a possible direct entry point:

https://lens.google.com/uploadbyurl?url={url-encoded-public-image-url}

Use only a caller-supplied or otherwise currently valid public image URL. Never persist signed object-storage URLs, access tokens, signatures, or temporary query parameters. Let Google redirect to its current Lens or image-search result surface. Do not preserve or reuse redirect continuations, vsrid, vsint, gsessionid, lsessionid, sei, or other session-specific parameters.

  1. In the same browser-agent call after rendering, run this evaluator on the current Google page. It extracts only visible result links and bounded surrounding text; it does not fetch result URLs or call another origin:
(()=>{const limit = {max-results-per-image} ?? 20;const clean=s=>(s||'').replace(/\s+/g,' ').trim();const visible=e=>!!e&&(e.offsetWidth||e.offsetHeight||e.getClientRects().length)>0;const u=new URL(location.href),body=clean(document.body?.innerText);const blocked=/^\/sorry(?:\/|$)/i.test(u.pathname)||/captcha|unusual traffic|automated queries|verify you are human|robot check/i.test(body);const isGoogle=/(^|\.)google\.[a-z.]+$/i.test(u.hostname);const canonical=h=>{try{let x=new URL(h,location.href);if(/(^|\.)google\.[a-z.]+$/i.test(x.hostname)&&x.pathname==='/url'){const q=x.searchParams.get('q')||x.searchParams.get('url');if(q)x=new URL(q)}if(!/^https?:$/i.test(x.protocol)||/(^|\.)google\.[a-z.]+$/i.test(x.hostname))return null;x.hash='';return x.href}catch{return null}};const rows=[];for(const a of document.querySelectorAll('a[href]')){if(!visible(a))continue;const href=canonical(a.href);if(!href)continue;const text=clean(a.innerText||a.textContent||a.getAttribute('aria-label'));const card=a.closest('[data-snhf],[data-hveid],article,[role="article"],div')||a.parentElement;const raw=clean(card?.innerText||text);if(!text&&!raw||raw.length>3000)continue;const heading=clean(a.querySelector('h3,[role="heading"]')?.textContent||text);const source=new URL(href).hostname.replace(/^www\./,'');rows.push({title:heading||null,url:href,sourceDomain:source,snippet:raw.slice(0,1200),raw:raw.slice(0,1800)})}const seen=new Set();const results=rows.filter(x=>(x.title||x.snippet)&&!seen.has(x.url)&&seen.add(x.url)).slice(0,limit);const labels=[...new Set((document.body?.innerText||'').split(/\n+/).map(clean).filter(x=>/visual matches|similar images|exact matches|lens|image source|pages that include|related searches|results/i.test(x)))].slice(0,30);return{url:location.href,isGoogle,isReverseImage:/searchbyimage|lens|udm=26|vsrid/i.test(location.href+' '+body),blocked,challengePath:/^\/sorry/i.test(u.pathname),resultCount:results.length,results,interfaceEvidence:labels,bodyExcerpt:body.slice(0,2200)}})()
  1. If Google shows a CAPTCHA, /sorry/, unusual-traffic, robot-check, consent, login, or verification prompt, stop automated interaction. If the caller explicitly requests human-in-the-loop continuation, leave the shared browser on the prompt and ask the caller to solve it manually in that browser. Do not click, type, replay, or automate the challenge; do not retain its URL, continuation parameters, cookies, tokens, or signed image URL. After the caller confirms completion, run the evaluator on the currently displayed Google page and continue only if it is a normal Lens/image-search result surface. Otherwise return the search as blocked or unresolved.

  2. For each image, preserve the original clean input URL separately from Google's rendered result URL. Deduplicate result rows by observed Google result URL, visible destination URL, or normalized title plus source domain. Keep the image index and any visible Lens/image-search labels on every result.

  3. Stitch results across the bounded image list locally. When the same page appears for multiple stills, return one deduplicated row with matchedImageIndexes; preserve all visible supporting snippets and source evidence. Treat snippets and visual similarity as discovery evidence only. Do not assert that a person depicted is the named subject, that two images show the same person, or that a page is current without explicit rendered evidence.

  4. If the caller requests more results, scroll only a visible Google result surface in bounded increments and rerun the evaluator, stopping when no new result URLs appear or the requested limit is reached. Do not click result links, image thumbnails, contact controls, or account prompts merely to expand discovery.

Possible Friction Points

  • The durable Google reverse-image entry point is /searchbyimage?image_url={encoded-public-image-url}&client=app.
  • Google Lens also accepts /uploadbyurl?url={encoded-public-image-url} on lens.google.com; use this only with a currently valid public image URL.
  • Some image hosts block Google's fetcher, producing "No image at the URL" even for a publicly reachable image. Try another caller-authorized public copy of the same image rather than treating that message as no matches.
  • Google may redirect either endpoint to Lens or a search page with opaque vsrid, vsint, gsessionid, lsessionid, sei, and continuation parameters. These are session-specific and must never become reusable URL templates.
  • Temporary signed object-storage URLs may contain credentials, signatures, and expiry values. Treat them as secret input: never include them in saved URLs, output, logs, or reusable examples.
  • The observed run reached /sorry/index; this is an anti-bot challenge, not search evidence. Do not automate or bypass it. A caller may manually solve a prompt in the shared browser only when explicitly requested; resume extraction only after confirmation and never retain challenge state.
  • Result markup varies between classic image search and Lens. Prefer visible links, headings, semantic result containers, and bounded card text over generated CSS classes.
  • Decode Google /url?q=... or /url?url=... wrappers locally and return the destination in url with visible source/title evidence. Discard internal Google links; do not navigate to result destinations unless explicitly requested.
  • A public image URL can expose sensitive material. Accept only caller-authorized public inputs, do not return image bytes or hidden metadata, and do not search private, intimate, or access-controlled images.
  • Reverse-image matches can be stale, duplicated, mirrored, or visually similar without depicting the same person or event. Preserve uncertainty and require human verification for identity or attribution.
  • Search coverage, rankings, snippets, and Lens classifications are time-dependent. An empty result or blocked page is not evidence that the image has no public matches.
  • Consent, login, CAPTCHA, unusual-traffic, and empty dynamic pages are unresolved states. Do not retain challenge URLs, continuation parameters, cookies, tokens, or account data.

Example Result

{
  "url": "https://example.com/search",
  "isGoogle": true,
  "isReverseImage": false,
  "blocked": false,
  "challengePath": false,
  "resultCount": 1,
  "results": [
    {
      "title": "Example Title",
      "url": "https://example.com/result",
      "sourceDomain": "example.com",
      "snippet": "Example result snippet",
      "raw": "Example Title Example result snippet"
    }
  ],
  "interfaceEvidence": [
    "Search results"
  ],
  "bodyExcerpt": "Example page text"
}

Call it

GET https://production-sfo.browserless.io/skills?token=TOKEN-HERE&domain=google.com&task=google-public-reverse-image-search