---
title: "Google Images scraper"
description: "Scrape Google Images results as JSON: image titles, source sites, source page URLs, thumbnails, license and video flags, and refinement filters. From Python or MCP."
canonical: https://www.zenrows.com/scrape/google-images
updated: 2026-10-20
---

# Google Images scraper

The Zenrows Google Images scraper turns any Google Images search URL into JSON: the title, source site name, source page URL and thumbnail link of every image result, flags for licensable images and videos, plus Google's refinement chips and related searches. Fetch in Adaptive Stealth Mode opens the page and Extract returns the fields. Run it from an API call, the CLI or an AI agent.

- Site: images.google.com
- Returns: Image results with titles, source sites, page URLs and thumbnails

## Run it: one Google Images search in, JSON out

```json Input
{
  "url": "https://www.google.com/search?q=golden+retriever&tbm=isch",
  "mode": "auto",
  "extract": "auto",
  "proxy_country": "us"
}
```

```json Output
{
  "search_query": { "text": "golden retriever" },
  "image_results": [
    {
      "title": "Golden Retriever - Wikipedia",
      "source_domain": "Wikipedia",
      "source_url": "https://en.wikipedia.org/wiki/Golden_Retriever",
      "thumbnail_url": "/goto?url=CAESZgHrOzAVoGye2LhCn7dZIDE4t0rod…",
      "is_licensed": null,
      "is_video": null,
      "is_translated": null
    },
    {
      "title": "How To Care For Golden Retrievers | VIDA Veterinary Care",
      "source_domain": "VIDA Veterinary Care",
      "source_url": "https://www.vidavetcare.com/dog-breed/golden-retriever/",
      "thumbnail_url": "/goto?url=CAESbwHrOzAVwLoLlnZ0lKFU4X4fqU9U…",
      "is_licensed": null,
      "is_video": null,
      "is_translated": null
    }
  ],
  "refinement_filters": [
    { "label": "Puppy", "url": null, "thumbnail_url": null },
    { "label": "English cream", "url": null, "thumbnail_url": null }
  ]
}
```

Request and output of a live call to a Google Images search on Oct 20, 2026, trimmed to two of the 100 image results returned. A field is returned when the result shows it.

## What data can you scrape from Google Images?

A Google Images page is a grid of images, each tied to the page it comes from, with refinement chips above it. Extract returns each image as a record in `image_results`, in grid order, plus the chips and related searches. These are the fields and their paths.

| Field | What it holds | Example |
|---|---|---|
| `search_query.text` | The query Google ran | `golden retriever` |
| `image_results[].title` | The title Google shows under the image, usually the page title | `Golden Retriever - Wikipedia` |
| `image_results[].source_domain` | The site name shown with the image | `VIDA Veterinary Care` |
| `image_results[].source_url` | The page the image appears on | `https://en.wikipedia.org/wiki/Golden_Retriever` |
| `image_results[].thumbnail_url` | The link Google attaches to the thumbnail | `/goto?url=CAESZgHrOzAV…` |
| `image_results[].is_licensed` | `true` when Google marks the image as licensable | `true` |
| `image_results[].is_video` | `true` when the result is a video | `true` |
| `image_results[].is_translated` | `true` when Google translated the title | `null` |
| `refinement_filters[].label` | The refinement chips above the grid | `Puppy`, `Labrador`, `English cream` |
| `refinement_filters[].url` | The search URL behind a chip, when present | `null` |
| `related_searches[].label` | Related query text, when Google prints it | `null` |
| `related_searches[].url` | The Google search URL of a related query | `/search?sca_esv=…&q=golden+retriever+puppy…` |

## How to scrape Google Images with Zenrows

1. **Create a free Zenrows account** and copy your API key from the dashboard.
2. **Build the Images URL.** Add `tbm=isch` to a Google search: `https://www.google.com/search?q=golden+retriever&tbm=isch`. Google's own links on the Images tab use `udm=2`, which opens the same tab.
3. **Set filters in the URL.** Size, color, type, time and usage rights from the Images "Tools" menu are written into the URL. Apply them once in your browser and copy the address.
4. **Send it with the default configuration**: Adaptive Stealth Mode to open the page, Extract to return the image results, and the country whose results you want.
5. **Run every query in Batch** with an ID per query, then fetch the source pages you need from `source_url`.

```python Python
# pip install requests
import requests

params = {
    "apikey": "YOUR_ZENROWS_API_KEY",
    "url": "https://www.google.com/search?q=golden+retriever&tbm=isch",
    "mode": "auto",          # Adaptive Stealth Mode
    "extract": "auto",       # structured JSON
    "proxy_country": "us",
}
response = requests.get("https://api.zenrows.com/v1/", params=params, timeout=180)
response.raise_for_status()

parsed = response.json()["parsed"]
for image in parsed["image_results"][:20]:
    print(image["source_domain"], image["source_url"], image["title"])
print([chip["label"] for chip in parsed["refinement_filters"]])
```

```javascript Node.js
// Node 18+ (built-in fetch)
const params = new URLSearchParams({
  apikey: "YOUR_ZENROWS_API_KEY",
  url: "https://www.google.com/search?q=golden+retriever&tbm=isch",
  mode: "auto",
  extract: "auto",
  proxy_country: "us",
});

const response = await fetch(`https://api.zenrows.com/v1/?${params}`, {
  signal: AbortSignal.timeout(180_000),
});
if (!response.ok) throw new Error(`${response.status}: ${await response.text()}`);

const { parsed } = await response.json();
for (const img of parsed.image_results) console.log(img.source_domain, img.source_url);
```

```bash cURL
curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.google.com%2Fsearch%3Fq%3Dgolden%2Bretriever%26tbm%3Disch&mode=auto&extract=auto&proxy_country=us"

# Only titles, source sites and source pages
curl "https://api.zenrows.com/v1/?apikey=YOUR_ZENROWS_API_KEY&url=https%3A%2F%2Fwww.google.com%2Fsearch%3Fq%3Dgolden%2Bretriever%26tbm%3Disch&mode=auto&extract=auto&proxy_country=us&extract_fields=image_results.title%2Cimage_results.source_domain%2Cimage_results.source_url"
```

## Input

The scraper takes one Google Images URL per request. The query and every filter from the Tools menu are part of the URL, so a list of queries and filters becomes a list of URLs with the settings below.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `url` | string | required | A Google Images URL with `tbm=isch` or `udm=2`, such as `https://www.google.com/search?q=golden+retriever&tbm=isch`, with any filters you set in Tools |
| `mode` | string | `auto` | Adaptive Stealth Mode: starts with the lightest setup and adds rendering and protected-site handling only when Google needs them |
| `extract` | string | `auto` | Returns `image_results`, `refinement_filters`, `related_searches` and `search_query` as JSON in `parsed` |
| `extract_fields` | string | all fields | Comma-separated paths to keep, such as `image_results.title,image_results.source_url` |
| `proxy_country` | string | any | Two-letter country code. Image results and chips follow the searcher's country and language |
| `wait_for` | string | none | A CSS selector to wait for before the page is read |
| `session_id` | integer | none | Keep the same session for up to 10 minutes across related requests |

```json Batch input
{
  "type": "regular",
  "status": "closed",
  "zenrows_params": {
    "mode": "auto",
    "extract": "auto",
    "proxy_country": "us"
  },
  "tasks": [
    { "url": "https://www.google.com/search?q=golden+retriever&tbm=isch", "external_id": "golden-retriever" },
    { "url": "https://www.google.com/search?q=golden+retriever+puppy&tbm=isch", "external_id": "golden-retriever-puppy" },
    { "url": "https://www.google.com/search?q=labrador+retriever&tbm=isch", "external_id": "labrador-retriever" }
  ]
}
```

## Output

The response holds `html`, the Images page as Google served it, and `parsed`, the structured results. One page of the sample query returned 100 image records, 33 refinement chips and 33 related searches. Trimmed from the live response:

```json Image results
{
  "search_query": { "text": "golden retriever" },
  "image_results": [
    {
      "title": "Golden Retriever: Pros, Cons & Diet Guide | Ollie",
      "source_domain": "Ollie Blog",
      "source_url": "https://blog.ollie.com/breed-deets-golden-retriever/",
      "thumbnail_url": "/goto?url=CAESbAHrOzAVxBO-mt2MPt5PH5r6ftAS…",
      "is_licensed": null,
      "is_translated": null,
      "is_video": null
    },
    {
      "title": "Golden Retriever - Wikipedia",
      "source_domain": "Wikipedia",
      "source_url": "https://en.wikipedia.org/wiki/Golden_Retriever",
      "thumbnail_url": "/goto?url=CAESZgHrOzAVoGye2LhCn7dZIDE4t0rod…",
      "is_licensed": null,
      "is_translated": null,
      "is_video": null
    }
  ],
  "refinement_filters": [
    { "label": "Puppy", "url": null, "thumbnail_url": null },
    { "label": "Labrador", "url": null, "thumbnail_url": null },
    { "label": "Full grown", "url": null, "thumbnail_url": null }
  ],
  "related_searches": [
    {
      "label": null,
      "url": "/search?sca_esv=c9b655d7b11e91c2&sxsrf=APpeQnv-4_EV4gItF2NTWJfgWIo7W6PHDg:1792462394908&q=golden+retriever+puppy&uds=…",
      "thumbnail_url": "/search?sca_esv=c9b655d7b11e91c2&sxsrf=APpeQnv-4_EV4gItF2NTWJfgWIo7W6PHDg:1792462394908&q=golden+retriever+puppy&uds=…"
    }
  ]
}
```

`source_url` is the field most pipelines start from: it is the page where the image lives, with the image's context, caption and license terms. Relative links (`/goto?…`, `/search?…`) are Google paths; prefix them with `https://www.google.com` to follow them.

## Scrape Google Images from your coding agent

Claude Code, Cursor, Codex and any MCP client can search Google Images and work with the results from a prompt.

The agent runs the same Fetch and Extract request as the code above, reads the image records and their source pages, and can open those pages with Fetch for captions and context. Connect the Zenrows MCP server once, or install the CLI and let the agent call it in the terminal.

```bash Connect the MCP server (Claude Code)
claude mcp add zenrows -e ZENROWS_API_KEY=YOUR_ZENROWS_API_KEY -- npx -y @zenrows/mcp
```

```json MCP config (Cursor, Claude Desktop, Windsurf)
{
  "mcpServers": {
    "zenrows": {
      "command": "npx",
      "args": ["-y", "@zenrows/mcp"],
      "env": { "ZENROWS_API_KEY": "YOUR_ZENROWS_API_KEY" }
    }
  }
}
```

```bash Or run the CLI
npx -y @zenrows/cli init
zenrows extract "https://www.google.com/search?q=golden+retriever&tbm=isch" --proxy-country us
```

```text Then ask your agent
Use Zenrows to search Google Images for "golden retriever". Group the
first 50 results by source site, tell me which sites appear most, and
list the results Google marks as licensable.
```

## Scrape Google Images at scale with Batch and Crawl

**Batch** runs a query list as one job: one Images URL per keyword and country, with the keyword as `external_id`. Use it to track which sites own the image results for your product names or to collect source pages for a dataset across hundreds of classes.

**Crawl** goes to the sources. When one site dominates the results, start a crawl on its section for the topic, keep the matching paths (on Wikipedia, `/wiki/`), and collect every page with its images and captions in context.

```bash Batch (cURL)
curl -X POST "https://async.api.zenrows.com/v1/jobs" \
  -H "X-API-Key: YOUR_ZENROWS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "regular",
    "status": "closed",
    "zenrows_params": { "mode": "auto", "extract": "auto", "proxy_country": "us" },
    "tasks": [
      { "url": "https://www.google.com/search?q=golden+retriever&tbm=isch", "external_id": "golden-retriever" },
      { "url": "https://www.google.com/search?q=labrador+retriever&tbm=isch", "external_id": "labrador-retriever" }
    ]
  }'

# Read the results when the job finishes
curl "https://async.api.zenrows.com/v1/jobs/JOB_ID/results?status=successful" \
  -H "X-API-Key: YOUR_ZENROWS_API_KEY"
```

```bash Batch (CLI)
# queries.jsonl: one {"url": "...", "external_id": "...", "extract": "auto"} per line
zenrows batch create queries.jsonl --proxy-country us --wait
zenrows batch results <job-id> --out google-images.jsonl
```

```bash Crawl (cURL)
curl -X POST "https://api.zenrows.com/v1/crawls" \
  -H "X-API-Key: YOUR_ZENROWS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://en.wikipedia.org/wiki/Golden_Retriever",
    "depth": 1,
    "max_pages": 100,
    "include_patterns": ["/wiki/"]
  }'
```

**Scheduled jobs** run the same Batch job on a timetable, on Zenrows' side: every few hours, once a day, at set times on chosen days, or once at a future date. Each run keeps its own results, a webhook can tell your app when a run finishes, and you can pause or resume the schedule at any time, with no cron server to keep alive.

```bash Scheduled job (cURL)
# Runs every day on Zenrows' side; each run keeps its own results
curl -X POST "https://async.api.zenrows.com/v1/jobs" \
  -H "X-API-Key: YOUR_ZENROWS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
      "type": "scheduled",
      "status": "closed",
      "schedule": {
        "rate": {
          "every": 1,
          "unit": "day"
        }
      },
      "zenrows_params": {
        "mode": "auto",
        "extract": "auto",
        "proxy_country": "us"
      },
      "tasks": [
        {
          "url": "https://www.google.com/search?q=golden+retriever&tbm=isch",
          "external_id": "google-images"
        }
      ]
    }'

# Or at set times: "schedule": { "calendar": { "times_of_day": ["09:00"],
#   "cadence": { "weekly": { "days": ["mon", "thu"] } } }, "timezone": "Europe/Madrid" }
```

## What teams do with Google Images data

| Use case | Data they pull | Who runs it |
|---|---|---|
| Image SEO tracking | Which sites and pages own the image results for target keywords, by country | SEO teams and ecommerce brands |
| Brand and product image monitoring | Source pages that show a brand's product photos or logo for brand queries | Brand protection and legal teams |
| Dataset sourcing | Source pages per class, to collect images with their captions and licenses | Computer vision and ML teams |
| Licensing research | Results Google marks as licensable, with the page that sells or explains the license | Creative, media and content teams |
| Visual trend research | Refinement chips and related searches for a topic, compared over time | Marketing and trend analysts |
| Multimodal agents | Image results and source pages an agent can open to answer a visual question | AI and product teams |

## Tips for scraping Google Images

- **Start from `source_url`.** It is the page the image lives on, with the alt text, caption and license terms you need before reusing anything.
- **Copy filters from the browser.** Set size, color, type, time or usage rights in the Images Tools menu and request the URL Google gives you; the filters travel with it.
- **Use the chips to widen a dataset.** `refinement_filters` lists the sub-topics Google sees for a query (Puppy, Full grown, English cream). Each chip is a natural next query.
- **Track ranking by grid position.** `image_results` keeps the grid order, so the index is the position for image SEO reports.
- **Separate videos.** `is_video` is `true` for video results mixed into the grid; filter them out when you only want stills.
- **Keep one country per run.** Titles, sources and chips follow the searcher's language and location, so compare runs made from the same country.

## Frequently asked questions

### Is it legal to scrape Google Images?

Google Images results, with their titles and source pages, are public, and collecting them for SEO or research is common practice. The images themselves belong to their owners and are usually protected by copyright, so check each source page's license before you reuse or train on an image, and remember that photos of people can be personal data under the GDPR and the CCPA. Check Google's terms for your use case and ask your lawyer if you are unsure.

### Is there an official Google Images API?

Google's Custom Search JSON API, which could return image results from a Programmable Search Engine, is closed to new customers. Teams that need the live Images page, with its refinement chips and related searches, use a scraper.

### What Google Images pages can I scrape?

Images results for any query, with tbm=isch or udm=2 in a google.com search URL, on any Google country site, with any filters from the Tools menu applied in the URL.

### Can I get the source page of each image?

Yes. Every result has source_url , the page the image is published on, and source_domain , the site name Google shows. Fetch the source page to read its captions, alt text and license.

### How do I scrape Google Images with Python?

Send a GET request to https://api.zenrows.com/v1/ with your API key, the Images URL, Adaptive Stealth Mode and Extract turned on, as in the Python example above. response.json()["parsed"]["image_results"] is a list of image dictionaries. The zenrows package on PyPI wraps the same request.

### How many image results can I scrape?

The sample request returned 100 image results from one page. For more, vary the query with the refinement chips and related searches, and send every URL as a Batch job. One Batch job accepts more than 10,000 URLs, inline or as a CSV file.

### Can AI agents scrape Google Images with Zenrows?

Yes. Connect the Zenrows MCP server to Claude, Cursor, Codex or any MCP client, or give your agent the Zenrows CLI. Ask for image results in plain language and the agent runs Fetch and Extract and opens the source pages it needs.

### Can I scrape Google Images on a schedule?

Yes. Create a scheduled Batch job with your Google Images URLs and the same settings as a single request, and Zenrows runs it on its side: every few hours, once a day, at set times on chosen days, or once at a future date. Each run keeps its own results, a webhook can notify your app when a run finishes, and the schedule can be paused or resumed at any time.

### Which integrations work with the Google Images scraper?

Zenrows works with n8n, Make, Zapier, Clay, Dify, LangChain, LlamaIndex, CrewAI and Mastra, plus the Python, Node.js and Go SDKs and any HTTP client. See the integrations page for the full list.

### What format does the data come in?

JSON by default, with the image records in parsed and the original page in html . You can also ask for Markdown or plain text, or flatten the JSON into CSV.

All scrapers: https://www.zenrows.com/scrape. Start free: https://app.zenrows.com/register. Docs: https://docs.zenrows.com
